Nvib-1 or Nvib3 < 0 or Nvib3 > Nvib-1:\n raise StatmechFitError('Invalid degeneracies {0} and {1} fitted for pseudo-frequencies.'.format(Nvib2, Nvib3))\n\n vib = [x[0]]\n for i in range(Nvib2): vib.append(x[2])\n for i in range(Nvib3): vib.append(x[3])\n hind = []\n for i in range(Nrot):\n hind.append((x[4], x[5]))\n\n return vib, hind","def weak_repulsion(Cents,a,k, CV_matrix,n_c,L):\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\n displacement = np.mod(Cents - CCW + L/2,L) - L/2\n rij = np.sqrt(displacement[:,:,0]**2 + displacement[:,:,1]**2)\n norm_disp = (displacement.T/rij.T).T\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\n V_soft = V_soft_CW + V_soft_CCW\n F_soft = np.zeros((n_c, 2))\n for i in range(3):\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\n return F_soft","def weak_repulsion_boundary(Cents,a,k, CV_matrix,n_c,n_C):\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\n CCW_displacement = Cents - CCW\n rij = np.sqrt(CCW_displacement[:,:,0]**2 + CCW_displacement[:,:,1]**2)\n norm_disp = (CCW_displacement.T/rij.T).T\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\n V_soft = V_soft_CW + V_soft_CCW\n F_soft = np.zeros((n_c, 2))\n for i in range(3):\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\n F_soft[n_C:] = 0\n return F_soft","def define_potts_helper_functions(k):\n\n @njit\n def calc_observables(X, k=k):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n\n Returns\n -------\n ndarray\n Dimensions (n_samples, n_observables).\n \"\"\"\n\n n = X.shape[1]\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\n \n # average orientation (magnetization)\n # note that fields for the third state are often set to 0\n counter = 0\n for i in range(k):\n for j in range(n):\n Y[:,counter] = X[:,j]==i\n counter += 1\n \n # pairwise correlations\n for i in range(n-1):\n for j in range(i+1, n):\n Y[:,counter] = X[:,i]==X[:,j]\n counter += 1\n \n return Y\n\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n multipliers : ndarray of dtype np.float64\n\n Returns\n -------\n ndarray\n Energies of each observable.\n \"\"\"\n\n return -calc_observables(X, k).dot(multipliers)\n\n def mch_approximation(sample, dlamda, calc_e=calc_e):\n \"\"\"Function for making MCH approximation step for Potts model.\n \n Parameters\n ----------\n sample : ndarray\n Of dimensions (n_sample, n_spins).\n dlamda : ndarray\n Change in parameters.\n \n Returns\n -------\n ndarray\n Predicted correlations.\n \"\"\"\n\n dE = calc_e(sample, dlamda)\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \n assert not ((predsisj<0).any() or\n (predsisj>(1+1e-10)).any()),\"Predicted values are beyond limits, (%E,%E)\"%(predsisj.min(),\n predsisj.max())\n return predsisj\n\n return calc_e, calc_observables, mch_approximation","def specific_heat(Ekinv,n0,N,t0):\n Cv = np.zeros(10)\n for i in range(10):\n avg_K_squared = (1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]))**2\n FluctK = 1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]**2) - avg_K_squared\n Cv[i] = -1 / (FluctK/ avg_K_squared * 3 * N / 2 - 1) * 3 * N / 2\n return Cv","def CLOMPR(task,sketch,featureMap,K,bounds,dimensions_to_consider=None, nb_cat_per_dim=None,nIterations=None, nRepetitions=1, ftol=1e-6, verbose=0 ):\n\n ## 0) Defining all the tools we need\n ####################################\n ## 0.1) Handle input\n\n ## 0.1.1) task name\n if task.lower() in [\"km\",\"ckm\",\"kmeans\",\"k-means\"]:\n task = \"kmeans\"\n task_finetuning = \"kmeans\"\n elif task.lower() in [\"gmm\",\"gaussian mixture model\"]:\n task = \"gmm\"\n task_finetuning = \"gmm\"\n elif task.lower() in [\"gmm-nondiag\"]:\n task = \"gmm\"\n task_finetuning = \"gmm-nondiag\"\n else:\n raise ValueError('The task argument does not match one of the available options.')\n\n ## 0.1.2) sketch feature function\n if isinstance(featureMap,SimpleFeatureMap):\n d_all = featureMap.d\n m = featureMap.m\n else:\n raise ValueError('The featureMap argument does not match one of the supported formats.')\n\n # Restrict the dimension\n if dimensions_to_consider is None:\n dimensions_to_consider = np.arange(d_all)\n dimensions_to_ignore = np.delete(np.arange(d_all), dimensions_to_consider)\n d = dimensions_to_consider.size\n \n # Pre-compute sketch of unused dimensions\n z_to_ignore = fourierSketchOfBox(bounds.T,featureMap,nb_cat_per_dim, dimensions_to_consider = dimensions_to_ignore)\n # Compensate the normalization constant and the dithering which will be taken into account in the centroid sketch\n z_to_ignore = z_to_ignore/(featureMap(np.zeros(d_all))) # giving zeros yields the dithering and the c_norm\n \n # Restrict the featureMap for the centroids\n Phi = copy(featureMap) # Don't touch to the inital map, Phi is featureMap restricted to relevant dims\n Phi.d = d\n Phi.Omega = featureMap.Omega[dimensions_to_consider]\n \n ## 0.1.3) nb of iterations\n if nIterations is None:\n nIterations = 2*K # By default: CLOMP-*R* (repeat twice)\n \n ## 0.1.4) Bounds of the optimization problems\n if bounds is None:\n lowb = -np.ones(d) # by default data is assumed normalized\n uppb = +np.ones(d)\n if verbose > 0: print(\"WARNING: data is assumed to be normalized in [-1,+1]^d\")\n else:\n lowb = bounds[0][dimensions_to_consider]\n uppb = bounds[1][dimensions_to_consider] # Bounds for one centroid\n\n # Format the bounds for the optimization solver\n if task_finetuning == \"kmeans\":\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the centroids\n elif task_finetuning == \"gmm\":\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\n elif task_finetuning == \"gmm-nondiag\":\n # Usual bounds of GMM\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\n \n # Bounds for the nondiagonal problem\n boundstheta_finetuning = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n varianceUpperBound = ((uppb-lowb).max()/2)**2\n\n _lowb_var = -varianceUpperBound*np.ones((d,d))\n np.fill_diagonal(_lowb_var, varianceLowerBound)\n _uppb_var = +varianceUpperBound*np.ones((d,d))\n\n _boundsvar = np.append(_lowb_var.reshape(-1),_uppb_var.reshape(-1)).reshape(2,d**2).T.tolist()\n for _i in _boundsvar: boundstheta_finetuning.append(_i) # bounds for the variance\n \n\n ## 0.1.5) Misc. initializations\n # Chosen method for the optimization solver\n opt_method = 'L-BFGS-B' # could also consider 'TNC'\n # Separated real and imaginary part of the sketch\n sketch_ri = np.r_[sketch.real, sketch.imag]\n if task == \"kmeans\":\n thetadim = d\n elif task == \"gmm\":\n thetadim = 2*d\n elif task == \"gmm-nondiag\":\n thetadim = d*(d+1)\n\n\n ## THE ACTUAL ALGORITHM\n #######################\n bestResidualNorm = np.inf \n bestTheta = None\n bestalpha = None\n for iRun in range(nRepetitions):\n \n ## 1) Initialization\n r = sketch # residual\n Theta = np.empty([0,thetadim]) # Theta is a nbAtoms-by-atomDimension array\n A = np.empty([m,0]) # Contains the sketches of the atoms\n\n ## 2) Main optimization\n for i in range(nIterations):\n ## 2.1] Step 1 : find new atom theta most correlated with residual\n # Initialize the new atom\n if task == \"kmeans\":\n th_0 = np.random.uniform(lowb,uppb)\n elif task == \"gmm\":\n mu0 = np.random.uniform(lowb,uppb) # initial mean\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\n th_0 = _stackAtom(\"gmm\",mu0,sig0)\n \n elif task == \"gmm-nondiag\":\n # Solve once for diagonal\n mu0 = np.random.uniform(lowb,uppb) # initial mean\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\n th_0 = _stackAtom(\"gmm\",mu0,sig0)\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(\"gmm\",Phi,th,r,z_to_ignore,verbose),\n x0 = th_0, method=opt_method, jac=True,\n bounds=boundstheta_gmm)\n\n (mu0,sig0) = _destackAtom(\"gmm\",sol.x,d)\n\n th_0 = _stackAtom(\"gmm-nondiag\",mu0,np.diag(sig0))\n\n # And solve with LBFGS \n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(task,Phi,th,r,z_to_ignore,verbose),\n x0 = th_0, method=opt_method, jac=True,\n bounds=boundstheta)\n new_theta = sol.x\n \n if task == \"gmm-nondiag\":\n new_theta = _makeGMMfeasible(new_theta,d)\n\n ## 2.2] Step 2 : add it to the support\n Theta = np.append(Theta,[new_theta],axis=0)\n A = np.c_[A,_sketchAtom(task,Phi,new_theta,z_to_ignore)] # Add a column to the A matrix\n\n ## 2.3] Step 3 : if necessary, hard-threshold to nforce sparsity\n if Theta.shape[0] > K:\n norms = np.linalg.norm(A,axis=0)\n norms[np.where(norms < 1e-15)[0]] = 1e-15 # Avoid /0\n A_norm = A/norms # normalize, unlike step 4\n A_normri = np.r_[A_norm.real, A_norm.imag] \n (beta,_) = nnls(A_normri,sketch_ri) # non-negative least squares\n index_to_delete = np.argmin(beta)\n Theta = np.delete(Theta, index_to_delete, axis=0)\n A = np.delete(A, index_to_delete, axis=1)\n if index_to_delete == K:\n continue # No gain to be expected wrt previous iteration\n\n ## 2.4] Step 4 : project to find weights\n Ari = np.r_[A.real, A.imag]\n (alpha,_) = nnls(Ari,sketch_ri) # non-negative least squares\n\n\n\n ## 2.5] Step 5\n p0 = _stackTheta(task,Theta,alpha) # Initialize at current solution \n # Compute the bounds for step 5 : boundsOfOneAtom * numberAtoms then boundsOneWeight * numberAtoms\n boundsThetaAlpha = boundstheta * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\n # Solve\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task,Phi,p,sketch,z_to_ignore),\n x0 = p0, method=opt_method, jac=True,\n bounds=boundsThetaAlpha, options={'ftol': ftol}) \n (Theta,alpha) = _destackTheta(task,sol.x,Phi.d)\n \n # Make covariances feasible\n if task == \"gmm-nondiag\":\n for k in range(Theta.shape[0]):\n Theta[k] = _makeGMMfeasible(Theta[k],d)\n\n # The atoms have changed: we must re-compute A\n A = np.empty([m,0])\n for theta_i in Theta:\n Apthi = _sketchAtom(task,Phi,theta_i,z_to_ignore)\n A = np.c_[A,Apthi]\n # Update residual\n r = sketch - A@alpha\n\n ## 3) Finalization boundstheta_finetuning\n # Last optimization with the default (fine-grained) tolerance\n if task_finetuning == \"gmm-nondiag\":\n if verbose > 0: print('finetuning')\n Theta_new = np.zeros((K,d*(d+1))) # Expand to have full cov matrix\n for k in range(K):\n (mu,sig2) = _destackAtom(\"gmm\",Theta[k],d)\n # put current sol on the diagonal of full covariance matrix\n Theta_new[k] = _stackAtom(\"gmm-nondiag\",mu,np.diag(sig2))\n Theta = Theta_new # overwrite\n \n boundsThetaAlpha = boundstheta_finetuning * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\n \n if task_finetuning == \"gmm-nondiag\" or ftol >= 1e-8:\n p0 = _stackTheta(task_finetuning,Theta,alpha)\n \n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task_finetuning,Phi,p,sketch,z_to_ignore),\n x0 = p0, method=opt_method, jac=True,\n bounds=boundsThetaAlpha) # Here ftol is much smaller\n (Theta,alpha) = _destackTheta(task_finetuning,sol.x,Phi.d) \n \n \n # Normalize alpha\n alpha /= np.sum(alpha)\n \n \n runResidualNorm = np.linalg.norm(sketch - A@alpha)\n if verbose>1: print('Run {}, residual norm is {} (best: {})'.format(iRun,runResidualNorm,bestResidualNorm))\n if runResidualNorm <= bestResidualNorm:\n bestResidualNorm = runResidualNorm\n bestTheta = Theta\n bestalpha = alpha\n \n ## FORMAT OUTPUT\n if task == \"kmeans\":\n return (bestalpha,bestTheta)\n elif task == \"gmm\" or task == \"gmm-nondiag\":\n return _ThetasToGMM(task_finetuning,bestTheta,bestalpha)\n\n return None","def optimize_force_field_parameters_Cv_FWHM(cgmodel, file_list, temperature_list, param_bounds_dict,\n frame_begin=0, frame_end=-1, sample_spacing=1, sparsify_stride=1, output_data='output.nc',\n verbose=False, n_cpu=12, min_eff_samples=50,\n n_trial_boot=200, num_intermediate_states=0, plotfile='optimize_FWHM_iterations.pdf',\n min_method='TNC'):\n\n # Parse the force field parameter change dict:\n x0 = []\n param_names = []\n bounds = []\n units = []\n \n for key,value in param_bounds_dict.items():\n # value should be [(bound_lo, bound_hi)]\n # key should be a valid force field parameter name\n param_names.append(key)\n # Every parameter except periodicity should have units\n # For now, changing periodicity is not supported.\n \n # TODO: add support for sums of periodic torsion terms\n units.append(value[0].unit)\n bounds.append((value[0].value_in_unit(units[-1]),value[1].value_in_unit(units[-1])))\n # Use mean value as starting guess:\n x0.append((value[1].value_in_unit(units[-1])+value[0].value_in_unit(units[-1]))/2)\n\n if verbose:\n print(f'param_names: {param_names}')\n print(f'unit: {units}')\n print(f'bounds: {bounds}')\n print(f'x0: {x0}')\n\n def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n \"\"\"\n Objective function to be minimized\n \"\"\"\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)\n\n # Run optimization:\n\n # if len(param_names) == 1:\n # # Do scalar optimization:\n # opt_results = minimize_scalar(get_reeval_FWHM, x0,\n # args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\n # frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\n # method='bounded',\n # bounds=[bounds[0][0],bounds[0][1]],\n # options={'maxiter': 25},\n # )\n\n # else:\n # Do multivariate optimization:\n opt_results = minimize(get_reeval_FWHM, x0, jac='2-point',\n args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\n frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\n method=min_method,\n bounds=bounds,\n options={'maxfun': 25, 'finite_diff_rel_step': 0.005, 'eta': 0.5}, # This should be user input\n ) \n \n # TODO: plot the heat capacity curves at each iteration, and make a plot of all FWHM_values \n\n # Construct dictionary of optimal parameters:\n opt_param_dict = {} \n \n k = 0\n for key,value in param_bounds_dict.items():\n opt_param_dict[key] = opt_results.x[k] * units[k]\n k += 1\n \n return opt_param_dict, opt_results","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def plot_dispersion(kpts, enk):\n\n # Lattice constant and reciprocal lattice vectors\n # b1 = 2 pi/a (kx - ky + kz)\n # b2 = 2 pi/a (kx + ky - kz)\n # b3 = 2 pi/a (-kx + ky + kz)\n a = 5.556 # [A]\n b1 = (2 * np.pi / a) * np.array([1, -1, 1])\n b2 = (2 * np.pi / a) * np.array([1, 1, -1])\n b3 = (2 * np.pi / a) * np.array([-1, 1, 1])\n\n # L point in BZ is given by 0.5*b1 + 0.5*b2 + 0.5*b3\n # X point in BZ is given by 0.5*b2 + 0.5*b3\n lpoint = 0.5 * (b1 + b2 + b3)\n xpoint = 0.5 * (b2 + b3)\n\n # We can find kpoints along a path just by considering a dot product with lpoint and xpoint vectors.\n # Any kpoints with angle smaller than some tolerance are considered on the path and we can plot their frequencies\n deg2rad = 2 * np.pi / 360\n ang_tol = 1 * deg2rad # 1 degree in radians\n\n print(list(kpts))\n\n enkonly = np.array(enk['energy [Ryd]'])[:, np.newaxis]\n enkinds = np.array(enk['q_inds'])\n kptsonly = np.array(kpts[['kx [1/A]', 'ky [1/A]', 'kz [1/A]']]) / (2 * np.pi / a)\n kptsinds = np.array(kpts['q_inds'])\n kptsmag = np.linalg.norm(kptsonly, axis=1)[:, np.newaxis]\n\n dot_l = np.zeros(len(kpts))\n dot_x = np.zeros(len(kpts))\n\n # Separate assignment for gamma point to avoid divide by zero error\n nongamma = kptsmag != 0\n dot_l[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, lpoint[:, np.newaxis])[nongamma],\n kptsmag[nongamma]) / np.linalg.norm(lpoint)\n dot_x[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, xpoint[:, np.newaxis])[nongamma],\n kptsmag[nongamma]) / np.linalg.norm(xpoint)\n dot_l[np.squeeze(kptsmag == 0)] = 0\n dot_x[np.squeeze(kptsmag == 0)] = 0\n\n lpath = np.logical_or(np.arccos(dot_l) < ang_tol, np.squeeze(kptsmag == 0))\n xpath = np.logical_or(np.arccos(dot_x) < ang_tol, np.squeeze(kptsmag == 0))\n\n linds = kptsinds[lpath]\n xinds = kptsinds[xpath]\n lkmag = kptsmag[lpath]\n xkmag = kptsmag[xpath]\n\n plt.figure()\n\n for i, ki in enumerate(linds):\n energies = enkonly[enkinds == ki, 0]\n thiskmag = lkmag[i]\n if len(energies) > 1:\n veck = np.ones((len(energies), 1)) * thiskmag\n plt.plot(veck, energies, '.', color='C0')\n else:\n plt.plot(thiskmag, energies, '.', color='C0')\n\n for i, ki in enumerate(xinds):\n energies = enkonly[enkinds == ki, 0]\n thiskmag = lkmag[i]\n if len(energies) > 1:\n veck = np.ones((len(energies), 1)) * thiskmag\n plt.plot(-1 * veck, energies, '.', color='C1')\n else:\n plt.plot(-1 * thiskmag, energies, '.', color='C1')\n\n plt.xlabel('k magnitude')\n plt.ylabel('Energy in Ry')","def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\n # We move from an array to a list of 2d-array for the competition over each template:\n\n cp=cps[0]\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\n new_cp = 1\n\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\n # update for fixed point:\n new_cp += w_inpIdx*x_eq\n # saving values\n layerEq[inpIdx] = x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n layerEq[inpIdx] = x_eq\n\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n new_cp += Inhib2/(E0*cp)*x_eq\n\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\n diff_cps = np.zeros(cps.shape)\n if new_cp>=1:\n diff_cps[0] = cp - new_cp\n else:\n diff_cps[0] = 10**3\n for l,m in enumerate(masks):\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\n return diff_cps","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def fit_full(self,K):\r\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\r\n mu = np.zeros(self.N)\r\n Sigma = K.copy()\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.N,dtype=float)\r\n self.v_ = np.empty(self.N,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.N,dtype=float)\r\n self.Z_hat = np.empty(self.N,dtype=float)\r\n phi = np.empty(self.N,dtype=float)\r\n mu_hat = np.empty(self.N,dtype=float)\r\n sigma2_hat = np.empty(self.N,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = self.epsilon + 1.\r\n epsilon_np2 = self.epsilon + 1.\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.N)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\r\n mu = np.dot(Sigma,self.v_tilde)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\r\n B = np.eye(self.N) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\r\n L = jitchol(B)\r\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\r\n Sigma = K - np.dot(V.T,V)\r\n mu = np.dot(Sigma,self.v_tilde)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def fit_FITC(self, Kmm, Kmn, Knn_diag):\r\n num_inducing = Kmm.shape[0]\r\n\r\n \"\"\"\r\n Prior approximation parameters:\r\n q(f|X) = int_{df}{N(f|KfuKuu_invu,diag(Kff-Qff)*N(u|0,Kuu)} = N(f|0,Sigma0)\r\n Sigma0 = diag(Knn-Qnn) + Qnn, Qnn = Knm*Kmmi*Kmn\r\n \"\"\"\r\n Lm = jitchol(Kmm)\r\n Lmi = chol_inv(Lm)\r\n Kmmi = np.dot(Lmi.T,Lmi)\r\n P0 = Kmn.T\r\n KmnKnm = np.dot(P0.T, P0)\r\n KmmiKmn = np.dot(Kmmi,P0.T)\r\n Qnn_diag = np.sum(P0.T*KmmiKmn,-2)\r\n Diag0 = Knn_diag - Qnn_diag\r\n R0 = jitchol(Kmmi).T\r\n\r\n \"\"\"\r\n Posterior approximation: q(f|y) = N(f| mu, Sigma)\r\n Sigma = Diag + P*R.T*R*P.T + K\r\n mu = w + P*Gamma\r\n \"\"\"\r\n self.w = np.zeros(self.N)\r\n self.Gamma = np.zeros(num_inducing)\r\n mu = np.zeros(self.N)\r\n P = P0.copy()\r\n R = R0.copy()\r\n Diag = Diag0.copy()\r\n Sigma_diag = Knn_diag\r\n RPT0 = np.dot(R0,P0.T)\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(g|mu_,sigma2_) = Product{q_i(g|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.N,dtype=float)\r\n self.v_ = np.empty(self.N,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.N,dtype=float)\r\n self.Z_hat = np.empty(self.N,dtype=float)\r\n phi = np.empty(self.N,dtype=float)\r\n mu_hat = np.empty(self.N,dtype=float)\r\n sigma2_hat = np.empty(self.N,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = 1\r\n epsilon_np2 = 1\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.N)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma_diag[i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma_diag[i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma_diag[i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma_diag[i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n dtd1 = Delta_tau*Diag[i] + 1.\r\n dii = Diag[i]\r\n Diag[i] = dii - (Delta_tau * dii**2.)/dtd1\r\n pi_ = P[i,:].reshape(1,num_inducing)\r\n P[i,:] = pi_ - (Delta_tau*dii)/dtd1 * pi_\r\n Rp_i = np.dot(R,pi_.T)\r\n RTR = np.dot(R.T,np.dot(np.eye(num_inducing) - Delta_tau/(1.+Delta_tau*Sigma_diag[i]) * np.dot(Rp_i,Rp_i.T),R))\r\n R = jitchol(RTR).T\r\n self.w[i] += (Delta_v - Delta_tau*self.w[i])*dii/dtd1\r\n self.Gamma += (Delta_v - Delta_tau*mu[i])*np.dot(RTR,P[i,:].T)\r\n RPT = np.dot(R,P.T)\r\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\r\n mu = self.w + np.dot(P,self.Gamma)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Iplus_Dprod_i = 1./(1.+ Diag0 * self.tau_tilde)\r\n Diag = Diag0 * Iplus_Dprod_i\r\n P = Iplus_Dprod_i[:,None] * P0\r\n safe_diag = np.where(Diag0 < self.tau_tilde, self.tau_tilde/(1.+Diag0*self.tau_tilde), (1. - Iplus_Dprod_i)/Diag0)\r\n L = jitchol(np.eye(num_inducing) + np.dot(RPT0,safe_diag[:,None]*RPT0.T))\r\n R,info = dtrtrs(L,R0,lower=1)\r\n RPT = np.dot(R,P.T)\r\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\r\n self.w = Diag * self.v_tilde\r\n self.Gamma = np.dot(R.T, np.dot(RPT,self.v_tilde))\r\n mu = self.w + np.dot(P,self.Gamma)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def ghosal_edge(img,Ks,thr=1,thrmax=0.995,lmin = 0.5,phimin=1.4,thresholding=True, debug=False):\n\ttotaltime = time.time()\n\tkerneltime = time.time()\n\t# Ks must be odd\n\tif Ks%2 != 1:\n\t\tprint(\"Ks must be odd! Continuing with Ks = Ks-1\")\n\t\tKs = Ks-1\n\t# define the rectangular kernels\n\t#Vc00 = np.zeros((Ks,Ks),dtype=complex)\n\tVc11 = np.zeros((Ks,Ks),dtype=complex)\n\tVc20 = np.zeros((Ks,Ks),dtype=complex)\n\tofs = 1 *(1-1/Ks) # offset for centering kernel around 0,0\n\tfor i in range(Ks):\n\t\tfor j in range(Ks):\n\t\t\tKx = 2*j/Ks-ofs # limits of integration between -1 and 1\n\t\t\tKy = 2*i/Ks-ofs\n\t\t\tif Kx**2+Ky**2 <= 1: # only a circle\n\t\t\t\t#Vc00[i,j] = 1 # the conjugate of V00\n\t\t\t\tVc11[i,j] = Kx-Ky*1j # ...\n\t\t\t\tVc20[i,j] = 2*Kx**2+2*Ky**2-1\n\tkerneltime = time.time() - kerneltime\n\t\n\t# Kernel Plots\n\t#\tVCplot = Vc00\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Vc11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Vc20\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\t# do the convolution with the images to get the zernike moments\n\tAnorm = lambda n : (n+1)/np.pi\t# a normalization value\n\tconvolvetime = time.time()\n\t#A00 = scig.convolve2d(img,Vc00,mode='same')\n\t#\tA11 = Anorm(1)*scig.convolve2d(img,Vc11,mode='same')\n\t#\tA20 = Anorm(2)*scig.convolve2d(img,Vc20,mode='same')\n\tA11 = Anorm(1)*scig.oaconvolve(img,Vc11,mode='same')\n\tA20 = Anorm(2)*scig.oaconvolve(img,Vc20,mode='same')\n\tconvolvetime = time.time() - convolvetime\n\t# Plot Zernike moments\n\t#\tVCplot = A00\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = A11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = A20\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\tparamstime = time.time()\n\t# calculate the edge paramters\n\t#\ttanphi = np.imag(A11)/np.real(A11)\n\t#\tphi = np.arctan(tanphi)\n\t#\tcosphi = np.cos(phi)\n\t#\tsinphi = cosphi*tanphi\n\t#\tAl11 = np.real(A11)*cosphi+np.imag(A11)*sinphi\n\t\n\tphi = np.arctan(np.imag(A11)/np.real(A11))\n\tAl11 = np.real(A11)*np.cos(phi)+np.imag(A11)*np.sin(phi)\n\t\n\t#\tAl11 = A11*np.exp(-phi*1j)\n\tl = A20/Al11 # A20 has no imaginary component so A20 = A'20\n\n\tk = 3*Al11/(2*(1-l**2)**(3/2))\n\tparamstime = time.time() - paramstime\n\t\n\t# Plot edge paramters\n\t#\tVCplot = phi\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real phi\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag phi\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Al11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A\\'11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A\\'11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = l\n\t#\tplt.pcolormesh(np.real(VCplot))#,vmin=-5,vmax=5\n\t#\tplt.title(\"real l\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot)) # ,vmin=-5,vmax=5\n\t#\tplt.title(\"imag l\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = k\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real k\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag k\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\t\n\ttreattime = time.time()\n\tif thresholding==True:\n\t\t# do the thresholding\n\t\tif (thrmax<0)&(thr>0):\n\t\t\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])\n\t\telif thrmax>0:\n\t\t\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])&(abs(k)<knorm[1])\n\t\telif thr<0:\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)\n\t\t\tknorm = np.sort(k[idx].flatten())[int(thr)]\n\t\t\tidx = idx&(abs(k)>abs(knorm))\n\t\tne = np.sum(idx)\n\telif thresholding==False:\n\t\traise ValueError(\"this option is not still uncer development\")\n\t\t# no thresholding\n\t\tidx = np.ones(np.shape(l),dtype=bool)\n\t\tne =np.sum(idx)\n\telse:\n\t\traise ValueError(\"thresholding should be boolean\")\n\t\n\t# put all detected points in a vector of (x,y) values\n\tedg = np.zeros((ne,2))\n\torg = np.zeros((ne,2))\n\tnx,ny = np.shape(img)\n\te = 0\n\tfor i in range(nx):\n\t\tfor j in range(ny):\n\t\t\tif idx[i,j]:\n\t\t\t\tedg[e]=np.array([i,j]) + l[i,j]*Ks/2*np.array(\n\t\t\t\t\t[np.sin(phi[i,j]),-np.cos(phi[i,j])])\n\t\t\t\torg[e]=np.array([i,j])\n\t\t\t\te +=1\n\ttreattime = time.time() - treattime\n\ttotaltime = time.time() - totaltime\n\tprint(\"total %0.5f\tconvolution %0.5f\tthresholding %0.5f\tparamters %0.5f\tkernel %0.5f\"%(totaltime,convolvetime,treattime,paramstime,kerneltime))\n\t\n\tif debug==True:\n\t\treturn edg, org, k, l, phi\n\telse:\n\t\treturn edg, org","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def spec_helm_decomp(k,Cu,Cv,GM=False):\n dk = k[1]-k[0]\n s = np.log(k)\n\n Fphi = np.zeros_like(Cu)\n Fpsi = np.zeros_like(Cu)\n Cphi = np.zeros_like(Cu)\n Cpsi = np.zeros_like(Cu)\n\n # assume GM for decomposing into wave and vortex\n if GM:\n gm = np.load(\"/Users/crocha/Projects/dp_spectra/GM/gm_omega_star.npz\")\n f2omg2 = gm['rgm']\n ks = gm['k']*1.e3\n\n for i in range(s.size-1):\n\n ds = np.diff(s[i:])\n\n sh = sinh(s[i]-s[i:])\n ch = cosh(s[i]-s[i:])\n\n # the function to integrate\n Fp = Cu[i:]*sh + Cv[i:]*ch\n Fs = Cv[i:]*sh + Cu[i:]*ch\n\n # integrate using Simpson's rule\n Fpsi[i] = integrate.simps(Fs,s[i:])\n Fphi[i] = integrate.simps(Fp,s[i:])\n\n # zero out unphysical values\n Fpsi[Fpsi < 0.] = 0.\n Fphi[Fphi < 0.] = 0.\n\n # compute rotational and divergent components\n Cpsi = Fpsi - Fphi + Cu\n Cphi = Fphi - Fpsi + Cv\n\n if GM:\n\n f2omg2i = np.interp(k,ks,f2omg2)\n\n Cv_w = f2omg2i*Fphi - Fpsi + Cv\n Cv_v = Cv - Cv_w\n \n kdkromg = diff_central(ks, f2omg2)\n kdkromg = np.interp(k,ks[1:-1],kdkromg)\n\n dFphi = diff_central(k, Fphi)\n #dFphi = np.gradient(Fphi,k)\n dFphi = np.interp(k,k[1:-1],dFphi.real)\n E_w = Fphi - k*dFphi\n\n Cu_w = -k*kdkromg*Fphi + f2omg2i*(-Fpsi+Cv) + Fphi\n Cu_v = Cu - Cu_w\n\n Cb_w = E_w - (Cu_w + Cv_w)/2.\n\n return Cpsi,Cphi, Cu_w,Cv_w, Cu_v,Cv_v, E_w, Cb_w\n\n else:\n return Cpsi,Cphi","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def tuto_kernel_overview(optimize=True, plot=True):\r\n ker1 = GPy.kern.rbf(1) # Equivalent to ker1 = GPy.kern.rbf(input_dim=1, variance=1., lengthscale=1.)\r\n ker2 = GPy.kern.rbf(input_dim=1, variance = .75, lengthscale=2.)\r\n ker3 = GPy.kern.rbf(1, .5, .5)\r\n\r\n print ker2\r\n\r\n if plot:\r\n ker1.plot()\r\n ker2.plot()\r\n ker3.plot()\r\n\r\n k1 = GPy.kern.rbf(1,1.,2.)\r\n k2 = GPy.kern.Matern32(1, 0.5, 0.2)\r\n\r\n # Product of kernels\r\n k_prod = k1.prod(k2) # By default, tensor=False\r\n k_prodtens = k1.prod(k2,tensor=True)\r\n\r\n # Sum of kernels\r\n k_add = k1.add(k2) # By default, tensor=False\r\n k_addtens = k1.add(k2,tensor=True)\r\n\r\n k1 = GPy.kern.rbf(1,1.,2)\r\n k2 = GPy.kern.periodic_Matern52(1,variance=1e3, lengthscale=1, period = 1.5, lower=-5., upper = 5)\r\n\r\n k = k1 * k2 # equivalent to k = k1.prod(k2)\r\n print k\r\n\r\n # Simulate sample paths\r\n X = np.linspace(-5,5,501)[:,None]\r\n Y = np.random.multivariate_normal(np.zeros(501),k.K(X),1)\r\n\r\n k1 = GPy.kern.rbf(1)\r\n k2 = GPy.kern.Matern32(1)\r\n k3 = GPy.kern.white(1)\r\n\r\n k = k1 + k2 + k3\r\n print k\r\n\r\n k.constrain_positive('.*var')\r\n k.constrain_fixed(np.array([1]),1.75)\r\n k.tie_params('.*len')\r\n k.unconstrain('white')\r\n k.constrain_bounded('white',lower=1e-5,upper=.5)\r\n print k\r\n\r\n k_cst = GPy.kern.bias(1,variance=1.)\r\n k_mat = GPy.kern.Matern52(1,variance=1., lengthscale=3)\r\n Kanova = (k_cst + k_mat).prod(k_cst + k_mat,tensor=True)\r\n print Kanova\r\n\r\n # sample inputs and outputs\r\n X = np.random.uniform(-3.,3.,(40,2))\r\n Y = 0.5*X[:,:1] + 0.5*X[:,1:] + 2*np.sin(X[:,:1]) * np.sin(X[:,1:])\r\n\r\n # Create GP regression model\r\n m = GPy.models.GPRegression(X, Y, Kanova)\r\n\r\n if plot:\r\n fig = pb.figure(figsize=(5,5))\r\n ax = fig.add_subplot(111)\r\n m.plot(ax=ax)\r\n\r\n pb.figure(figsize=(20,3))\r\n pb.subplots_adjust(wspace=0.5)\r\n axs = pb.subplot(1,5,1)\r\n m.plot(ax=axs)\r\n pb.subplot(1,5,2)\r\n pb.ylabel(\"= \",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,3)\r\n m.plot(ax=axs, which_parts=[False,True,False,False])\r\n pb.ylabel(\"cst +\",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,4)\r\n m.plot(ax=axs, which_parts=[False,False,True,False])\r\n pb.ylabel(\"+ \",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,5)\r\n pb.ylabel(\"+ \",rotation='horizontal',fontsize='30')\r\n m.plot(ax=axs, which_parts=[False,False,False,True])\r\n\r\n return(m)","def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\n # get activation for each seperated vc\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\n max_ch_index = max_ch_index.view(-1, L) # n, L\n\n all_activation_vcs = []\n\n for i in range(len(integrate_activation_vc)):\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\n all_activation_vcs.append(integrate_activation_vc_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n print(f\"unique_vc_i {unique_vc_i.shape}\")\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\n activate_vc_i[index_vc_i, :] = 0.\n all_activation_vcs.append(activate_vc_i)\n \n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\n \n # decompose each mask \n all_masks = []\n for i in range(len(sim_map_max)):\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\n all_masks.append(sim_map_max_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\n vc_sim_map_max_i[index_vc_i] = 0.\n all_masks.append(vc_sim_map_max_i)\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\n\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\"\n\n return all_activation_vcs, all_masks","def error_specific_heat(Cv):\n ncv = 10\n tcv = np.linspace(0,50,ncv) \n \n chi = auto_correlation(tcv,Cv,ncv)\n tau_fit = curve_fit(exp,tcv,chi)\n tau = tau_fit[0]\n\n error_Cv = error(tau,ncv,Cv,tcv) \n\n return error_Cv","def ALIGNF(km_list, ky):\n n_feat = len(km_list)\n\n #km_list_copy = []\n # center the kernel first\n #for i in range(n_feat):\n # km_list_copy.append(center(km_list[i].copy()))\n #ky_copy = center(ky.copy())\n\n\n a = np.zeros(n_feat)\n for i in range(n_feat):\n a[i] = f_dot(km_list[i], ky)\n\n M = np.zeros((n_feat, n_feat))\n for i in range(n_feat):\n for j in range(i,n_feat):\n M[i,j] = f_dot(km_list[i],km_list[j])\n M[j,i] = M[i,j]\n\n Q = 2*M\n C = -2*a\n\n Q = Q + np.diag(np.ones(n_feat)*1e-8)\n\n ################################################\n # Using mosek to solve the quadratice programming\n\n # Set upper diagonal element to zeros, mosek only accept lower triangle\n iu = np.triu_indices(n_feat,1)\n Q[iu] = 0\n\n # start solving with mosek\n inf = 0.0\n env = mosek.Env()\n env.set_Stream(mosek.streamtype.log, streamprinter)\n\n # Create a task \n task = env.Task()\n task.set_Stream(mosek.streamtype.log, streamprinter)\n\n # Set up bound for variables \n bkx = [mosek.boundkey.lo]* n_feat\n blx = [0.0] * n_feat\n #bkx = [mosek.boundkey.fr]* n_feat\n #blx = [-inf] * n_feat\n bux = [+inf] * n_feat\n\n numvar = len(bkx)\n\n task.appendvars(numvar)\n\n for j in range(numvar):\n task.putcj(j,C[j])\n task.putvarbound(j,bkx[j],blx[j],bux[j])\n\n # Set up quadratic objective \n inds = np.nonzero(Q)\n qsubi = inds[0].tolist()\n qsubj = inds[1].tolist()\n qval = Q[inds].tolist()\n\n # Input quadratic objective \n task.putqobj(qsubi,qsubj,qval)\n\n # Input objective sense (minimize/mximize) \n task.putobjsense(mosek.objsense.minimize)\n\n task.optimize()\n\n # Print a summary containing information \n # about the solution for debugging purposes \n task.solutionsummary(mosek.streamtype.msg)\n\n solsta = task.getsolsta(mosek.soltype.itr)\n if (solsta == mosek.solsta.optimal or\n solsta == mosek.solsta.near_optimal):\n # Output a solution \n xx = np.zeros(numvar, float)\n task.getxx(mosek.soltype.itr, xx)\n #xx = xx/np.linalg.norm(xx)\n return xx\n else:\n print solsta\n xx = np.zeros(numvar, float)\n task.getxx(mosek.soltype.itr, xx)\n #xx = xx/np.linalg.norm(xx)\n return xx","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\n \n # INPUTS FROM TTTW SYSTEM\n self.b = b #buoyancy field: [Ly,N]\n self.u = u # x-component of velocity [Ly,N]\n self.v = v # y-component of velocity [Ly+1,N]\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\n self.grid_dict = grid_dict #gridded data\n self.f = f #coriolis parameter\n # KPP-SPECIFIC VARIABLES \n self.hbls = np.zeros([self.b.shape[0]])\n self.hbbl = np.zeros([self.b.shape[0]])\n self.ustar = []\n self.bvf = [] \n self.kmo = []\n self.C_h_MO = []\n self.kbl = []\n self.Cr = [] \n self.Fc = []\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\n self.dt = dt","def grid_visibilities_parallel(self, visibilities,min_attenuation = 1e-10, N = 120):\n\n #Find out the number of frequencies to process per thread\n nfreq = len(self.frequencies)\n numperthread = int(np.ceil(nfreq/self.n_obs))\n offset = 0\n nfreqstart = np.zeros(self.n_obs,dtype=int)\n nfreqend = np.zeros(self.n_obs,dtype=int)\n infreq = np.zeros(self.n_obs,dtype=int)\n for i in range(self.n_obs):\n nfreqstart[i] = offset\n nfreqend[i] = offset + numperthread\n\n if(i==self.n_obs-1):\n infreq[i] = nfreq - offset\n else:\n infreq[i] = numperthread\n\n offset+=numperthread\n\n # Set the last process to the number of frequencies\n nfreqend[-1] = nfreq\n\n processes = []\n\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\n \n centres = (ugrid[1:] + ugrid[:-1]) / 2\n \n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\n\n\n if(os.path.exists(self.datafile[0][:-4]+\".kernel_weights.npy\")):\n kernel_weights = np.load(self.datafile[0][:-4]+\".kernel_weights.npy\")\n else:\n kernel_weights=None\n \n if kernel_weights is None:\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\n\n visgrid_buff_real = []\n visgrid_buff_imag = []\n weights_buff = []\n\n #Lets split this array up into chunks\n for i in range(self.n_obs):\n\n visgrid_buff_real.append(multiprocessing.RawArray(np.sctype2char(visgrid.real),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\n visgrid_buff_imag.append(multiprocessing.RawArray(np.sctype2char(visgrid.imag),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\n visgrid_tmp_real = np.frombuffer(visgrid_buff_real[i])\n visgrid_tmp_imag = np.frombuffer(visgrid_buff_imag[i])\n visgrid_tmp_real = visgrid[:,:,nfreqstart[i]:nfreqend[i]].real.flatten()\n visgrid_tmp_imag = visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag.flatten()\n\n\n if(kernel_weights is None):\n weights_buff.append(multiprocessing.RawArray(np.sctype2char(weights),weights[:,:,nfreqstart[i]:nfreqend[i]].size))\n weights_tmp = np.frombuffer(weights_buff[i])\n weights_tmp = weights[:,:,nfreqstart[i]:nfreqend[i]]\n else:\n weights_buff.append(None)\n\n processes.append(multiprocessing.Process(target=self._grid_visibilities_buff,args=(self.n_uv,visgrid_buff_real[i],visgrid_buff_imag[i],weights_buff[i], visibilities[:,nfreqstart[i]:nfreqend[i]],self.frequencies[nfreqstart[i]:nfreqend[i]],self.baselines,centres,self._instr_core.sigma(self.frequencies[nfreqstart[i]:nfreqend[i]]),min_attenuation, N) ))\n\n for p in processes:\n p.start()\n\n for p in processes:\n p.join()\n\n for i in range(self.n_obs):\n\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].real = np.frombuffer(visgrid_buff_real[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag = np.frombuffer(visgrid_buff_imag[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n\n if(kernel_weights is None):\n weights[:,:,nfreqstart[i]:nfreqend[i]] = np.frombuffer(weights_buff[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n\n if kernel_weights is None:\n kernel_weights = weights\n \n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\n\n return visgrid,kernel_weights","def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\n pi, ids = induced_distribution(hmsm, 0, level)\n\n discrete_free_energy = np.ndarray(pi.shape)\n for i, id in enumerate(ids):\n discrete_free_energy[i] = \\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\n boltzmann = np.exp(-discrete_free_energy/kT)\n boltzmann *= (1/np.sum(boltzmann))\n return D_KL(boltzmann, pi)","def Boltzchoice(LFnum, energylist, RNs):\n # transform list to energy values in kT according to experimental\n # affinities and the energy window allowed by the threshold\n energylist = cf.y0 + np.array(energylist) * cf.m\n # calculate norm of initial list\n Norm = sum([math.exp(-ener) for ener in energylist])\n # calculate initial probability vector\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\n # list to catch indices of selected cells\n selected = []\n # cells to be picked: determined by the lesser of #waiters and #LFs\n cellpick = min(len(energylist), LFnum)\n while len(selected) < cellpick:\n bins = np.cumsum(probs)\n ind = np.digitize(RNs.getR(), bins)\n selected.append(ind)\n # now, set the probability of the selected cell to 0 and renormalise\n # the remaining probability vector\n newNorm = Norm - math.exp(-energylist[ind])\n probs[ind] = 0\n probs = probs * Norm / newNorm\n Norm = newNorm\n\n return selected","def fit_FITC(self, Kmm, Kmn, Knn_diag, epsilon=1e-3,power_ep=[1.,1.]):\r\n self.epsilon = epsilon\r\n self.eta, self.delta = power_ep\r\n\r\n num_inducing = Kmm.shape[0]\r\n\r\n \"\"\"\r\n Prior approximation parameters:\r\n q(f|X) = int_{df}{N(f|KfuKuu_invu,diag(Kff-Qff)*N(u|0,Kuu)} = N(f|0,Sigma0)\r\n Sigma0 = diag(Knn-Qnn) + Qnn, Qnn = Knm*Kmmi*Kmn\r\n \"\"\"\r\n Lm = jitchol(Kmm)\r\n Lmi = chol_inv(Lm)\r\n Kmmi = np.dot(Lmi.T,Lmi)\r\n P0 = Kmn.T\r\n KmnKnm = np.dot(P0.T, P0)\r\n KmmiKmn = np.dot(Kmmi,P0.T)\r\n Qnn_diag = np.sum(P0.T*KmmiKmn,-2)\r\n Diag0 = Knn_diag - Qnn_diag\r\n R0 = jitchol(Kmmi).T\r\n\r\n \"\"\"\r\n Posterior approximation: q(f|y) = N(f| mu, Sigma)\r\n Sigma = Diag + P*R.T*R*P.T + K\r\n mu = w + P*Gamma\r\n \"\"\"\r\n self.w = np.zeros(self.num_data)\r\n self.Gamma = np.zeros(num_inducing)\r\n mu = np.zeros(self.num_data)\r\n P = P0.copy()\r\n R = R0.copy()\r\n Diag = Diag0.copy()\r\n Sigma_diag = Knn_diag\r\n RPT0 = np.dot(R0,P0.T)\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(g|mu_,sigma2_) = Product{q_i(g|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.num_data,dtype=float)\r\n self.v_ = np.empty(self.num_data,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.num_data,dtype=float)\r\n self.Z_hat = np.empty(self.num_data,dtype=float)\r\n phi = np.empty(self.num_data,dtype=float)\r\n mu_hat = np.empty(self.num_data,dtype=float)\r\n sigma2_hat = np.empty(self.num_data,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = 1\r\n epsilon_np2 = 1\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.num_data)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma_diag[i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma_diag[i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model.moments_match(self.data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma_diag[i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma_diag[i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n dtd1 = Delta_tau*Diag[i] + 1.\r\n dii = Diag[i]\r\n Diag[i] = dii - (Delta_tau * dii**2.)/dtd1\r\n pi_ = P[i,:].reshape(1,num_inducing)\r\n P[i,:] = pi_ - (Delta_tau*dii)/dtd1 * pi_\r\n Rp_i = np.dot(R,pi_.T)\r\n RTR = np.dot(R.T,np.dot(np.eye(num_inducing) - Delta_tau/(1.+Delta_tau*Sigma_diag[i]) * np.dot(Rp_i,Rp_i.T),R))\r\n R = jitchol(RTR).T\r\n self.w[i] += (Delta_v - Delta_tau*self.w[i])*dii/dtd1\r\n self.Gamma += (Delta_v - Delta_tau*mu[i])*np.dot(RTR,P[i,:].T)\r\n RPT = np.dot(R,P.T)\r\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\r\n mu = self.w + np.dot(P,self.Gamma)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Iplus_Dprod_i = 1./(1.+ Diag0 * self.tau_tilde)\r\n Diag = Diag0 * Iplus_Dprod_i\r\n P = Iplus_Dprod_i[:,None] * P0\r\n safe_diag = np.where(Diag0 < self.tau_tilde, self.tau_tilde/(1.+Diag0*self.tau_tilde), (1. - Iplus_Dprod_i)/Diag0)\r\n L = jitchol(np.eye(num_inducing) + np.dot(RPT0,safe_diag[:,None]*RPT0.T))\r\n R,info = dtrtrs(L,R0,lower=1)\r\n RPT = np.dot(R,P.T)\r\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\r\n self.w = Diag * self.v_tilde\r\n self.Gamma = np.dot(R.T, np.dot(RPT,self.v_tilde))\r\n mu = self.w + np.dot(P,self.Gamma)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.num_data\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.num_data\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def attach_to_controller(self, controller):\r\n\r\n def cv_amp(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n return np.std(amps) / np.mean(amps) if len(amps) >= 1 else 0\r\n\r\n def cum_amp_drift(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n # return cum_feat(amps) if len(amps) >= 2 else 0\r\n return np.sum(np.abs(np.diff(amps))) / len(amps) if len(amps) >= 2 else 0\r\n\r\n def cum_depth_drift(cluster_id):\r\n depths = controller.model.spike_depths[controller.get_spike_ids(cluster_id)].data\r\n # return cum_feat(depths) if len(depths) >= 2 else 0\r\n return np.sum(np.abs(np.diff(depths))) / len(depths) if len(depths) >= 2 else 0\r\n\r\n def cv_fr(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n fr = bb.singlecell.firing_rate(ts, hist_win=0.01, fr_win=0.25)\r\n return np.std(fr) / np.mean(fr) if len(fr) >= 1 else 0\r\n\r\n def frac_isi_viol(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n frac_isi_viol, _, _ = isi_viol(ts, rp=0.002)\r\n return frac_isi_viol\r\n\r\n def frac_missing_spikes(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n try:\r\n frac_missing_spks, _, _ = feat_cutoff(\r\n amps, spks_per_bin=10, sigma=4, min_num_bins=50)\r\n except:\r\n frac_missing_spks = np.NAN\r\n return frac_missing_spks\r\n\r\n def fp_estimate(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n return fp_est(ts, rp=0.002)\r\n\r\n def presence_ratio(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n pr, _ = pres_ratio(ts, hist_win=10)\r\n return pr\r\n\r\n def presence_ratio_std(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n pr, pr_bins = pres_ratio(ts, hist_win=10)\r\n return pr / np.std(pr_bins)\r\n\r\n def refp_viol(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n return FP_RP(ts)\r\n\r\n def n_cutoff(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n return noise_cutoff(amps, quartile_length=.25)\r\n\r\n def mean_amp_true(cluster_id):\r\n # Three cases: raw data\r\n\r\n # THIS APPROACH WORKS FOR BOTH SAMPLE WAVEFORMS AND RAW DATA\r\n # Specify 100 waveforms to average over, but may be less in the case where in the subset\r\n # of sample waveforms it doesn't contain 100 samples for specific cluster\r\n\r\n # N.B. These waveforms are median subtracted and have a high pass applied\r\n waveforms = controller._get_waveforms_with_n_spikes(\r\n cluster_id, 100)['data'].data\r\n\r\n # This way finds (max-min) on each channel, and then for each waveform finds the\r\n # maximum (max-min) on any channel and averages these\r\n # For each sample waveform find value on channel that has largest (max-min)\r\n p2p = np.max((np.max(waveforms, axis=1) - np.min(waveforms, axis=1)), axis=1)\r\n # Find mean p2p across all available sample waveforms\r\n p2p_mean = np.mean(p2p)\r\n\r\n # Alternative way\r\n # This way finds (max-min) on each channel, on each channel averages across all sample\r\n # waveforms and then finds the channel with the maximum average value\r\n p2p_mean_alt = np.max(np.mean(np.max(waveforms, axis=1) - np.min(waveforms, axis=1),\r\n axis=0))\r\n\r\n # Approach 2\r\n # Only works for sample waveforms\r\n # For non median subtracted and no high pass can access sample waveforms like this\r\n # spike_ids = controller.get_spike_ids(cluster_id).data\r\n # # Find which of the spike ids are in the subset of sample waveforms\r\n # _, _, idx = np.intersect1d(spike_ids,\r\n # controller.model.spike_waveforms['spike_ids'].data,\r\n # return_indices=True)\r\n # # Sample waveforms that are available for this cluster\r\n # # Shape of waveforms (n_waveforms, n_samples, n_channels)\r\n # # where len(idx) == n_waveforms\r\n # waveforms = controller.model.spike_waveforms['waveforms'][idx].data\r\n\r\n # RAW DATA CASE\r\n\r\n return p2p_mean\r\n\r\n # no waveforms\r\n\r\n # def ptp_sigma(cluster_id):\r\n # this also requires checking 3 cases above.\r\n\r\n def m_label(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n amps = controller.get_amplitudes(cluster_id).data\r\n metrics_label = int(FP_RP(ts) and noise_cutoff(amps, quartile_length=.25) < 20)\r\n return metrics_label\r\n # if amplitudes are correct (i.e. raw data or sample wfs exist):\r\n #metrics_label = (FP_RP(ts) and noise_cutoff(amps,quartile_length=.25)<20 and np.mean(amps)>50)\r\n\r\n # Use this dictionary to define custom cluster metrics.\r\n # We memcache the function so that cluster metrics are only computed once and saved\r\n # within the session, and also between sessions (the memcached values are also saved\r\n # on disk).\r\n controller.cluster_metrics['cv_amp'] = controller.context.memcache(cv_amp)\r\n controller.cluster_metrics['cum_amp_drift'] = controller.context.memcache(cum_amp_drift)\r\n\r\n # NOTE: the branch of phylib which defines model.spike_depths is not working yet\r\n # controller.cluster_metrics['cum_depth_drift'] = controller.context.memcache(\r\n # cum_depth_drift)\r\n\r\n controller.cluster_metrics['cv_fr'] = controller.context.memcache(cv_fr)\r\n controller.cluster_metrics['frac_isi_viol'] = controller.context.memcache(frac_isi_viol)\r\n controller.cluster_metrics['frac_missing_spikes'] = controller.context.memcache(\r\n frac_missing_spikes)\r\n controller.cluster_metrics['fp_estimate'] = controller.context.memcache(fp_estimate)\r\n controller.cluster_metrics['presence_ratio'] = controller.context.memcache(presence_ratio)\r\n controller.cluster_metrics['presence_ratio_std'] = controller.context.memcache(\r\n presence_ratio_std)\r\n controller.cluster_metrics['refp_viol'] = controller.context.memcache(refp_viol)\r\n controller.cluster_metrics['noise_cutoff'] = controller.context.memcache(n_cutoff)\r\n controller.cluster_metrics['mean_amp'] = controller.context.memcache(mean_amp_true)\r\n controller.cluster_metrics['metrics_label'] = controller.context.memcache(m_label)","def hcn_kn(Y,t,voltage_clamp_func,voltage_clamp_params):\n\n v = voltage_clamp_func(t,voltage_clamp_params)\n n_s = Y[0]\n n_f = Y[1]\n\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\n ninf_f = ninf_s\n\n if v > -70.0:\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\n else:\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\n\n dns = (ninf_s - n_s)/tau_ns\n dnf = (ninf_f - n_f)/tau_nf\n\n return [dns, dnf]","def WakeVorticityFromCirculation_Cont(r_cp,Gamma_cp,R,U0,Omega,bSwirl,method='analytical',bHighThrustCorr=True):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cp[0]==0:\n r_cp[0]=r_cp[1]*0.5;\n # Non dimensional parameters\n k = Omega*Gamma_cp/(np.pi*U0**2)\n vr_bar = r_cp/R \n lambda_r = Omega*r_cp/U0\n # Finding inductions\n a,a_prime,misc= InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method=method,bHighThrustCorr=bHighThrustCorr)\n # Computing convection\n misc['Vz'] = U0*(1-2*a)\n misc['h'] = misc['Vz']*2*np.pi/(Omega*(1+2*a_prime))\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n # Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n gamma_t = - Gamma_tilde/misc['h']\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = 0\n Gamma_r = 0\n return gamma_t,gamma_l,Gamma_r,misc","def HKS(evals,evects, time_list,scaled=False):\n evals_s = np.asarray(evals).flatten()\n t_list = np.asarray(time_list).flatten()\n\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\n\n if scaled:\n inv_scaling = coefs.sum(1) # (num_T)\n return (1/inv_scaling)[None,:] * natural_HKS\n\n else:\n return natural_HKS","def hcn_tf(Y,t,voltage_clamp_func,voltage_clamp_params):\n \n v = voltage_clamp_func(t,voltage_clamp_params)\n n_s = Y[0]\n n_f = Y[1]\n \n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\n ninf_f = ninf_s\n\n if v > -70.0:\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\n else:\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\n\n dns = (ninf_s - n_s)/tau_ns\n dnf = (ninf_f - n_f)/tau_nf\n \n return [dns, dnf]","def model(**params):\n N_frb = 0\n vs = []\n hs = []\n cs = []\n ncands = []\n\n for cand in candlist:\n c_res = calculate_metric_terms(\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\n )\n t, frb_found, h, c, v = c_res\n vs.append(v)\n hs.append(h)\n cs.append(c)\n ncands.append(t)\n\n if frb_found:\n N_frb += 1\n\n vs = np.array(vs)\n hs = np.array(hs)\n cs = np.array(cs)\n c_avg = np.average(cs, axis=0, weights=ncands)\n h_avg = np.average(hs, axis=0, weights=ncands)\n v_avg = np.average(vs, axis=0, weights=ncands)\n recall = N_frb / len(vs)\n score = v_avg * recall\n\n return score","def grid_visibilities(self, visibilities, N = 120):\n logger.info(\"Gridding the visibilities\")\n\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\n\n centres = (ugrid[1:] + ugrid[:-1]) / 2\n\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\n\n if(os.path.exists(self.datafile[0][:-4]+\".kernel_weights.npy\")):\n kernel_weights = np.load(self.datafile[0][:-4]+\".kernel_weights.npy\")\n else:\n kernel_weights=None\n\n if kernel_weights is None:\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\n\n for jj, freq in enumerate(self.frequencies):\n u_bl = (self.baselines[:,0] * freq / const.c).value\n v_bl = (self.baselines[:,1] * freq / const.c).value\n\n beam, indx_u, indx_v = self.fourierBeam(centres, u_bl, v_bl, freq, N=N)\n for kk in range(len(indx_u)):\n visgrid[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk]) * visibilities[kk,jj]\n\n if kernel_weights is None:\n weights[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk])\n\n if kernel_weights is None:\n kernel_weights = weights\n\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\n\n return visgrid,kernel_weights","def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \n N_res=30):\n x_eps = 0.3 # shift from Dirac point\n x_res = 20\n kx_int = 0 + x_eps # -np.pi\n kx_fin = 4*np.pi/3 + x_eps\n Dx = (kx_fin - kx_int)/x_res\n\n y_res = 20\n ky_int = 0 # -np.pi\n ky_fin = 2*np.pi/np.sqrt(3)\n Dy = (ky_fin - ky_int)/y_res\n\n Nd = self.Nd # dimension of the Hamiltonian\n Dk = np.array([Dx,Dy], float)\n\n LF = np.zeros((Nd), dtype=complex)\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n sumN = np.zeros((Nd), dtype=complex)\n E_k = np.zeros((Nd), dtype=complex)\n chernN = np.zeros((Nd), dtype=complex)\n\n # Loop over kx\n for ix in range(x_res):\n kx = kx_int + ix*Dx\n\n # Loop over ky\n for iy in range(y_res):\n ky = ky_int + iy*Dy\n\n k_vec = np.array([kx,ky], float)\n\n LF, E_k = self.latF(k_vec, Dk, self.delta)\n\n sumN += LF\n\n # # save data for plotting\n LF_arr[:,ix,iy] = LF.imag\n\n E_arr[:,ix,iy] = np.sort(E_k.real)\n\n # End of ky Loop\n # End of kx Loop\n\n chernN = sumN.imag/(2*np.pi)\n print(\"Chern number bands are (%.3f, %.3f) \" \n %(chernN[0], chernN[1]))\n print(\"Sum of all bands Chern Number is %.2f \" %(sum(chernN)))\n return chernN, E_arr\n #################### ","def set_kbest_features_list(data_dict, features_list):\n \n print \" --- \"\n\n k_best = get_k_best(data_dict,features_list,len(features_list)-1)\n \n ### Sort the k_best features in descending order\n arr_features = []\n print \"sorted k_best:\"\n for key, value in sorted(k_best.iteritems(), key=lambda (k,v): (v,k), reverse=True):\n print \"%s: %s\" % (key, value)\n arr_features.append(key)\n\n print \"---\"\n poi = [\"poi\"]\n features_list = poi\n features_list += arr_features\n\n print \"---\"\n print \"features List: \"\n print features_list\n print(\"Number of features in k_best: \",len(features_list))\n print \" \"\n\n return features_list","def vote_for_k(utilities, k):\n utilities = np.asarray(utilities)\n n_cands = utilities.shape[1]\n if k == 'half':\n # \"It is interesting to observe that the vote-for-k and vote-for-(n-k)\n # voting systems are equally effective.\"\n # So for 7 candidates, we could use either k=4 or k=3 (= 7//2)\n # TODO: Though this seems only true with infinite voters?\n k = n_cands // 2\n elif -n_cands < k < 0:\n k = n_cands + k\n elif not 0 < k < n_cands:\n raise ValueError(f'k of {k} not possible with {n_cands} candidates')\n\n # Efficiently get indices of top k candidates for each voter\n # https://stackoverflow.com/a/23734295/125507\n # TODO: How are tied utilities handled, such as top 2 with 3 tied? Random?\n top_k = np.argpartition(utilities, -k, axis=1)[:, -k:]\n\n # Create blank ballots\n approvals = np.zeros(utilities.shape, np.uint8)\n\n # Fill in approvals\n # TODO: Not sure if this is the most efficient way\n approvals[np.arange(len(approvals))[:, np.newaxis], top_k] = 1\n return approvals","def estimate_opt_eff(self, iv_fn_hot, iv_fn_cold,t_hot=293.,t_cold=77.,\n channels = None, dPdT_lim=(0.,0.5)):\n ivs_hot = np.load(iv_fn_hot).item()\n ivs_cold = np.load(iv_fn_cold).item()\n \n iv_fn_raw_hot = iv_fn_hot.split('.')[0] + '_raw_data.npy'\n iv_fn_raw_cold = iv_fn_cold.split('.')[0] + '_raw_data.npy'\n\n ivs_raw_hot = np.load(iv_fn_raw_hot).item()\n ivs_raw_cold = np.load(iv_fn_raw_cold).item()\n \n basename_hot = ivs_raw_hot['basename']\n basename_cold = ivs_raw_cold['basename']\n\n #band = ivs_raw_hot['band']\n #assert ivs_raw_cold['band'] == band, \\\n # 'Files must contain IVs from the same band'\n group = ivs_raw_hot['bias group']\n assert ivs_raw_cold['bias group'], \\\n 'Files must contain IVs from the same bias group'\n \n import matplotlib.pyplot as plt\n plot_dir = self.plot_dir\n\n dT = t_hot - t_cold\n dPdT_list = []\n n_outliers = 0\n for ch in ivs_hot:\n if channels is not None:\n if ch not in channels:\n continue\n elif not isinstance(ch,np.int64):\n continue\n \n if ch not in ivs_cold:\n continue\n \n P_hot = ivs_hot[ch]['P']\n P_cold = ivs_cold[ch]['P']\n R_hot = ivs_hot[ch]['R']\n R_cold = ivs_cold[ch]['R']\n Ptrans_hot = ivs_hot[ch]['Ptrans']\n Ptrans_cold = ivs_cold[ch]['Ptrans']\n if Ptrans_hot is None or Ptrans_cold is None:\n print('Missing in-transition electrical powers for Ch. %i' % (ch))\n continue\n dPdT = (Ptrans_cold - Ptrans_hot)/dT\n self.log('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\n if dPdT_lim is not None:\n if dPdT >= dPdT_lim[0] and dPdT <= dPdT_lim[1]:\n dPdT_list.append(dPdT)\n else:\n n_outliers += 1\n else:\n dPdT_list.append(dPdT)\n\n fig_pr,ax_pr = plt.subplots(1,sharex=True)\n ax_pr.set_xlabel(r'$R_\\mathrm{TES}$ [$\\Omega$]')\n ax_pr.set_ylabel(r'$P_\\mathrm{TES}$ [pW]')\n label_hot = '%s: %.0f K' % (basename_hot,t_hot)\n label_cold = '%s: %.0f K' % (basename_cold,t_cold)\n ax_pr.axhline(y=Ptrans_hot,linestyle = '--',color = 'b')\n ax_pr.axhline(y=Ptrans_cold,linestyle = '--',color = 'r')\n ax_pr.plot(R_hot,P_hot,label=label_hot,color='b')\n ax_pr.plot(R_cold,P_cold,label=label_cold,color='r')\n ax_pr.legend(loc='best')\n fig_pr.suptitle('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\n ax_pr.grid()\n \n plot_name = basename_hot + '_' + basename_cold + '_optEff_g{}_ch{:03}.png'.format(group, ch)\n plot_filename = os.path.join(plot_dir, plot_name)\n self.log('Saving optical-efficiency plot to {}'.format(plot_filename))\n plt.savefig(plot_filename,bbox_inches='tight', dpi=300)\n plt.close()\n\n plt.figure()\n plt.hist(dPdT_list,edgecolor='k')\n plt.xlabel('dP/dT [pW/K]')\n plt.grid()\n dPdT_median = np.median(dPdT_list)\n plt.title('Group {}, median = {:.3f} pW/K ({} outliers not plotted)'.format(group,dPdT_median,n_outliers))\n plot_name = basename_hot + '_' + basename_cold + '_dPdT_hist_g{}.png'.format(group)\n hist_filename = os.path.join(plot_dir,plot_name)\n self.log('Saving optical-efficiency histogram to {}'.format(hist_filename))\n plt.savefig(hist_filename,bbox_inches='tight',dpi=300)\n plt.close()","def define_pseudo_potts_helper_functions(n, k):\n\n assert n>1\n assert k>1\n\n @njit\n def get_multipliers_r(r, multipliers, n=n, k=k):\n \"\"\"Return r's field and all couplings to spin r.\n\n Parameters\n ----------\n r : int\n multipliers : ndarray\n All fields and couplings concatenated together.\n\n Returns\n -------\n ndarray\n Relevant multipliers.\n list\n Index of where multipliers appear in full multipliers array.\n \"\"\"\n \n ix = [r+n*i for i in range(k)]\n multipliersr = np.zeros(k-1+n)\n for i in range(k):\n multipliersr[i] = multipliers[r+n*i]\n\n # fill in the couplings\n ixcounter = k\n for i in range(n):\n if i!=r:\n if i<r:\n ix.append( sub_to_ind(n, i, r) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n else:\n ix.append( sub_to_ind(n, r, i) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n ixcounter += 1\n return multipliersr, ix\n\n @njit\n def calc_observables_r(r, X, n=n, k=k):\n \"\"\"Return the observables relevant for calculating the conditional probability of\n spin r.\n\n Parameters\n ----------\n r : int\n Spin index.\n X : ndarray\n Data samples of dimensions (n_samples, n_dim).\n\n Returns\n -------\n ndarray\n observables\n list of ndarray\n observables if spin r were to occupy all other possible states\n ndarray\n Each col details the occupied by spin r in each array of the previous return\n value, i.e., the first col of this array tells me what r has been changed to\n in the first array in the above list.\n \"\"\"\n\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n # keep another copy of observables where the spin iterates thru all other possible states\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n for i in range(k-1)]\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\n \n # for each data sample in X\n for rowix in range(X.shape[0]):\n counter = 0\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\n for i in range(k):\n if X[rowix,r]==i:\n obs[rowix,i] = 1\n else:\n otherobs[counter][rowix,i] = 1\n otherstates[rowix,counter] = i\n counter += 1\n ixcounter = k\n \n for i in range(n-1):\n for j in range(i+1,n):\n if i==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\n kcounter += 1\n ixcounter += 1\n elif j==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\n kcounter += 1\n ixcounter += 1\n return obs, otherobs, otherstates\n\n return get_multipliers_r, calc_observables_r","def model(cp_list,cp_now):\r\n global record\r\n distance_threshold = 0.5\r\n model_path = \"trained_knn_model.clf\"\r\n \r\n # Load a trained KNN model (if one was passed in)\r\n with open(model_path, 'rb') as f:\r\n knn_clf = pickle.load(f)\r\n\r\n for X_img in cp_list:\r\n # Load image file and find face locations\r\n X_face_locations = face_recognition.face_locations(X_img)\r\n\r\n # If no faces are found in the image, return an empty result.\r\n if len(X_face_locations) == 0:\r\n return []\r\n\r\n # Find encodings for faces in the test iamge\r\n faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)\r\n\r\n # Use the KNN model to find the best matches for the test face\r\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\r\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]\r\n # Predict classes and remove classifications that aren't within the threshold\r\n for pred, rec in zip(knn_clf.predict(faces_encodings), are_matches):\r\n if rec:\r\n name = pred\r\n else:\r\n name = \"unknown\"\r\n if name not in record:\r\n end = datetime.now()\r\n record.append(name)\r\n record_time.append(end-cp_now)","def build_param_grid(self, C_list:list=[0.1, 1, 10, 100], gamma_list:list=[1, 0.1, 0.01, 0.001], kernel_list:list=['rbf']):\n ans = {}\n ans['C'] = C_list\n ans['gamma'] = gamma_list\n ans['kernel'] = kernel_list\n self.param_grid = ans\n return ans","def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\n max_cp = 1\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n max_cp += w_inpIdx*X0[inpIdx]\n # saving values\n layerEq[inpIdx] = X0[inpIdx]\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n layerEq[inpIdx] = x_eq\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n max_cp += firstComplex + Inhib2/E0*x_eq\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n max_cp += Inhib2/E0*x_eq\n return max_cp","def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n pad=np.random.rand(nspad)/100\n trc_norm=trc/np.amax(np.abs(trc))\n trc_norm_padded=np.hstack((pad,trc_norm))\n trc_entropy=self.entropy(trc_norm_padded,50)\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\n for i,j in enumerate(trc):\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def fit(self):\n N = self.data.shape\n prev_k = 1\n k_lst = []\n k_list = self.tt_ranks.copy()\n if self.model=='tt': depth = len(N)-1\n elif self.model=='tk': depth = len(N)\n\n for axis in range(depth):\n if self.global_rank==0: print('Decomposing for stage=',axis+1)\n if self.model=='tt':\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([prev_k * N[axis], -1])\n elif self.model=='tk':\n k_lst.append(prev_k)\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([N[axis], np.product(k_lst)*np.product(N[axis+1:])])\n\n if np.any(k_list) != False:\n self.this_k = k_list[axis]\n else:\n if self.global_rank==0: print('Estimating rank now with SVD...')\n self.this_k = self.determine_rank(self.data, self.err)\n\n if self.routine=='nmf':\n self.params.k = self.this_k\n if self.global_rank==0: print('Performing NMF for TN stage=',axis+1)\n W, H, rel_error = PyNMF(self.data, factors=None, params=self.params).fit()\n\n elif self.routine=='svd':\n if self.global_rank == 0: print('Performing SVD for TN stage=', axis + 1)\n singularValues, U, V,rel_error = self.compute_svd(self.data,self.this_k)\n S = np.diag(singularValues)\n W = U\n H = S @ V\n\n if self.model=='tt':\n self.factors.append(np.reshape(W, (prev_k, N[axis], self.this_k)))\n elif self.model=='tk':\n self.factors.append(W)\n if axis==depth-1:\n H_final = np.hstack((self.comm.allgather(H)))\n if self.model=='tk':\n k_lst.append(self.this_k)\n H_final = np.reshape(H_final,k_lst[1:])\n # H_final = np.hstack((block_idx_rank_H_tran(H_final,1, self.size)))\n self.factors.append(H_final)\n self.rel_error.append(rel_error)\n prev_k = self.this_k\n fpath = 'data/H_factor.zarr'\n self.data = tn_data_operations(self.comm1,fpath,H).lazy_store_file()","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy","def get_best_k_cv(air_quality_model):\n\n locations = air_quality_model.air_quality_locations\n time_series = air_quality_model.air_quality_time_series\n\n for each_location in locations:\n\n other_locations = [i for i in locations if i != each_location]\n training_time_series = time_series[other_locations]\n scaled_training_time_series = air_quality_model.scaler.transform(training_time_series)\n training_time_series_dropna = scaled_training_time_series.dropna().T\n\n # k means determine k\n distortions = []\n K = range(1, len(other_locations) + 1, 1)\n for k in K:\n kmeans = KMeans(n_clusters=k, max_iter=300).fit(training_time_series_dropna)\n # err = sum(np.min(cdist(training_time_series_dropna, kmeans.cluster_centers_, 'euclidean'), axis=1)) \\\n # / training_time_series_dropna.shape[0]\n\n # Sum of squared distances of samples to their closest cluster center\n err = kmeans.inertia_\n distortions.append(err)\n print(k, dict(zip(other_locations, kmeans.labels_)))\n print(each_location, k, 'err=', err)\n\n # Plot the elbow\n plt.figure(figsize=(15, 20))\n plt.plot(K, distortions, 'bx-')\n plt.xlabel('k')\n plt.ylabel('Distortion')\n plt.title(str(each_location) + ' The Elbow Method showing the optimal k')\n plt.show()","def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cyl is None:\n r_cyl = np.zeros(r_cp.shape)\n if len(r_cyl)==1:\n r_cyl=np.array([R])\n else:\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\n else:\n r_cyl = np.asarray(r_cyl).ravel()\n misc={}\n # --- Checks\n if np.amax(r_cyl) < np.amax(r_cp):\n warnings.warn('Cylinders are assumed to enclose the control points')\n import pdb; pdb.set_trace()\n if r_cyl[0] == 0:\n raise Exception('First cylinder at 0, impossible')\n\n ## Interpolating Circulation on the control points\n Gamma_cp = Gamma_cp * nB # IMPORTANT\n lambda_rcp = Omega*r_cp/U0\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\n ## Some init\n\n n = len(r_cyl)\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n # --- Case 1: Using k / ct to determine gamma\n # Using a_prime to correct Ct\n # Tangential convection velocity\n if not bTanInd_k:\n ap_cyl_conv = 0 * Gamma_cp\n else:\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\n # See Equation (26) of [1]: a'_c,i = (\\Gamma_i+\\Gamma_i+1)/(4 pi Omega R_i^2)\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\n # --- Allocation\n b = np.zeros(n) # Cummulative sum of gamma_bar\n S = np.zeros(n) # Term under the square root\n Sbis = np.zeros(n) # Term under the square root, account\n Ctrot = np.zeros(n)\n Ctrot_loc = np.zeros(n)\n Cti = np.zeros(n)\n Cteff = np.zeros(n)\n gamma_t_bar = np.zeros(n)\n # --- Init\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\n lambda_R = Omega * r_cyl / U0\n # Looping through radii in reversed order\n for i in np.arange(n-1,-1,-1):\n if i==n-1:\n b[i] = 1\n S[i] = 1 - C[i]\n Sbis[i] = 1 - C[i]\n Ctrot[i] = 0\n Ctrot_loc[i] = 0\n else:\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\n if not bSwirl:\n Ctrot[i] = 0\n Cti[i] = k_r[i]\n else:\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\n Sbis[i] = 1 - Cteff[i]\n if bSwirl :\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\n else:\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \n# print('b',b,'S',S)\n if bHighThrustCorr:\n if (Cteff[i] > Ct_c):\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\n #if np.abs(imag(gamma_t_bar(i))) > 0:\n # gamma_t_bar[i] = - b[i] + 0\n Vc = U0 * (b + gamma_t_bar / 2)\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\n\n\n # Analytical 1\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\n a_1=a_1[-1::-1]\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\n a=a_1;\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\n # # Analytical 2\n # a_2=-(gamma_t_hat/2)/U0;\n # a=a_2;\n #else\n # a=a_1;\n #end\n if bSwirl:\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\n else:\n a_prime=a*0\n\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n misc['h'] = h\n\n # --- Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n #gamma_t = - Gamma_tilde/h\n gamma_t = gamma_t_bar * U0\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = None\n Gamma_r = None\n\n return gamma_t,gamma_l,Gamma_r, misc","def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cyl is None:\n r_cyl = np.zeros(r_cp.shape)\n if len(r_cyl)==1:\n r_cyl=np.array([R])\n else:\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\n else:\n r_cyl = np.asarray(r_cyl).ravel()\n misc={}\n # --- Checks\n if np.amax(r_cyl) < np.amax(r_cp):\n warnings.warn('Cylinders are assumed to enclose the control points')\n import pdb; pdb.set_trace()\n if r_cyl[0] == 0:\n raise Exception('First cylinder at 0, impossible')\n\n ## Interpolating Circulation on the control points\n Gamma_cp = Gamma_cp * nB # IMPORTANT\n lambda_rcp = Omega*r_cp/U0\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\n ## Some init\n\n n = len(r_cyl)\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n # --- Case 1: Using k / ct to determine gamma\n # Using a_prime to correct Ct\n # Tangential convection velocity\n if not bTanInd_k:\n ap_cyl_conv = 0 * Gamma_cp\n else:\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\n # See Equation (26) of [1]: a'_c,i = (\\Gamma_i+\\Gamma_i+1)/(4 pi Omega R_i^2)\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\n # --- Allocation\n b = np.zeros(n) # Cummulative sum of gamma_bar\n S = np.zeros(n) # Term under the square root\n Sbis = np.zeros(n) # Term under the square root, account\n Ctrot = np.zeros(n)\n Ctrot_loc = np.zeros(n)\n Cti = np.zeros(n)\n Cteff = np.zeros(n)\n gamma_t_bar = np.zeros(n)\n # --- Init\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\n lambda_R = Omega * r_cyl / U0\n # Looping through radii in reversed order\n for i in np.arange(n-1,-1,-1):\n if i==n-1:\n b[i] = 1\n S[i] = 1 - C[i]\n Sbis[i] = 1 - C[i]\n Ctrot[i] = 0\n Ctrot_loc[i] = 0\n else:\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\n if not bSwirl:\n Ctrot[i] = 0\n Cti[i] = k_r[i]\n else:\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\n Sbis[i] = 1 - Cteff[i]\n if bSwirl :\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\n else:\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \n# print('b',b,'S',S)\n if bHighThrustCorr:\n if (Cteff[i] > Ct_c):\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\n #if np.abs(imag(gamma_t_bar(i))) > 0:\n # gamma_t_bar[i] = - b[i] + 0\n Vc = U0 * (b + gamma_t_bar / 2)\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\n\n\n # Analytical 1\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\n a_1=a_1[-1::-1]\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\n a=a_1;\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\n # # Analytical 2\n # a_2=-(gamma_t_hat/2)/U0;\n # a=a_2;\n #else\n # a=a_1;\n #end\n if bSwirl:\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\n else:\n a_prime=a*0\n\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n misc['h'] = h\n\n # --- Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n #gamma_t = - Gamma_tilde/h\n gamma_t = gamma_t_bar * U0\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = None\n Gamma_r = None\n\n return gamma_t,gamma_l,Gamma_r, misc","def non_max_suppression_kneron(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\n if prediction.dtype is torch.float16:\n prediction = prediction.float() # to FP32\n\n nc = prediction[0].shape[1] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Settings\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_det = 300 # maximum number of detections per image\n time_limit = 10.0 # seconds to quit after\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\n\n t = time.time()\n output = [None] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n\n\n # If none remain process next image\n n = x.shape[0] # number of boxes\n if not n:\n continue\n\n # Sort by confidence\n # x = x[x[:, 4].argsort(descending=True)]\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n # Sort by confidence\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\n x = x[ind_Sort_by_confidence][:top_k_num] #\n # cross classes nms\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n break # time limit exceeded\n\n return output","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def ridge_joint(trn_fs,trn_data,alphas,val_fs=None,val_data=None,square_alphas=False,chunk_sz=5000,is_verbose=True):\n\n n_resp, n_voxels = trn_data.shape\n n_channels = np.sum([tfs.shape[1] for tfs in trn_fs])\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\n\n if square_alphas:\n alphas = [a**2 for a in alphas]\n\n num_train_points = float(list(trn_data.shape)[0])\n num_val_points = float(list(val_data.shape)[0])\n\n n_abc = [np.minimum(*t_fs.shape) for t_fs in trn_fs]\n ######################################################################################\n ### --- First up: compute modified covariance matrix & scaled/rotated stimulus --- ###\n ######################################################################################\n # Perform SVD on training sets for all three models \n if is_verbose:\n print(\"computing SVD\")\n U_trn,W_trn,Vt_trn = [],[],[]\n for t_fs in trn_fs:\n uu,ww,vv = np.linalg.svd(trn_stim_A, full_matrices=False)\n U_trn.append(uu)\n W_trn.append(ww)\n Vt_trn.append(vv)\n\n # The square of Ws (the singular values from the SVD) are the eigenvalues of the covariance matrix but have not been divided by n-1.\n L = [ww**2/float(num_train_points-1) for ww in W_trn]\n\n ### --- IDK WTF. Ask Wendino. --- ###\n ## to change: make sure that Ws are in the right units (divided by n-1) when bootstrapping, so that alphas are already in correct units\n ## at that point you can change the lines below and not divide alpha by (n-1)\n # TO DO: make this more than one line for clarity.\n w_alpha_trn = [np.diag(np.sqrt(1./(LL + aa)/(num_train_points-1))) for LL,aa in zip(L,alphas)]\n #w1_alpha_trn = sqrt(1./(L1+ alphas_A2[0]/(num_train_points-1))) \n #w1_alpha_trn = diag(w1_alpha_trn) #%turn it from an array to a matrix\n\n # Create & combine rotated & scaled stimulus space \n X_prime_trn_t = [ww.dot(vv).dot(t_fs) for ww,vv,t_fs in zip(W_trn,Vt_trn,trn_fs)]\n #S1_prime_trn_t = np.dot(np.dot(w1_alpha_trn, Vt1_trn), trn_stim_A.T) #w1_alpha_trn = 1200x1200, Vt1_trn = 1200x1200, trn_stim_A.T = 1200x3737\n Xcomb_prime_trn_t = np.vstack(X_prime_trn_t)\n\n # Create & modify covariance matrix\n stim_cov_mat_r = X_prime_trn_t.dot(X_prime_trn_t.T) / float(num_train_points-1)\n cov_diag = np.sqrt(np.diag(stim_cov_mat_r))\n full_mat_cov_diag = np.tile(cov_diag, [cov_diag.shape[0], 1])\n # re-do w/ simpler syntax?\n all_divisor = np.multiply(full_mat_cov_diag.T, full_mat_cov_diag) \n corr_mat_r = np.divide(stim_cov_mat_r, all_divisor)\n\n ### --- Clean up the correlation matrix to have zeros where we know they exist and use that data to set a threshold --- ###\n idx_ct = np.cumsum([0]+n_abc)\n idxs = [(a,b) for a,b in zip(idx_ct[:-1],idx_ct[1:])]\n # Block diagonal components of covariance matrix\n for n,(ii,jj) in zip(n_abc,idxs):\n corr_mat_r[ii:jj] = np.eye(n)\n # Off-diagonal elements: ignore for now? \n #for i1,i2 in zip(idxs[:-1],idxs[1:]):\n # (ii,jj),(kk,ll) = i1,i2\n \n\n # ##### --- WORKING HERE - SEE IPYTHON NOTEBOOK --- #########\n # upper_right_corr = np.ravel(corr_mat_r[0:nA, nA:])\n # middle_right_corr = np.ravel(corr_mat_r[nA:(nA+nB),(nA+nB):])\n # right_corr = np.hstack([upper_right_corr, middle_right_corr])\n # s_right_corr = argsort(right_corr)\n # # WTF is this?\n # #corr_cutoff = 954 # WH magic number; something to do with the fact that it's needless to have \n # # ALL the block-diagonal diagonals, since we have limited data\n # #goodcorrs_idx = np.hstack([s_right_corr[0:corr_cutoff], s_right_corr[-1:-(corr_cutoff+1):-1]])\n\n # new_right_corrs = np.squeeze(np.zeros([s_right_corr.shape[0],1]))\n # #new_right_corrs[goodcorrs_idx] = right_corr[goodcorrs_idx]\n # new_upper_right_corrs = np.reshape(new_right_corrs[0:(nB+nC)*nA],[nA,nB+nC])\n # new_lower_left_corrs = new_upper_right_corrs.T\n # new_middle_right_corrs = np.reshape(new_right_corrs[(nB+nC)*nA:],[nB,nC])\n # new_middle_left_corrs = new_middle_right_corrs.T\n\n # ##NEED TO CHANGE THIS: REMOVE HARDCODED MATRIX SIZES\n # new_corr_mat_r = copy.copy(corr_mat_r)\n # new_corr_mat_r[0:nA, nA:]= new_upper_right_corrs\n # new_corr_mat_r[nA:(nA+nB), (nA+nB):] = new_middle_right_corrs\n # new_corr_mat_r[(nA+nB):, nA:(nA+nB)]= new_middle_left_corrs # More like bottom middle\n # new_corr_mat_r[nA:,0:nA] = new_lower_left_corrs # \n # new_corr_mat_r[0:nA,0:nA]= np.identity(nA)\n # new_corr_mat_r[nA:(nA+nB), nA:(nA+nB)] = np.identity(nB)\n # new_corr_mat_r[(nA+nB):,(nA+nB):] = np.identity(nC)\n\n #perform eigenvalue decomposition (WHAT FOR? delete this?)\n #w, v = np.linalg.eigh(new_corr_mat_r)\n # Invert modified covariance matrix\n #corr_r_inv = np.linalg.inv(new_corr_mat_r)\n corr_r_inv = np.linalg.inv(corr_mat_r)\n #for \n ##create filter\n dot1 = np.dot(X_prime_trn_t, trn_data) #precompute for speed\n dot2 = np.dot(corr_r_inv, dot1) #precompute for speed\n # Weights\n h_123_prime = np.divide(dot2, (float(num_train_points-1)))\n\n\n ##create estimated responses from training data\n #r_hat = np.dot(X_prime_trn_t.T, h_123_prime) # not usually done...\n #if do_pred:\n #validation set results\n val_stim_A_prime = np.dot(np.dot(w1_alpha_r, Vt1_r), val_stim_A.T)\n val_stim_B_prime = np.dot(np.dot(w2_alpha_r, Vh2_r), val_stim_B.T)\n val_stim_C_prime = np.dot(np.dot(w3_alpha_r, Vh3_r), val_stim_C.T)\n #S1_prime = S1_prime[0:200,:]\n #S2_prime = S2_prime[0:200,:]\n\n S123_val_prime_t = np.vstack([val_stim_A_prime, val_stim_B_prime, val_stim_C_prime])\n\n #create validation set correlations\n r_hat_val = np.dot(S123_val_prime_t.T, h_123_prime)\n\n\n #look at performance\n valcorr = _sutils.column_corr(r_hat_val, val_data)\n out = dict(\n #weights=wt,\n #alphas=alphas,\n #n_sig_vox_byalpha=n_sig_vox_byalpha,\n cc=valcorr\n )\n return out","def optical_kernels(K, J, Lxy, fmax, num):\n\n df = 1/Lxy\n\n # Compute TCC\n TCC, f = trans_cross_coeff(K, J, df, fmax)\n \n # Convert to 2D matrix\n N = f.size\n TCCm = np.reshape(np.reshape(TCC, (N, N, -1)), (N**2, -1))\n\n # Compute largest eigenvalues and eigenvectors\n w, v = scipy.linalg.eigh(TCCm, eigvals=(N**2 - num, N**2 - 1))\n w = np.flip(w, 0)\n v = np.flip(v, 1)\n\n # Get real-space optical kernels\n phi = []\n for i in range(num):\n Phi = np.fft.ifftshift(np.reshape(v[:,i], [N, N]))\n #phi.append(np.fft.fftshift(np.fft.ifft2(Phi)))\n phi.append(np.fft.ifft2(Phi))\n \n return w, phi","def camb_XPk(self,\n z = 0.,\n k = np.logspace(-4., 2., 1001),\n nonlinear = False,\n halofit = 'mead2020',\n var_1 = ['tot'],\n var_2 = ['tot'],\n share_delta_neff = True,\n **kwargs\n ):\n\n # Neutrino part\n nu_mass_eigen = len(np.unique([mm for mm in self.M_nu])) if np.any(self.M_nu!=0.) else 0\n nu_mass_numbers = [list(self.M_nu).count(x) for x in set(list(self.M_nu))]\n nu_mass_numbers = sorted(nu_mass_numbers,reverse=True) if np.any(self.M_nu!=0.) else [0]\n # Set parameters\n cambparams = {\n 'num_nu_massive': self.massive_nu,\n 'num_nu_massless': self.massless_nu,\n 'nu_mass_eigenstates': nu_mass_eigen, \n 'nu_mass_numbers': nu_mass_numbers,\n 'nnu': self.N_eff,\n 'omnuh2': self.omega_nu_tot,\n 'ombh2': self.omega_b,\n 'omch2': self.omega_cdm+self.omega_wdm_tot,\n 'omk': self.Omega_K,\n 'H0': 100.*self.h,\n 'As': self.As,\n 'ns': self.ns,\n 'w': self.w0,\n 'wa': self.wa,\n 'TCMB': self.T_cmb,\n 'tau': self.tau,\n 'share_delta_neff':True,\n 'dark_energy_model':'DarkEnergyPPF'}\n # kwargs\n for key, value in kwargs.items():\n if not key in cambparams: cambparams[key] = value\n params = camb.set_params(**cambparams)\n\n # Redshifts and scales\n k = np.atleast_1d(k)\n nk = len(k)\n z = np.atleast_1d(z)\n nz = len(z)\n if nz > 3: spline = 'cubic'\n else: spline = 'linear'\n\n # Possible components to use\n components = {'tot' : 'delta_tot',\n 'cdm' : 'delta_cdm',\n 'b' : 'delta_baryon',\n 'nu' : 'delta_nu',\n 'cb' : 'delta_nonu',\n 'gamma': 'delta_photon',\n 'v_cdm': 'v_newtonian_cdm',\n 'v_b' : 'v_newtonian_baryon',\n 'Phi' : 'Weyl'}\n\n # Number of points (according to logint)\n npoints = int(100*np.log10(k.max()/k.min()))\n dlogk = 2.*np.log10(k.max()/k.min())/npoints\n\n # Halofit version\n if nonlinear == True:\n #camb.nonlinear.Halofit(halofit_version = halofit)\n params.NonLinearModel.set_params(halofit_version=halofit)\n params.NonLinear = camb.model.NonLinear_both\n\n # Initialize power spectrum as a dictionary and compute it\n pk = {}\n params.set_matter_power(redshifts = z, kmax = k.max()*10**dlogk, silent = True,accurate_massive_neutrino_transfers=True)\n results = camb.get_results(params)\n\n # Fill the power spectrum array\n for c1 in var_1:\n for c2 in var_2:\n string = c1+'-'+c2\n kh, zz, ppkk = results.get_matter_power_spectrum(minkh = k.min()*10.**-dlogk,\n maxkh = k.max()*10**dlogk,\n npoints = npoints,\n var1 = components[c1],\n var2 = components[c2])\n\n pk[string] = np.zeros((nz,nk))\n for iz in range(nz):\n lnpower = si.InterpolatedUnivariateSpline(kh,np.log(ppkk[iz]),k=3,ext=0, check_finite=False)\n pk[string][iz] = np.exp(lnpower(k))\n \n #if nz != 1:\n # power = si.interp2d(kh, zz, ppkk, kind = spline)\n # pk[string] = power(k, z)\n # pk[string] = np.nan_to_num(pk[string])\n #else:\n # power = si.interp1d(kh, ppkk, kind = spline)\n # pk[string] = power(k)\n # pk[string] = np.nan_to_num(pk[string])\n\n return k, pk","def main():\n # Directory where the DICOM files are being stored (in this\n input_path = './Inputs/valve'\n\n # Original image from the filepath\n img_original = read_image(input_path)\n\n # Image with smoothing applied to reduce noise\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\n\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\n\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \"blood\" without cardiac tissue,\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\n # valve tissue from the rest - all we need is the overlap of the two labels\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\n\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\n\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\n x_mid = df['x'].mean()\n y_mid = df['y'].mean()\n df = get_df_from_img(labels_valve_filtered)\n distance_df = df.drop('z', axis=1)\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\n labels = fit.labels_\n df['label'] = pd.Series(labels)\n counts = df['label'].value_counts().to_dict()\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Use a segmentation-based clustering algorithm to attempt to find each valve\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\n\n left, right = (label_segments[0], label_segments[1])\n if x_max[0] > x_max[1]:\n left, right = right, left\n\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\n # this can be done by every z value\n left_points = {'x': [], 'y': [], 'z': []}\n right_points = {'x': [], 'y': [], 'z': []}\n zlen = len(sitk.GetArrayFromImage(left))\n for z in xrange(zlen):\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\n if len(left_df['y']) > 0:\n index = left_df['y'].idxmin()\n row = left_df.iloc[index]\n left_points['x'].append(int(row['x']))\n left_points['y'].append(int(row['y']))\n left_points['z'].append(z)\n\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\n if len(right_df['x']) > 0:\n index = right_df['x'].idxmax()\n row = right_df.iloc[index]\n right_points['x'].append(int(row['x']))\n right_points['y'].append(int(row['y']))\n right_points['z'].append(z)\n\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\n # points\n final_left = pd.DataFrame.from_dict(left_points)\n final_right = pd.DataFrame.from_dict(right_points)\n print('Coordinates for one side of the ring')\n print(final_left)\n print('\\n\\nCoordinates for the other side of the ring')\n print(final_right)\n\n final_image = make_empty_img_from_img(left)\n x = left_points['x'] + right_points['x']\n y = left_points['y'] + right_points['y']\n z = left_points['z'] + right_points['z']\n for x, y, z in zip(x, y, z):\n final_image.SetPixel(x, y, z, 1)\n\n show_all(img_smooth, final_image)","def compute_mixing_coefficients_surf(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n\n # SET UP NEW MIXING COEFFICIENT ARRAYS\n self.Kv_surf = np.zeros([Ly,N+1])\n self.Kt_surf = np.zeros([Ly,N+1])\n \n self.ghat = np.zeros([Ly,N+1])\n \n\n #################################\n # \tSURFACE KPP\n ################################\n #---> j-loop\n \n self.wm2 = []\n self.ws2 = []\n self.sigma_y = []\n for j in range(Ly):\n #--> k-loop (top to kbl[j])\n # in fortran k=N-1,kbl(j),-1\n for k in range(N-1,self.kbl[j]-1,-1):\n k_w = k\n k_r = k-1\n\n Bfsfc = self.Bfsfc_bl[j]\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\n \n # CALCULATE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm2.append(wm)\n self.ws2.append(ws)\n # COMPUTE VERTICAL MIXING COEFFICIENTS\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\n self.sigma1 = sigma #for debugging\n if j == 25: \n self.sigma_y.append(sigma)\n a1 = sigma - 2.\n a2 = 3.-2.*sigma\n a3 = sigma - 1.\n\n if sigma < 0.07:\n cff = 0.5 * (sigma-0.07)**2/0.07\n else:\n cff = 0\n \n \n if k == N-1: \n self.wm_debug = wm\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\n\n if k == N-1:\n self.ws_debug = ws\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n \n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\n #---> end k-loop \n if self.LMD_NONLOCAL:\n if Bfsfc < 0:\n self.ghat[j,k_w] = 0\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\n else:\n self.ghat[j,k_w] = 0.\n\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \n if self.LMD_CONVEC and self.MLCONVEC: \n for k in range(N-1,int(self.kbl[j]-1),-1):\n k_w = k\n k_r = k -1\n\n if self.bvf[j,k_w] < 0:\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\n\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\n # IF BKPP IS SWITCHED OFF!!\n for k in range(int(self.kbl[j]-1),-1,-1):\n k_w = k\n k_r = k -1\n if self.LMD_NONLOCAL:\n self.ghat[j,k_w] = 0\n if self.LMD_CONVEC and self.LMD_BKPP == False:\n if self.bvf[j,k_w] < 0:\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\n \n\n #---> end j-loop","def kbcht(data, k=10, shrinking_threshold=2):\n if k <= 0:\n raise ValueError('k={} must be > 0'.format(k))\n \n if shrinking_threshold <= 0:\n raise ValueError('shrinking_threshold={} must be > 0'\n .format(shrinking_threshold))\n \n if data.shape[1] != 2:\n raise ValueError('KBCHT only works on two-dimensional data')\n\n # perform k-Means for finding inital clusters\n km = kmeans(data, k)\n km_clusters = km.predict(data)\n initial_clusters = create_clusters(data, km_clusters)\n\n visualizations = []\n\n visualizations.append(visualize(initial_clusters, 'K-Means Clustering'))\n\n # get subclusters from convex hulls and shrinking\n sub_clusters, sc_average_distances, released, shrinked_vertices = \\\n get_all_subclusters(initial_clusters, shrinking_threshold)\n\n visualizations.append(visualize_vertices(\n shrinked_vertices, initial_clusters, released, 'Shrinked Vertices'))\n visualizations.append(visualize(\n sub_clusters + [released], 'Subclusters', contains_noise=True))\n\n # merge subclusters\n clusters, average_distances = \\\n merge_clusters(sub_clusters, sc_average_distances)\n\n clusters, contains_noise = \\\n add_released(clusters, average_distances, released)\n\n visualizations.append(\n visualize(clusters, 'KBCHT Clustering', contains_noise=contains_noise))\n\n # recreate cluster assignments for points in original data set\n assignments = create_assignments(data, clusters)\n\n return assignments, visualizations","def kViterbi(crf_obj, emissions, topK, mask):\n assert topK >=1\n if topK == 1:\n seq_length = emissions.size(1)\n best_path = crf_obj.decode(emissions, mask)\n observation = pad_seq(best_path, seq_length, crf_obj.batch_first, 0)\n best_probs = calculate_prob_byObser(crf_obj, emissions, observation, mask)\n return best_path, best_probs.squeeze()\n\n crf_obj._validate(emissions, mask=mask)\n if mask is None:\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\n if crf_obj.batch_first:\n emissions = emissions.transpose(0, 1)\n mask = mask.transpose(0, 1)\n normalizer = crf_obj._compute_normalizer(emissions, mask)\n # ===============start main part========================\n # emissions: (seq_length, batch_size, num_tags)\n # mask: (seq_length, batch_size)\n assert emissions.dim() == 3 and mask.dim() == 2\n assert emissions.shape[:2] == mask.shape\n assert emissions.size(2) == crf_obj.num_tags\n assert mask[0].all()\n\n seq_length, batch_size = mask.shape\n\n # Start transition and first emission\n # score is a tensor of size(batch_size, num_tags, topK) where for each\n # batch, value at tags i and top j stores the scores of the j-th best tag\n # sequence so far that ends with tag i\n #\n # pre_states saves the previous tag where the j-th best path that ends with tag i currently\n score = emissions.new_zeros((seq_length, batch_size, crf_obj.num_tags, topK))\n score[0,:,:,0] = crf_obj.start_transitions + emissions[0] # batch x num_tags\n\n pre_states = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\n for i in range(crf_obj.num_tags):\n for b in range(batch_size):\n for k in range(topK):\n pre_states[0,b,i,k] = i # should be start transition\n\n # The ranking of multiple paths through same state\n rank = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\n for t in range(1, seq_length):\n next_score_list = []\n for k in range(topK):\n broadcast_score = score[t-1,:,:,k].unsqueeze(2) #(batch_size, num_tags, 1)\n broadcast_emissions = emissions[t].unsqueeze(1) #(batch_size, 1, num_tags)\n\n # Compute the score tensor of size (batch_size, num_tags, num_tags)\n # where for each sample, entry at row i and column j stores\n # the sum of scores of all possible tag sequences so far that end\n # with transitioning from tag i to tag j and emitting\n # shape: (batch_size, num_tags, num_tags)\n next_score = broadcast_score + crf_obj.transitions + broadcast_emissions\n next_score_list.append(next_score)\n\n for b in range(batch_size):\n if mask[t,b]:\n for cur_state in range(crf_obj.num_tags):\n h = []\n for pre_state in range(crf_obj.num_tags):\n for k in range(topK):\n heapq.heappush(h, (-1*next_score_list[k][b, pre_state, cur_state], pre_state))\n\n # Get the sorted list\n h_sorted = [heapq.heappop(h) for _ in range(topK)] #get topK path into cur_state\n # We need to keep a ranking if a path crosses a state more than once\n rankDict = dict()\n # Retain the topK scoring paths\n for k in range(topK):\n score[t, b, cur_state, k] = score[t, b, cur_state, k] + (h_sorted[k][0].data * -1)\n pre_states[t, b, cur_state, k] = h_sorted[k][1]\n state = h_sorted[k][1]\n if state in rankDict:\n rankDict[state] = rankDict[state]+1\n else:\n rankDict[state] = 0\n rank[t, b, cur_state, k] = rankDict[state]\n else:\n for cur_state in range(crf_obj.num_tags):\n for k in range(topK):\n score[t, b, cur_state, k]=score[t-1, b, cur_state, k]\n\n\n batch_path = []\n batch_path_prob = []\n seq_ends = mask.long().sum(dim=0) - 1 # seq_len x batch # assume seq_ends=8, seq_len=9\n for b in range(batch_size):\n h = []\n for cur_state in range(crf_obj.num_tags):\n for k in range(topK):\n heapq.heappush(h, ( -1 * (score[seq_ends[b], b, cur_state, k]+crf_obj.end_transitions[cur_state]),\n cur_state, k))\n h_sorted = [heapq.heappop(h) for _ in range(topK)]\n k_list = np.zeros((topK, seq_ends[b]+1), int) # k x 9\n k_list_probs = list()\n for k in range(topK):\n prob = h_sorted[k][0]\n state = h_sorted[k][1]\n rankK = h_sorted[k][2]\n\n k_list_probs.append((prob*-1)-(normalizer[b]))\n k_list[k][seq_ends[b]] = state # assign index 8 == last one\n for t in range(seq_ends[b]-1, -1, -1): # t = 7,6,5,4,3,2,1,0\n nextState = k_list[k][t+1]\n preState = pre_states[t+1, b, nextState, rankK]\n k_list[k][t] = preState\n rankK = rank[t+1,b,nextState,rankK]\n batch_path.append(k_list.tolist())\n batch_path_prob.append(k_list_probs)\n if crf_obj.batch_first:\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions.transpose(0,1), mask.transpose(0,1), topK)\n else:\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions, mask, topK)\n return batch_path, batch_probs","def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\n mask, max_iter=100, init=None,\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\n\n # shape of image box\n \n alpha = 1\n\n flat_mask = mask.ravel()\n volume_shape = mask.shape\n H_size = len(Hurst_init)\n\n if lipschitz_constant == 0:\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\n\n #init[\"z\"] = Hurst_init.copy()\n #init[\"t\"] = 1\n #ini[\"stepsize\"] = 1 / lipschitz_constant\n\n def total_energy(x):\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\n\n def unmaskvec(w):\n return _unmask(w, mask)\n\n def maskvec(w):\n return w[flat_mask]\n\n def f1_grad(x):\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\n\n def f2_prox(w, stepsize, dgap_tol, init):\n out, info = _prox_tvl1(unmaskvec(w),\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\n dgap_tol=dgap_tol, init=unmaskvec(init),\n max_iter=prox_max_iter, fista = False,\n verbose=verbose)\n #pdb.set_trace()\n return maskvec(out.ravel()), info\n\n w, obj, init = mfista(\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\n max_iter=max_iter, callback=None)\n \n return w, obj, init","def component_func(B, C, F, list_funcs, len_kegg, threshold=0.05):\n\n size_label = 18\n size_tick = 18\n sns.set_style(\"darkgrid\")\n\n list_funcs = list_funcs[0:len_kegg]\n B = B[0:len_kegg]\n C = C[0:len_kegg]\n\n idx_p = [idx*2+0 for idx in range(B.shape[1]/2)]\n idx_m = [idx*2+1 for idx in range(B.shape[1]/2)]\n is_p = F[:,idx_p].mean(axis=1) - F[:,idx_m].mean(axis=1) > threshold\n is_m = F[:,idx_m].mean(axis=1) - F[:,idx_p].mean(axis=1) > threshold\n is_p = [idx for idx, val in enumerate(is_p) if val]\n is_m = [idx for idx, val in enumerate(is_m) if val]\n is_n = [idx for idx in range(C.shape[1]) if (idx not in is_p) and (idx not in is_m)]\n\n fig = plt.figure(figsize=(6, 6))\n\n for idx_c in range(C.shape[1]):\n clone_num = idx_c +1\n if idx_c in is_p:\n color=\"green\"\n label = \"C\"+str(clone_num)+\"|P\"\n elif idx_c in is_m:\n color=\"red\"\n label = \"C\"+str(clone_num)+\"|M\"\n else:\n color = \"royalblue\"\n label = \"C\"+str(clone_num)\n\n if clone_num in [1]:\n marker = \"$1$\"\n elif clone_num in [2]:\n marker = \"$2$\"\n elif clone_num in [3]:\n marker = \"$3$\"\n elif clone_num in [4]:\n marker = \"$4$\"\n elif clone_num in [5]:\n marker = \"$5$\"\n elif clone_num in [6]:\n marker = \"$6$\"\n else:\n print(\"error\")\n plt.plot(C[:,idx_c],range(len_kegg), color=color, marker=marker, markersize=10, linestyle=\"\",label=label, alpha=0.5)\n\n plt.yticks(range(len_kegg), list_funcs)\n plt.xlabel(\"Pathway strength\", fontsize=size_label)\n plt.legend()\n plt.tick_params(labelsize=size_tick-4)\n plt.show()\n ##fig.savefig(\"figures/fig7compfunc.pdf\", bbox_inches=\"tight\")","def getContSpec(par):\n # read input\n if par['verbose']:\n print('\\n(*) Start\\n(*) Loading Data File: {}...'.format(par['GexpFile']))\n\n # t, Gexp = GetExpData(par['GexpFile'])\n t, Gexp, wexp = GetExpData(par['GexpFile'])\n\n if par['verbose']:\n print('(*) Initial Set up...', end=\"\")\n \n # Set up some internal variables\n n = len(t)\n ns = par['ns'] # discretization of 'tau'\n\n tmin = t[0];\n tmax = t[n-1];\n \n # determine frequency window\n if par['FreqEnd'] == 1:\n smin = np.exp(-np.pi/2) * tmin; smax = np.exp(np.pi/2) * tmax\t\t\n elif par['FreqEnd'] == 2:\n smin = tmin; smax = tmax\t\t\t\t\n elif par['FreqEnd'] == 3:\n smin = np.exp(+np.pi/2) * tmin; smax = np.exp(-np.pi/2) * tmax\t\t\n\n hs = (smax/smin)**(1./(ns-1))\n s = smin * hs**np.arange(ns)\n \n kernMat = getKernMat(s, t)\n tic = time.time()\n \n # get an initial guess for Hgs, G0\n if par['plateau']:\n Hgs, G0 = InitializeH(Gexp, wexp, s, kernMat, np.min(Gexp))\t\t\n else:\n Hgs = InitializeH(Gexp, wexp, s, kernMat)\n \n if par['verbose']:\n te = time.time() - tic\n print('\\t({0:.1f} seconds)\\n(*) Building the L-curve ...'.format(te), end=\"\")\t\n tic = time.time()\n\n # Find Optimum Lambda with 'lcurve'\n if par['lamC'] == 0:\n if par['plateau']:\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par, G0)\n else:\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par)\n else:\n lamC = par['lamC']\n\n if par['verbose']:\n te = time.time() - tic\n print('({1:.1f} seconds)\\n(*) Extracting CRS, ...\\n\\t... lamC = {0:0.3e}; '.\n format(lamC, te), end=\"\")\n \n tic = time.time()\n\n # Get the best spectrum\t\n if par['plateau']:\n H, G0 = getH(lamC, Gexp, wexp, Hgs, kernMat, G0);\n print('G0 = {0:0.3e} ...'.format(G0), end=\"\")\n else:\n H = getH(lamC, Gexp, wexp, Hgs, kernMat);\n\n #----------------------\n # Print some datafiles\n #----------------------\n\n if par['verbose']:\n te = time.time() - tic\n print('done ({0:.1f} seconds)\\n(*) Writing and Printing, ...'.format(te), end=\"\")\n\n # Save inferred G(t)\n if par['plateau']:\n K = kernel_prestore(H, kernMat, G0);\t\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e', header='G0 = {0:0.3e}'.format(G0))\n else:\n K = kernel_prestore(H, kernMat);\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e')\n \n np.savetxt('output/Gfit.dat', np.c_[t, K], fmt='%e')\n\n # print Hlam, rho-eta, and logP if lcurve has been visited\n if par['lamC'] == 0:\n if os.path.exists(\"output/Hlam.dat\"):\n os.remove(\"output/Hlam.dat\")\n \n fHlam = open('output/Hlam.dat','ab')\n for i, lamb in enumerate(lam):\n np.savetxt(fHlam, Hlam[:,i])\t\n fHlam.close()\t\n\n # print logP\n np.savetxt('output/logPlam.dat', np.c_[lam, logP])\n \n # print rho-eta\n np.savetxt('output/rho-eta.dat', np.c_[lam, rho, eta], fmt='%e')\n\n #------------\n # Graphing\n #------------\n\n if par['plotting']:\n\n # plot spectrum \"H.pdf\" with errorbars\n plt.clf()\n\n plt.semilogx(s,H,'o-')\n plt.xlabel(r'$s$')\n plt.ylabel(r'$H(s)$')\n\n # error bounds are only available if lcurve has been implemented\n if par['lamC'] == 0:\n plam = np.exp(logP); plam = plam/np.sum(plam)\t\t\t\n Hm = np.zeros(len(s))\n Hm2 = np.zeros(len(s))\n cnt = 0\n for i in range(len(lam)):\t\n #~ Hm += plam[i]*Hlam[:,i]\n #~ Hm2 += plam[i]*Hlam[:,i]**2\n # count all spectra within a threshold\n if plam[i] > 0.1:\n Hm += Hlam[:,i]\n Hm2 += Hlam[:,i]**2\n cnt += 1\n\n Hm = Hm/cnt\n dH = np.sqrt(Hm2/cnt - Hm**2)\n\n plt.semilogx(s,Hm+2.5*dH, c='gray', alpha=0.5)\n plt.semilogx(s,Hm-2.5*dH, c='gray', alpha=0.5)\n\n plt.tight_layout()\n plt.savefig('output/H.pdf')\n\n\n #\n # plot comparison with input spectrum\n #\n\n plt.clf()\n\n if par['plateau']:\n K = kernel_prestore(H, kernMat, G0);\t\n else:\n K = kernel_prestore(H, kernMat);\n\n plt.loglog(t, Gexp,'o',t, K, 'k-')\n plt.xlabel(r'$t$')\n plt.ylabel(r'$G(t)$')\n plt.tight_layout()\n plt.savefig('output/Gfit.pdf')\n\n\n #\n # if lam not explicitly specified then print rho-eta.pdf\n #\n\n try:\n lam\n except NameError:\n print(\"lamC prespecified, so not printing rho-eta.pdf/dat\")\n else:\n plt.clf()\n plt.scatter(rho, eta, marker='x')\n plt.plot(rho, eta)\n\n\n rhost = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(rho)))\n etast = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(eta)))\n\n plt.plot(rhost, etast, 'o', color='k')\n plt.xscale('log')\n plt.yscale('log')\n \n #~ print(rhost, etast)\n \n plt.xlabel(r'$\\rho$')\n plt.ylabel(r'$\\eta$')\n plt.tight_layout()\n plt.savefig('output/rho-eta.pdf')\n\n if par['verbose']:\n print('done\\n(*) End\\n')\n \n return H, lamC","def default_grid_feature_hp_kernel_config(defn):\n defn = _validate_definition(defn)\n config = {}\n\n grid = enumerate(zip(defn.models(), defn.hyperpriors()))\n\n for fi, (model, priors) in grid:\n partials = copy.deepcopy(model.default_partial_hypergrid())\n if not partials:\n continue\n\n evals = []\n for update_descs, fn in priors.iteritems():\n if not hasattr(update_descs, '__iter__'):\n update_descs = [update_descs]\n keyidxs = []\n for update_desc in update_descs:\n key, idx = _parse_descriptor(update_desc, default=None)\n keyidxs.append((key, idx))\n\n def func(raw, keyidxs):\n s = 0.\n for key, idx in keyidxs:\n if idx is None:\n s += raw[key]\n else:\n s += raw[key][idx]\n return s\n evals.append(lambda raw, keyidxs=keyidxs: func(raw, keyidxs))\n\n def jointprior(raw, evals):\n return np.array([f(raw) for f in evals]).sum()\n\n config[fi] = {\n 'hpdf': lambda raw, evals=evals: jointprior(raw, evals),\n 'hgrid': partials,\n }\n\n if not config:\n return []\n else:\n return [('grid_feature_hp', config)]","def one_iteration_step(self, tsm, tank, chp, kessel, cvalve, heizkurve, t_a, el_heat_status, actual_time, heatc_conf):\n #print('\\n chp = {}; kessel = {}; t2 = {}; t3 = {}'.format(chp.get_status(), kessel.get_status(), self.t2, self.t3))\n # combined heat and power unit - link outputs\n wyn = chp.get_chp()\n #self.t27 = wyn[1] # tin in °C = self.t1 = wyn[t1]\n self.t26 = wyn[2] # tout in °C = chp.get_out_temp = wyn[2]\n m3 = wyn[3] # mstr in kg/s \n self.V_3 = m3 / utils.rho_fluid_water(self.t26, self.p_atm, 1) # volume flow incoming to chp from tank\n V_chp = chp.get_volume_flow_at_output() # volume flow outoming from chp into tank\n # combined heat and power unit - link inputs\n chp.set_inp_temp(self.t27) # temperature incoming from tank to chp\n\n # ..............................................................\n\n # gas boiler - link outputs\n wyn = kessel.get_kessel()\n #self.t29 = wyn[1] # tin in °C - incoming into gas heater\n self.t28 = wyn[2] # tout in °C - outcoming from gas heater\n m4 = wyn[3] # mstr in kg/s - incoming into gas heater\n self.V_4 = kessel.get_volume_flow_at_input()\n V_kessel = kessel.get_volume_flow_at_output()\n # gas boiler - link inputs\n kessel.set_inp_temp(self.t29)\n #kessel.calc_mass_flow()\n\n # ..............................................................\n # at first no delay - just linking chp and heater\n # delay due to the seuence of commands ie equal to the Timestep length\n self.t27 = self.t1\n self.t29 = self.t1\n # ..............................................................\n\n # heating circuit\n self.t23 = self.t20 # no delay assumed\n #print('t20 = {}; t23 = {}'.format(self.t20, self.t23))\n self.t25 = heizkurve.get_supply_temperature(t_a)\n self.t24 = heizkurve.get_return_temperature(t_a)\n heizkurve.calc_volume_flow()\n\n # comprehensive control algorithm - it stays\n (m23, m25, m4) = self.control_internal_1(heizkurve, kessel, chp, cvalve, t_a, actual_time, m4, heatc_conf)\n\n m_bypass = m25 - m23\n rho23 = utils.rho_fluid_water(self.t23, self.p_atm, 1)\n V_23 = m23 / rho23 # in m3/s = kg/s / kg/m3\n #print('V_23 = {}; m23 = {}; rho23 = {}; t23 = {}'.format(V_23,m23, rho23, self.t23))\n m24 = m23\n rho24 = utils.rho_fluid_water(self.t24, self.p_atm, 1)\n V_24 = m24 / rho24\n \n # demand for domestic hot water\n m22 = self.V_1 * utils.rho_fluid_water(self.t22, self.p_atm, 1) # in kg/s = m3/s * kg/m3\n #m22 = 0.01 # kg/s\n # ..............................................................\n\n t_ambient = 15.0\n # storage tank - calculation\n tank.calculate_storage_tank_obj(tsm, # time step manager\n self.t23, # hk_inp_temp\n V_23, # hk_inp_volfl_m3s\n self.t24, # hk_out_temp\n self.t27, # chp_inp_temp\n self.t26, # chp_out_temp\n self.V_3, # chp_inp_volfl_m3s\n self.t29, # gb_inp_temp\n self.t28, # gp_out_temp\n self.V_4, # gb_inp_volfl_m3s\n self.t22, # dhw_inp_temp\n self.t21, # dhw_out_temp\n self.V_1, # dhw_inp_volfl_m3s\n el_heat_status, # el_heat_status\n actual_time, # time in the timestamp format\n t_ambient) # ambient temperature of the tank - defines heat losses to the outside\n \n self.t21 = tank.get_temp_dhw()\n #self.t27 = \n #self.t29 = \n #self.t23 = \n \n # storage tank - linking\n [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, \n self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20] = tank.output_temperatures()\n\n # ..............................................................\n # get rid of this part\n #self.control_internal_2(chp, kessel, actual_time, m4)\n # ..............................................................\n heizwert_in_MJ_per_kg = 50.0 # kg/m3 N ~CH4\n gas_density = 0.79 # kg/m3 N ~Erdgas\n Z_boiler = kessel.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\n self.Z_2 = chp.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\n self.Z_1 = self.Z_2 + Z_boiler\n \n self.Wh1 = -1.0 * chp.get_el_prod()\n self.Wh2 = tank.get_el_heater_consumption()\n self.Wh3 = self.Wh1 + self.Wh2 + self.electricity_consumption_kWh\n #print('END chp = {}; kessel = {}; heating = {}; t2 = {}; t3 = {};V1 = {}; V2 = {}; V3 = {}; V4 = {}; t_a = {}'.format(chp.get_status(), kessel.get_status(), heizkurve.get_status(), self.t2, self.t3, self.V_1, self.V_2, self.V_3, self.V_4, t_a))","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 Kgrid(struc, Kresol=0.10, dimension=3):\n a, b, c, alpha, beta, gamma = struc.get_cell_lengths_and_angles()\n vol = struc.get_volume()\n dist = np.zeros(3);\n dist[2] = np.abs(vol/(a*b*np.sin(np.radians(gamma))))\n dist[1] = np.abs(vol/(a*c*np.sin(np.radians(beta))))\n dist[0] = np.abs(vol/(b*c*np.sin(np.radians(alpha))))\n Kpoints = np.ceil(1./(dist*Kresol))\n if dimension == 2:\n Kpoints[-1] = 1;\n #print(a, b, c, alpha, beta, gamma)\n #print(vol/(a*b*np.sin(gamma)), a*b, np.sin(gamma))\n #print(vol/(a*c*np.sin(beta)), a*c, np.sin(beta))\n #print(vol/(b*c*np.sin(alpha)), b*c, np.sin(alpha))\n #print(Kpoints)\n #import sys; sys.exit()\n return Kpoints.astype(int)","def plot_electrode_depth_profile(keyword_blk=keyword_blk, keyword_tank=keyword_tank, dir_tdt_tank=dir_tdt_tank,\n ch_index = 1, range_ch= None,\n speed_retract=speed_retract, binsize_dist=binsize_dist, range_ch_pos_rel=None,\n tf_reverse_dist=tf_reverse_dist, total_distance=None, t_gauss_sigma_spcg = t_gauss_sigma_spcg,\n tf_spectragram=tf_spectragram, tf_spectragram_interactive=tf_spectragram_interactive):\n\n \"\"\" ----- load data ----- \"\"\"\n seg = load_blk(keyword_blk=keyword_blk, keyword_tank=keyword_tank, dir_tdt_tank=dir_tdt_tank)\n\n \"\"\" ----- use time and speed to infer depth ----- \"\"\"\n t_range = np.array([seg.t_start, seg.t_stop])\n if total_distance is not None:\n t_range[1] = total_distance/speed_retract\n dist_range = t_range*speed_retract\n\n \"\"\" ----- get spiking pattern ----- \"\"\"\n spk_time = np.sort(np.concatenate([np.array(spktrn.times) for spktrn in seg.spiketrains if spktrn.annotations['channel_index']==ch_index]))\n spk_dist = spk_time * speed_retract\n spk_bin, dist_bin_edge = np.histogram(spk_dist, np.arange(dist_range[0], dist_range[1], binsize_dist))\n dist_bin_center = (dist_bin_edge[:-1] + dist_bin_edge[1:]) / 2\n if range_ch is not None:\n list_spk_bin = []\n for ch_cur in range_ch:\n try:\n spk_time_cur = np.sort(np.concatenate([np.array(spktrn.times) for spktrn in seg.spiketrains if\n spktrn.annotations['channel_index'] == ch_cur]))\n except:\n spk_time_cur = np.array([])\n spk_dist_cur = spk_time_cur * speed_retract\n spk_bin_cur, _ = np.histogram(spk_dist_cur, np.arange(dist_range[0], dist_range[1], binsize_dist))\n list_spk_bin.append(spk_bin_cur)\n spk_bin_array = np.vstack(list_spk_bin)\n\n \"\"\" ----- compute spectrogram ----- \"\"\"\n if tf_spectragram:\n scale_factor = 10**6\n lfp_sig = [anasig for anasig in seg.analogsignals if re.search('LFPs.*', anasig.name) and anasig.annotations['channel_index']==ch_index][0]\n lfp_trace = np.ravel(lfp_sig) * scale_factor\n lfp_fs = np.array(lfp_sig.sampling_rate)\n lfp_ts = range(len(lfp_trace))/lfp_fs + np.array(lfp_sig.t_start)\n if total_distance is not None:\n lfp_ts = lfp_ts[lfp_ts<t_range[1]]\n lfp_trace = lfp_trace[:len(lfp_ts)]\n spcg, spcg_t, spcg_f = pna.ComputeSpectrogram(data=np.expand_dims(lfp_trace, axis=0),\n fs=lfp_fs, t_ini=lfp_ts[0], t_bin=1.0, t_step=1.0, t_axis=1, f_lim=[0,100])\n spcg = spcg[0,:,:]\n if t_gauss_sigma_spcg is not None:\n spcg = sp.ndimage.filters.gaussian_filter1d(spcg, sigma=t_gauss_sigma_spcg, axis=1)\n spcg_dist = spcg_t * speed_retract\n\n \"\"\" ----- direction of distance axis ----- \"\"\"\n if tf_reverse_dist: # top to bottom\n dist_bin = np.flip(dist_bin_center, axis=0)\n if tf_spectragram:\n dist_spcg = np.flip(spcg_dist, axis=0)\n else: # bottom to top\n dist_bin = dist_bin_center\n if tf_spectragram:\n dist_spcg = spcg_dist\n\n \"\"\" ----- plot ----- \"\"\"\n if tf_spectragram:\n h_fig, h_ax = plt.subplots(2, 1, figsize=[8, 8], sharex=True, squeeze=False)\n else:\n h_fig, h_ax = plt.subplots(1, 1, figsize=[8, 4], sharex=True, squeeze=False)\n\n \"\"\" upper panel: spiking pattern \"\"\"\n plt.axes(h_ax[0,0])\n if range_ch is not None:\n list_color = plt.cm.rainbow(np.linspace(0,1,len(range_ch)))\n for i, ch_cur in enumerate(range_ch):\n if range_ch_pos_rel is None:\n dist_shift = 0\n else:\n dist_shift = range_ch_pos_rel[i]\n plt.plot(dist_bin+dist_shift, spk_bin_array[i,:], color=list_color[i], linewidth=1, alpha=0.5)\n plt.plot(dist_bin, spk_bin, color='k', linewidth=2)\n plt.xlabel('distance, um')\n plt.ylabel('spk count in {} um window'.format(binsize_dist))\n plt.title('spiking pattern')\n\n \"\"\" lower panel: spectrogram \"\"\"\n if tf_spectragram:\n plt.axes(h_ax[1,0])\n plt.pcolormesh(dist_spcg, spcg_f, np.log(spcg), cmap='inferno')\n plt.xlabel('distance, um')\n plt.ylabel('frequency, Hz')\n plt.title('LFP spectragram')\n\n \"\"\" colorbar \"\"\"\n ax_loc = h_ax[1, 0].get_position()\n h_colorbar = plt.colorbar( cax = h_fig.add_axes([ax_loc.x1+0.02, ax_loc.y0, 0.02, ax_loc.y1-ax_loc.y0]))\n\n \"\"\" colorbar, interactive control widgets \"\"\"\n if tf_spectragram_interactive:\n clim_org_min, clim_org_max = h_colorbar.get_clim()\n clim_range = clim_org_max - clim_org_min\n h_slider_clim_min = mpl.widgets.Slider(ax=h_fig.add_axes([ax_loc.x0, 0.02, (ax_loc.x1 - ax_loc.x0) * 0.3, 0.02]),\n label='c_min', valmin=clim_org_min-0.5*clim_range, valmax=clim_org_min+0.5*clim_range, valinit=clim_org_min)\n h_slider_clim_max = mpl.widgets.Slider(ax=h_fig.add_axes([(ax_loc.x0+ax_loc.x1)*0.5, 0.02, (ax_loc.x1-ax_loc.x0)*0.3, 0.02]),\n label='c_max', valmin=clim_org_max-0.5*clim_range, valmax=clim_org_max+0.5*clim_range, valinit=clim_org_max)\n def update_clim_min(val):\n plt.axes(h_ax[1,0])\n plt.clim(vmin=val)\n def update_clim_max(val):\n plt.axes(h_ax[1, 0])\n plt.clim(vmax=val)\n h_slider_clim_min.on_changed(update_clim_min)\n h_slider_clim_max.on_changed(update_clim_max)\n\n h_button_savefig = mpl.widgets.Button(ax=h_fig.add_axes([ax_loc.x1, 0.02, 0.05, 0.03]), label='save')\n def savefig(event):\n plt.savefig('{}/electrode_depth_profile_tank_{}.png'.format(path_save_fig, keyword_tank))\n h_button_savefig.on_clicked(savefig)\n h_ax[0,0].set_xlim([dist_bin.min(), dist_bin.max()])\n plt.suptitle('electrode depth profile, tank {}'.format(keyword_tank))\n\n \"\"\" return results \"\"\"\n return_dict = {'spk': (dist_bin, spk_bin), 'spcg': None, 'slider': None}\n if tf_spectragram:\n return_dict['spcg'] = (dist_spcg, spcg_f, spcg)\n if tf_spectragram_interactive and tf_spectragram: # to return the widegets object is important, otherwise widgets do not work whtin functions\n return_dict['widgets'] = (h_slider_clim_min, h_slider_clim_max, h_button_savefig)\n\n return return_dict","def normal_modes_gHST(R, NL, KL, params, dispersion=[], spin_dir=[], sublattice_labels=[], b='hang', spring='auto',\n pin='auto'):\n try:\n NP, NN = np.shape(NL)\n except:\n '''There is only one particle.'''\n NP = 1\n NN = 0\n\n M1 = np.zeros((2 * NP, 2 * NP))\n M2 = np.zeros((2 * NP, 2 * NP))\n if spring == 'auto':\n spring = params['k'] * params['l'] ** 2 / (params['I3'] * np.abs(params['w3']))\n # If there is more than one particle, and if the speeds vary from particle to particle,\n # then make spring the same length as a dynamical matrix column\n if len(spring) > 0:\n if (abs(spring - spring[0]) > 1e-9).any():\n # The rotation rates vary from particle to particle, so reshape\n spring_new = np.zeros_like(spring)\n dmyi = 0 # a new index ('dummy i')\n for ii in range(NP):\n # Since 2 dof for position of pivot of gHST, double the size\n spring_new[dmyi] = spring[ii]\n spring_new[dmyi + 1] = spring[ii]\n dmyi += 2\n else:\n # the elements are all identical, so just keep the first one\n spring = spring[0]\n\n if pin == 'auto':\n gn = params['Mm'] * params['g']\n pin = params['l'] * gn / (params['I3'] * np.abs(params['w3']))\n # If there is more than one particle, and if the speeds vary from particle to particle,\n # then make pin the same length as a dynamical matrix column\n if len(pin) > 0:\n if (abs(pin - pin[0]) > 1e-9).any():\n # The rotation rates vary from particle to particle, so reshape\n pin_new = np.zeros_like(pin)\n dmyi = 0 # a new index ('dummy i')\n for ii in range(NP):\n # Since 2 dof for position of pivot of gHST, double the size\n pin_new[dmyi] = pin[ii]\n pin_new[dmyi + 1] = pin[ii]\n dmyi += 2\n else:\n # the elements are all identical, so just keep the first one\n pin = pin[0]\n\n m2_shape = np.shape(M2)\n\n if b == 'hang':\n b = np.zeros(NP)\n elif b == 'stand':\n b = np.ones(NP)\n\n if spin_dir == []:\n '''Assume antialigned with a, aligned with body axis 3'''\n spin_dir = np.ones(NP)\n\n print 'Constructing dynamical matrix...'\n for i in range(NP):\n for nn in range(NN):\n\n ni = NL[i, nn] # the number of the gyroscope i is connected to (particle j)\n k = KL[i, nn] # true connection?\n\n if len(dispersion) > 1:\n disp = 1. / (1. + dispersion[i])\n else:\n disp = 1.\n\n diffx = R[ni, 0] - R[i, 0]\n diffy = R[ni, 1] - R[i, 1]\n alphaij = 0.\n\n rij_mag = np.sqrt(diffx ** 2 + diffy ** 2)\n\n if k != 0:\n alphaij = np.arctan2(diffy, diffx)\n\n # for periodic systems, KL is -1 for particles on opposing boundaries\n if KL[i, nn] == -1:\n alphaij = (np.pi + alphaij) % (2 * pi)\n\n # What is this for?\n if KL[i, nn] == -2: # will only happen on first or last gyro in a line\n if i == 0 or i == (NP - 1):\n print i, '--> NL=-2 for this particle'\n yy = np.where(KL[i] == 1)\n dx = R[NL[i, yy], 0] - R[NL[i, yy], 0]\n dy = R[NL[i, yy], 1] - R[NL[i, yy], 1]\n al = (np.arctan2(dy, dx)) % (2 * pi)\n alphaij = np.pi - al\n if i == 1:\n alphaij = np.pi - ((90 / 2) * np.pi / 180.)\n else:\n alphaij = - ((90 / 2) * np.pi / 180.)\n\n Cos = np.cos(alphaij)\n Sin = np.sin(alphaij)\n\n if abs(Cos) < 10E-8:\n Cos = 0.0\n\n if abs(Sin) < 10E-8:\n Sin = 0\n\n Cos2 = Cos ** 2\n Sin2 = Sin ** 2\n CosSin = Cos * Sin\n\n # -1 for aligned with a, 1 for aligned with 3.\n # dir factor :== 1/(-1)^c = (-1)^c\n dir_factor = spin_dir[i]\n\n if len(sublattice_labels) > 0:\n if sublattice_labels[i] == 1:\n extra_factor = 1. * del_A_B\n # print self.del_A_B\n elif sublattice_labels[i] == 0:\n extra_factor = 1.\n else:\n extra_factor = 1.\n else:\n extra_factor = 1.\n\n M1[2 * i, 2 * i] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxi\n M1[2 * i, 2 * i + 1] += -disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyi\n M1[2 * i, 2 * ni] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxj\n M1[2 * i, 2 * ni + 1] += disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyj\n\n # (y components)\n M1[2 * i + 1, 2 * i] += disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxi\n M1[2 * i + 1, 2 * i + 1] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyi\n M1[2 * i + 1, 2 * ni] += -disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxj\n M1[2 * i + 1, 2 * ni + 1] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyj\n\n # if i==0:\n # print '\\n --- \\n added M1[2*i+1, 2*i] = ',disp*k*Cos2 *((-1)**b[i]) *dir_factor\n # print 'dir_factor = ', dir_factor\n # print 'k = ', k\n # print 'else =', ((-1)**b[i]) *dir_factor\n\n # pinning/gravitational matrix\n M2[2 * i, 2 * i + 1] = (1.) * disp * dir_factor * extra_factor\n M2[2 * i + 1, 2 * i] = -(1.) * disp * dir_factor * extra_factor\n\n # self.pin_array.append(2*pi*1*extra_factor)\n # Assumes:\n # (-1)**c adot = - spring* (-1)**b SUM{ z x nij*(nij.(dri-drj)) } + pin\n matrix = - (-spring * M1 + pin * M2)\n\n return matrix","def Heston_fft(self,alpha,n,B,K):\r\n bt = time.time()\r\n r = self.r\r\n T = self.T\r\n S0 = self.S0\r\n N = 2**n\r\n Eta = B / N\r\n Lambda_Eta = 2 * math.pi / N\r\n Lambda = Lambda_Eta / Eta\r\n \r\n J = np.arange(1,N+1,dtype = complex)\r\n vj = (J-1) * Eta\r\n m = np.arange(1,N+1,dtype = complex)\r\n Beta = np.log(S0) - Lambda * N / 2\r\n km = Beta + (m-1) * Lambda\r\n \r\n ii = complex(0,1)\r\n \r\n Psi_vj = np.zeros(len(J),dtype = complex)\r\n \r\n for zz in range(0,N):\r\n u = vj[zz] - (alpha + 1) * ii\r\n numer = self.Heston_cf(u)\r\n denom = (alpha + vj[zz] * ii) * (alpha + 1 + vj[zz] * ii)\r\n \r\n Psi_vj [zz] = numer / denom\r\n \r\n # Compute FTT\r\n xx = (Eta/2) * Psi_vj * np.exp(-ii * Beta * vj) * (2 - self.dirac(J-1))\r\n zz = np.fft.fft(xx)\r\n \r\n # Option price\r\n Mul = np.exp(-alpha * np.array(km)) / np.pi\r\n zz2 = Mul * np.array(zz).real\r\n k_List = list(Beta + (np.cumsum(np.ones((N, 1))) - 1) * Lambda)\r\n Kt = np.exp(np.array(k_List))\r\n \r\n Kz = []\r\n Z = []\r\n for i in range(len(Kt)):\r\n if( Kt[i]>1e-16 )&(Kt[i] < 1e16)& ( Kt[i] != float(\"inf\"))&( Kt[i] != float(\"-inf\")) &( zz2[i] != float(\"inf\"))&(zz2[i] != float(\"-inf\")) & (zz2[i] is not float(\"nan\")):\r\n Kz += [Kt[i]]\r\n Z += [zz2[i]]\r\n tck = interpolate.splrep(Kz , np.real(Z))\r\n price = np.exp(-r*T)*interpolate.splev(K, tck).real\r\n et = time.time()\r\n \r\n runt = et-bt\r\n\r\n return(price,runt)","def non_interacting_conductivity(self,\n sigma=0.04,\n freq_range=(0.0, 6.0, 1000),\n imag_dielectric=False,\n broadening='lorentz'):\n cell_area = np.abs(float(np.cross(self.a1, self.a2)))*len(self.k_grid)\n broad_fnc = get_broadening_function(broadening, sigma)\n\n frequency_grid = np.linspace(*freq_range)\n energy_increment = np.abs(frequency_grid[1] - frequency_grid[0])\n num_freqs, min_freq = len(frequency_grid), min(frequency_grid)\n output_grid = np.zeros(num_freqs)\n\n energy_power = 1 + int(imag_dielectric)\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\n prefactor = prefactor/cell_area\n\n # Assuming x polarisation for now\n position_dipole_matrix = self.construct_position_dipole_matrix()\n\n n_shift = self.n_spins*self.n_orbs\n for idx1, kpt in enumerate(self.k_grid):\n for s0 in range(self.n_spins):\n velocity_matrix = self.load_velocity_matrix(idx1)\n bands = self.exciton_obj.get_number_conduction_valence_bands(\n idx1, s0\n )\n v_num, c_num = bands\n eigvals = np.array(\n self.file_storage['eigensystem']['eigenvalues'][idx1]\n )\n\n j1 = n_shift*idx1 + (self.n_spins - 1)*s0*self.n_orbs\n j2 = j1 + self.n_orbs\n eigvecs = np.array(\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\n )\n for v, c in product(range(v_num), range(c_num)):\n cb_vector = eigvecs[:, v_num + c]\n vb_vector = eigvecs[:, v]\n cb_energy, vb_energy = eigvals[v_num + c], eigvals[v]\n energy_diff = (cb_energy - vb_energy)\n\n energy_diff_pow = energy_diff**energy_power\n matrix_elem = velocity_matrix_element(vb_vector,\n cb_vector,\n velocity_matrix)\n if self.use_dipole_term:\n position_dipole_term = get_position_dipole_element(\n vb_vector,\n cb_vector,\n vb_energy,\n cb_energy,\n position_dipole_matrix\n )\n matrix_elem = matrix_elem + position_dipole_term\n\n main_term = np.abs(matrix_elem)**2/energy_diff_pow\n closest_idx = (energy_diff - min_freq)//energy_increment\n idx_reach = self.reach_multiplier*(sigma//energy_increment)\n\n lower_idx = max([closest_idx - idx_reach, 0])\n upper_idx = min([closest_idx + idx_reach, num_freqs - 1])\n\n for idx2 in range(int(lower_idx), int(upper_idx)):\n smearing = broad_fnc(energy_diff, frequency_grid[idx2])\n output = prefactor*main_term*smearing\n output_grid[idx2] += output\n\n return frequency_grid, output_grid","def findScalingCoeffsMultiExp(self, PFC, lqCN, lqCF, lqPN, lqPF):\n # Get R and Z vectors at the midplane\n R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\n R_omp_min = R_omp_sol - 5.0*(lqPN + lqPF) #already in m\n R_omp_max = R_omp_sol + 20.0*(lqCN + lqCF) #already in m\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\n if R_omp_max > max(PFC.ep.g['R']):\n R_omp_max = max(PFC.ep.g['R']) #in meters now\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\n Z_omp = np.zeros(R_omp.shape)\n\n\n # Evaluate B at outboard midplane\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\n\n #Find coordinate transformation vector at midplane\n psiaxis = PFC.ep.g['psiAxis']\n psiedge = PFC.ep.g['psiSep']\n deltaPsi = np.abs(psiedge - psiaxis)\n gradPsi = Bp_omp*R_omp\n xfm = gradPsi / deltaPsi\n # transform hf width into flux space\n lqPN_hat = lqPN*xfm\n lqPF_hat = lqPF*xfm\n lqCN_hat = lqCN*xfm\n lqCF_hat = lqCF*xfm\n\n #Calculate flux at midplane using gfile\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\n psi = psiN*(psiedge - psiaxis) + psiaxis\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\n s_hat = psiN - PFC.psiMinLCFS\n\n #find locations in Private vs Common flux regions\n useP = np.where(s_hat < 0.0)[0]\n useC = np.where(s_hat >= 0.0)[0]\n\n #integral for SOL in flux space\n if len(useP)>0:\n qPN_hat = np.exp( s_hat[useP] / lqPN_hat[useP])\n qPF_hat = np.exp( s_hat[useP] / lqPF_hat[useP])\n #reinke method\n #intPN = simps(qPN_hat / B_omp[useP], psi[useP])\n #intPF = simps(qPF_hat / B_omp[useP], psi[useP])\n #menard method\n intPN = simps(qPN_hat, psi[useP])\n intPF = simps(qPF_hat, psi[useP])\n else:\n qPN_hat = 0.0\n qPF_hat = 0.0\n intPN = 0.0\n intPF = 0.0\n\n if len(useC)>0:\n qCN_hat = np.exp(-s_hat[useC] / lqCN_hat[useC])\n qCF_hat = np.exp(-s_hat[useC] / lqCF_hat[useC])\n #reinke method\n #intCN = simps(qCN_hat / B_omp[useC], psi[useC])\n #intCF = simps(qCF_hat / B_omp[useC], psi[useC])\n #menard method\n intCN = simps(qCN_hat, psi[useC])\n intCF = simps(qCF_hat, psi[useC])\n else:\n qCN_hat = 0.0\n qCF_hat = 0.0\n intCN = 0.0\n intCF = 0.0\n\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF +\n intPN*self.fracPN + intPF*self.fracPF)\n #account for nonphysical power\n if P0 < 0: P0 = -P0\n #Scale to input power\n q0 = self.Psol/P0\n\n #old method left for reference (same math)\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF +\n # intPN*self.fracPN + intPF*self.fracPF)\n\n return q0","def init_kern_act(num_pitches):\n\n kern_act = []\n\n for i in range(num_pitches):\n kern_act.append(Matern32(1, lengthscales=1.0, variance=3.5))\n return kern_act","def fit(self, spike_times, input_current, window, dt):\n spks_in_window = self._get_spikes_in_window(spike_times, window, dt)\n\n # Compute and store summary metrics.\n ISIs = [np.diff(x) for x in spks_in_window]\n self.CV = [x.std() / x.mean() if len(x) > 0 else 0 for x in ISIs]\n\n self.f = np.array([len(x) for x in spks_in_window]) / (\n 1e-3 * dt * (window[1] - window[0])\n )\n\n self.I = input_current[\n max(window[1] - 1000, window[0]) : (\n window[1] - 10\n ) # Offsets are to avoid boundary effects from stimulus edges.\n ].mean(axis=0)\n\n self._rheobase_ind = np.where(self.f > 1e-8)[0][0]\n self.rheobase = self.I[self._rheobase_ind]\n self.freq_at_rheobase = self.f[self._rheobase_ind]\n\n self.freq_at_50 = self._get_interpolated_f_at_I(50.0)\n\n self.is_monotonic = self.is_monotonic_function(self.f)\n self._linear_fit_coeffs = np.polyfit(\n self.I[self._rheobase_ind :], self.f[self._rheobase_ind :], 1\n )\n self.gain = self._linear_fit_coeffs[0]\n\n self.spearman_rho, self.spearman_p = spearmanr(\n self.I[self._rheobase_ind :], self.f[self._rheobase_ind :]\n )","def rk8(accel,m,r,h,v): \n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\n\n\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \n \n return new_v8,new_r8","def getPartitionFunction(self, Tlist):\n\t\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\n\t\t# Active K-rotor\n\t\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\n\t\tif len(rotors) == 0:\n\t\t\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\n\t\t\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\t# Other modes\n\t\tfor mode in self.modes:\n\t\t\tQ0 = mode.getPartitionFunction(Tlist)\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\treturn Q","def get_hbls_hbbl(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n z_u_r = self.grid_dict['z_u_r']\n u = self.u\n v = self.v\n \n v_upts = TTTW_func.v2u(v)\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\n\n\n\n # CALCULATE swr_frac\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\n\n\n # WHOLE THING HAPPENS IN j loop through y-indices\n \n # INITIALIZE ARRAYS\n self.kmo = np.zeros([Ly])\n self.Cr = np.zeros([Ly])\n self.kbl = np.empty([Ly],dtype='int')\n self.C_h_MO = np.zeros([Ly])\n self.Cr = np.zeros([Ly,N+1]) # sum term\n self.FC = np.zeros([Ly,N+1])\n self.swdk_r = np.zeros([Ly,N+1])\n \n self.zscale = np.zeros([Ly,N])\n self.Kern = np.zeros([Ly,N])\n\n \n # --> LOOP THROUGH Y-INDICES\n for j in range(Ly):\n if self.LIMIT_MO_DEPTH:\n self.kmo[j] = 0\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\n \n self.kbl[j] = 0\n self.Cr[j,-1] = 0 # set top Cr\n self.Cr[j,0] = 0 # set bottom Cr\n \n # SEARCH FOR MIXED LAYER DEPTH\n self.FC[j,-1] = 0.\n\n\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\n for k in range(N-1,0,-1):\n # INDEX MAP\n k_r = k-1\n k_w = k\n\n \n zscale = z_u_w[j,N] - z_u_r[j,k_r]\n self.zscale[j,k_w] = zscale\n if self.LMD_KPP:\n if self.LMD_BKPP:\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\n else:\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\n else:\n Kern = 1.\n \n\n\n self.Kern[j,k_w] = Kern\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\n\n\n #\t\tLOOP THAT FINDS BL DEPTH ##\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \n \n if self.LMD_KPP:\n #swdk_r only used in this function so don't need to be class attribute\n # but for testing make it an attribute to see what it is\n \n # fortran equivlanet ===> k=N,1,-1 \n for k in range(N,0,-1):\n # INDEX MAP\n k_r = k-1\n k_w = k\n\n ###################################################################### \n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\n \n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\n \n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\n \t\t\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\n \n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\n \n\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\n \n\n #######################################################################\n \n # SEARCH FOR hbls vertical level #\n '''\n kbl is specified at vertical w-level (via Cr which is at\n vertical w-levels)\n '''\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\n self.kbl[j] = k_w\n if self.LIMIT_MO_DEPTH:\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\n self.kmo[j] = k_w\n\n \n #--> still in j-loop\n #######################################################\n \n # \t\tGET SURFACE BOUNDARY LAYER DEPTH # \n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\n if self.kbl[j] > 0:\n k_w = self.kbl[j]\n k_r = k_w - 1 \n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\n \n else:\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\n \n if self.LIMIT_MO_DEPTH:\n if self.kmo[j] > 0:\n k_w = self.kmo[j]\n k_r = k_w-1\n if k_w == N:\n z_up = z_u_w[j,N]\n cff_up = np.max([0,Bo[j]])\n else:\n z_up = z_r[j,k_w+1]\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\n \n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\n + self.C_h_MO[j] * (cff_dn - cff_up)\n\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\n\n\n\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\n if self.LMD_BKPP:\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\n self.Cr[j,0] = 0.\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\n \n #---> LOOP BOTTOM TO TOP\n # FIND kbl for BBL\n for k in range(1,N+1):\n k_r = k-1\n k_w = k \n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\n \n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\n self.kbl[j] = k_w \n \n\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\n if self.kbl[j] > 0 :\n k_w = self.kbl[j] \n k_r = k_w -1\n if k_w == 1: # NO BBL CASE\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\n else:\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]","def BACF_optimized(params):\n import math as m\n import numpy as np\n import cv2\n import time\n import matplotlib.pyplot as plt\n import matplotlib.patches as patches\n\n from resizeDFT2 import resizeDFT2\n from get_pixels import get_pixels\n from get_features import get_features\n from resp_newton import resp_newton\n from get_subwindow_no_window import get_subwindow_no_window\n\n # Setting parameters\n search_area_scale = params['search_area_scale'] # size of training/detection area proportional to the target size\n output_sigma_factor = params['output_sigma_factor']\n learning_rate = params['learning_rate']\n filter_max_area = params['filter_max_area']\n nScales = params['number_of_scales'] # number of scale resolutions to check\n scale_step = params['scale_step']\n interpolate_response = params['interpolate_response']\n\n features = params['t_features']\n video_path = params['video_path']\n s_frames = params['s_frames']\n pos = np.floor(params['init_pos']) # initial centre-point (y by x) of target bounding box\n target_sz = np.floor(params['wsize']) # initial height and height of target bounding box\n\n visualization = params['visualization']\n num_frames = params['no_fram']\n init_target_sz = target_sz\n\n # Set the features ratio to the feature-cell size\n featureRatio = params['t_global']['cell_size']\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\n\n # when the number of cells are small, choose a smaller cell size\n if 'cell_selection_thresh' in params['t_global']:\n if search_area < params['t_global']['cell_selection_thresh'] * filter_max_area:\n params['t_global']['cell_size'] = min(featureRatio,\n max(1, np.ceil(m.sqrt(np.prod(init_target_sz * search_area_scale) /\n (params['t_global']['cell_selection_thresh'] *\n filter_max_area)))))\n featureRatio = params['t_global']['cell_size']\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\n\n global_feat_params = params['t_global']\n\n if search_area > filter_max_area:\n currentScaleFactor = m.sqrt(search_area / filter_max_area)\n else:\n currentScaleFactor = 1.0\n\n # target size at the initial scale\n base_target_sz = target_sz / currentScaleFactor\n\n # window size, taking padding into account\n if params['search_area_shape'] == 'proportional':\n sz = np.floor(base_target_sz * search_area_scale) # proportional area, same aspect ratio as the target\n elif params['search_area_shape'] == 'square':\n sz = np.tile(m.sqrt(np.prod(base_target_sz * search_area_scale)), [1, 2]) # ignores target aspect ratio\n elif params['search_area_shape'] == 'fix_padding':\n sz = base_target_sz + m.sqrt(np.prod(base_target_sz * search_area_scale) +\n (base_target_sz[0] - base_target_sz[1]) / 4) - \\\n sum(base_target_sz) / 2 # const padding\n else:\n raise ValueError('Unknown \"search_area_shape\". Must be \"proportional\", \"square\", or \"fix_padding\".')\n\n # set the size to exactly match the cell size\n sz = np.round(sz[0] / featureRatio) * featureRatio\n use_sz = np.floor(sz / featureRatio)\n\n # construct the label function- correlation output, 2D gaussian function, with a peak located upon the target\n # np.roll acts a circular shift operator. This is used to compute all possible patches in the entire frame\n output_sigma = m.sqrt(np.prod(np.floor(base_target_sz / featureRatio))) * output_sigma_factor\n rg = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1)/2) + 1),\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\n cg = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\n int(-1 * np.floor((use_sz[1] - 1) / 2)))\n [rs, cs] = np.meshgrid(rg, cg)\n rs = rs.T\n cs = cs.T\n # y is the desired correlation response at each point within the size of the filter\n y = np.exp(-0.5 * ((np.power(rs, 2) + np.power(cs, 2)) / np.power(output_sigma, 2)))\n yf = np.fft.fft2(y) # fast fourier transform of y\n\n if interpolate_response == 1:\n interp_sz = use_sz * featureRatio\n else:\n interp_sz = use_sz\n\n # construct cosine window\n term1 = np.array([np.hanning(use_sz[0])])\n term2 = np.array([np.hanning(use_sz[1])])\n cos_window = np.matmul(term1.T, term2)\n cos_window = cos_window.astype('float32')\n\n # Calculate feature dimension\n try:\n im = cv2.imread(video_path + '/img/' + s_frames[0])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n try:\n im = cv2.imread(s_frames[0])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n im = cv2.imread(video_path + '/' + s_frames[0])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n\n # Check to see if it is a color image or grayscale\n if im.shape[2] == 3:\n if np.all(np.equal(im[:,:,0], im[:,:,1])):\n colorImage = False\n else:\n colorImage = True\n else:\n colorImage = False\n \n if im.shape[2] > 1 and colorImage is False:\n im = im[:,:,0]\n im = im.reshape([im.shape[0], im.shape[1], 1])\n\n # create scale factors to check for object at various scale resolutions\n if nScales > 0:\n scale_exp = np.arange(-1 * np.floor((nScales - 1) / 2), np.ceil((nScales - 1) / 2) + 1)\n scaleFactors = scale_step ** scale_exp\n min_scale_factor = scale_step ** np.ceil(m.log(max(np.divide(5, sz))) / m.log(scale_step))\n max_scale_factor = scale_step ** np.floor(m.log(min(np.divide([im.shape[0],\n im.shape[1]],\n base_target_sz))) / m.log(scale_step))\n\n if interpolate_response >= 3:\n # pre-computes the grid that is used for score optimization\n ky = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1) / 2) + 1),\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\n kx = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\n int(-1 * np.floor((use_sz[1] - 1) / 2))) # --> SAME AS MATLAB\n kx = kx.T\n newton_iterations = params['newton_iterations']\n\n # initialize the projection matrix (x,y,h,w)\n rect_position = np.zeros([num_frames, 4])\n\n # allocate memory for multi-scale tracking\n multires_pixel_template = np.zeros([int(sz[0]), int(sz[1]), im.shape[2], nScales], dtype=np.uint8)\n small_filter_sz = np.floor(base_target_sz / featureRatio)\n start_time = time.time()\n\n loop_frame = 0\n for frame in range(0, len(s_frames)):\n try:\n im = cv2.imread(video_path + '/img/' + s_frames[frame])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n try:\n im = cv2.imread(s_frames[frame])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n im = cv2.imread(video_path + '/' + s_frames[frame])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n\n if im.shape[2] > 1 and colorImage is False:\n im = im[:, :, 0]\n im = im.reshape([im.shape[0], im.shape[1], 1])\n\n # do not estimate translation and scaling on the first frame, since we are just initializing the tracker\n if frame > 0:\n\n # The filter is applied on multiple resolutions of the search area. This is used to determine any changes in\n # scale of the target object\n for scale_ind in range(0, nScales):\n multires_pixel_template[:, :, :, scale_ind] = \\\n get_pixels(im, pos, np.round(sz * currentScaleFactor * scaleFactors[scale_ind]), sz)\n\n feat_term2, _ = get_features(multires_pixel_template, features, global_feat_params, None)\n xtf = np.zeros(feat_term2.shape, dtype=complex)\n for p in range(0, feat_term2.shape[2]):\n for n in range(0, feat_term2.shape[3]):\n xtf[:,:,p,n] = np.fft.fft2(np.multiply(feat_term2[:,:,p,n], cos_window[:, :]))\n responsef = np.sum(np.multiply(np.conj(g_f)[:, :, :, None], xtf), axis=2)\n\n # if we undersampled features, we want to interpolate the response to have the same size as the image patch\n if interpolate_response == 2:\n # use dynamic interp size\n interp_sz = np.floor(y.shape * featureRatio * currentScaleFactor)\n\n responsef_padded = resizeDFT2(responsef, interp_sz)\n\n # Get the response in the spatial domain\n response = np.zeros(responsef_padded.shape)\n for n in range(0, responsef.shape[2]):\n response[:,:,n] = np.real(np.fft.ifft2(responsef_padded[:,:,n])) # MAY HAVE AN ISSUE HERE NOT BEING SYMMETRIC -- therefore added real --> SAME AS MATLAB :D :)\n\n # find maximum peak\n if interpolate_response == 3:\n raise ValueError('Invalid parameter value for \"interpolate_response\"')\n elif interpolate_response == 4:\n [disp_row, disp_col, sind] = resp_newton(response, responsef_padded, newton_iterations, ky, kx, use_sz)\n\n # Check if the target has completely gone off the frame\n if np.isnan(disp_row) or np.isnan(disp_col):\n break\n\n # calculate translation vector\n if interpolate_response == 0 or 3 or 4:\n translation_vec = np.round(np.array([disp_row, disp_col]) * featureRatio *\n currentScaleFactor * scaleFactors[sind])\n elif interpolate_response == 1:\n translation_vec = np.round([disp_row, disp_col] * currentScaleFactor * scaleFactors[sind])\n elif interpolate_response == 2:\n translation_vec = np.round([disp_row, disp_col] * scaleFactors[sind])\n\n # set the scale\n currentScaleFactor = currentScaleFactor * scaleFactors[sind]\n\n # adjust to make sure we are not too large or too small\n if currentScaleFactor < min_scale_factor:\n currentScaleFactor = min_scale_factor\n elif currentScaleFactor > max_scale_factor:\n currentScaleFactor = max_scale_factor\n\n # update position\n old_pos = pos\n pos = pos + translation_vec\n\n # extract training sample image region\n pixels = get_pixels(im, pos, np.round(sz*currentScaleFactor), sz)\n\n # extract features and perform windowing\n feat_term, _ = get_features(pixels, features, global_feat_params, None)\n xf = np.zeros([feat_term.shape[1], feat_term.shape[1], feat_term.shape[2]], dtype=complex)\n for n in range(0, feat_term.shape[2]):\n xf[:, :, n] = np.fft.fft2(np.multiply(feat_term[:, :, n, 0], cos_window[:, :]))\n if frame == 0:\n model_xf = xf\n else:\n model_xf = ((1 - learning_rate) * model_xf) + (learning_rate * xf)\n\n g_f = np.zeros(xf.shape)\n g_f = g_f.astype('float32')\n h_f = g_f\n l_f = g_f\n\n # parameters from the original paper\n mu = 1\n betha = 10\n mumax = 10000\n i = 1\n\n T = np.prod(use_sz)\n S_xx = np.sum(np.multiply(model_xf.conj(), model_xf), axis=2)\n params['admm_iterations'] = 2\n\n while i <= params['admm_iterations']:\n # Solve for G\n B = S_xx + (T * mu)\n S_lx = np.sum(np.multiply(model_xf.conj(), l_f), axis=2)\n S_hx = np.sum(np.multiply(model_xf.conj(), h_f), axis=2)\n\n # equation (10) in original paper\n g_f = (((1 / (T * mu)) * np.multiply(yf[:, :, None], model_xf)) - ((1 / mu) * l_f) + h_f) - \\\n np.divide((((1 / (T * mu)) * np.multiply(model_xf, np.multiply(S_xx, yf)[:, :, None])) -\n ((1 / mu) * np.multiply(model_xf, S_lx[:, :, None])) +\n (np.multiply(model_xf, S_hx[:, :, None]))), B[:, :, None])\n\n # solve for H\n # Equation (6) in original paper\n h = np.zeros([g_f.shape[0], g_f.shape[1], g_f.shape[2]], dtype=complex)\n for n in range(0, g_f.shape[2]):\n h[:, :, n] = (T / ((mu * T) + params['admm_lambda'])) * np.fft.ifft2((mu * g_f[:, :, n]) + l_f[:, :, n])\n\n [sx, sy, h] = get_subwindow_no_window(h, np.floor(use_sz / 2), small_filter_sz)\n t = np.zeros([int(use_sz[0]), int(use_sz[1]), h.shape[2]], dtype=complex)\n t[int(sx[0]):int(sx[-1])+1, int(sy[0]):int(sy[-1])+1, :] = h\n\n h_f = np.zeros([t.shape[1], t.shape[1], t.shape[2]], dtype=complex)\n for n in range(0, t.shape[2]):\n h_f[:, :, n] = np.fft.fft2(t[:, :, n])\n\n # update L\n l_f = l_f + (mu * (g_f - h_f))\n\n # update mu- betha = 10\n mu = min(betha * mu, mumax)\n i = i + 1\n\n target_sz = np.floor(base_target_sz * currentScaleFactor)\n\n # save position and calculate FPS\n rect_position[loop_frame, :] = np.concatenate((pos[1::-1] - np.floor(target_sz[1::-1] / 2), target_sz[1::-1]))\n\n elapsed = time.time() - start_time\n\n # visualization\n if visualization == 1:\n rect_position_vis = np.concatenate((pos[1::-1] - (target_sz[1::-1] / 2), target_sz[1::-1]))\n im_to_show = im / 255\n if im_to_show.shape[2] == 1:\n im_to_show = np.tile(im_to_show, [1, 1, 3]) # if grayscale, ensure it plots image in grayscale\n if frame == 0:\n fig, ax = plt.subplots(1, num='Tracking')\n ax.imshow(im_to_show)\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\n linewidth=3, edgecolor='g', facecolor='none')\n ax.add_patch(rect)\n ax.annotate(str(frame + 1), [10, 10], color='c')\n ax.axis('off') # remove axis values\n ax.axis('image') # scale image appropriately\n ax.set_position([0, 0, 1, 1])\n fig.show()\n fig.canvas.draw()\n else:\n ax.clear()\n resp_sz = np.round(sz * currentScaleFactor * scaleFactors[scale_ind])\n xs = np.floor(old_pos[1]) + (np.arange(1, resp_sz[1] + 1)) - np.floor(resp_sz[1] / 2)\n ys = np.floor(old_pos[0]) + (np.arange(1, resp_sz[0] + 1)) - np.floor(resp_sz[0] / 2)\n sc_ind = np.floor((nScales - 1) / 2)\n\n ax.imshow(im_to_show)\n ax.axis('off') # remove axis values\n ax.axis('image') # scale image appropriately\n ax.set_position([0, 0, 1, 1])\n im_overlay = np.fft.fftshift(response[:,:,int(sc_ind)])\n ax.imshow(im_overlay, extent=[xs[0], xs[-1], ys[0], ys[-1]],\n alpha=0.2, cmap='hsv')\n rect.remove() # remove previous rectangle each time\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\n linewidth=3, edgecolor='g', facecolor='none')\n ax.add_patch(rect)\n frame_str = '# Frame: ' + str(loop_frame + 1) + ' / ' + str(num_frames)\n FPS_str = 'FPS: ' + str(1 / (elapsed / loop_frame))\n ax.annotate(frame_str, [20, 30], color='r', backgroundcolor='w')\n ax.annotate(FPS_str, [20, 60], color='r', backgroundcolor='w', fontsize=16)\n fig.show()\n fig.canvas.draw() # used to update the plot in real-time\n\n loop_frame += 1\n\n # Save results\n fps = loop_frame / elapsed\n results = {'res': rect_position, 'fps': fps}\n\n return results","def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 4th order calculation\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\n \n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n\n # Calculate truncation error between 5th and 4th order\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\n \n # Compare eps to emin and emax and update h accordingly\n if np.max(eps) < emin:\n if h*2.0 < hmax:\n h *= 2.0\n new_v = new_v5\n new_r = new_r5 \n \n if np.max(eps) > emax:\n if h/2.0 > hmin:\n h /= 2.0\n print h\n # Error too large, call rk_adaptive again with smaller h\n if recur < recurmax:\n recur += 1\n rk_adaptive(accel,m,r,h,v,recur)\n new_v = new_v5\n new_r = new_r5\n \n else:\n new_v = new_v5\n new_r = new_r5\n \n return new_v, new_r, h","def set_voltages(): \n #0) set parameters\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\n import pickle\n with open(trapFile,'rb') as f:\n trap = pickle.load(f)\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\n tc=trap.configuration\n C = tc.multipoleControl\n el = []\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\n if tc.trap_knobs != True:\n return 'WARNING: You must run trap_knobs first!'\n #2a) determine electrode voltages directly\n elif multipoleControls: # note plurality to contrast from attribute\n el = np.dot(C,coefs.T) # these are the electrode voltages\n #2b) determine electrode volages indirectly\n else:\n charge = tc.charge\n mass = tc.mass\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\n U2 = az*V0/8\n U1 = U2+ax*V0/4\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\n U1p= np.sqrt(U1**2+U3**2/2)\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\n mCf = tc.multipoleCoefficients[1:9,:]\n el = np.dot(mCf.T,inp) # these are the electrode voltages\n el = np.real(el)\n #3) regularize if set to do so\n reg = 0\n if reg: \n C = el\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\n Lambda=Lambda[0]\n el = el-(np.dot(tc.multipoleKernel,Lambda))\n return el","def WakeVorticityFromCt(r,Ct,R,U0,Omega):\n if Omega==np.inf:\n Omega=800 # TODO, implement infinite lambd formulae directly\n Lambda=Omega*R/U0\n bSwirl=Lambda<20\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\n Gamma = vk*np.pi*U0**2/Omega\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)","def WakeVorticityFromCt(r,Ct,R,U0,Omega):\n if Omega==np.inf:\n Omega=800 # TODO, implement infinite lambd formulae directly\n Lambda=Omega*R/U0\n bSwirl=Lambda<20\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\n Gamma = vk*np.pi*U0**2/Omega\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)","def homology_basis(bd, k, C=None, shortest=False, log=None):\n L1, R1, S1, L1inv = smith_normal_form_mod2(bd[k])\n L2, R2, S2, L2inv = smith_normal_form_mod2(bd[k + 1])\n\n rank1 = np.sum(S1)\n rank2 = np.sum(S2)\n nullity1 = S1.shape[1] - rank1\n betti1 = S1.shape[1] - rank1 - rank2\n cokernel2_dim = S1.shape[1] - rank2\n\n print(f'Summary: \\nrank{k} = {rank1}\\nrank{k+1} = {rank2}\\nnullity{k} = {nullity1}')\n\n ker1 = R1[:, rank1:]\n im2 = L2inv[:, :rank2]\n cokernel2 = L2inv[:, rank2:]\n cokproj2 = L2[rank2:, :]\n\n proj = matmulreduce([cokernel2, cokproj2, ker1]).transpose()\n ######\n print(proj)\n _, proj, _ = reduced_row_echelon_form_mod2(proj)\n proj = np.array(proj)\n proj = np.array([row for row in proj if np.any(row)])\n # print(f'hom basis reps: {proj*1}\\n')\n basis = []\n if shortest:\n shortest_basis = list()\n for idx, bs in enumerate(proj):\n shortest_basis.append(coset(im2, bs=bs, shortest=True))\n if C:\n basis = [interpret(C, sb) for sb in shortest_basis]\n\n proj = shortest_basis\n else:\n if C:\n basis = interpret(C, proj)\n else:\n basis = proj\n if log:\n try:\n logdict = pickle.load(open(log, 'rb'))\n except:\n logdict = dict()\n logdict.update({'k': k,\n f'betti{k}': betti1,\n 'ker': ker1,\n 'im': im2,\n 'proj': proj,\n 'basis': basis})\n pickle.dump(logdict, open(log, 'wb'))\n\n return basis","def genBzKnot(numofCV, degree):\n numofKnots = numofCV + degree - 1\n result = []\n knot = 0\n for i in range(numofKnots):\n result.append(knot)\n if(i%3 >= 2):\n knot += 1\n return result","def computeB(linsys_setup):\n datamaps, ninvs, beams, freqs, power_2d, precond_2d, clumaps, g_nu, \\\n map_prop = linsys_setup\n nx, ny, pixScaleX, pixScaleY = map_prop\n nFreq = len(g_nu); nCluster = len(clumaps[0])\n ksz = False\n if len(clumaps)==2: ksz = True\n \n def computeCMBY(d0):\n \"\"\"\n For CMB, y = S^1/2 A N^-1 d, where S is CMB signal covariance matrix (Cl's)\n \"\"\"\n # N.B. Reshaping operations required to go between 2D pixel arrays and \n # 1D vector (for linear system)\n d2 = 0\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny,nx))\n d1 *= ninvs[freq]\n a_l = fft.fft(d1,axes=[-2,-1])\n a_l *= beams[freq]*precond_2d\n d1 = numpy.real(fft.ifft(a_l,axes=[-2,-1],normalize=True))\n d1 = numpy.reshape(d1,(nx*ny))\n d2 += d1\n return d2\n \n def computeClusterY(d0):\n \"\"\"\n For cluster, y = F^T A^T N^-1 d, where F is TSZ spatial template for cluster.\n \"\"\"\n d2 = numpy.zeros(nCluster)\n for ic in range(nCluster):\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny, nx))\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[0][ic][freq] * g_nu[freq])\n return d2\n \n def computeClusterKSZY(d0):\n \"\"\"\n For cluster, y = K^T A^T N^-1 d, where K is KSZ spatial template for cluster.\n \"\"\"\n d2 = numpy.zeros(nCluster)\n for ic in range(nCluster):\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny, nx))\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[1][ic][freq])\n return d2\n \n def computeMonopoleY(d0):\n \"\"\"\n Overall monopole amplitude.\n \"\"\"\n d2 = 0\n for freq in range(nFreq):\n d1 = d0[freq].data.copy().reshape((ny, nx))\n d2 += numpy.sum(d1 * ninvs[freq])\n return(d2)\n \n \n # CMB realisation; convolve white noise map with beam and multiply by \n # signal covmat S^1/2 in harmonic space\n b0 = numpy.random.randn(ny,nx)\n a_l = numpy.fft.fft2(b0, b0.shape)\n a_l *= precond_2d * power_2d**(-0.5)\n b0 = numpy.fft.irfft2(a_l, b0.shape)\n \n # Calculate per-band noise realisation.\n # Multiply by pixel-space N^1/2, convolve with beam, and sum over \n # cluster pixels to get RHS\n b1 = 0; b4 = 0\n b2 = numpy.zeros(nCluster)\n if ksz: b3 = numpy.zeros(nCluster)\n \n for freq in range(nFreq):\n _b = numpy.random.randn(ny,nx) * ninvs[freq]**0.5\n a_l = numpy.fft.fft2(_b) * beams[freq] * precond_2d\n b1 += numpy.fft.irfft2(a_l, _b.shape)\n b4 += numpy.sum(_b)\n for ic in range(nCluster):\n b2[ic] += numpy.sum( _b * g_nu[freq] * clumaps[0][ic][freq] )\n if ksz: b3[ic] += numpy.sum( _b * clumaps[1][ic][freq] )\n\n b0 = numpy.reshape(b0,(nx*ny))\n b1 = numpy.reshape(b1,(nx*ny))\n \n\n # Compute CMB and cluster data parts of b\n b_CMB = computeCMBY(datamaps) + b0 + b1\n b_mono = computeMonopoleY(datamaps) + b4\n b_tsz = computeClusterY(datamaps) + b2\n if ksz: b_ksz = computeClusterKSZY(datamaps) + b3\n \n # Return total b vector (Ncmbpix + 1 + (1|2)*Ncluster elements in vector)\n b = numpy.append(b_CMB, b_mono)\n b = numpy.append(b, b_tsz)\n if ksz: b = numpy.append(b, b_ksz)\n return b","def compute_gain( hv, cv, thot, tcold):\n\n nData = len(cv) \n epsilons = np.full( nData, EPSILON)\n\n # For full Temp calibration, a spectrum taken at high elevation, away from \n # The galactic plan is used.\n dv = hv - cv \n dv = np.maximum( dv, epsilons)\n hv = np.maximum( hv, epsilons)\n\n # use the comparison of hot and cold to get gain without trx contribution\n gain = (thot - tcold)/dv\n\n trx = gain*cv \n trx = trx - tcold # correct for cold load input in counts\n\n n6 = int(nData/6)\n n56 = 5*n6\n\n trxmedian = np.median( trx[n6:n56])\n gain = (thot + trxmedian)/hv\n \n return trxmedian, gain # channel by channel gain in K/counts","def _ftl_jump(self, y, K, **kwargs):\n\n logger.debug(\"Re-initializing with K-means++ at K = {}\".format(K))\n\n # Initialize new centroids by k-means++\n mixtures = []\n mls = []\n for z in range(30):\n\n mean = kmeans._k_init(y, K, kmeans.row_norms(y, squared=True),\n kmeans.check_random_state(None))\n\n # Calculate weights by L2 distances to closest centers.\n distance = np.sum((y[:, :, None] - mean.T)**2, axis=1).T\n\n N, D = y.shape\n responsibility = np.zeros((K, N))\n responsibility[np.argmin(distance, axis=0), np.arange(N)] = 1.0\n\n weight = responsibility.sum(axis=1)/N\n\n covariance = _estimate_covariance_matrix(y, responsibility, mean,\n self.covariance_type, self.covariance_regularization)\n\n mixture = self.__class__(\n threshold=self.threshold,\n covariance_type=self.covariance_type,\n max_em_iterations=self.max_em_iterations,\n covariance_regularization=self.covariance_regularization)\n\n # Initialize it.\n mixture.set_parameters(mean=mean, weight=weight, covariance=covariance)\n\n # Run E-M on the partial mixture.\n R, meta = mixture._expectation_maximization(\n y, parent_responsibility=responsibility)\n raise UnsureError\n\n mixtures.append(mixture)\n mls.append(meta[\"message_length\"])\n\n print(np.std(mls))\n index = np.argmin(mls)\n mixture = mixtures[index]\n\n #slogdet = np.sum(np.log(np.linalg.det(mixture.covariance)))\n slogdet = np.sum(_slogdet(mixture.covariance, mixture.covariance_type))\n self._proposed_mixtures.append(mixture)\n self._mixture_predictors.append([\n mixture.weight.size,\n np.sum(np.log(mixture.weight)),\n meta[\"log_likelihood\"],\n slogdet,\n -meta[\"log_likelihood\"] + (D+2)/2.0 * slogdet\n ])\n # TODO: Remove predictors that we don't use.\n #self._slogs.append(np.linalg.det(mixture.covariance))\n\n return mixture, R, meta #(len(self._proposed_mixtures) - 1, R, meta)\n\n\n raise a\n\n #self.set_parameters(\n # weight=weight, mean=mean, covariance=covariance)\n\n #return responsibility","def fit_full(self, K, epsilon=1e-3,power_ep=[1.,1.]):\r\n self.epsilon = epsilon\r\n self.eta, self.delta = power_ep\r\n\r\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\r\n mu = np.zeros(self.num_data)\r\n Sigma = K.copy()\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.num_data,dtype=float)\r\n self.v_ = np.empty(self.num_data,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.num_data,dtype=float)\r\n self.Z_hat = np.empty(self.num_data,dtype=float)\r\n phi = np.empty(self.num_data,dtype=float)\r\n mu_hat = np.empty(self.num_data,dtype=float)\r\n sigma2_hat = np.empty(self.num_data,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = self.epsilon + 1.\r\n epsilon_np2 = self.epsilon + 1.\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.num_data)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model.moments_match(self.data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\r\n mu = np.dot(Sigma,self.v_tilde)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\r\n B = np.eye(self.num_data) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\r\n L = jitchol(B)\r\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\r\n Sigma = K - np.dot(V.T,V)\r\n mu = np.dot(Sigma,self.v_tilde)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.num_data\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.num_data\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def ridge_cv(trn_fs, trn_data, val_fs=None, val_data=None, alphas=DEFAULT_ALPHAS, \n n_resamps=10, n_splits=10, chunk_sz=5000, dtype=np.single,pthr=0.005,\n square_alpha=False,is_verbose=False):\n #def ridge_cv(model,data,n_splits=10,n_resamps=10,alpha=DEFAULT_ALPHAS,efficient=np.nan,):\n # (trn_fs, trn_data, val_fs, val_data, alphas, nboots, chunklen, n_chunks, dtype=np.single, corrmin=0.2):\n n_resp, n_voxels = trn_data.shape\n _,n_channels = trn_fs.shape\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\n bestalphas = np.zeros((n_resamps, n_voxels)) ## Will hold the best alphas for each voxel\n trn_idx,val_idx = _utils.contig_partition(trn_fs.shape[0],n_splits)\n\n Rcmats = np.zeros((n_voxels,len(alphas),n_resamps))\n for iRpt,cvi in enumerate(np.random.permutation(n_splits)[:n_resamps]):\n if is_verbose:\n print('Running split %d/%d'%(iRpt+1,n_resamps))\n ti,vi = trn_idx[cvi],val_idx[cvi]\n trn_fs_split = trn_fs[ti,:]\n val_fs_split = trn_fs[vi,:]\n trn_data_split = trn_data[ti,:]\n val_data_split = trn_data[vi,:]\n \n # Run ridge regression to estimate predictions (within training set) for different alphas\n Rcmats[:,:,iRpt] = _fit_ridge_alpha(trn_fs_split, trn_data_split, val_fs_split, val_data_split, alphas,\n dtype=dtype, chunk_sz=chunk_sz,pthr=pthr,square_alpha=square_alpha)\n if is_verbose:\n print(\"Finding best alpha...\")\n ## Find best alpha for each voxel\n #trncc_byvox = np.nansum(Rcmats,axis=2)/np.sum(np.logical_not(np.isnan(Rcmats)),axis=2)\n trncc_byvox = np.nanmean(Rcmats,axis=2)\n # Taking mean is BS: too many voxels poorly predicted, floor effect. \n #mean_cv_corr = np.nanmean(mean_cv_corr_byvox,axis=0)\n #bestalphaind = np.argmax(mean_cv_corr)\n # Thus just count voxels over significance threshold (with a lenient threshold)\n #print(len(vi))\n sig_thresh = _sutils.pval2r(pthr,len(vi),is_two_sided=False)\n n_sig_vox_byalpha = sum(trncc_byvox>sig_thresh)-sum(trncc_byvox<-sig_thresh)\n bestalphaind = np.argmax(n_sig_vox_byalpha)\n alpha = alphas[bestalphaind]\n if is_verbose:\n print(\"Best alpha = %0.3f\"%alpha)\n \n ## Find weights for each voxel\n U,S,Vt = np.linalg.svd(trn_fs, full_matrices=False)\n # Loop over groups of voxels\n wt = np.zeros((n_channels,n_voxels),dtype=dtype)\n\n ###\n if (not val_fs is None) and (not val_data is None):\n # Validation data / model supplied implies we want predictions\n do_pred = True\n if np.sum(val_fs[:,0]) != val_fs.shape[0]:\n warnings.warn('First column of val_fs is NOT all ones! Consider including a DC term!')\n # Pre-allocate for predictions, with or without separate validation sequences to predict\n is_rpts = np.ndim(val_data)==3\n if is_rpts:\n n_rpts,n_tps_val,n_voxels_val = val_data.shape\n cc = np.zeros((n_rpts,n_voxels),dtype);\n else:\n n_rpts,(n_tps_val,n_voxels_val) = 0,val_data.shape\n cc = np.zeros((n_voxels),dtype);\n pred = np.zeros((n_tps_val,n_voxels_val),dtype)\n else:\n # No Validation data / model supplied\n do_pred = False;\n\n if is_verbose:\n predstr = ' and model predictions...' if do_pred else \"...\"\n print('Computing weights'+predstr)\n for iChunk in range(n_chunks):\n if is_verbose:\n print('Running chunk %d of %d...\\n'%(iChunk+1,n_chunks))\n ChIdx = np.arange(chunk_sz) + chunk_sz*iChunk\n ChIdx = ChIdx[ChIdx<n_voxels] # clip extra voxels in last run.\n Ychunk = trn_data[:,ChIdx]\n\n UtYchunk = np.dot(U.T, np.nan_to_num(Ychunk))\n if square_alpha:\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha**2)), UtYchunk])\n else:\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha)), UtYchunk])\n\n ## Find test correlations if validation data is present\n if do_pred:\n # Compute correlations btw validation data and model prediction\n pred[:,ChIdx] = val_fs.dot(wt[:,ChIdx]).astype(dtype) \n nnpred = np.nan_to_num(pred[:,ChIdx])\n if is_rpts:\n # The transpose here is related to deep mysteries in python. See \n cc[:,ChIdx] = np.vstack([_sutils.column_corr(nnpred,val_data[rpt,:,ChIdx].T) for rpt in range(n_rpts)])\n else:\n cc[ChIdx] = _sutils.column_corr(nnpred,val_data[:,ChIdx])\n\n # Output\n out = dict(\n weights=wt,\n alpha=alpha,\n n_sig_vox_byalpha=n_sig_vox_byalpha,\n #trncc_byvox=trncc_byvox,f\n #trncc_byvox_byalpha=Rcmats\n )\n if not val_data is None: \n out['cc'] = cc\n return out","def pfit(Vrf,Vdc,X,Y,Z,Irf,Jrf,Krf):\n #1) find dc potential\n #from all_functions import plot_potential,p2d,trap_depth,find_saddle,exact_saddle\n from project_parameters import charge,mass,driveAmplitude,Omega,debug,scale\n #2) find pseudopotential\n \"\"\"Gebhard, Oct 2010:\n changed back to calculating field numerically in ppt2 instead directly\n with bemsolver. this is because the slow bemsolver (new version) does not output EX, EY, EZ.\"\"\"\n [Ey,Ex,Ez] = np.gradient(Vrf,abs(X[1]-X[0])/scale,abs(Y[1]-Y[0])/scale,abs(Z[1]-Z[0])/scale) # fortran indexing\n Esq = Ex**2 + Ey**2 + Ez**2\n #3) plotting pseudopotential, etc; outdated?\n PseudoPhi = Esq*(charge**2)/(4*mass*Omega**2) \n U = PseudoPhi+charge*Vdc # total trap potential\n if debug.pfit:\n# plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Ex,X,Y,Z,'1D plots','Ex','U_{ps} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Ey,X,Y,Z,'1D plots','Ey','U_{ps} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Ez,X,Y,Z,'1D plots','Ez','U_{ps} (eV)',[Irf,Jrf,Krf]) \n# plot_potential(Esq,X,Y,Z,'1D plots','E**2','U_{ps} (eV)',[Irf,Jrf,Krf])\n plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\n plot_potential(PseudoPhi/charge,X,Y,Z,'1D plots','Pseudopotential','U_{ps} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Vdc,X,Y,Z,'1D plots','DC Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\n plot_potential(U/charge,X,Y,Z,'1D plots','Trap Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\n #4) determine trap frequencies and tilt in radial directions\n Uxy = U[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]\n MU = np.max(Uxy) # normalization factor, will be undone when calculating frequencies\n Uxy = Uxy/MU \n nx,ny,nz=X.shape[0],Y.shape[0],Z.shape[0]\n x,y,z = np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz))\n for i in range(nx):\n for j in range(ny):\n for k in range(nz):\n x[i,j,k] = X[i]\n y[i,j,k] = Y[j]\n z[i,j,k] = Z[k]\n dL = x[Irf+3,Jrf,Krf]-x[Irf,Jrf,Krf] # is this X? Originally x. Temporarily y so that dL not 0. Probably related to meshgrid or indexing.\n xr = (x[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-x[Irf,Jrf,Krf])/dL \n yr = (y[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-y[Irf,Jrf,Krf])/dL\n [C1,C2,theta] = p2d(Uxy,xr,yr) \n C1,C2,theta = C1[0],C2[0],theta[0] \n fx = (1e3/dL)*np.sqrt(abs(2*C1*MU/(mass)))/(2*np.pi)\n fy = (1e3/dL)*np.sqrt(abs(2*C2*MU/(mass)))/(2*np.pi)\n #5) trap frequency in axial direction\n Uz=U[Irf,Jrf,:] # old projection\n l1 = np.max([Krf-6,1])\n l2 = np.min([Krf+6,np.max(Z.shape)])\n p = np.polyfit((Z[l1:l2+1]-Z[Krf])/dL,Uz[l1:l2+1],6)\n fz = (1e3/dL)*np.sqrt(2*p[4]/mass)/(2*np.pi)\n [Depth,Xe,Ye,Ze] = trap_depth(U/charge,X,Y,Z,Irf,Jrf,Krf) \n return [fx,fy,fz,theta,Depth,Xe,Ye,Ze]","def performance(N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w):\n \"\"\"\"I have produced two plots. The first one p24.png compares the time taken\n by solveFlunet with the three different RHS methods. We notice that the fastest\n technique is using the RHS computed in Python. This can be explained by the \n fact that in Python we have vectorized our calculations whereas in Fortran\n we used a loop for our calculations. Secondly, we also notice that solveFlunet \n is faster using the Fortran OMP code than using the Fortran code. This\n is expected since we use two threads with the Fortran OMP code instead of \n only one with the regular Fortran code. The second plot p25.png provides\n the speedup of the Fortran OMP RHS compared to the Fortran RHS.\n The speedup is less than 1 for small values of Nt but increases as Nt\n increases. It goes up to 1.6 for larger sized problems, which is quite\n satisfying. We can expect that it the speedup to reach 2 for even larger\n problem sizes.\n \"\"\"\n #I have added as inputs N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w to\n #be able to call initialize and solveFluNet\n Nt = Ntmax/10\n dt = Ntmax/10\n Ntu = np.zeros(10)\n \n #tpy,tf90 and tf90OMP are the times for our different RHS\n #methods\n tpy = np.zeros(10)\n tf90 = np.zeros(10)\n tf90OMP = np.zeros(10)\n \n #speedup is the speedup of the Fortran OMP RHS compared\n #to the Fortran RHS\n speedup = np.zeros(10)\n \n for i in range(10):\n #compute initial conditions\n init,infnode,P = initialize(N0,L,Nt,True)\n N = N0+Nt\n \n #time solveFluNet for the three different RHS\n t0 = time()\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,1)\n t1 = time()\n tpy[i] = t1-t0\n t0 = time()\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,2)\n t1 = time()\n tf90[i] = t1-t0\n t0 = time()\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,3)\n t1 = time()\n tf90OMP[i] = t1-t0\n \n #time the two Fortran RHS methods\n t0 = time()\n fn.rhs(P,init,1,a,b0,b1,g,k,w)\n tRHS = time() - t0\n t0 = time()\n fn.rhs_omp(P,init,1,a,b0,b1,g,k,w,2)\n tRHSOMP = time() - t0\n speedup[i] = tRHS/tRHSOMP\n \n Ntu[i] = Nt\n Nt = Nt+dt\n \n plt.figure()\n plt.plot(Ntu,tpy,label='Time with Python RHS')\n plt.plot(Ntu,tf90,label='Time with Fortran RHS')\n plt.plot(Ntu,tf90OMP,label='Time with Fortran OMP RHS')\n plt.legend(loc='best')\n plt.title('performance Mathilde Duverger')\n plt.xlabel('Nt')\n plt.ylabel('Time of solveFluNet')\n \n plt.figure()\n plt.plot(Ntu,speedup,label='Speedup for RHS')\n plt.legend(loc='best')\n plt.title('performance Mathilde Duverger')\n plt.xlabel('Nt')\n plt.ylabel('Speedup of the Fortran OMP code compared to the Fortran code')\n plt.show()","def _plot_ctc(self, save_path=None, topk=10):\n if self.ctc_weight == 0:\n return\n if len(self.ctc.prob_dict.keys()) == 0:\n return\n from matplotlib import pyplot as plt\n if save_path is not None and os.path.isdir(save_path):\n shutil.rmtree(save_path)\n os.mkdir(save_path)\n elen = self.ctc.data_dict['elens'][-1]\n probs = self.ctc.prob_dict['probs'][-1, :elen]\n topk_ids = np.argsort(probs, axis=1)\n plt.clf()\n n_frames = probs.shape[0]\n times_probs = np.arange(n_frames)\n plt.figure(figsize=(20, 8))\n for idx in set(topk_ids.reshape(-1).tolist()):\n if idx == 0:\n plt.plot(times_probs, probs[:, 0], ':', label='<blank>', color='grey')\n else:\n plt.plot(times_probs, probs[:, idx])\n plt.xlabel(u'Time [frame]', fontsize=12)\n plt.ylabel('Posteriors', fontsize=12)\n plt.xticks(list(range(0, int(n_frames) + 1, 10)))\n plt.yticks(list(range(0, 2, 1)))\n plt.tight_layout()\n if save_path is not None:\n plt.savefig(os.path.join(save_path, 'prob.png'))\n plt.close()","def eclatGeneration(self, cList):\n # to generate all\n tidList = {}\n key = list(cList.keys())\n for i in range(0, len(key)):\n nighbousItems=self.getNighboirItems(key[i])\n for j in range(i + 1, len(key)):\n # print(c[key[i]],c[key[j]])\n if not key[j] in nighbousItems:\n \tcontinue\n intersectionList = list(set(cList[key[i]]).intersection(set(cList[key[j]])))\n itemList = []\n itemList += key[i]\n itemList += key[j]\n if len(intersectionList) >= self.minSup:\n itemList.sort()\n if tuple(itemList) not in tidList:\n tidList[tuple(set(itemList))] = intersectionList\n return tidList","def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\n\n # def Q_gen(I, R):\n # w = I * I * R\n # return w\n\n # def Q_rad_in(I_sun, A_s, a_s):\n # w = I_sun * D * a_s\n # return w\n\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\n # w = htcoeff * A_s * (T_line - T_amb)\n # return w\n\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\n # return w\n\n def reynolds(V, D, v, Mair=1.103):\n r = V * D / v\n return r\n\n def nusselt(Re, Pr):\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\n c = (Re / 282000) ** (5.0/8.0)\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\n return n\n\n def air_prop(T_amb):\n # temp v k Pr\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\n [250, 11.44e-6, 22.3e-3, 0.720],\n [300, 15.89e-6, 26.3e-3, 0.707],\n [350, 20.92e-6, 30.0e-3, 0.700],\n [400, 26.41e-6, 33.8e-3, 0.690],\n [450, 32.39e-6, 37.3e-3, 0.686],\n [500, 38.79e-6, 40.7e-3, 0.684],\n [550, 45.57e-6, 43.9e-3, 0.683],\n [600, 52.69e-6, 46.9e-3, 0.685]])\n\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\n 0, air_prop[:,1:])\n return v, k, Pr\n\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\n if 273 <= T_line <= 323:\n R = ((R_lo + \n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\n *(T_line - T_range[0]))/N_cond)\n elif T_line > 323:\n R = ((R_mid + \n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\n *(T_line - T_range[1]))/N_cond)\n else:\n R = R_lo\n print('Out of bounds')\n return R\n\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\n temp_factor = 1\n wind_factor = 1\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\n\n T_amb = T_amb*temp_factor\n V = V*wind_factor\n\n v, k, Pr = air_prop(T_amb)\n Re = reynolds(V, D, v)\n htcoeff = nusselt(Re, Pr) * k / D\n\n def T_line(T_init):\n \n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\n print R\n\n C4 = e_s * sigma * D * math.pi\n C3 = 0.0\n C2 = 0.0\n C1 = htcoeff * D * math.pi\n C0 = - ( I ** 2 * R\n + I_sun * a_s * D\n + htcoeff * D * math.pi * T_amb\n + e_s * D * math.pi * sigma * (T_amb ** 4))\n\n return np.roots([C4, C3, C2, C1, C0])\n\n T_c = T_amb\n \n for i in range(n_iter):\n T_arr = T_line(T_c)\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\n print T_c\n\n return T_c","def solve(list_k, examples, out_path, centers_=None,\n conf_num=None, out_minus=True, out_iterations=False):\n\n # start_centers = utils.get_centers()\n dimension = len(examples[0][0])\n # print (dimension)\n N = len(examples) # print(N)\n for k in list_k:\n # sys.stderr.write(str(k) + \"\\n\")\n h = np.zeros((N, k), dtype=np.float64)\n # responsibilities.fill(1/float(k))\n pi_k = np.zeros(k, dtype=np.float64)\n pi_k.fill(1/float(k))\n # print\n configuration = False\n if centers_ == None:\n centers = utils.get_centers(k, examples)\n else:\n centers = centers_\n configuration = True\n\n matrix = np.identity(dimension, dtype=np.float64)\n matrices = np.array([matrix] * k)\n # print (matrices)\n log = calc_log(examples, centers, matrices, pi_k)\n # print (log)\n\n # output stuff\n num_iter = 0\n # if k == 4:\n # groups = [list([])] * k\n groups = []\n for i in range(k):\n groups.append([])\n probabilities = dict()\n\n # if k == 4:\n # print (h)\n # print (pi_k)\n # print (matrices)\n # print (centers)\n\n if out_iterations:\n iter_out = open(out_path + \"em-kmeans.dat\", \"w\")\n iter_out.write(\"#iteracije: log-izglednost\\n\")\n iter_out.write(\"--\\n\")\n iter_out.write(\"#0: %.2lf\\n\" % log)\n # buffer_all = \"K = %d\\n\" % k\n # number of members in a certain group\n\n while True:\n num_iter += 1\n group_count = [0] * k\n # init = dict()\n group_dicts = []\n for i in range(k):\n group_dicts.append({})\n # group_dicts = [] * k\n # E step\n # print (num_iter)\n # changed = 0\n for i in range(N):\n x = examples[i][0]\n mi_j = centers[0][0]\n sigma_j = matrices[0]\n p = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[0]\n h[i][0] = p\n sum_h = h[i][0]\n probabilities[i] = p\n group = examples[i][1]\n if group not in group_dicts[0]:\n group_dicts[0][group] = 1\n else:\n group_dicts[0][group] += 1\n\n # if p > \n group_count[0] += 1\n examples[i][2] = 0\n\n for j in range(1,k):\n mi_j = centers[j][0]\n sigma_j = matrices[j]\n # print (sigma_j)\n p2 = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[j]\n if p2 > p:\n group_count[examples[i][2]] -= 1\n group_dicts[examples[i][2]][group] -= 1\n if group not in group_dicts[j]:\n group_dicts[j][group] = 1\n else:\n group_dicts[j][group] += 1\n examples[i][2] = j\n group_count[j] += 1\n p = p2\n probabilities[i] = p\n\n h[i][j] = p2\n sum_h += h[i][j]\n\n h[i] /= sum_h\n probabilities[i] /= sum_h\n # print (\"$$$$$$$\")\n # M step\n # if num_iter == 1:\n # print (h)\n # sys.exit(1)\n for i in range(k):\n new_mi = np.zeros(dimension, dtype=np.float64)\n sum_h = 0.\n new_sigma = np.zeros((dimension, dimension), dtype=np.float64)\n\n for j in range(N):\n x = examples[j][0]\n sum_h += h[j][i]\n new_mi += h[j][i] * x\n\n new_mi /= sum_h\n # if utils.euclid(new_mi, centers[i][0]) > EPS:\n # changed = 1\n centers[i] = (new_mi, centers[i][1], centers[i][2])\n\n # mi = np.matrix(new_mi)\n mi = new_mi\n for j in range(N):\n x = examples[j][0]\n # print ((x-mi).T * (x - mi))\n diff = np.matrix(x - mi)\n # print (diff.T * diff)\n new_sigma += h[j][i] * (diff.T * diff)\n # break\n\n new_sigma /= sum_h\n matrices[i] = new_sigma\n new_pi = sum_h / float(N)\n pi_k[i] = new_pi\n\n # print (matrices)\n # if num_iter == 1:\n # sys.exit(1)\n\n new_log = calc_log(examples, centers, matrices, pi_k)\n\n # print (new_log)\n if abs(new_log - log) < EPS:\n break\n log = new_log\n # if k == 4:\n # print (log)\n if out_iterations:\n iter_out.write(\"#%d: %.2lf\\n\" % (num_iter, log))\n # if changed == 0:\n # break\n\n # set the groups for K = 4\n # print (groups)\n if not configuration and not out_iterations:\n if k == 4:\n for i in range(N):\n # print (examples[i][2])\n # print (groups)\n groups[examples[i][2]].append((examples[i][1], probabilities[i]))\n\n with open(out_path + \"/em-k4.dat\", \"a\") as f:\n for i in range(k):\n # print (len(groups[i]))\n groups[i] = sorted(groups[i], key=lambda tup: tup[1], reverse=True)\n f.write(\"Grupa %d:\\n\" % (i+1))\n for j in range(len(groups[i])):\n f.write(groups[i][j][0] + \" %.2lf\\n\" % groups[i][j][1])\n if i < k-1:\n f.write(\"--\\n\")\n\n with open(out_path + \"/em-all.dat\", \"a\") as f:\n f.write(\"K = %d\\n\" % k)\n for i in range(k):\n f.write(\"c%d:\" % (i+1))\n for j in range(dimension):\n f.write(\" %.2lf\" % centers[i][0][j])\n f.write(\"\\n\")\n f.write(\"grupa %d: %d primjera\\n\" % ((i+1), group_count[i]))\n f.write(\"#iter: %d\\n\" % num_iter)\n f.write(\"log-izglednost: %.2lf\\n\" % log)\n if k < 5:\n f.write(\"--\\n\")\n elif not out_iterations:\n with open(out_path + \"/em-konf.dat\", \"a\") as f:\n f.write(\"Konfiguracija %d:\\n\" % conf_num)\n f.write(\"log-izglednost: %.2lf\\n\" % log)\n f.write(\"#iteracija: %d\\n\" % num_iter)\n if out_minus == True:\n f.write(\"--\\n\")\n # if i < k - 1:\n else:\n iter_out.write(\"--\\n\")\n for i in range(len(group_dicts)):\n iter_out.write(\"Grupa %d:\" % (i+1))\n buff = \"\"\n for key in group_dicts[i]:\n buff += \" \" + key + \" %d\" % group_dicts[i][key] + \",\"\n\n buff = buff[:-1]\n iter_out.write(buff + \"\\n\")\n # pass","def heatbasic(u0,T,K):\n import numpy as np\n N = len(u0)-1\n\n dx = 1.0/N;\n dt = 0.1/K;\n x = np.linspace(0,1,N+1)\n\n u = np.copy(u0)\n\n u_history = [u]\n\n A = np.zeros( (N+1,N+1) )\n for i in range(1,N):\n A[i,i-1] = 1;\n A[i,i] = -2;\n A[i,i+1] = 1\n A = A * dt/(dx*dx)\n A = A + np.eye(N+1)\n A[0,0] = 0.0;\n A[N,N] = 0.0;\n\n for k in range(K):\n u = np.dot(A,u)\n u_history.append(u)\n\n return u_history","def decision_heatmaps(obs):\n global model\n assert obs > 4 and obs < 1788, \"Chosen observation is outside the range of the demonstration episode.\"\n saved_observations = np.load('saved_observations.npy')\n state = saved_observations[obs-3:obs+1]\n state_batch = np.expand_dims(state, axis=0)\n q_vals = model.compute_q_values(state)\n print(q_vals)\n decision = np.argmax(q_vals)\n print(decision)\n decision_encodings = ['None','Up','Right','Left','Down','Right-Up','Left-Up','Right-Down','Left-Down']\n decision_node = model.model.output[:, decision]\n last_conv_layer = model.model.layers[3]\n grads = K.gradients(decision_node, last_conv_layer.output)[0]\n pooled_grads = K.mean(grads, axis=(0,2,3))\n frame = Image.fromarray(state[-1])\n iterate = K.function([model.model.input],[pooled_grads, last_conv_layer.output[0]])\n pooled_grads_value, conv_layer_output_value = iterate([state_batch])\n for i in range(64):\n conv_layer_output_value[i, :, :] *= pooled_grads_value[i]\n\n heatmap = np.mean(conv_layer_output_value, axis=0)\n heatmap = np.maximum(heatmap, 0)\n heatmap /= np.max(heatmap)\n heatmap = cv2.resize(heatmap, (84, 84))\n heatmap = np.uint8(255 * heatmap)\n superimposed_img = heatmap * .3 + np.array(frame) * .35\n\n plt.xlabel(decision_encodings[decision])\n plt.imshow(superimposed_img, cmap='gray')\n plt.show()","def lac(X, conts, k, nsteps=30, window_size=1):\n dim = len(conts)\n\n #np.random.seed(42)\n # Initialize parameters\n priors = np.ones(k) / k\n\n\n import sys; sys.stdout.flush()\n if X is not None:\n means, covars = initialize_sample_kmeans(X, k)\n else:\n means, covars = initialize_random(conts, k)\n\n #means, covars = initialize_kmeans(conts, k)\n\n w = [np.empty((k, len(c[0]),)) for c in conts]\n\n\n for i in range(1, nsteps + 1):\n for l, (c, cw) in enumerate(conts):\n lower = l - window_size if l - window_size >= 0 else None\n upper = l + window_size + 1 if l + window_size + 1 <= dim else None\n dims = slice(lower, upper)\n active_dim = min(l, window_size)\n\n x = c\n\n # E step\n for j in range(k):\n if any(np.abs(covars[j, dims]) < 1e-15):\n assert False, 'covars should be fixed'\n\n det = covars[j, dims].prod()\n inv_covars = 1. / covars[j, dims]\n xn = x - means[j, dims]\n factor = (2.0 * np.pi) ** (x.shape[1]/ 2.0) * det ** 0.5\n w[l][j] = priors[j] * np.exp(np.sum(xn * inv_covars * xn, axis=1) * -.5) / factor\n wsum = w[l].sum(axis=0)\n wsum[wsum == 0] = 1.\n w[l] /= wsum\n\n # M step\n n = np.sum(w[l], axis=1)\n priors = n / np.sum(n)\n for j in range(k):\n if n[j]:\n mu = np.dot(w[l][j, :] * cw, x[:, active_dim]) / (w[l][j, :] * cw).sum()\n\n xn = x[:, active_dim] - mu\n sigma = np.sum(xn ** 2 * w[l][j] * cw, axis=0) / (w[l][j, :] * cw).sum()\n sigma = sigma if sigma > 1e-3 else 1e-3\n\n if np.isnan(mu).any() or np.isnan(sigma).any():\n return w, means, covars, priors\n else:\n mu = means[j, l]\n sigma = MIN_COVARIANCE\n means[j, l] = mu\n covars[j, l] = sigma\n\n # w = np.zeros((k, m))\n # for j in range(k):\n # if active[j]:\n # det = covars[j].prod()\n # inv_covars = 1. / covars[j]\n # xn = X - means[j]\n # factor = (2.0 * np.pi) ** (xn.shape[1] / 2.0) * det ** 0.5\n # w[j] = priors[j] * exp(-.5 * np.sum(xn * inv_covars * xn, axis=1)) / factor\n # w[active] /= w[active].sum(axis=0)\n\n return w, means, covars, priors","def __init__(self, num_heads: int, size: int, size_v: int, dropout: float = 0.1):\n super(ContMultiHeadedAttention, self).__init__()\n\n assert size % num_heads == 0\n\n self.head_size = head_size = size // num_heads\n self.model_size = size\n self.num_heads = num_heads\n\n self.k_layer = nn.Linear(size, num_heads * head_size)\n self.v_layer = nn.Linear(size_v, num_heads * head_size)\n self.q_layer = nn.Linear(size, num_heads * head_size)\n\n self.output_layer = nn.Linear(size, size_v)\n self.softmax = nn.Softmax(dim=-1)\n self.dropout = nn.Dropout(dropout)","def cvstem(self):\n if (self.iEC == \"est\") and (len(sig(self.Cfun).parameters) == 1):\n fun1 = self.Cfun\n self.Cfun = lambda x,p: fun1(x)\n if (self.iEC == \"est\") and (len(sig(self.Gw).parameters) == 1):\n fun2 = self.Gw\n self.Gw = lambda x,p: fun2(x)\n if self.iEC == \"est\":\n self.c_over = self.matrix_2bound(self.Cfun)\n self.g_over = self.matrix_2bound(self.Gw)\n if (len(sig(self.Bw).parameters) == 1):\n fun3 = self.Bw\n self.Bw = lambda x,p: fun3(x)\n self.b_over = self.matrix_2bound(self.Bw)\n self.linesearch()\n alp = self.alp_opt\n Nx = self.Nx\n Nsplit = 1\n Np = int(Nx/Nsplit)\n Nr = np.remainder(Nx,Nsplit)\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\n Nxp = self.n+self.n_p\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\n Ws_opt = []\n chi_opt = 0\n nu_opt = 0\n print(\"========================================================\")\n print(\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\")\n print(\"========================================================\")\n for p in range(Np):\n if np.remainder(p,int(Np/10)) == 0:\n print(\"# sampled metrics: \",p*Nsplit,\"...\")\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n if Nr != 0:\n print(\"# samples metrics: \",Nx,\"...\")\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n self.xs_opt = xs_opt\n self.ps_opt = ps_opt\n self.Ws_opt = Ws_opt\n self.chi_opt = chi_opt\n self.nu_opt = nu_opt\n if self.iEC == \"est\":\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\n print(\"Optimal steady-state estimation error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n elif self.iEC == \"con\":\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\n print(\"Optimal steady-state tracking error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n else:\n raise ValueError('Invalid iEC: iEC = \"est\" or \"con\"')\n self.M2cholM()\n path = \"models/optvals/\"+self.fname\n if os.path.exists(path) == False:\n try:\n os.makedirs(path)\n except: \n raise OSError(\"Creation of directory %s failed\" %path)\n else:\n print (\"Successfully created directory %s \" %path)\n else:\n print (\"Directory %s already exists\" %path)\n np.save(path+\"/alp_opt.npy\",alp)\n np.save(path+\"/chi_opt.npy\",self.chi_opt)\n np.save(path+\"/nu_opt.npy\",self.nu_opt)\n np.save(path+\"/Jcv_opt.npy\",self.Jcv_opt)\n print(\"========================================================\")\n print(\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\")\n print(\"========================================================\\n\\n\")\n pass"],"string":"[\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # Bounds for harmonic oscillator frequencies\\n for i in range(Nvib):\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # Bounds for pseudo-hindered rotor frequency and barrier height\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n # Initial guesses within each mode type must be distinct or else the\\n # optimization will fail\\n x0 = numpy.zeros(Nvib + 2, numpy.float64)\\n # Initial guess for harmonic oscillator frequencies\\n if Nvib > 0:\\n x0[0] = 200.0\\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\\n # Initial guess for hindered rotor frequencies and barrier heights\\n x0[Nvib] = 100.0\\n x0[Nvib+1] = 300.0\\n\\n # Execute the optimization\\n fit = PseudoRotorFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n vib = list(x[0:Nvib])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[Nvib], x[Nvib+1]))\\n\\n return vib, hind\",\n \"def fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # x[0] corresponds to the first harmonic oscillator (real) frequency\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # x[1] corresponds to the degeneracy of the second harmonic oscillator\\n bounds.append((1.0, float(Nvib - 2)))\\n # x[2] corresponds to the second harmonic oscillator pseudo-frequency\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # x[3] corresponds to the third harmonic oscillator pseudo-frequency\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # x[4] corresponds to the hindered rotor pseudo-frequency\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n # x[5] corresponds to the hindered rotor pseudo-barrier\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n x0 = numpy.zeros(6, numpy.float64) # Initial guess\\n x0[0] = 300.0\\n x0[1] = float(math.floor((Nvib - 1) / 2.0))\\n x0[2] = 800.0\\n x0[3] = 1600.0\\n x0[4] = 100.0\\n x0[5] = 300.0\\n\\n # Execute the optimization\\n fit = PseudoFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n Nvib2 = int(round(x[1]))\\n Nvib3 = Nvib - Nvib2 - 1\\n if Nvib2 < 0 or Nvib2 > Nvib-1 or Nvib3 < 0 or Nvib3 > Nvib-1:\\n raise StatmechFitError('Invalid degeneracies {0} and {1} fitted for pseudo-frequencies.'.format(Nvib2, Nvib3))\\n\\n vib = [x[0]]\\n for i in range(Nvib2): vib.append(x[2])\\n for i in range(Nvib3): vib.append(x[3])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[4], x[5]))\\n\\n return vib, hind\",\n \"def weak_repulsion(Cents,a,k, CV_matrix,n_c,L):\\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\\n displacement = np.mod(Cents - CCW + L/2,L) - L/2\\n rij = np.sqrt(displacement[:,:,0]**2 + displacement[:,:,1]**2)\\n norm_disp = (displacement.T/rij.T).T\\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\\n V_soft = V_soft_CW + V_soft_CCW\\n F_soft = np.zeros((n_c, 2))\\n for i in range(3):\\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\\n return F_soft\",\n \"def weak_repulsion_boundary(Cents,a,k, CV_matrix,n_c,n_C):\\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\\n CCW_displacement = Cents - CCW\\n rij = np.sqrt(CCW_displacement[:,:,0]**2 + CCW_displacement[:,:,1]**2)\\n norm_disp = (CCW_displacement.T/rij.T).T\\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\\n V_soft = V_soft_CW + V_soft_CCW\\n F_soft = np.zeros((n_c, 2))\\n for i in range(3):\\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\\n F_soft[n_C:] = 0\\n return F_soft\",\n \"def define_potts_helper_functions(k):\\n\\n @njit\\n def calc_observables(X, k=k):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n\\n Returns\\n -------\\n ndarray\\n Dimensions (n_samples, n_observables).\\n \\\"\\\"\\\"\\n\\n n = X.shape[1]\\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\\n \\n # average orientation (magnetization)\\n # note that fields for the third state are often set to 0\\n counter = 0\\n for i in range(k):\\n for j in range(n):\\n Y[:,counter] = X[:,j]==i\\n counter += 1\\n \\n # pairwise correlations\\n for i in range(n-1):\\n for j in range(i+1, n):\\n Y[:,counter] = X[:,i]==X[:,j]\\n counter += 1\\n \\n return Y\\n\\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n multipliers : ndarray of dtype np.float64\\n\\n Returns\\n -------\\n ndarray\\n Energies of each observable.\\n \\\"\\\"\\\"\\n\\n return -calc_observables(X, k).dot(multipliers)\\n\\n def mch_approximation(sample, dlamda, calc_e=calc_e):\\n \\\"\\\"\\\"Function for making MCH approximation step for Potts model.\\n \\n Parameters\\n ----------\\n sample : ndarray\\n Of dimensions (n_sample, n_spins).\\n dlamda : ndarray\\n Change in parameters.\\n \\n Returns\\n -------\\n ndarray\\n Predicted correlations.\\n \\\"\\\"\\\"\\n\\n dE = calc_e(sample, dlamda)\\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \\n assert not ((predsisj<0).any() or\\n (predsisj>(1+1e-10)).any()),\\\"Predicted values are beyond limits, (%E,%E)\\\"%(predsisj.min(),\\n predsisj.max())\\n return predsisj\\n\\n return calc_e, calc_observables, mch_approximation\",\n \"def specific_heat(Ekinv,n0,N,t0):\\n Cv = np.zeros(10)\\n for i in range(10):\\n avg_K_squared = (1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]))**2\\n FluctK = 1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]**2) - avg_K_squared\\n Cv[i] = -1 / (FluctK/ avg_K_squared * 3 * N / 2 - 1) * 3 * N / 2\\n return Cv\",\n \"def CLOMPR(task,sketch,featureMap,K,bounds,dimensions_to_consider=None, nb_cat_per_dim=None,nIterations=None, nRepetitions=1, ftol=1e-6, verbose=0 ):\\n\\n ## 0) Defining all the tools we need\\n ####################################\\n ## 0.1) Handle input\\n\\n ## 0.1.1) task name\\n if task.lower() in [\\\"km\\\",\\\"ckm\\\",\\\"kmeans\\\",\\\"k-means\\\"]:\\n task = \\\"kmeans\\\"\\n task_finetuning = \\\"kmeans\\\"\\n elif task.lower() in [\\\"gmm\\\",\\\"gaussian mixture model\\\"]:\\n task = \\\"gmm\\\"\\n task_finetuning = \\\"gmm\\\"\\n elif task.lower() in [\\\"gmm-nondiag\\\"]:\\n task = \\\"gmm\\\"\\n task_finetuning = \\\"gmm-nondiag\\\"\\n else:\\n raise ValueError('The task argument does not match one of the available options.')\\n\\n ## 0.1.2) sketch feature function\\n if isinstance(featureMap,SimpleFeatureMap):\\n d_all = featureMap.d\\n m = featureMap.m\\n else:\\n raise ValueError('The featureMap argument does not match one of the supported formats.')\\n\\n # Restrict the dimension\\n if dimensions_to_consider is None:\\n dimensions_to_consider = np.arange(d_all)\\n dimensions_to_ignore = np.delete(np.arange(d_all), dimensions_to_consider)\\n d = dimensions_to_consider.size\\n \\n # Pre-compute sketch of unused dimensions\\n z_to_ignore = fourierSketchOfBox(bounds.T,featureMap,nb_cat_per_dim, dimensions_to_consider = dimensions_to_ignore)\\n # Compensate the normalization constant and the dithering which will be taken into account in the centroid sketch\\n z_to_ignore = z_to_ignore/(featureMap(np.zeros(d_all))) # giving zeros yields the dithering and the c_norm\\n \\n # Restrict the featureMap for the centroids\\n Phi = copy(featureMap) # Don't touch to the inital map, Phi is featureMap restricted to relevant dims\\n Phi.d = d\\n Phi.Omega = featureMap.Omega[dimensions_to_consider]\\n \\n ## 0.1.3) nb of iterations\\n if nIterations is None:\\n nIterations = 2*K # By default: CLOMP-*R* (repeat twice)\\n \\n ## 0.1.4) Bounds of the optimization problems\\n if bounds is None:\\n lowb = -np.ones(d) # by default data is assumed normalized\\n uppb = +np.ones(d)\\n if verbose > 0: print(\\\"WARNING: data is assumed to be normalized in [-1,+1]^d\\\")\\n else:\\n lowb = bounds[0][dimensions_to_consider]\\n uppb = bounds[1][dimensions_to_consider] # Bounds for one centroid\\n\\n # Format the bounds for the optimization solver\\n if task_finetuning == \\\"kmeans\\\":\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the centroids\\n elif task_finetuning == \\\"gmm\\\":\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\\n elif task_finetuning == \\\"gmm-nondiag\\\":\\n # Usual bounds of GMM\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\\n \\n # Bounds for the nondiagonal problem\\n boundstheta_finetuning = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n varianceUpperBound = ((uppb-lowb).max()/2)**2\\n\\n _lowb_var = -varianceUpperBound*np.ones((d,d))\\n np.fill_diagonal(_lowb_var, varianceLowerBound)\\n _uppb_var = +varianceUpperBound*np.ones((d,d))\\n\\n _boundsvar = np.append(_lowb_var.reshape(-1),_uppb_var.reshape(-1)).reshape(2,d**2).T.tolist()\\n for _i in _boundsvar: boundstheta_finetuning.append(_i) # bounds for the variance\\n \\n\\n ## 0.1.5) Misc. initializations\\n # Chosen method for the optimization solver\\n opt_method = 'L-BFGS-B' # could also consider 'TNC'\\n # Separated real and imaginary part of the sketch\\n sketch_ri = np.r_[sketch.real, sketch.imag]\\n if task == \\\"kmeans\\\":\\n thetadim = d\\n elif task == \\\"gmm\\\":\\n thetadim = 2*d\\n elif task == \\\"gmm-nondiag\\\":\\n thetadim = d*(d+1)\\n\\n\\n ## THE ACTUAL ALGORITHM\\n #######################\\n bestResidualNorm = np.inf \\n bestTheta = None\\n bestalpha = None\\n for iRun in range(nRepetitions):\\n \\n ## 1) Initialization\\n r = sketch # residual\\n Theta = np.empty([0,thetadim]) # Theta is a nbAtoms-by-atomDimension array\\n A = np.empty([m,0]) # Contains the sketches of the atoms\\n\\n ## 2) Main optimization\\n for i in range(nIterations):\\n ## 2.1] Step 1 : find new atom theta most correlated with residual\\n # Initialize the new atom\\n if task == \\\"kmeans\\\":\\n th_0 = np.random.uniform(lowb,uppb)\\n elif task == \\\"gmm\\\":\\n mu0 = np.random.uniform(lowb,uppb) # initial mean\\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\\n th_0 = _stackAtom(\\\"gmm\\\",mu0,sig0)\\n \\n elif task == \\\"gmm-nondiag\\\":\\n # Solve once for diagonal\\n mu0 = np.random.uniform(lowb,uppb) # initial mean\\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\\n th_0 = _stackAtom(\\\"gmm\\\",mu0,sig0)\\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(\\\"gmm\\\",Phi,th,r,z_to_ignore,verbose),\\n x0 = th_0, method=opt_method, jac=True,\\n bounds=boundstheta_gmm)\\n\\n (mu0,sig0) = _destackAtom(\\\"gmm\\\",sol.x,d)\\n\\n th_0 = _stackAtom(\\\"gmm-nondiag\\\",mu0,np.diag(sig0))\\n\\n # And solve with LBFGS \\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(task,Phi,th,r,z_to_ignore,verbose),\\n x0 = th_0, method=opt_method, jac=True,\\n bounds=boundstheta)\\n new_theta = sol.x\\n \\n if task == \\\"gmm-nondiag\\\":\\n new_theta = _makeGMMfeasible(new_theta,d)\\n\\n ## 2.2] Step 2 : add it to the support\\n Theta = np.append(Theta,[new_theta],axis=0)\\n A = np.c_[A,_sketchAtom(task,Phi,new_theta,z_to_ignore)] # Add a column to the A matrix\\n\\n ## 2.3] Step 3 : if necessary, hard-threshold to nforce sparsity\\n if Theta.shape[0] > K:\\n norms = np.linalg.norm(A,axis=0)\\n norms[np.where(norms < 1e-15)[0]] = 1e-15 # Avoid /0\\n A_norm = A/norms # normalize, unlike step 4\\n A_normri = np.r_[A_norm.real, A_norm.imag] \\n (beta,_) = nnls(A_normri,sketch_ri) # non-negative least squares\\n index_to_delete = np.argmin(beta)\\n Theta = np.delete(Theta, index_to_delete, axis=0)\\n A = np.delete(A, index_to_delete, axis=1)\\n if index_to_delete == K:\\n continue # No gain to be expected wrt previous iteration\\n\\n ## 2.4] Step 4 : project to find weights\\n Ari = np.r_[A.real, A.imag]\\n (alpha,_) = nnls(Ari,sketch_ri) # non-negative least squares\\n\\n\\n\\n ## 2.5] Step 5\\n p0 = _stackTheta(task,Theta,alpha) # Initialize at current solution \\n # Compute the bounds for step 5 : boundsOfOneAtom * numberAtoms then boundsOneWeight * numberAtoms\\n boundsThetaAlpha = boundstheta * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\\n # Solve\\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task,Phi,p,sketch,z_to_ignore),\\n x0 = p0, method=opt_method, jac=True,\\n bounds=boundsThetaAlpha, options={'ftol': ftol}) \\n (Theta,alpha) = _destackTheta(task,sol.x,Phi.d)\\n \\n # Make covariances feasible\\n if task == \\\"gmm-nondiag\\\":\\n for k in range(Theta.shape[0]):\\n Theta[k] = _makeGMMfeasible(Theta[k],d)\\n\\n # The atoms have changed: we must re-compute A\\n A = np.empty([m,0])\\n for theta_i in Theta:\\n Apthi = _sketchAtom(task,Phi,theta_i,z_to_ignore)\\n A = np.c_[A,Apthi]\\n # Update residual\\n r = sketch - A@alpha\\n\\n ## 3) Finalization boundstheta_finetuning\\n # Last optimization with the default (fine-grained) tolerance\\n if task_finetuning == \\\"gmm-nondiag\\\":\\n if verbose > 0: print('finetuning')\\n Theta_new = np.zeros((K,d*(d+1))) # Expand to have full cov matrix\\n for k in range(K):\\n (mu,sig2) = _destackAtom(\\\"gmm\\\",Theta[k],d)\\n # put current sol on the diagonal of full covariance matrix\\n Theta_new[k] = _stackAtom(\\\"gmm-nondiag\\\",mu,np.diag(sig2))\\n Theta = Theta_new # overwrite\\n \\n boundsThetaAlpha = boundstheta_finetuning * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\\n \\n if task_finetuning == \\\"gmm-nondiag\\\" or ftol >= 1e-8:\\n p0 = _stackTheta(task_finetuning,Theta,alpha)\\n \\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task_finetuning,Phi,p,sketch,z_to_ignore),\\n x0 = p0, method=opt_method, jac=True,\\n bounds=boundsThetaAlpha) # Here ftol is much smaller\\n (Theta,alpha) = _destackTheta(task_finetuning,sol.x,Phi.d) \\n \\n \\n # Normalize alpha\\n alpha /= np.sum(alpha)\\n \\n \\n runResidualNorm = np.linalg.norm(sketch - A@alpha)\\n if verbose>1: print('Run {}, residual norm is {} (best: {})'.format(iRun,runResidualNorm,bestResidualNorm))\\n if runResidualNorm <= bestResidualNorm:\\n bestResidualNorm = runResidualNorm\\n bestTheta = Theta\\n bestalpha = alpha\\n \\n ## FORMAT OUTPUT\\n if task == \\\"kmeans\\\":\\n return (bestalpha,bestTheta)\\n elif task == \\\"gmm\\\" or task == \\\"gmm-nondiag\\\":\\n return _ThetasToGMM(task_finetuning,bestTheta,bestalpha)\\n\\n return None\",\n \"def optimize_force_field_parameters_Cv_FWHM(cgmodel, file_list, temperature_list, param_bounds_dict,\\n frame_begin=0, frame_end=-1, sample_spacing=1, sparsify_stride=1, output_data='output.nc',\\n verbose=False, n_cpu=12, min_eff_samples=50,\\n n_trial_boot=200, num_intermediate_states=0, plotfile='optimize_FWHM_iterations.pdf',\\n min_method='TNC'):\\n\\n # Parse the force field parameter change dict:\\n x0 = []\\n param_names = []\\n bounds = []\\n units = []\\n \\n for key,value in param_bounds_dict.items():\\n # value should be [(bound_lo, bound_hi)]\\n # key should be a valid force field parameter name\\n param_names.append(key)\\n # Every parameter except periodicity should have units\\n # For now, changing periodicity is not supported.\\n \\n # TODO: add support for sums of periodic torsion terms\\n units.append(value[0].unit)\\n bounds.append((value[0].value_in_unit(units[-1]),value[1].value_in_unit(units[-1])))\\n # Use mean value as starting guess:\\n x0.append((value[1].value_in_unit(units[-1])+value[0].value_in_unit(units[-1]))/2)\\n\\n if verbose:\\n print(f'param_names: {param_names}')\\n print(f'unit: {units}')\\n print(f'bounds: {bounds}')\\n print(f'x0: {x0}')\\n\\n def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n \\\"\\\"\\\"\\n Objective function to be minimized\\n \\\"\\\"\\\"\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\\n\\n # Run optimization:\\n\\n # if len(param_names) == 1:\\n # # Do scalar optimization:\\n # opt_results = minimize_scalar(get_reeval_FWHM, x0,\\n # args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\\n # frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\\n # method='bounded',\\n # bounds=[bounds[0][0],bounds[0][1]],\\n # options={'maxiter': 25},\\n # )\\n\\n # else:\\n # Do multivariate optimization:\\n opt_results = minimize(get_reeval_FWHM, x0, jac='2-point',\\n args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\\n frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\\n method=min_method,\\n bounds=bounds,\\n options={'maxfun': 25, 'finite_diff_rel_step': 0.005, 'eta': 0.5}, # This should be user input\\n ) \\n \\n # TODO: plot the heat capacity curves at each iteration, and make a plot of all FWHM_values \\n\\n # Construct dictionary of optimal parameters:\\n opt_param_dict = {} \\n \\n k = 0\\n for key,value in param_bounds_dict.items():\\n opt_param_dict[key] = opt_results.x[k] * units[k]\\n k += 1\\n \\n return opt_param_dict, opt_results\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def plot_dispersion(kpts, enk):\\n\\n # Lattice constant and reciprocal lattice vectors\\n # b1 = 2 pi/a (kx - ky + kz)\\n # b2 = 2 pi/a (kx + ky - kz)\\n # b3 = 2 pi/a (-kx + ky + kz)\\n a = 5.556 # [A]\\n b1 = (2 * np.pi / a) * np.array([1, -1, 1])\\n b2 = (2 * np.pi / a) * np.array([1, 1, -1])\\n b3 = (2 * np.pi / a) * np.array([-1, 1, 1])\\n\\n # L point in BZ is given by 0.5*b1 + 0.5*b2 + 0.5*b3\\n # X point in BZ is given by 0.5*b2 + 0.5*b3\\n lpoint = 0.5 * (b1 + b2 + b3)\\n xpoint = 0.5 * (b2 + b3)\\n\\n # We can find kpoints along a path just by considering a dot product with lpoint and xpoint vectors.\\n # Any kpoints with angle smaller than some tolerance are considered on the path and we can plot their frequencies\\n deg2rad = 2 * np.pi / 360\\n ang_tol = 1 * deg2rad # 1 degree in radians\\n\\n print(list(kpts))\\n\\n enkonly = np.array(enk['energy [Ryd]'])[:, np.newaxis]\\n enkinds = np.array(enk['q_inds'])\\n kptsonly = np.array(kpts[['kx [1/A]', 'ky [1/A]', 'kz [1/A]']]) / (2 * np.pi / a)\\n kptsinds = np.array(kpts['q_inds'])\\n kptsmag = np.linalg.norm(kptsonly, axis=1)[:, np.newaxis]\\n\\n dot_l = np.zeros(len(kpts))\\n dot_x = np.zeros(len(kpts))\\n\\n # Separate assignment for gamma point to avoid divide by zero error\\n nongamma = kptsmag != 0\\n dot_l[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, lpoint[:, np.newaxis])[nongamma],\\n kptsmag[nongamma]) / np.linalg.norm(lpoint)\\n dot_x[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, xpoint[:, np.newaxis])[nongamma],\\n kptsmag[nongamma]) / np.linalg.norm(xpoint)\\n dot_l[np.squeeze(kptsmag == 0)] = 0\\n dot_x[np.squeeze(kptsmag == 0)] = 0\\n\\n lpath = np.logical_or(np.arccos(dot_l) < ang_tol, np.squeeze(kptsmag == 0))\\n xpath = np.logical_or(np.arccos(dot_x) < ang_tol, np.squeeze(kptsmag == 0))\\n\\n linds = kptsinds[lpath]\\n xinds = kptsinds[xpath]\\n lkmag = kptsmag[lpath]\\n xkmag = kptsmag[xpath]\\n\\n plt.figure()\\n\\n for i, ki in enumerate(linds):\\n energies = enkonly[enkinds == ki, 0]\\n thiskmag = lkmag[i]\\n if len(energies) > 1:\\n veck = np.ones((len(energies), 1)) * thiskmag\\n plt.plot(veck, energies, '.', color='C0')\\n else:\\n plt.plot(thiskmag, energies, '.', color='C0')\\n\\n for i, ki in enumerate(xinds):\\n energies = enkonly[enkinds == ki, 0]\\n thiskmag = lkmag[i]\\n if len(energies) > 1:\\n veck = np.ones((len(energies), 1)) * thiskmag\\n plt.plot(-1 * veck, energies, '.', color='C1')\\n else:\\n plt.plot(-1 * thiskmag, energies, '.', color='C1')\\n\\n plt.xlabel('k magnitude')\\n plt.ylabel('Energy in Ry')\",\n \"def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\\n # We move from an array to a list of 2d-array for the competition over each template:\\n\\n cp=cps[0]\\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\\n new_cp = 1\\n\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\\n # update for fixed point:\\n new_cp += w_inpIdx*x_eq\\n # saving values\\n layerEq[inpIdx] = x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n layerEq[inpIdx] = x_eq\\n\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n\\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n new_cp += Inhib2/(E0*cp)*x_eq\\n\\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\\n diff_cps = np.zeros(cps.shape)\\n if new_cp>=1:\\n diff_cps[0] = cp - new_cp\\n else:\\n diff_cps[0] = 10**3\\n for l,m in enumerate(masks):\\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\\n return diff_cps\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def fit_full(self,K):\\r\\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\\r\\n mu = np.zeros(self.N)\\r\\n Sigma = K.copy()\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.N,dtype=float)\\r\\n self.v_ = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.N,dtype=float)\\r\\n self.Z_hat = np.empty(self.N,dtype=float)\\r\\n phi = np.empty(self.N,dtype=float)\\r\\n mu_hat = np.empty(self.N,dtype=float)\\r\\n sigma2_hat = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = self.epsilon + 1.\\r\\n epsilon_np2 = self.epsilon + 1.\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.N)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\\r\\n B = np.eye(self.N) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\\r\\n L = jitchol(B)\\r\\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\\r\\n Sigma = K - np.dot(V.T,V)\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def fit_FITC(self, Kmm, Kmn, Knn_diag):\\r\\n num_inducing = Kmm.shape[0]\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Prior approximation parameters:\\r\\n q(f|X) = int_{df}{N(f|KfuKuu_invu,diag(Kff-Qff)*N(u|0,Kuu)} = N(f|0,Sigma0)\\r\\n Sigma0 = diag(Knn-Qnn) + Qnn, Qnn = Knm*Kmmi*Kmn\\r\\n \\\"\\\"\\\"\\r\\n Lm = jitchol(Kmm)\\r\\n Lmi = chol_inv(Lm)\\r\\n Kmmi = np.dot(Lmi.T,Lmi)\\r\\n P0 = Kmn.T\\r\\n KmnKnm = np.dot(P0.T, P0)\\r\\n KmmiKmn = np.dot(Kmmi,P0.T)\\r\\n Qnn_diag = np.sum(P0.T*KmmiKmn,-2)\\r\\n Diag0 = Knn_diag - Qnn_diag\\r\\n R0 = jitchol(Kmmi).T\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Posterior approximation: q(f|y) = N(f| mu, Sigma)\\r\\n Sigma = Diag + P*R.T*R*P.T + K\\r\\n mu = w + P*Gamma\\r\\n \\\"\\\"\\\"\\r\\n self.w = np.zeros(self.N)\\r\\n self.Gamma = np.zeros(num_inducing)\\r\\n mu = np.zeros(self.N)\\r\\n P = P0.copy()\\r\\n R = R0.copy()\\r\\n Diag = Diag0.copy()\\r\\n Sigma_diag = Knn_diag\\r\\n RPT0 = np.dot(R0,P0.T)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(g|mu_,sigma2_) = Product{q_i(g|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.N,dtype=float)\\r\\n self.v_ = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.N,dtype=float)\\r\\n self.Z_hat = np.empty(self.N,dtype=float)\\r\\n phi = np.empty(self.N,dtype=float)\\r\\n mu_hat = np.empty(self.N,dtype=float)\\r\\n sigma2_hat = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = 1\\r\\n epsilon_np2 = 1\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.N)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma_diag[i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma_diag[i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma_diag[i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma_diag[i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n dtd1 = Delta_tau*Diag[i] + 1.\\r\\n dii = Diag[i]\\r\\n Diag[i] = dii - (Delta_tau * dii**2.)/dtd1\\r\\n pi_ = P[i,:].reshape(1,num_inducing)\\r\\n P[i,:] = pi_ - (Delta_tau*dii)/dtd1 * pi_\\r\\n Rp_i = np.dot(R,pi_.T)\\r\\n RTR = np.dot(R.T,np.dot(np.eye(num_inducing) - Delta_tau/(1.+Delta_tau*Sigma_diag[i]) * np.dot(Rp_i,Rp_i.T),R))\\r\\n R = jitchol(RTR).T\\r\\n self.w[i] += (Delta_v - Delta_tau*self.w[i])*dii/dtd1\\r\\n self.Gamma += (Delta_v - Delta_tau*mu[i])*np.dot(RTR,P[i,:].T)\\r\\n RPT = np.dot(R,P.T)\\r\\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\\r\\n mu = self.w + np.dot(P,self.Gamma)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Iplus_Dprod_i = 1./(1.+ Diag0 * self.tau_tilde)\\r\\n Diag = Diag0 * Iplus_Dprod_i\\r\\n P = Iplus_Dprod_i[:,None] * P0\\r\\n safe_diag = np.where(Diag0 < self.tau_tilde, self.tau_tilde/(1.+Diag0*self.tau_tilde), (1. - Iplus_Dprod_i)/Diag0)\\r\\n L = jitchol(np.eye(num_inducing) + np.dot(RPT0,safe_diag[:,None]*RPT0.T))\\r\\n R,info = dtrtrs(L,R0,lower=1)\\r\\n RPT = np.dot(R,P.T)\\r\\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\\r\\n self.w = Diag * self.v_tilde\\r\\n self.Gamma = np.dot(R.T, np.dot(RPT,self.v_tilde))\\r\\n mu = self.w + np.dot(P,self.Gamma)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def ghosal_edge(img,Ks,thr=1,thrmax=0.995,lmin = 0.5,phimin=1.4,thresholding=True, debug=False):\\n\\ttotaltime = time.time()\\n\\tkerneltime = time.time()\\n\\t# Ks must be odd\\n\\tif Ks%2 != 1:\\n\\t\\tprint(\\\"Ks must be odd! Continuing with Ks = Ks-1\\\")\\n\\t\\tKs = Ks-1\\n\\t# define the rectangular kernels\\n\\t#Vc00 = np.zeros((Ks,Ks),dtype=complex)\\n\\tVc11 = np.zeros((Ks,Ks),dtype=complex)\\n\\tVc20 = np.zeros((Ks,Ks),dtype=complex)\\n\\tofs = 1 *(1-1/Ks) # offset for centering kernel around 0,0\\n\\tfor i in range(Ks):\\n\\t\\tfor j in range(Ks):\\n\\t\\t\\tKx = 2*j/Ks-ofs # limits of integration between -1 and 1\\n\\t\\t\\tKy = 2*i/Ks-ofs\\n\\t\\t\\tif Kx**2+Ky**2 <= 1: # only a circle\\n\\t\\t\\t\\t#Vc00[i,j] = 1 # the conjugate of V00\\n\\t\\t\\t\\tVc11[i,j] = Kx-Ky*1j # ...\\n\\t\\t\\t\\tVc20[i,j] = 2*Kx**2+2*Ky**2-1\\n\\tkerneltime = time.time() - kerneltime\\n\\t\\n\\t# Kernel Plots\\n\\t#\\tVCplot = Vc00\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Vc11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Vc20\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\t# do the convolution with the images to get the zernike moments\\n\\tAnorm = lambda n : (n+1)/np.pi\\t# a normalization value\\n\\tconvolvetime = time.time()\\n\\t#A00 = scig.convolve2d(img,Vc00,mode='same')\\n\\t#\\tA11 = Anorm(1)*scig.convolve2d(img,Vc11,mode='same')\\n\\t#\\tA20 = Anorm(2)*scig.convolve2d(img,Vc20,mode='same')\\n\\tA11 = Anorm(1)*scig.oaconvolve(img,Vc11,mode='same')\\n\\tA20 = Anorm(2)*scig.oaconvolve(img,Vc20,mode='same')\\n\\tconvolvetime = time.time() - convolvetime\\n\\t# Plot Zernike moments\\n\\t#\\tVCplot = A00\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = A11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = A20\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\tparamstime = time.time()\\n\\t# calculate the edge paramters\\n\\t#\\ttanphi = np.imag(A11)/np.real(A11)\\n\\t#\\tphi = np.arctan(tanphi)\\n\\t#\\tcosphi = np.cos(phi)\\n\\t#\\tsinphi = cosphi*tanphi\\n\\t#\\tAl11 = np.real(A11)*cosphi+np.imag(A11)*sinphi\\n\\t\\n\\tphi = np.arctan(np.imag(A11)/np.real(A11))\\n\\tAl11 = np.real(A11)*np.cos(phi)+np.imag(A11)*np.sin(phi)\\n\\t\\n\\t#\\tAl11 = A11*np.exp(-phi*1j)\\n\\tl = A20/Al11 # A20 has no imaginary component so A20 = A'20\\n\\n\\tk = 3*Al11/(2*(1-l**2)**(3/2))\\n\\tparamstime = time.time() - paramstime\\n\\t\\n\\t# Plot edge paramters\\n\\t#\\tVCplot = phi\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real phi\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag phi\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Al11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A\\\\'11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A\\\\'11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = l\\n\\t#\\tplt.pcolormesh(np.real(VCplot))#,vmin=-5,vmax=5\\n\\t#\\tplt.title(\\\"real l\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot)) # ,vmin=-5,vmax=5\\n\\t#\\tplt.title(\\\"imag l\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = k\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real k\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag k\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\t\\n\\ttreattime = time.time()\\n\\tif thresholding==True:\\n\\t\\t# do the thresholding\\n\\t\\tif (thrmax<0)&(thr>0):\\n\\t\\t\\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])\\n\\t\\telif thrmax>0:\\n\\t\\t\\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])&(abs(k)<knorm[1])\\n\\t\\telif thr<0:\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)\\n\\t\\t\\tknorm = np.sort(k[idx].flatten())[int(thr)]\\n\\t\\t\\tidx = idx&(abs(k)>abs(knorm))\\n\\t\\tne = np.sum(idx)\\n\\telif thresholding==False:\\n\\t\\traise ValueError(\\\"this option is not still uncer development\\\")\\n\\t\\t# no thresholding\\n\\t\\tidx = np.ones(np.shape(l),dtype=bool)\\n\\t\\tne =np.sum(idx)\\n\\telse:\\n\\t\\traise ValueError(\\\"thresholding should be boolean\\\")\\n\\t\\n\\t# put all detected points in a vector of (x,y) values\\n\\tedg = np.zeros((ne,2))\\n\\torg = np.zeros((ne,2))\\n\\tnx,ny = np.shape(img)\\n\\te = 0\\n\\tfor i in range(nx):\\n\\t\\tfor j in range(ny):\\n\\t\\t\\tif idx[i,j]:\\n\\t\\t\\t\\tedg[e]=np.array([i,j]) + l[i,j]*Ks/2*np.array(\\n\\t\\t\\t\\t\\t[np.sin(phi[i,j]),-np.cos(phi[i,j])])\\n\\t\\t\\t\\torg[e]=np.array([i,j])\\n\\t\\t\\t\\te +=1\\n\\ttreattime = time.time() - treattime\\n\\ttotaltime = time.time() - totaltime\\n\\tprint(\\\"total %0.5f\\tconvolution %0.5f\\tthresholding %0.5f\\tparamters %0.5f\\tkernel %0.5f\\\"%(totaltime,convolvetime,treattime,paramstime,kerneltime))\\n\\t\\n\\tif debug==True:\\n\\t\\treturn edg, org, k, l, phi\\n\\telse:\\n\\t\\treturn edg, org\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def spec_helm_decomp(k,Cu,Cv,GM=False):\\n dk = k[1]-k[0]\\n s = np.log(k)\\n\\n Fphi = np.zeros_like(Cu)\\n Fpsi = np.zeros_like(Cu)\\n Cphi = np.zeros_like(Cu)\\n Cpsi = np.zeros_like(Cu)\\n\\n # assume GM for decomposing into wave and vortex\\n if GM:\\n gm = np.load(\\\"/Users/crocha/Projects/dp_spectra/GM/gm_omega_star.npz\\\")\\n f2omg2 = gm['rgm']\\n ks = gm['k']*1.e3\\n\\n for i in range(s.size-1):\\n\\n ds = np.diff(s[i:])\\n\\n sh = sinh(s[i]-s[i:])\\n ch = cosh(s[i]-s[i:])\\n\\n # the function to integrate\\n Fp = Cu[i:]*sh + Cv[i:]*ch\\n Fs = Cv[i:]*sh + Cu[i:]*ch\\n\\n # integrate using Simpson's rule\\n Fpsi[i] = integrate.simps(Fs,s[i:])\\n Fphi[i] = integrate.simps(Fp,s[i:])\\n\\n # zero out unphysical values\\n Fpsi[Fpsi < 0.] = 0.\\n Fphi[Fphi < 0.] = 0.\\n\\n # compute rotational and divergent components\\n Cpsi = Fpsi - Fphi + Cu\\n Cphi = Fphi - Fpsi + Cv\\n\\n if GM:\\n\\n f2omg2i = np.interp(k,ks,f2omg2)\\n\\n Cv_w = f2omg2i*Fphi - Fpsi + Cv\\n Cv_v = Cv - Cv_w\\n \\n kdkromg = diff_central(ks, f2omg2)\\n kdkromg = np.interp(k,ks[1:-1],kdkromg)\\n\\n dFphi = diff_central(k, Fphi)\\n #dFphi = np.gradient(Fphi,k)\\n dFphi = np.interp(k,k[1:-1],dFphi.real)\\n E_w = Fphi - k*dFphi\\n\\n Cu_w = -k*kdkromg*Fphi + f2omg2i*(-Fpsi+Cv) + Fphi\\n Cu_v = Cu - Cu_w\\n\\n Cb_w = E_w - (Cu_w + Cv_w)/2.\\n\\n return Cpsi,Cphi, Cu_w,Cv_w, Cu_v,Cv_v, E_w, Cb_w\\n\\n else:\\n return Cpsi,Cphi\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def tuto_kernel_overview(optimize=True, plot=True):\\r\\n ker1 = GPy.kern.rbf(1) # Equivalent to ker1 = GPy.kern.rbf(input_dim=1, variance=1., lengthscale=1.)\\r\\n ker2 = GPy.kern.rbf(input_dim=1, variance = .75, lengthscale=2.)\\r\\n ker3 = GPy.kern.rbf(1, .5, .5)\\r\\n\\r\\n print ker2\\r\\n\\r\\n if plot:\\r\\n ker1.plot()\\r\\n ker2.plot()\\r\\n ker3.plot()\\r\\n\\r\\n k1 = GPy.kern.rbf(1,1.,2.)\\r\\n k2 = GPy.kern.Matern32(1, 0.5, 0.2)\\r\\n\\r\\n # Product of kernels\\r\\n k_prod = k1.prod(k2) # By default, tensor=False\\r\\n k_prodtens = k1.prod(k2,tensor=True)\\r\\n\\r\\n # Sum of kernels\\r\\n k_add = k1.add(k2) # By default, tensor=False\\r\\n k_addtens = k1.add(k2,tensor=True)\\r\\n\\r\\n k1 = GPy.kern.rbf(1,1.,2)\\r\\n k2 = GPy.kern.periodic_Matern52(1,variance=1e3, lengthscale=1, period = 1.5, lower=-5., upper = 5)\\r\\n\\r\\n k = k1 * k2 # equivalent to k = k1.prod(k2)\\r\\n print k\\r\\n\\r\\n # Simulate sample paths\\r\\n X = np.linspace(-5,5,501)[:,None]\\r\\n Y = np.random.multivariate_normal(np.zeros(501),k.K(X),1)\\r\\n\\r\\n k1 = GPy.kern.rbf(1)\\r\\n k2 = GPy.kern.Matern32(1)\\r\\n k3 = GPy.kern.white(1)\\r\\n\\r\\n k = k1 + k2 + k3\\r\\n print k\\r\\n\\r\\n k.constrain_positive('.*var')\\r\\n k.constrain_fixed(np.array([1]),1.75)\\r\\n k.tie_params('.*len')\\r\\n k.unconstrain('white')\\r\\n k.constrain_bounded('white',lower=1e-5,upper=.5)\\r\\n print k\\r\\n\\r\\n k_cst = GPy.kern.bias(1,variance=1.)\\r\\n k_mat = GPy.kern.Matern52(1,variance=1., lengthscale=3)\\r\\n Kanova = (k_cst + k_mat).prod(k_cst + k_mat,tensor=True)\\r\\n print Kanova\\r\\n\\r\\n # sample inputs and outputs\\r\\n X = np.random.uniform(-3.,3.,(40,2))\\r\\n Y = 0.5*X[:,:1] + 0.5*X[:,1:] + 2*np.sin(X[:,:1]) * np.sin(X[:,1:])\\r\\n\\r\\n # Create GP regression model\\r\\n m = GPy.models.GPRegression(X, Y, Kanova)\\r\\n\\r\\n if plot:\\r\\n fig = pb.figure(figsize=(5,5))\\r\\n ax = fig.add_subplot(111)\\r\\n m.plot(ax=ax)\\r\\n\\r\\n pb.figure(figsize=(20,3))\\r\\n pb.subplots_adjust(wspace=0.5)\\r\\n axs = pb.subplot(1,5,1)\\r\\n m.plot(ax=axs)\\r\\n pb.subplot(1,5,2)\\r\\n pb.ylabel(\\\"= \\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,3)\\r\\n m.plot(ax=axs, which_parts=[False,True,False,False])\\r\\n pb.ylabel(\\\"cst +\\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,4)\\r\\n m.plot(ax=axs, which_parts=[False,False,True,False])\\r\\n pb.ylabel(\\\"+ \\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,5)\\r\\n pb.ylabel(\\\"+ \\\",rotation='horizontal',fontsize='30')\\r\\n m.plot(ax=axs, which_parts=[False,False,False,True])\\r\\n\\r\\n return(m)\",\n \"def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\\n # get activation for each seperated vc\\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\\n max_ch_index = max_ch_index.view(-1, L) # n, L\\n\\n all_activation_vcs = []\\n\\n for i in range(len(integrate_activation_vc)):\\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\\n all_activation_vcs.append(integrate_activation_vc_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n print(f\\\"unique_vc_i {unique_vc_i.shape}\\\")\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\\n activate_vc_i[index_vc_i, :] = 0.\\n all_activation_vcs.append(activate_vc_i)\\n \\n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\\n \\n # decompose each mask \\n all_masks = []\\n for i in range(len(sim_map_max)):\\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\\n all_masks.append(sim_map_max_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\\n vc_sim_map_max_i[index_vc_i] = 0.\\n all_masks.append(vc_sim_map_max_i)\\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\\n\\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\\\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\\\"\\n\\n return all_activation_vcs, all_masks\",\n \"def error_specific_heat(Cv):\\n ncv = 10\\n tcv = np.linspace(0,50,ncv) \\n \\n chi = auto_correlation(tcv,Cv,ncv)\\n tau_fit = curve_fit(exp,tcv,chi)\\n tau = tau_fit[0]\\n\\n error_Cv = error(tau,ncv,Cv,tcv) \\n\\n return error_Cv\",\n \"def ALIGNF(km_list, ky):\\n n_feat = len(km_list)\\n\\n #km_list_copy = []\\n # center the kernel first\\n #for i in range(n_feat):\\n # km_list_copy.append(center(km_list[i].copy()))\\n #ky_copy = center(ky.copy())\\n\\n\\n a = np.zeros(n_feat)\\n for i in range(n_feat):\\n a[i] = f_dot(km_list[i], ky)\\n\\n M = np.zeros((n_feat, n_feat))\\n for i in range(n_feat):\\n for j in range(i,n_feat):\\n M[i,j] = f_dot(km_list[i],km_list[j])\\n M[j,i] = M[i,j]\\n\\n Q = 2*M\\n C = -2*a\\n\\n Q = Q + np.diag(np.ones(n_feat)*1e-8)\\n\\n ################################################\\n # Using mosek to solve the quadratice programming\\n\\n # Set upper diagonal element to zeros, mosek only accept lower triangle\\n iu = np.triu_indices(n_feat,1)\\n Q[iu] = 0\\n\\n # start solving with mosek\\n inf = 0.0\\n env = mosek.Env()\\n env.set_Stream(mosek.streamtype.log, streamprinter)\\n\\n # Create a task \\n task = env.Task()\\n task.set_Stream(mosek.streamtype.log, streamprinter)\\n\\n # Set up bound for variables \\n bkx = [mosek.boundkey.lo]* n_feat\\n blx = [0.0] * n_feat\\n #bkx = [mosek.boundkey.fr]* n_feat\\n #blx = [-inf] * n_feat\\n bux = [+inf] * n_feat\\n\\n numvar = len(bkx)\\n\\n task.appendvars(numvar)\\n\\n for j in range(numvar):\\n task.putcj(j,C[j])\\n task.putvarbound(j,bkx[j],blx[j],bux[j])\\n\\n # Set up quadratic objective \\n inds = np.nonzero(Q)\\n qsubi = inds[0].tolist()\\n qsubj = inds[1].tolist()\\n qval = Q[inds].tolist()\\n\\n # Input quadratic objective \\n task.putqobj(qsubi,qsubj,qval)\\n\\n # Input objective sense (minimize/mximize) \\n task.putobjsense(mosek.objsense.minimize)\\n\\n task.optimize()\\n\\n # Print a summary containing information \\n # about the solution for debugging purposes \\n task.solutionsummary(mosek.streamtype.msg)\\n\\n solsta = task.getsolsta(mosek.soltype.itr)\\n if (solsta == mosek.solsta.optimal or\\n solsta == mosek.solsta.near_optimal):\\n # Output a solution \\n xx = np.zeros(numvar, float)\\n task.getxx(mosek.soltype.itr, xx)\\n #xx = xx/np.linalg.norm(xx)\\n return xx\\n else:\\n print solsta\\n xx = np.zeros(numvar, float)\\n task.getxx(mosek.soltype.itr, xx)\\n #xx = xx/np.linalg.norm(xx)\\n return xx\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\\n \\n # INPUTS FROM TTTW SYSTEM\\n self.b = b #buoyancy field: [Ly,N]\\n self.u = u # x-component of velocity [Ly,N]\\n self.v = v # y-component of velocity [Ly+1,N]\\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \\n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\\n self.grid_dict = grid_dict #gridded data\\n self.f = f #coriolis parameter\\n # KPP-SPECIFIC VARIABLES \\n self.hbls = np.zeros([self.b.shape[0]])\\n self.hbbl = np.zeros([self.b.shape[0]])\\n self.ustar = []\\n self.bvf = [] \\n self.kmo = []\\n self.C_h_MO = []\\n self.kbl = []\\n self.Cr = [] \\n self.Fc = []\\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\\n self.dt = dt\",\n \"def grid_visibilities_parallel(self, visibilities,min_attenuation = 1e-10, N = 120):\\n\\n #Find out the number of frequencies to process per thread\\n nfreq = len(self.frequencies)\\n numperthread = int(np.ceil(nfreq/self.n_obs))\\n offset = 0\\n nfreqstart = np.zeros(self.n_obs,dtype=int)\\n nfreqend = np.zeros(self.n_obs,dtype=int)\\n infreq = np.zeros(self.n_obs,dtype=int)\\n for i in range(self.n_obs):\\n nfreqstart[i] = offset\\n nfreqend[i] = offset + numperthread\\n\\n if(i==self.n_obs-1):\\n infreq[i] = nfreq - offset\\n else:\\n infreq[i] = numperthread\\n\\n offset+=numperthread\\n\\n # Set the last process to the number of frequencies\\n nfreqend[-1] = nfreq\\n\\n processes = []\\n\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\\n \\n centres = (ugrid[1:] + ugrid[:-1]) / 2\\n \\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\\n\\n\\n if(os.path.exists(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")):\\n kernel_weights = np.load(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")\\n else:\\n kernel_weights=None\\n \\n if kernel_weights is None:\\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\\n\\n visgrid_buff_real = []\\n visgrid_buff_imag = []\\n weights_buff = []\\n\\n #Lets split this array up into chunks\\n for i in range(self.n_obs):\\n\\n visgrid_buff_real.append(multiprocessing.RawArray(np.sctype2char(visgrid.real),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\\n visgrid_buff_imag.append(multiprocessing.RawArray(np.sctype2char(visgrid.imag),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\\n visgrid_tmp_real = np.frombuffer(visgrid_buff_real[i])\\n visgrid_tmp_imag = np.frombuffer(visgrid_buff_imag[i])\\n visgrid_tmp_real = visgrid[:,:,nfreqstart[i]:nfreqend[i]].real.flatten()\\n visgrid_tmp_imag = visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag.flatten()\\n\\n\\n if(kernel_weights is None):\\n weights_buff.append(multiprocessing.RawArray(np.sctype2char(weights),weights[:,:,nfreqstart[i]:nfreqend[i]].size))\\n weights_tmp = np.frombuffer(weights_buff[i])\\n weights_tmp = weights[:,:,nfreqstart[i]:nfreqend[i]]\\n else:\\n weights_buff.append(None)\\n\\n processes.append(multiprocessing.Process(target=self._grid_visibilities_buff,args=(self.n_uv,visgrid_buff_real[i],visgrid_buff_imag[i],weights_buff[i], visibilities[:,nfreqstart[i]:nfreqend[i]],self.frequencies[nfreqstart[i]:nfreqend[i]],self.baselines,centres,self._instr_core.sigma(self.frequencies[nfreqstart[i]:nfreqend[i]]),min_attenuation, N) ))\\n\\n for p in processes:\\n p.start()\\n\\n for p in processes:\\n p.join()\\n\\n for i in range(self.n_obs):\\n\\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].real = np.frombuffer(visgrid_buff_real[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag = np.frombuffer(visgrid_buff_imag[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n\\n if(kernel_weights is None):\\n weights[:,:,nfreqstart[i]:nfreqend[i]] = np.frombuffer(weights_buff[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n\\n if kernel_weights is None:\\n kernel_weights = weights\\n \\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\\n\\n return visgrid,kernel_weights\",\n \"def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\\n pi, ids = induced_distribution(hmsm, 0, level)\\n\\n discrete_free_energy = np.ndarray(pi.shape)\\n for i, id in enumerate(ids):\\n discrete_free_energy[i] = \\\\\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\\n boltzmann = np.exp(-discrete_free_energy/kT)\\n boltzmann *= (1/np.sum(boltzmann))\\n return D_KL(boltzmann, pi)\",\n \"def Boltzchoice(LFnum, energylist, RNs):\\n # transform list to energy values in kT according to experimental\\n # affinities and the energy window allowed by the threshold\\n energylist = cf.y0 + np.array(energylist) * cf.m\\n # calculate norm of initial list\\n Norm = sum([math.exp(-ener) for ener in energylist])\\n # calculate initial probability vector\\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\\n # list to catch indices of selected cells\\n selected = []\\n # cells to be picked: determined by the lesser of #waiters and #LFs\\n cellpick = min(len(energylist), LFnum)\\n while len(selected) < cellpick:\\n bins = np.cumsum(probs)\\n ind = np.digitize(RNs.getR(), bins)\\n selected.append(ind)\\n # now, set the probability of the selected cell to 0 and renormalise\\n # the remaining probability vector\\n newNorm = Norm - math.exp(-energylist[ind])\\n probs[ind] = 0\\n probs = probs * Norm / newNorm\\n Norm = newNorm\\n\\n return selected\",\n \"def fit_FITC(self, Kmm, Kmn, Knn_diag, epsilon=1e-3,power_ep=[1.,1.]):\\r\\n self.epsilon = epsilon\\r\\n self.eta, self.delta = power_ep\\r\\n\\r\\n num_inducing = Kmm.shape[0]\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Prior approximation parameters:\\r\\n q(f|X) = int_{df}{N(f|KfuKuu_invu,diag(Kff-Qff)*N(u|0,Kuu)} = N(f|0,Sigma0)\\r\\n Sigma0 = diag(Knn-Qnn) + Qnn, Qnn = Knm*Kmmi*Kmn\\r\\n \\\"\\\"\\\"\\r\\n Lm = jitchol(Kmm)\\r\\n Lmi = chol_inv(Lm)\\r\\n Kmmi = np.dot(Lmi.T,Lmi)\\r\\n P0 = Kmn.T\\r\\n KmnKnm = np.dot(P0.T, P0)\\r\\n KmmiKmn = np.dot(Kmmi,P0.T)\\r\\n Qnn_diag = np.sum(P0.T*KmmiKmn,-2)\\r\\n Diag0 = Knn_diag - Qnn_diag\\r\\n R0 = jitchol(Kmmi).T\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Posterior approximation: q(f|y) = N(f| mu, Sigma)\\r\\n Sigma = Diag + P*R.T*R*P.T + K\\r\\n mu = w + P*Gamma\\r\\n \\\"\\\"\\\"\\r\\n self.w = np.zeros(self.num_data)\\r\\n self.Gamma = np.zeros(num_inducing)\\r\\n mu = np.zeros(self.num_data)\\r\\n P = P0.copy()\\r\\n R = R0.copy()\\r\\n Diag = Diag0.copy()\\r\\n Sigma_diag = Knn_diag\\r\\n RPT0 = np.dot(R0,P0.T)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(g|mu_,sigma2_) = Product{q_i(g|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.num_data,dtype=float)\\r\\n self.v_ = np.empty(self.num_data,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.num_data,dtype=float)\\r\\n self.Z_hat = np.empty(self.num_data,dtype=float)\\r\\n phi = np.empty(self.num_data,dtype=float)\\r\\n mu_hat = np.empty(self.num_data,dtype=float)\\r\\n sigma2_hat = np.empty(self.num_data,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = 1\\r\\n epsilon_np2 = 1\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.num_data)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma_diag[i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma_diag[i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model.moments_match(self.data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma_diag[i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma_diag[i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n dtd1 = Delta_tau*Diag[i] + 1.\\r\\n dii = Diag[i]\\r\\n Diag[i] = dii - (Delta_tau * dii**2.)/dtd1\\r\\n pi_ = P[i,:].reshape(1,num_inducing)\\r\\n P[i,:] = pi_ - (Delta_tau*dii)/dtd1 * pi_\\r\\n Rp_i = np.dot(R,pi_.T)\\r\\n RTR = np.dot(R.T,np.dot(np.eye(num_inducing) - Delta_tau/(1.+Delta_tau*Sigma_diag[i]) * np.dot(Rp_i,Rp_i.T),R))\\r\\n R = jitchol(RTR).T\\r\\n self.w[i] += (Delta_v - Delta_tau*self.w[i])*dii/dtd1\\r\\n self.Gamma += (Delta_v - Delta_tau*mu[i])*np.dot(RTR,P[i,:].T)\\r\\n RPT = np.dot(R,P.T)\\r\\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\\r\\n mu = self.w + np.dot(P,self.Gamma)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Iplus_Dprod_i = 1./(1.+ Diag0 * self.tau_tilde)\\r\\n Diag = Diag0 * Iplus_Dprod_i\\r\\n P = Iplus_Dprod_i[:,None] * P0\\r\\n safe_diag = np.where(Diag0 < self.tau_tilde, self.tau_tilde/(1.+Diag0*self.tau_tilde), (1. - Iplus_Dprod_i)/Diag0)\\r\\n L = jitchol(np.eye(num_inducing) + np.dot(RPT0,safe_diag[:,None]*RPT0.T))\\r\\n R,info = dtrtrs(L,R0,lower=1)\\r\\n RPT = np.dot(R,P.T)\\r\\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\\r\\n self.w = Diag * self.v_tilde\\r\\n self.Gamma = np.dot(R.T, np.dot(RPT,self.v_tilde))\\r\\n mu = self.w + np.dot(P,self.Gamma)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.num_data\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.num_data\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def attach_to_controller(self, controller):\\r\\n\\r\\n def cv_amp(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n return np.std(amps) / np.mean(amps) if len(amps) >= 1 else 0\\r\\n\\r\\n def cum_amp_drift(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n # return cum_feat(amps) if len(amps) >= 2 else 0\\r\\n return np.sum(np.abs(np.diff(amps))) / len(amps) if len(amps) >= 2 else 0\\r\\n\\r\\n def cum_depth_drift(cluster_id):\\r\\n depths = controller.model.spike_depths[controller.get_spike_ids(cluster_id)].data\\r\\n # return cum_feat(depths) if len(depths) >= 2 else 0\\r\\n return np.sum(np.abs(np.diff(depths))) / len(depths) if len(depths) >= 2 else 0\\r\\n\\r\\n def cv_fr(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n fr = bb.singlecell.firing_rate(ts, hist_win=0.01, fr_win=0.25)\\r\\n return np.std(fr) / np.mean(fr) if len(fr) >= 1 else 0\\r\\n\\r\\n def frac_isi_viol(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n frac_isi_viol, _, _ = isi_viol(ts, rp=0.002)\\r\\n return frac_isi_viol\\r\\n\\r\\n def frac_missing_spikes(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n try:\\r\\n frac_missing_spks, _, _ = feat_cutoff(\\r\\n amps, spks_per_bin=10, sigma=4, min_num_bins=50)\\r\\n except:\\r\\n frac_missing_spks = np.NAN\\r\\n return frac_missing_spks\\r\\n\\r\\n def fp_estimate(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n return fp_est(ts, rp=0.002)\\r\\n\\r\\n def presence_ratio(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n pr, _ = pres_ratio(ts, hist_win=10)\\r\\n return pr\\r\\n\\r\\n def presence_ratio_std(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n pr, pr_bins = pres_ratio(ts, hist_win=10)\\r\\n return pr / np.std(pr_bins)\\r\\n\\r\\n def refp_viol(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n return FP_RP(ts)\\r\\n\\r\\n def n_cutoff(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n return noise_cutoff(amps, quartile_length=.25)\\r\\n\\r\\n def mean_amp_true(cluster_id):\\r\\n # Three cases: raw data\\r\\n\\r\\n # THIS APPROACH WORKS FOR BOTH SAMPLE WAVEFORMS AND RAW DATA\\r\\n # Specify 100 waveforms to average over, but may be less in the case where in the subset\\r\\n # of sample waveforms it doesn't contain 100 samples for specific cluster\\r\\n\\r\\n # N.B. These waveforms are median subtracted and have a high pass applied\\r\\n waveforms = controller._get_waveforms_with_n_spikes(\\r\\n cluster_id, 100)['data'].data\\r\\n\\r\\n # This way finds (max-min) on each channel, and then for each waveform finds the\\r\\n # maximum (max-min) on any channel and averages these\\r\\n # For each sample waveform find value on channel that has largest (max-min)\\r\\n p2p = np.max((np.max(waveforms, axis=1) - np.min(waveforms, axis=1)), axis=1)\\r\\n # Find mean p2p across all available sample waveforms\\r\\n p2p_mean = np.mean(p2p)\\r\\n\\r\\n # Alternative way\\r\\n # This way finds (max-min) on each channel, on each channel averages across all sample\\r\\n # waveforms and then finds the channel with the maximum average value\\r\\n p2p_mean_alt = np.max(np.mean(np.max(waveforms, axis=1) - np.min(waveforms, axis=1),\\r\\n axis=0))\\r\\n\\r\\n # Approach 2\\r\\n # Only works for sample waveforms\\r\\n # For non median subtracted and no high pass can access sample waveforms like this\\r\\n # spike_ids = controller.get_spike_ids(cluster_id).data\\r\\n # # Find which of the spike ids are in the subset of sample waveforms\\r\\n # _, _, idx = np.intersect1d(spike_ids,\\r\\n # controller.model.spike_waveforms['spike_ids'].data,\\r\\n # return_indices=True)\\r\\n # # Sample waveforms that are available for this cluster\\r\\n # # Shape of waveforms (n_waveforms, n_samples, n_channels)\\r\\n # # where len(idx) == n_waveforms\\r\\n # waveforms = controller.model.spike_waveforms['waveforms'][idx].data\\r\\n\\r\\n # RAW DATA CASE\\r\\n\\r\\n return p2p_mean\\r\\n\\r\\n # no waveforms\\r\\n\\r\\n # def ptp_sigma(cluster_id):\\r\\n # this also requires checking 3 cases above.\\r\\n\\r\\n def m_label(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n metrics_label = int(FP_RP(ts) and noise_cutoff(amps, quartile_length=.25) < 20)\\r\\n return metrics_label\\r\\n # if amplitudes are correct (i.e. raw data or sample wfs exist):\\r\\n #metrics_label = (FP_RP(ts) and noise_cutoff(amps,quartile_length=.25)<20 and np.mean(amps)>50)\\r\\n\\r\\n # Use this dictionary to define custom cluster metrics.\\r\\n # We memcache the function so that cluster metrics are only computed once and saved\\r\\n # within the session, and also between sessions (the memcached values are also saved\\r\\n # on disk).\\r\\n controller.cluster_metrics['cv_amp'] = controller.context.memcache(cv_amp)\\r\\n controller.cluster_metrics['cum_amp_drift'] = controller.context.memcache(cum_amp_drift)\\r\\n\\r\\n # NOTE: the branch of phylib which defines model.spike_depths is not working yet\\r\\n # controller.cluster_metrics['cum_depth_drift'] = controller.context.memcache(\\r\\n # cum_depth_drift)\\r\\n\\r\\n controller.cluster_metrics['cv_fr'] = controller.context.memcache(cv_fr)\\r\\n controller.cluster_metrics['frac_isi_viol'] = controller.context.memcache(frac_isi_viol)\\r\\n controller.cluster_metrics['frac_missing_spikes'] = controller.context.memcache(\\r\\n frac_missing_spikes)\\r\\n controller.cluster_metrics['fp_estimate'] = controller.context.memcache(fp_estimate)\\r\\n controller.cluster_metrics['presence_ratio'] = controller.context.memcache(presence_ratio)\\r\\n controller.cluster_metrics['presence_ratio_std'] = controller.context.memcache(\\r\\n presence_ratio_std)\\r\\n controller.cluster_metrics['refp_viol'] = controller.context.memcache(refp_viol)\\r\\n controller.cluster_metrics['noise_cutoff'] = controller.context.memcache(n_cutoff)\\r\\n controller.cluster_metrics['mean_amp'] = controller.context.memcache(mean_amp_true)\\r\\n controller.cluster_metrics['metrics_label'] = controller.context.memcache(m_label)\",\n \"def hcn_kn(Y,t,voltage_clamp_func,voltage_clamp_params):\\n\\n v = voltage_clamp_func(t,voltage_clamp_params)\\n n_s = Y[0]\\n n_f = Y[1]\\n\\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\\n ninf_f = ninf_s\\n\\n if v > -70.0:\\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\\n else:\\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\\n\\n dns = (ninf_s - n_s)/tau_ns\\n dnf = (ninf_f - n_f)/tau_nf\\n\\n return [dns, dnf]\",\n \"def WakeVorticityFromCirculation_Cont(r_cp,Gamma_cp,R,U0,Omega,bSwirl,method='analytical',bHighThrustCorr=True):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cp[0]==0:\\n r_cp[0]=r_cp[1]*0.5;\\n # Non dimensional parameters\\n k = Omega*Gamma_cp/(np.pi*U0**2)\\n vr_bar = r_cp/R \\n lambda_r = Omega*r_cp/U0\\n # Finding inductions\\n a,a_prime,misc= InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method=method,bHighThrustCorr=bHighThrustCorr)\\n # Computing convection\\n misc['Vz'] = U0*(1-2*a)\\n misc['h'] = misc['Vz']*2*np.pi/(Omega*(1+2*a_prime))\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n # Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n gamma_t = - Gamma_tilde/misc['h']\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = 0\\n Gamma_r = 0\\n return gamma_t,gamma_l,Gamma_r,misc\",\n \"def HKS(evals,evects, time_list,scaled=False):\\n evals_s = np.asarray(evals).flatten()\\n t_list = np.asarray(time_list).flatten()\\n\\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\\n\\n if scaled:\\n inv_scaling = coefs.sum(1) # (num_T)\\n return (1/inv_scaling)[None,:] * natural_HKS\\n\\n else:\\n return natural_HKS\",\n \"def hcn_tf(Y,t,voltage_clamp_func,voltage_clamp_params):\\n \\n v = voltage_clamp_func(t,voltage_clamp_params)\\n n_s = Y[0]\\n n_f = Y[1]\\n \\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\\n ninf_f = ninf_s\\n\\n if v > -70.0:\\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\\n else:\\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\\n\\n dns = (ninf_s - n_s)/tau_ns\\n dnf = (ninf_f - n_f)/tau_nf\\n \\n return [dns, dnf]\",\n \"def model(**params):\\n N_frb = 0\\n vs = []\\n hs = []\\n cs = []\\n ncands = []\\n\\n for cand in candlist:\\n c_res = calculate_metric_terms(\\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\\n )\\n t, frb_found, h, c, v = c_res\\n vs.append(v)\\n hs.append(h)\\n cs.append(c)\\n ncands.append(t)\\n\\n if frb_found:\\n N_frb += 1\\n\\n vs = np.array(vs)\\n hs = np.array(hs)\\n cs = np.array(cs)\\n c_avg = np.average(cs, axis=0, weights=ncands)\\n h_avg = np.average(hs, axis=0, weights=ncands)\\n v_avg = np.average(vs, axis=0, weights=ncands)\\n recall = N_frb / len(vs)\\n score = v_avg * recall\\n\\n return score\",\n \"def grid_visibilities(self, visibilities, N = 120):\\n logger.info(\\\"Gridding the visibilities\\\")\\n\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\\n\\n centres = (ugrid[1:] + ugrid[:-1]) / 2\\n\\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\\n\\n if(os.path.exists(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")):\\n kernel_weights = np.load(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")\\n else:\\n kernel_weights=None\\n\\n if kernel_weights is None:\\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\\n\\n for jj, freq in enumerate(self.frequencies):\\n u_bl = (self.baselines[:,0] * freq / const.c).value\\n v_bl = (self.baselines[:,1] * freq / const.c).value\\n\\n beam, indx_u, indx_v = self.fourierBeam(centres, u_bl, v_bl, freq, N=N)\\n for kk in range(len(indx_u)):\\n visgrid[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk]) * visibilities[kk,jj]\\n\\n if kernel_weights is None:\\n weights[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk])\\n\\n if kernel_weights is None:\\n kernel_weights = weights\\n\\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\\n\\n return visgrid,kernel_weights\",\n \"def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \\n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \\n N_res=30):\\n x_eps = 0.3 # shift from Dirac point\\n x_res = 20\\n kx_int = 0 + x_eps # -np.pi\\n kx_fin = 4*np.pi/3 + x_eps\\n Dx = (kx_fin - kx_int)/x_res\\n\\n y_res = 20\\n ky_int = 0 # -np.pi\\n ky_fin = 2*np.pi/np.sqrt(3)\\n Dy = (ky_fin - ky_int)/y_res\\n\\n Nd = self.Nd # dimension of the Hamiltonian\\n Dk = np.array([Dx,Dy], float)\\n\\n LF = np.zeros((Nd), dtype=complex)\\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n sumN = np.zeros((Nd), dtype=complex)\\n E_k = np.zeros((Nd), dtype=complex)\\n chernN = np.zeros((Nd), dtype=complex)\\n\\n # Loop over kx\\n for ix in range(x_res):\\n kx = kx_int + ix*Dx\\n\\n # Loop over ky\\n for iy in range(y_res):\\n ky = ky_int + iy*Dy\\n\\n k_vec = np.array([kx,ky], float)\\n\\n LF, E_k = self.latF(k_vec, Dk, self.delta)\\n\\n sumN += LF\\n\\n # # save data for plotting\\n LF_arr[:,ix,iy] = LF.imag\\n\\n E_arr[:,ix,iy] = np.sort(E_k.real)\\n\\n # End of ky Loop\\n # End of kx Loop\\n\\n chernN = sumN.imag/(2*np.pi)\\n print(\\\"Chern number bands are (%.3f, %.3f) \\\" \\n %(chernN[0], chernN[1]))\\n print(\\\"Sum of all bands Chern Number is %.2f \\\" %(sum(chernN)))\\n return chernN, E_arr\\n #################### \",\n \"def set_kbest_features_list(data_dict, features_list):\\n \\n print \\\" --- \\\"\\n\\n k_best = get_k_best(data_dict,features_list,len(features_list)-1)\\n \\n ### Sort the k_best features in descending order\\n arr_features = []\\n print \\\"sorted k_best:\\\"\\n for key, value in sorted(k_best.iteritems(), key=lambda (k,v): (v,k), reverse=True):\\n print \\\"%s: %s\\\" % (key, value)\\n arr_features.append(key)\\n\\n print \\\"---\\\"\\n poi = [\\\"poi\\\"]\\n features_list = poi\\n features_list += arr_features\\n\\n print \\\"---\\\"\\n print \\\"features List: \\\"\\n print features_list\\n print(\\\"Number of features in k_best: \\\",len(features_list))\\n print \\\" \\\"\\n\\n return features_list\",\n \"def vote_for_k(utilities, k):\\n utilities = np.asarray(utilities)\\n n_cands = utilities.shape[1]\\n if k == 'half':\\n # \\\"It is interesting to observe that the vote-for-k and vote-for-(n-k)\\n # voting systems are equally effective.\\\"\\n # So for 7 candidates, we could use either k=4 or k=3 (= 7//2)\\n # TODO: Though this seems only true with infinite voters?\\n k = n_cands // 2\\n elif -n_cands < k < 0:\\n k = n_cands + k\\n elif not 0 < k < n_cands:\\n raise ValueError(f'k of {k} not possible with {n_cands} candidates')\\n\\n # Efficiently get indices of top k candidates for each voter\\n # https://stackoverflow.com/a/23734295/125507\\n # TODO: How are tied utilities handled, such as top 2 with 3 tied? Random?\\n top_k = np.argpartition(utilities, -k, axis=1)[:, -k:]\\n\\n # Create blank ballots\\n approvals = np.zeros(utilities.shape, np.uint8)\\n\\n # Fill in approvals\\n # TODO: Not sure if this is the most efficient way\\n approvals[np.arange(len(approvals))[:, np.newaxis], top_k] = 1\\n return approvals\",\n \"def estimate_opt_eff(self, iv_fn_hot, iv_fn_cold,t_hot=293.,t_cold=77.,\\n channels = None, dPdT_lim=(0.,0.5)):\\n ivs_hot = np.load(iv_fn_hot).item()\\n ivs_cold = np.load(iv_fn_cold).item()\\n \\n iv_fn_raw_hot = iv_fn_hot.split('.')[0] + '_raw_data.npy'\\n iv_fn_raw_cold = iv_fn_cold.split('.')[0] + '_raw_data.npy'\\n\\n ivs_raw_hot = np.load(iv_fn_raw_hot).item()\\n ivs_raw_cold = np.load(iv_fn_raw_cold).item()\\n \\n basename_hot = ivs_raw_hot['basename']\\n basename_cold = ivs_raw_cold['basename']\\n\\n #band = ivs_raw_hot['band']\\n #assert ivs_raw_cold['band'] == band, \\\\\\n # 'Files must contain IVs from the same band'\\n group = ivs_raw_hot['bias group']\\n assert ivs_raw_cold['bias group'], \\\\\\n 'Files must contain IVs from the same bias group'\\n \\n import matplotlib.pyplot as plt\\n plot_dir = self.plot_dir\\n\\n dT = t_hot - t_cold\\n dPdT_list = []\\n n_outliers = 0\\n for ch in ivs_hot:\\n if channels is not None:\\n if ch not in channels:\\n continue\\n elif not isinstance(ch,np.int64):\\n continue\\n \\n if ch not in ivs_cold:\\n continue\\n \\n P_hot = ivs_hot[ch]['P']\\n P_cold = ivs_cold[ch]['P']\\n R_hot = ivs_hot[ch]['R']\\n R_cold = ivs_cold[ch]['R']\\n Ptrans_hot = ivs_hot[ch]['Ptrans']\\n Ptrans_cold = ivs_cold[ch]['Ptrans']\\n if Ptrans_hot is None or Ptrans_cold is None:\\n print('Missing in-transition electrical powers for Ch. %i' % (ch))\\n continue\\n dPdT = (Ptrans_cold - Ptrans_hot)/dT\\n self.log('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\\n if dPdT_lim is not None:\\n if dPdT >= dPdT_lim[0] and dPdT <= dPdT_lim[1]:\\n dPdT_list.append(dPdT)\\n else:\\n n_outliers += 1\\n else:\\n dPdT_list.append(dPdT)\\n\\n fig_pr,ax_pr = plt.subplots(1,sharex=True)\\n ax_pr.set_xlabel(r'$R_\\\\mathrm{TES}$ [$\\\\Omega$]')\\n ax_pr.set_ylabel(r'$P_\\\\mathrm{TES}$ [pW]')\\n label_hot = '%s: %.0f K' % (basename_hot,t_hot)\\n label_cold = '%s: %.0f K' % (basename_cold,t_cold)\\n ax_pr.axhline(y=Ptrans_hot,linestyle = '--',color = 'b')\\n ax_pr.axhline(y=Ptrans_cold,linestyle = '--',color = 'r')\\n ax_pr.plot(R_hot,P_hot,label=label_hot,color='b')\\n ax_pr.plot(R_cold,P_cold,label=label_cold,color='r')\\n ax_pr.legend(loc='best')\\n fig_pr.suptitle('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\\n ax_pr.grid()\\n \\n plot_name = basename_hot + '_' + basename_cold + '_optEff_g{}_ch{:03}.png'.format(group, ch)\\n plot_filename = os.path.join(plot_dir, plot_name)\\n self.log('Saving optical-efficiency plot to {}'.format(plot_filename))\\n plt.savefig(plot_filename,bbox_inches='tight', dpi=300)\\n plt.close()\\n\\n plt.figure()\\n plt.hist(dPdT_list,edgecolor='k')\\n plt.xlabel('dP/dT [pW/K]')\\n plt.grid()\\n dPdT_median = np.median(dPdT_list)\\n plt.title('Group {}, median = {:.3f} pW/K ({} outliers not plotted)'.format(group,dPdT_median,n_outliers))\\n plot_name = basename_hot + '_' + basename_cold + '_dPdT_hist_g{}.png'.format(group)\\n hist_filename = os.path.join(plot_dir,plot_name)\\n self.log('Saving optical-efficiency histogram to {}'.format(hist_filename))\\n plt.savefig(hist_filename,bbox_inches='tight',dpi=300)\\n plt.close()\",\n \"def define_pseudo_potts_helper_functions(n, k):\\n\\n assert n>1\\n assert k>1\\n\\n @njit\\n def get_multipliers_r(r, multipliers, n=n, k=k):\\n \\\"\\\"\\\"Return r's field and all couplings to spin r.\\n\\n Parameters\\n ----------\\n r : int\\n multipliers : ndarray\\n All fields and couplings concatenated together.\\n\\n Returns\\n -------\\n ndarray\\n Relevant multipliers.\\n list\\n Index of where multipliers appear in full multipliers array.\\n \\\"\\\"\\\"\\n \\n ix = [r+n*i for i in range(k)]\\n multipliersr = np.zeros(k-1+n)\\n for i in range(k):\\n multipliersr[i] = multipliers[r+n*i]\\n\\n # fill in the couplings\\n ixcounter = k\\n for i in range(n):\\n if i!=r:\\n if i<r:\\n ix.append( sub_to_ind(n, i, r) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n else:\\n ix.append( sub_to_ind(n, r, i) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n ixcounter += 1\\n return multipliersr, ix\\n\\n @njit\\n def calc_observables_r(r, X, n=n, k=k):\\n \\\"\\\"\\\"Return the observables relevant for calculating the conditional probability of\\n spin r.\\n\\n Parameters\\n ----------\\n r : int\\n Spin index.\\n X : ndarray\\n Data samples of dimensions (n_samples, n_dim).\\n\\n Returns\\n -------\\n ndarray\\n observables\\n list of ndarray\\n observables if spin r were to occupy all other possible states\\n ndarray\\n Each col details the occupied by spin r in each array of the previous return\\n value, i.e., the first col of this array tells me what r has been changed to\\n in the first array in the above list.\\n \\\"\\\"\\\"\\n\\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n # keep another copy of observables where the spin iterates thru all other possible states\\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n for i in range(k-1)]\\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\\n \\n # for each data sample in X\\n for rowix in range(X.shape[0]):\\n counter = 0\\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\\n for i in range(k):\\n if X[rowix,r]==i:\\n obs[rowix,i] = 1\\n else:\\n otherobs[counter][rowix,i] = 1\\n otherstates[rowix,counter] = i\\n counter += 1\\n ixcounter = k\\n \\n for i in range(n-1):\\n for j in range(i+1,n):\\n if i==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\\n kcounter += 1\\n ixcounter += 1\\n elif j==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\\n kcounter += 1\\n ixcounter += 1\\n return obs, otherobs, otherstates\\n\\n return get_multipliers_r, calc_observables_r\",\n \"def model(cp_list,cp_now):\\r\\n global record\\r\\n distance_threshold = 0.5\\r\\n model_path = \\\"trained_knn_model.clf\\\"\\r\\n \\r\\n # Load a trained KNN model (if one was passed in)\\r\\n with open(model_path, 'rb') as f:\\r\\n knn_clf = pickle.load(f)\\r\\n\\r\\n for X_img in cp_list:\\r\\n # Load image file and find face locations\\r\\n X_face_locations = face_recognition.face_locations(X_img)\\r\\n\\r\\n # If no faces are found in the image, return an empty result.\\r\\n if len(X_face_locations) == 0:\\r\\n return []\\r\\n\\r\\n # Find encodings for faces in the test iamge\\r\\n faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)\\r\\n\\r\\n # Use the KNN model to find the best matches for the test face\\r\\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\\r\\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]\\r\\n # Predict classes and remove classifications that aren't within the threshold\\r\\n for pred, rec in zip(knn_clf.predict(faces_encodings), are_matches):\\r\\n if rec:\\r\\n name = pred\\r\\n else:\\r\\n name = \\\"unknown\\\"\\r\\n if name not in record:\\r\\n end = datetime.now()\\r\\n record.append(name)\\r\\n record_time.append(end-cp_now)\",\n \"def build_param_grid(self, C_list:list=[0.1, 1, 10, 100], gamma_list:list=[1, 0.1, 0.01, 0.001], kernel_list:list=['rbf']):\\n ans = {}\\n ans['C'] = C_list\\n ans['gamma'] = gamma_list\\n ans['kernel'] = kernel_list\\n self.param_grid = ans\\n return ans\",\n \"def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\\n max_cp = 1\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n max_cp += w_inpIdx*X0[inpIdx]\\n # saving values\\n layerEq[inpIdx] = X0[inpIdx]\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n layerEq[inpIdx] = x_eq\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n max_cp += firstComplex + Inhib2/E0*x_eq\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n max_cp += Inhib2/E0*x_eq\\n return max_cp\",\n \"def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n pad=np.random.rand(nspad)/100\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_norm_padded=np.hstack((pad,trc_norm))\\n trc_entropy=self.entropy(trc_norm_padded,50)\\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\\n for i,j in enumerate(trc):\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def fit(self):\\n N = self.data.shape\\n prev_k = 1\\n k_lst = []\\n k_list = self.tt_ranks.copy()\\n if self.model=='tt': depth = len(N)-1\\n elif self.model=='tk': depth = len(N)\\n\\n for axis in range(depth):\\n if self.global_rank==0: print('Decomposing for stage=',axis+1)\\n if self.model=='tt':\\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([prev_k * N[axis], -1])\\n elif self.model=='tk':\\n k_lst.append(prev_k)\\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([N[axis], np.product(k_lst)*np.product(N[axis+1:])])\\n\\n if np.any(k_list) != False:\\n self.this_k = k_list[axis]\\n else:\\n if self.global_rank==0: print('Estimating rank now with SVD...')\\n self.this_k = self.determine_rank(self.data, self.err)\\n\\n if self.routine=='nmf':\\n self.params.k = self.this_k\\n if self.global_rank==0: print('Performing NMF for TN stage=',axis+1)\\n W, H, rel_error = PyNMF(self.data, factors=None, params=self.params).fit()\\n\\n elif self.routine=='svd':\\n if self.global_rank == 0: print('Performing SVD for TN stage=', axis + 1)\\n singularValues, U, V,rel_error = self.compute_svd(self.data,self.this_k)\\n S = np.diag(singularValues)\\n W = U\\n H = S @ V\\n\\n if self.model=='tt':\\n self.factors.append(np.reshape(W, (prev_k, N[axis], self.this_k)))\\n elif self.model=='tk':\\n self.factors.append(W)\\n if axis==depth-1:\\n H_final = np.hstack((self.comm.allgather(H)))\\n if self.model=='tk':\\n k_lst.append(self.this_k)\\n H_final = np.reshape(H_final,k_lst[1:])\\n # H_final = np.hstack((block_idx_rank_H_tran(H_final,1, self.size)))\\n self.factors.append(H_final)\\n self.rel_error.append(rel_error)\\n prev_k = self.this_k\\n fpath = 'data/H_factor.zarr'\\n self.data = tn_data_operations(self.comm1,fpath,H).lazy_store_file()\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy\",\n \"def get_best_k_cv(air_quality_model):\\n\\n locations = air_quality_model.air_quality_locations\\n time_series = air_quality_model.air_quality_time_series\\n\\n for each_location in locations:\\n\\n other_locations = [i for i in locations if i != each_location]\\n training_time_series = time_series[other_locations]\\n scaled_training_time_series = air_quality_model.scaler.transform(training_time_series)\\n training_time_series_dropna = scaled_training_time_series.dropna().T\\n\\n # k means determine k\\n distortions = []\\n K = range(1, len(other_locations) + 1, 1)\\n for k in K:\\n kmeans = KMeans(n_clusters=k, max_iter=300).fit(training_time_series_dropna)\\n # err = sum(np.min(cdist(training_time_series_dropna, kmeans.cluster_centers_, 'euclidean'), axis=1)) \\\\\\n # / training_time_series_dropna.shape[0]\\n\\n # Sum of squared distances of samples to their closest cluster center\\n err = kmeans.inertia_\\n distortions.append(err)\\n print(k, dict(zip(other_locations, kmeans.labels_)))\\n print(each_location, k, 'err=', err)\\n\\n # Plot the elbow\\n plt.figure(figsize=(15, 20))\\n plt.plot(K, distortions, 'bx-')\\n plt.xlabel('k')\\n plt.ylabel('Distortion')\\n plt.title(str(each_location) + ' The Elbow Method showing the optimal k')\\n plt.show()\",\n \"def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cyl is None:\\n r_cyl = np.zeros(r_cp.shape)\\n if len(r_cyl)==1:\\n r_cyl=np.array([R])\\n else:\\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\\n else:\\n r_cyl = np.asarray(r_cyl).ravel()\\n misc={}\\n # --- Checks\\n if np.amax(r_cyl) < np.amax(r_cp):\\n warnings.warn('Cylinders are assumed to enclose the control points')\\n import pdb; pdb.set_trace()\\n if r_cyl[0] == 0:\\n raise Exception('First cylinder at 0, impossible')\\n\\n ## Interpolating Circulation on the control points\\n Gamma_cp = Gamma_cp * nB # IMPORTANT\\n lambda_rcp = Omega*r_cp/U0\\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\\n ## Some init\\n\\n n = len(r_cyl)\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n # --- Case 1: Using k / ct to determine gamma\\n # Using a_prime to correct Ct\\n # Tangential convection velocity\\n if not bTanInd_k:\\n ap_cyl_conv = 0 * Gamma_cp\\n else:\\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\\n # See Equation (26) of [1]: a'_c,i = (\\\\Gamma_i+\\\\Gamma_i+1)/(4 pi Omega R_i^2)\\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\\n # --- Allocation\\n b = np.zeros(n) # Cummulative sum of gamma_bar\\n S = np.zeros(n) # Term under the square root\\n Sbis = np.zeros(n) # Term under the square root, account\\n Ctrot = np.zeros(n)\\n Ctrot_loc = np.zeros(n)\\n Cti = np.zeros(n)\\n Cteff = np.zeros(n)\\n gamma_t_bar = np.zeros(n)\\n # --- Init\\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\\n lambda_R = Omega * r_cyl / U0\\n # Looping through radii in reversed order\\n for i in np.arange(n-1,-1,-1):\\n if i==n-1:\\n b[i] = 1\\n S[i] = 1 - C[i]\\n Sbis[i] = 1 - C[i]\\n Ctrot[i] = 0\\n Ctrot_loc[i] = 0\\n else:\\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\\n if not bSwirl:\\n Ctrot[i] = 0\\n Cti[i] = k_r[i]\\n else:\\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\\n Sbis[i] = 1 - Cteff[i]\\n if bSwirl :\\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\\n else:\\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \\n# print('b',b,'S',S)\\n if bHighThrustCorr:\\n if (Cteff[i] > Ct_c):\\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\\n #if np.abs(imag(gamma_t_bar(i))) > 0:\\n # gamma_t_bar[i] = - b[i] + 0\\n Vc = U0 * (b + gamma_t_bar / 2)\\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\\n\\n\\n # Analytical 1\\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\\n a_1=a_1[-1::-1]\\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\\n a=a_1;\\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\\n # # Analytical 2\\n # a_2=-(gamma_t_hat/2)/U0;\\n # a=a_2;\\n #else\\n # a=a_1;\\n #end\\n if bSwirl:\\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\\n else:\\n a_prime=a*0\\n\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n misc['h'] = h\\n\\n # --- Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n #gamma_t = - Gamma_tilde/h\\n gamma_t = gamma_t_bar * U0\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = None\\n Gamma_r = None\\n\\n return gamma_t,gamma_l,Gamma_r, misc\",\n \"def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cyl is None:\\n r_cyl = np.zeros(r_cp.shape)\\n if len(r_cyl)==1:\\n r_cyl=np.array([R])\\n else:\\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\\n else:\\n r_cyl = np.asarray(r_cyl).ravel()\\n misc={}\\n # --- Checks\\n if np.amax(r_cyl) < np.amax(r_cp):\\n warnings.warn('Cylinders are assumed to enclose the control points')\\n import pdb; pdb.set_trace()\\n if r_cyl[0] == 0:\\n raise Exception('First cylinder at 0, impossible')\\n\\n ## Interpolating Circulation on the control points\\n Gamma_cp = Gamma_cp * nB # IMPORTANT\\n lambda_rcp = Omega*r_cp/U0\\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\\n ## Some init\\n\\n n = len(r_cyl)\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n # --- Case 1: Using k / ct to determine gamma\\n # Using a_prime to correct Ct\\n # Tangential convection velocity\\n if not bTanInd_k:\\n ap_cyl_conv = 0 * Gamma_cp\\n else:\\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\\n # See Equation (26) of [1]: a'_c,i = (\\\\Gamma_i+\\\\Gamma_i+1)/(4 pi Omega R_i^2)\\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\\n # --- Allocation\\n b = np.zeros(n) # Cummulative sum of gamma_bar\\n S = np.zeros(n) # Term under the square root\\n Sbis = np.zeros(n) # Term under the square root, account\\n Ctrot = np.zeros(n)\\n Ctrot_loc = np.zeros(n)\\n Cti = np.zeros(n)\\n Cteff = np.zeros(n)\\n gamma_t_bar = np.zeros(n)\\n # --- Init\\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\\n lambda_R = Omega * r_cyl / U0\\n # Looping through radii in reversed order\\n for i in np.arange(n-1,-1,-1):\\n if i==n-1:\\n b[i] = 1\\n S[i] = 1 - C[i]\\n Sbis[i] = 1 - C[i]\\n Ctrot[i] = 0\\n Ctrot_loc[i] = 0\\n else:\\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\\n if not bSwirl:\\n Ctrot[i] = 0\\n Cti[i] = k_r[i]\\n else:\\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\\n Sbis[i] = 1 - Cteff[i]\\n if bSwirl :\\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\\n else:\\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \\n# print('b',b,'S',S)\\n if bHighThrustCorr:\\n if (Cteff[i] > Ct_c):\\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\\n #if np.abs(imag(gamma_t_bar(i))) > 0:\\n # gamma_t_bar[i] = - b[i] + 0\\n Vc = U0 * (b + gamma_t_bar / 2)\\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\\n\\n\\n # Analytical 1\\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\\n a_1=a_1[-1::-1]\\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\\n a=a_1;\\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\\n # # Analytical 2\\n # a_2=-(gamma_t_hat/2)/U0;\\n # a=a_2;\\n #else\\n # a=a_1;\\n #end\\n if bSwirl:\\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\\n else:\\n a_prime=a*0\\n\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n misc['h'] = h\\n\\n # --- Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n #gamma_t = - Gamma_tilde/h\\n gamma_t = gamma_t_bar * U0\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = None\\n Gamma_r = None\\n\\n return gamma_t,gamma_l,Gamma_r, misc\",\n \"def non_max_suppression_kneron(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\\n if prediction.dtype is torch.float16:\\n prediction = prediction.float() # to FP32\\n\\n nc = prediction[0].shape[1] - 5 # number of classes\\n xc = prediction[..., 4] > conf_thres # candidates\\n\\n # Settings\\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\\n max_det = 300 # maximum number of detections per image\\n time_limit = 10.0 # seconds to quit after\\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\\n\\n t = time.time()\\n output = [None] * prediction.shape[0]\\n for xi, x in enumerate(prediction): # image index, image inference\\n # Apply constraints\\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\\n x = x[xc[xi]] # confidence\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\\n box = xywh2xyxy(x[:, :4])\\n\\n # Detections matrix nx6 (xyxy, conf, cls)\\n if multi_label:\\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\\n else: # best class only\\n conf, j = x[:, 5:].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\\n\\n\\n\\n # If none remain process next image\\n n = x.shape[0] # number of boxes\\n if not n:\\n continue\\n\\n # Sort by confidence\\n # x = x[x[:, 4].argsort(descending=True)]\\n\\n # Batched NMS\\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\\n # Sort by confidence\\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\\n x = x[ind_Sort_by_confidence][:top_k_num] #\\n # cross classes nms\\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n\\n\\n output[xi] = x[i]\\n if (time.time() - t) > time_limit:\\n break # time limit exceeded\\n\\n return output\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def ridge_joint(trn_fs,trn_data,alphas,val_fs=None,val_data=None,square_alphas=False,chunk_sz=5000,is_verbose=True):\\n\\n n_resp, n_voxels = trn_data.shape\\n n_channels = np.sum([tfs.shape[1] for tfs in trn_fs])\\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\\n\\n if square_alphas:\\n alphas = [a**2 for a in alphas]\\n\\n num_train_points = float(list(trn_data.shape)[0])\\n num_val_points = float(list(val_data.shape)[0])\\n\\n n_abc = [np.minimum(*t_fs.shape) for t_fs in trn_fs]\\n ######################################################################################\\n ### --- First up: compute modified covariance matrix & scaled/rotated stimulus --- ###\\n ######################################################################################\\n # Perform SVD on training sets for all three models \\n if is_verbose:\\n print(\\\"computing SVD\\\")\\n U_trn,W_trn,Vt_trn = [],[],[]\\n for t_fs in trn_fs:\\n uu,ww,vv = np.linalg.svd(trn_stim_A, full_matrices=False)\\n U_trn.append(uu)\\n W_trn.append(ww)\\n Vt_trn.append(vv)\\n\\n # The square of Ws (the singular values from the SVD) are the eigenvalues of the covariance matrix but have not been divided by n-1.\\n L = [ww**2/float(num_train_points-1) for ww in W_trn]\\n\\n ### --- IDK WTF. Ask Wendino. --- ###\\n ## to change: make sure that Ws are in the right units (divided by n-1) when bootstrapping, so that alphas are already in correct units\\n ## at that point you can change the lines below and not divide alpha by (n-1)\\n # TO DO: make this more than one line for clarity.\\n w_alpha_trn = [np.diag(np.sqrt(1./(LL + aa)/(num_train_points-1))) for LL,aa in zip(L,alphas)]\\n #w1_alpha_trn = sqrt(1./(L1+ alphas_A2[0]/(num_train_points-1))) \\n #w1_alpha_trn = diag(w1_alpha_trn) #%turn it from an array to a matrix\\n\\n # Create & combine rotated & scaled stimulus space \\n X_prime_trn_t = [ww.dot(vv).dot(t_fs) for ww,vv,t_fs in zip(W_trn,Vt_trn,trn_fs)]\\n #S1_prime_trn_t = np.dot(np.dot(w1_alpha_trn, Vt1_trn), trn_stim_A.T) #w1_alpha_trn = 1200x1200, Vt1_trn = 1200x1200, trn_stim_A.T = 1200x3737\\n Xcomb_prime_trn_t = np.vstack(X_prime_trn_t)\\n\\n # Create & modify covariance matrix\\n stim_cov_mat_r = X_prime_trn_t.dot(X_prime_trn_t.T) / float(num_train_points-1)\\n cov_diag = np.sqrt(np.diag(stim_cov_mat_r))\\n full_mat_cov_diag = np.tile(cov_diag, [cov_diag.shape[0], 1])\\n # re-do w/ simpler syntax?\\n all_divisor = np.multiply(full_mat_cov_diag.T, full_mat_cov_diag) \\n corr_mat_r = np.divide(stim_cov_mat_r, all_divisor)\\n\\n ### --- Clean up the correlation matrix to have zeros where we know they exist and use that data to set a threshold --- ###\\n idx_ct = np.cumsum([0]+n_abc)\\n idxs = [(a,b) for a,b in zip(idx_ct[:-1],idx_ct[1:])]\\n # Block diagonal components of covariance matrix\\n for n,(ii,jj) in zip(n_abc,idxs):\\n corr_mat_r[ii:jj] = np.eye(n)\\n # Off-diagonal elements: ignore for now? \\n #for i1,i2 in zip(idxs[:-1],idxs[1:]):\\n # (ii,jj),(kk,ll) = i1,i2\\n \\n\\n # ##### --- WORKING HERE - SEE IPYTHON NOTEBOOK --- #########\\n # upper_right_corr = np.ravel(corr_mat_r[0:nA, nA:])\\n # middle_right_corr = np.ravel(corr_mat_r[nA:(nA+nB),(nA+nB):])\\n # right_corr = np.hstack([upper_right_corr, middle_right_corr])\\n # s_right_corr = argsort(right_corr)\\n # # WTF is this?\\n # #corr_cutoff = 954 # WH magic number; something to do with the fact that it's needless to have \\n # # ALL the block-diagonal diagonals, since we have limited data\\n # #goodcorrs_idx = np.hstack([s_right_corr[0:corr_cutoff], s_right_corr[-1:-(corr_cutoff+1):-1]])\\n\\n # new_right_corrs = np.squeeze(np.zeros([s_right_corr.shape[0],1]))\\n # #new_right_corrs[goodcorrs_idx] = right_corr[goodcorrs_idx]\\n # new_upper_right_corrs = np.reshape(new_right_corrs[0:(nB+nC)*nA],[nA,nB+nC])\\n # new_lower_left_corrs = new_upper_right_corrs.T\\n # new_middle_right_corrs = np.reshape(new_right_corrs[(nB+nC)*nA:],[nB,nC])\\n # new_middle_left_corrs = new_middle_right_corrs.T\\n\\n # ##NEED TO CHANGE THIS: REMOVE HARDCODED MATRIX SIZES\\n # new_corr_mat_r = copy.copy(corr_mat_r)\\n # new_corr_mat_r[0:nA, nA:]= new_upper_right_corrs\\n # new_corr_mat_r[nA:(nA+nB), (nA+nB):] = new_middle_right_corrs\\n # new_corr_mat_r[(nA+nB):, nA:(nA+nB)]= new_middle_left_corrs # More like bottom middle\\n # new_corr_mat_r[nA:,0:nA] = new_lower_left_corrs # \\n # new_corr_mat_r[0:nA,0:nA]= np.identity(nA)\\n # new_corr_mat_r[nA:(nA+nB), nA:(nA+nB)] = np.identity(nB)\\n # new_corr_mat_r[(nA+nB):,(nA+nB):] = np.identity(nC)\\n\\n #perform eigenvalue decomposition (WHAT FOR? delete this?)\\n #w, v = np.linalg.eigh(new_corr_mat_r)\\n # Invert modified covariance matrix\\n #corr_r_inv = np.linalg.inv(new_corr_mat_r)\\n corr_r_inv = np.linalg.inv(corr_mat_r)\\n #for \\n ##create filter\\n dot1 = np.dot(X_prime_trn_t, trn_data) #precompute for speed\\n dot2 = np.dot(corr_r_inv, dot1) #precompute for speed\\n # Weights\\n h_123_prime = np.divide(dot2, (float(num_train_points-1)))\\n\\n\\n ##create estimated responses from training data\\n #r_hat = np.dot(X_prime_trn_t.T, h_123_prime) # not usually done...\\n #if do_pred:\\n #validation set results\\n val_stim_A_prime = np.dot(np.dot(w1_alpha_r, Vt1_r), val_stim_A.T)\\n val_stim_B_prime = np.dot(np.dot(w2_alpha_r, Vh2_r), val_stim_B.T)\\n val_stim_C_prime = np.dot(np.dot(w3_alpha_r, Vh3_r), val_stim_C.T)\\n #S1_prime = S1_prime[0:200,:]\\n #S2_prime = S2_prime[0:200,:]\\n\\n S123_val_prime_t = np.vstack([val_stim_A_prime, val_stim_B_prime, val_stim_C_prime])\\n\\n #create validation set correlations\\n r_hat_val = np.dot(S123_val_prime_t.T, h_123_prime)\\n\\n\\n #look at performance\\n valcorr = _sutils.column_corr(r_hat_val, val_data)\\n out = dict(\\n #weights=wt,\\n #alphas=alphas,\\n #n_sig_vox_byalpha=n_sig_vox_byalpha,\\n cc=valcorr\\n )\\n return out\",\n \"def optical_kernels(K, J, Lxy, fmax, num):\\n\\n df = 1/Lxy\\n\\n # Compute TCC\\n TCC, f = trans_cross_coeff(K, J, df, fmax)\\n \\n # Convert to 2D matrix\\n N = f.size\\n TCCm = np.reshape(np.reshape(TCC, (N, N, -1)), (N**2, -1))\\n\\n # Compute largest eigenvalues and eigenvectors\\n w, v = scipy.linalg.eigh(TCCm, eigvals=(N**2 - num, N**2 - 1))\\n w = np.flip(w, 0)\\n v = np.flip(v, 1)\\n\\n # Get real-space optical kernels\\n phi = []\\n for i in range(num):\\n Phi = np.fft.ifftshift(np.reshape(v[:,i], [N, N]))\\n #phi.append(np.fft.fftshift(np.fft.ifft2(Phi)))\\n phi.append(np.fft.ifft2(Phi))\\n \\n return w, phi\",\n \"def camb_XPk(self,\\n z = 0.,\\n k = np.logspace(-4., 2., 1001),\\n nonlinear = False,\\n halofit = 'mead2020',\\n var_1 = ['tot'],\\n var_2 = ['tot'],\\n share_delta_neff = True,\\n **kwargs\\n ):\\n\\n # Neutrino part\\n nu_mass_eigen = len(np.unique([mm for mm in self.M_nu])) if np.any(self.M_nu!=0.) else 0\\n nu_mass_numbers = [list(self.M_nu).count(x) for x in set(list(self.M_nu))]\\n nu_mass_numbers = sorted(nu_mass_numbers,reverse=True) if np.any(self.M_nu!=0.) else [0]\\n # Set parameters\\n cambparams = {\\n 'num_nu_massive': self.massive_nu,\\n 'num_nu_massless': self.massless_nu,\\n 'nu_mass_eigenstates': nu_mass_eigen, \\n 'nu_mass_numbers': nu_mass_numbers,\\n 'nnu': self.N_eff,\\n 'omnuh2': self.omega_nu_tot,\\n 'ombh2': self.omega_b,\\n 'omch2': self.omega_cdm+self.omega_wdm_tot,\\n 'omk': self.Omega_K,\\n 'H0': 100.*self.h,\\n 'As': self.As,\\n 'ns': self.ns,\\n 'w': self.w0,\\n 'wa': self.wa,\\n 'TCMB': self.T_cmb,\\n 'tau': self.tau,\\n 'share_delta_neff':True,\\n 'dark_energy_model':'DarkEnergyPPF'}\\n # kwargs\\n for key, value in kwargs.items():\\n if not key in cambparams: cambparams[key] = value\\n params = camb.set_params(**cambparams)\\n\\n # Redshifts and scales\\n k = np.atleast_1d(k)\\n nk = len(k)\\n z = np.atleast_1d(z)\\n nz = len(z)\\n if nz > 3: spline = 'cubic'\\n else: spline = 'linear'\\n\\n # Possible components to use\\n components = {'tot' : 'delta_tot',\\n 'cdm' : 'delta_cdm',\\n 'b' : 'delta_baryon',\\n 'nu' : 'delta_nu',\\n 'cb' : 'delta_nonu',\\n 'gamma': 'delta_photon',\\n 'v_cdm': 'v_newtonian_cdm',\\n 'v_b' : 'v_newtonian_baryon',\\n 'Phi' : 'Weyl'}\\n\\n # Number of points (according to logint)\\n npoints = int(100*np.log10(k.max()/k.min()))\\n dlogk = 2.*np.log10(k.max()/k.min())/npoints\\n\\n # Halofit version\\n if nonlinear == True:\\n #camb.nonlinear.Halofit(halofit_version = halofit)\\n params.NonLinearModel.set_params(halofit_version=halofit)\\n params.NonLinear = camb.model.NonLinear_both\\n\\n # Initialize power spectrum as a dictionary and compute it\\n pk = {}\\n params.set_matter_power(redshifts = z, kmax = k.max()*10**dlogk, silent = True,accurate_massive_neutrino_transfers=True)\\n results = camb.get_results(params)\\n\\n # Fill the power spectrum array\\n for c1 in var_1:\\n for c2 in var_2:\\n string = c1+'-'+c2\\n kh, zz, ppkk = results.get_matter_power_spectrum(minkh = k.min()*10.**-dlogk,\\n maxkh = k.max()*10**dlogk,\\n npoints = npoints,\\n var1 = components[c1],\\n var2 = components[c2])\\n\\n pk[string] = np.zeros((nz,nk))\\n for iz in range(nz):\\n lnpower = si.InterpolatedUnivariateSpline(kh,np.log(ppkk[iz]),k=3,ext=0, check_finite=False)\\n pk[string][iz] = np.exp(lnpower(k))\\n \\n #if nz != 1:\\n # power = si.interp2d(kh, zz, ppkk, kind = spline)\\n # pk[string] = power(k, z)\\n # pk[string] = np.nan_to_num(pk[string])\\n #else:\\n # power = si.interp1d(kh, ppkk, kind = spline)\\n # pk[string] = power(k)\\n # pk[string] = np.nan_to_num(pk[string])\\n\\n return k, pk\",\n \"def main():\\n # Directory where the DICOM files are being stored (in this\\n input_path = './Inputs/valve'\\n\\n # Original image from the filepath\\n img_original = read_image(input_path)\\n\\n # Image with smoothing applied to reduce noise\\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\\n\\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\\n\\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \\\"blood\\\" without cardiac tissue,\\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\\n # valve tissue from the rest - all we need is the overlap of the two labels\\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\\n\\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\\n\\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\\n x_mid = df['x'].mean()\\n y_mid = df['y'].mean()\\n df = get_df_from_img(labels_valve_filtered)\\n distance_df = df.drop('z', axis=1)\\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\\n labels = fit.labels_\\n df['label'] = pd.Series(labels)\\n counts = df['label'].value_counts().to_dict()\\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Use a segmentation-based clustering algorithm to attempt to find each valve\\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\\n\\n left, right = (label_segments[0], label_segments[1])\\n if x_max[0] > x_max[1]:\\n left, right = right, left\\n\\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\\n # this can be done by every z value\\n left_points = {'x': [], 'y': [], 'z': []}\\n right_points = {'x': [], 'y': [], 'z': []}\\n zlen = len(sitk.GetArrayFromImage(left))\\n for z in xrange(zlen):\\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\\n if len(left_df['y']) > 0:\\n index = left_df['y'].idxmin()\\n row = left_df.iloc[index]\\n left_points['x'].append(int(row['x']))\\n left_points['y'].append(int(row['y']))\\n left_points['z'].append(z)\\n\\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\\n if len(right_df['x']) > 0:\\n index = right_df['x'].idxmax()\\n row = right_df.iloc[index]\\n right_points['x'].append(int(row['x']))\\n right_points['y'].append(int(row['y']))\\n right_points['z'].append(z)\\n\\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\\n # points\\n final_left = pd.DataFrame.from_dict(left_points)\\n final_right = pd.DataFrame.from_dict(right_points)\\n print('Coordinates for one side of the ring')\\n print(final_left)\\n print('\\\\n\\\\nCoordinates for the other side of the ring')\\n print(final_right)\\n\\n final_image = make_empty_img_from_img(left)\\n x = left_points['x'] + right_points['x']\\n y = left_points['y'] + right_points['y']\\n z = left_points['z'] + right_points['z']\\n for x, y, z in zip(x, y, z):\\n final_image.SetPixel(x, y, z, 1)\\n\\n show_all(img_smooth, final_image)\",\n \"def compute_mixing_coefficients_surf(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n\\n # SET UP NEW MIXING COEFFICIENT ARRAYS\\n self.Kv_surf = np.zeros([Ly,N+1])\\n self.Kt_surf = np.zeros([Ly,N+1])\\n \\n self.ghat = np.zeros([Ly,N+1])\\n \\n\\n #################################\\n # \\tSURFACE KPP\\n ################################\\n #---> j-loop\\n \\n self.wm2 = []\\n self.ws2 = []\\n self.sigma_y = []\\n for j in range(Ly):\\n #--> k-loop (top to kbl[j])\\n # in fortran k=N-1,kbl(j),-1\\n for k in range(N-1,self.kbl[j]-1,-1):\\n k_w = k\\n k_r = k-1\\n\\n Bfsfc = self.Bfsfc_bl[j]\\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\\n \\n # CALCULATE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm2.append(wm)\\n self.ws2.append(ws)\\n # COMPUTE VERTICAL MIXING COEFFICIENTS\\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\\n self.sigma1 = sigma #for debugging\\n if j == 25: \\n self.sigma_y.append(sigma)\\n a1 = sigma - 2.\\n a2 = 3.-2.*sigma\\n a3 = sigma - 1.\\n\\n if sigma < 0.07:\\n cff = 0.5 * (sigma-0.07)**2/0.07\\n else:\\n cff = 0\\n \\n \\n if k == N-1: \\n self.wm_debug = wm\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n\\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\\n\\n if k == N-1:\\n self.ws_debug = ws\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n \\n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\\n #---> end k-loop \\n if self.LMD_NONLOCAL:\\n if Bfsfc < 0:\\n self.ghat[j,k_w] = 0\\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\\n else:\\n self.ghat[j,k_w] = 0.\\n\\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \\n if self.LMD_CONVEC and self.MLCONVEC: \\n for k in range(N-1,int(self.kbl[j]-1),-1):\\n k_w = k\\n k_r = k -1\\n\\n if self.bvf[j,k_w] < 0:\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\\n\\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\\n # IF BKPP IS SWITCHED OFF!!\\n for k in range(int(self.kbl[j]-1),-1,-1):\\n k_w = k\\n k_r = k -1\\n if self.LMD_NONLOCAL:\\n self.ghat[j,k_w] = 0\\n if self.LMD_CONVEC and self.LMD_BKPP == False:\\n if self.bvf[j,k_w] < 0:\\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\\n \\n\\n #---> end j-loop\",\n \"def kbcht(data, k=10, shrinking_threshold=2):\\n if k <= 0:\\n raise ValueError('k={} must be > 0'.format(k))\\n \\n if shrinking_threshold <= 0:\\n raise ValueError('shrinking_threshold={} must be > 0'\\n .format(shrinking_threshold))\\n \\n if data.shape[1] != 2:\\n raise ValueError('KBCHT only works on two-dimensional data')\\n\\n # perform k-Means for finding inital clusters\\n km = kmeans(data, k)\\n km_clusters = km.predict(data)\\n initial_clusters = create_clusters(data, km_clusters)\\n\\n visualizations = []\\n\\n visualizations.append(visualize(initial_clusters, 'K-Means Clustering'))\\n\\n # get subclusters from convex hulls and shrinking\\n sub_clusters, sc_average_distances, released, shrinked_vertices = \\\\\\n get_all_subclusters(initial_clusters, shrinking_threshold)\\n\\n visualizations.append(visualize_vertices(\\n shrinked_vertices, initial_clusters, released, 'Shrinked Vertices'))\\n visualizations.append(visualize(\\n sub_clusters + [released], 'Subclusters', contains_noise=True))\\n\\n # merge subclusters\\n clusters, average_distances = \\\\\\n merge_clusters(sub_clusters, sc_average_distances)\\n\\n clusters, contains_noise = \\\\\\n add_released(clusters, average_distances, released)\\n\\n visualizations.append(\\n visualize(clusters, 'KBCHT Clustering', contains_noise=contains_noise))\\n\\n # recreate cluster assignments for points in original data set\\n assignments = create_assignments(data, clusters)\\n\\n return assignments, visualizations\",\n \"def kViterbi(crf_obj, emissions, topK, mask):\\n assert topK >=1\\n if topK == 1:\\n seq_length = emissions.size(1)\\n best_path = crf_obj.decode(emissions, mask)\\n observation = pad_seq(best_path, seq_length, crf_obj.batch_first, 0)\\n best_probs = calculate_prob_byObser(crf_obj, emissions, observation, mask)\\n return best_path, best_probs.squeeze()\\n\\n crf_obj._validate(emissions, mask=mask)\\n if mask is None:\\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\\n if crf_obj.batch_first:\\n emissions = emissions.transpose(0, 1)\\n mask = mask.transpose(0, 1)\\n normalizer = crf_obj._compute_normalizer(emissions, mask)\\n # ===============start main part========================\\n # emissions: (seq_length, batch_size, num_tags)\\n # mask: (seq_length, batch_size)\\n assert emissions.dim() == 3 and mask.dim() == 2\\n assert emissions.shape[:2] == mask.shape\\n assert emissions.size(2) == crf_obj.num_tags\\n assert mask[0].all()\\n\\n seq_length, batch_size = mask.shape\\n\\n # Start transition and first emission\\n # score is a tensor of size(batch_size, num_tags, topK) where for each\\n # batch, value at tags i and top j stores the scores of the j-th best tag\\n # sequence so far that ends with tag i\\n #\\n # pre_states saves the previous tag where the j-th best path that ends with tag i currently\\n score = emissions.new_zeros((seq_length, batch_size, crf_obj.num_tags, topK))\\n score[0,:,:,0] = crf_obj.start_transitions + emissions[0] # batch x num_tags\\n\\n pre_states = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\\n for i in range(crf_obj.num_tags):\\n for b in range(batch_size):\\n for k in range(topK):\\n pre_states[0,b,i,k] = i # should be start transition\\n\\n # The ranking of multiple paths through same state\\n rank = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\\n for t in range(1, seq_length):\\n next_score_list = []\\n for k in range(topK):\\n broadcast_score = score[t-1,:,:,k].unsqueeze(2) #(batch_size, num_tags, 1)\\n broadcast_emissions = emissions[t].unsqueeze(1) #(batch_size, 1, num_tags)\\n\\n # Compute the score tensor of size (batch_size, num_tags, num_tags)\\n # where for each sample, entry at row i and column j stores\\n # the sum of scores of all possible tag sequences so far that end\\n # with transitioning from tag i to tag j and emitting\\n # shape: (batch_size, num_tags, num_tags)\\n next_score = broadcast_score + crf_obj.transitions + broadcast_emissions\\n next_score_list.append(next_score)\\n\\n for b in range(batch_size):\\n if mask[t,b]:\\n for cur_state in range(crf_obj.num_tags):\\n h = []\\n for pre_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n heapq.heappush(h, (-1*next_score_list[k][b, pre_state, cur_state], pre_state))\\n\\n # Get the sorted list\\n h_sorted = [heapq.heappop(h) for _ in range(topK)] #get topK path into cur_state\\n # We need to keep a ranking if a path crosses a state more than once\\n rankDict = dict()\\n # Retain the topK scoring paths\\n for k in range(topK):\\n score[t, b, cur_state, k] = score[t, b, cur_state, k] + (h_sorted[k][0].data * -1)\\n pre_states[t, b, cur_state, k] = h_sorted[k][1]\\n state = h_sorted[k][1]\\n if state in rankDict:\\n rankDict[state] = rankDict[state]+1\\n else:\\n rankDict[state] = 0\\n rank[t, b, cur_state, k] = rankDict[state]\\n else:\\n for cur_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n score[t, b, cur_state, k]=score[t-1, b, cur_state, k]\\n\\n\\n batch_path = []\\n batch_path_prob = []\\n seq_ends = mask.long().sum(dim=0) - 1 # seq_len x batch # assume seq_ends=8, seq_len=9\\n for b in range(batch_size):\\n h = []\\n for cur_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n heapq.heappush(h, ( -1 * (score[seq_ends[b], b, cur_state, k]+crf_obj.end_transitions[cur_state]),\\n cur_state, k))\\n h_sorted = [heapq.heappop(h) for _ in range(topK)]\\n k_list = np.zeros((topK, seq_ends[b]+1), int) # k x 9\\n k_list_probs = list()\\n for k in range(topK):\\n prob = h_sorted[k][0]\\n state = h_sorted[k][1]\\n rankK = h_sorted[k][2]\\n\\n k_list_probs.append((prob*-1)-(normalizer[b]))\\n k_list[k][seq_ends[b]] = state # assign index 8 == last one\\n for t in range(seq_ends[b]-1, -1, -1): # t = 7,6,5,4,3,2,1,0\\n nextState = k_list[k][t+1]\\n preState = pre_states[t+1, b, nextState, rankK]\\n k_list[k][t] = preState\\n rankK = rank[t+1,b,nextState,rankK]\\n batch_path.append(k_list.tolist())\\n batch_path_prob.append(k_list_probs)\\n if crf_obj.batch_first:\\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions.transpose(0,1), mask.transpose(0,1), topK)\\n else:\\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions, mask, topK)\\n return batch_path, batch_probs\",\n \"def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurst_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(x):\\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\\n\\n def unmaskvec(w):\\n return _unmask(w, mask)\\n\\n def maskvec(w):\\n return w[flat_mask]\\n\\n def f1_grad(x):\\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(w, stepsize, dgap_tol, init):\\n out, info = _prox_tvl1(unmaskvec(w),\\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=unmaskvec(init),\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return maskvec(out.ravel()), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def component_func(B, C, F, list_funcs, len_kegg, threshold=0.05):\\n\\n size_label = 18\\n size_tick = 18\\n sns.set_style(\\\"darkgrid\\\")\\n\\n list_funcs = list_funcs[0:len_kegg]\\n B = B[0:len_kegg]\\n C = C[0:len_kegg]\\n\\n idx_p = [idx*2+0 for idx in range(B.shape[1]/2)]\\n idx_m = [idx*2+1 for idx in range(B.shape[1]/2)]\\n is_p = F[:,idx_p].mean(axis=1) - F[:,idx_m].mean(axis=1) > threshold\\n is_m = F[:,idx_m].mean(axis=1) - F[:,idx_p].mean(axis=1) > threshold\\n is_p = [idx for idx, val in enumerate(is_p) if val]\\n is_m = [idx for idx, val in enumerate(is_m) if val]\\n is_n = [idx for idx in range(C.shape[1]) if (idx not in is_p) and (idx not in is_m)]\\n\\n fig = plt.figure(figsize=(6, 6))\\n\\n for idx_c in range(C.shape[1]):\\n clone_num = idx_c +1\\n if idx_c in is_p:\\n color=\\\"green\\\"\\n label = \\\"C\\\"+str(clone_num)+\\\"|P\\\"\\n elif idx_c in is_m:\\n color=\\\"red\\\"\\n label = \\\"C\\\"+str(clone_num)+\\\"|M\\\"\\n else:\\n color = \\\"royalblue\\\"\\n label = \\\"C\\\"+str(clone_num)\\n\\n if clone_num in [1]:\\n marker = \\\"$1$\\\"\\n elif clone_num in [2]:\\n marker = \\\"$2$\\\"\\n elif clone_num in [3]:\\n marker = \\\"$3$\\\"\\n elif clone_num in [4]:\\n marker = \\\"$4$\\\"\\n elif clone_num in [5]:\\n marker = \\\"$5$\\\"\\n elif clone_num in [6]:\\n marker = \\\"$6$\\\"\\n else:\\n print(\\\"error\\\")\\n plt.plot(C[:,idx_c],range(len_kegg), color=color, marker=marker, markersize=10, linestyle=\\\"\\\",label=label, alpha=0.5)\\n\\n plt.yticks(range(len_kegg), list_funcs)\\n plt.xlabel(\\\"Pathway strength\\\", fontsize=size_label)\\n plt.legend()\\n plt.tick_params(labelsize=size_tick-4)\\n plt.show()\\n ##fig.savefig(\\\"figures/fig7compfunc.pdf\\\", bbox_inches=\\\"tight\\\")\",\n \"def getContSpec(par):\\n # read input\\n if par['verbose']:\\n print('\\\\n(*) Start\\\\n(*) Loading Data File: {}...'.format(par['GexpFile']))\\n\\n # t, Gexp = GetExpData(par['GexpFile'])\\n t, Gexp, wexp = GetExpData(par['GexpFile'])\\n\\n if par['verbose']:\\n print('(*) Initial Set up...', end=\\\"\\\")\\n \\n # Set up some internal variables\\n n = len(t)\\n ns = par['ns'] # discretization of 'tau'\\n\\n tmin = t[0];\\n tmax = t[n-1];\\n \\n # determine frequency window\\n if par['FreqEnd'] == 1:\\n smin = np.exp(-np.pi/2) * tmin; smax = np.exp(np.pi/2) * tmax\\t\\t\\n elif par['FreqEnd'] == 2:\\n smin = tmin; smax = tmax\\t\\t\\t\\t\\n elif par['FreqEnd'] == 3:\\n smin = np.exp(+np.pi/2) * tmin; smax = np.exp(-np.pi/2) * tmax\\t\\t\\n\\n hs = (smax/smin)**(1./(ns-1))\\n s = smin * hs**np.arange(ns)\\n \\n kernMat = getKernMat(s, t)\\n tic = time.time()\\n \\n # get an initial guess for Hgs, G0\\n if par['plateau']:\\n Hgs, G0 = InitializeH(Gexp, wexp, s, kernMat, np.min(Gexp))\\t\\t\\n else:\\n Hgs = InitializeH(Gexp, wexp, s, kernMat)\\n \\n if par['verbose']:\\n te = time.time() - tic\\n print('\\\\t({0:.1f} seconds)\\\\n(*) Building the L-curve ...'.format(te), end=\\\"\\\")\\t\\n tic = time.time()\\n\\n # Find Optimum Lambda with 'lcurve'\\n if par['lamC'] == 0:\\n if par['plateau']:\\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par, G0)\\n else:\\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par)\\n else:\\n lamC = par['lamC']\\n\\n if par['verbose']:\\n te = time.time() - tic\\n print('({1:.1f} seconds)\\\\n(*) Extracting CRS, ...\\\\n\\\\t... lamC = {0:0.3e}; '.\\n format(lamC, te), end=\\\"\\\")\\n \\n tic = time.time()\\n\\n # Get the best spectrum\\t\\n if par['plateau']:\\n H, G0 = getH(lamC, Gexp, wexp, Hgs, kernMat, G0);\\n print('G0 = {0:0.3e} ...'.format(G0), end=\\\"\\\")\\n else:\\n H = getH(lamC, Gexp, wexp, Hgs, kernMat);\\n\\n #----------------------\\n # Print some datafiles\\n #----------------------\\n\\n if par['verbose']:\\n te = time.time() - tic\\n print('done ({0:.1f} seconds)\\\\n(*) Writing and Printing, ...'.format(te), end=\\\"\\\")\\n\\n # Save inferred G(t)\\n if par['plateau']:\\n K = kernel_prestore(H, kernMat, G0);\\t\\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e', header='G0 = {0:0.3e}'.format(G0))\\n else:\\n K = kernel_prestore(H, kernMat);\\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e')\\n \\n np.savetxt('output/Gfit.dat', np.c_[t, K], fmt='%e')\\n\\n # print Hlam, rho-eta, and logP if lcurve has been visited\\n if par['lamC'] == 0:\\n if os.path.exists(\\\"output/Hlam.dat\\\"):\\n os.remove(\\\"output/Hlam.dat\\\")\\n \\n fHlam = open('output/Hlam.dat','ab')\\n for i, lamb in enumerate(lam):\\n np.savetxt(fHlam, Hlam[:,i])\\t\\n fHlam.close()\\t\\n\\n # print logP\\n np.savetxt('output/logPlam.dat', np.c_[lam, logP])\\n \\n # print rho-eta\\n np.savetxt('output/rho-eta.dat', np.c_[lam, rho, eta], fmt='%e')\\n\\n #------------\\n # Graphing\\n #------------\\n\\n if par['plotting']:\\n\\n # plot spectrum \\\"H.pdf\\\" with errorbars\\n plt.clf()\\n\\n plt.semilogx(s,H,'o-')\\n plt.xlabel(r'$s$')\\n plt.ylabel(r'$H(s)$')\\n\\n # error bounds are only available if lcurve has been implemented\\n if par['lamC'] == 0:\\n plam = np.exp(logP); plam = plam/np.sum(plam)\\t\\t\\t\\n Hm = np.zeros(len(s))\\n Hm2 = np.zeros(len(s))\\n cnt = 0\\n for i in range(len(lam)):\\t\\n #~ Hm += plam[i]*Hlam[:,i]\\n #~ Hm2 += plam[i]*Hlam[:,i]**2\\n # count all spectra within a threshold\\n if plam[i] > 0.1:\\n Hm += Hlam[:,i]\\n Hm2 += Hlam[:,i]**2\\n cnt += 1\\n\\n Hm = Hm/cnt\\n dH = np.sqrt(Hm2/cnt - Hm**2)\\n\\n plt.semilogx(s,Hm+2.5*dH, c='gray', alpha=0.5)\\n plt.semilogx(s,Hm-2.5*dH, c='gray', alpha=0.5)\\n\\n plt.tight_layout()\\n plt.savefig('output/H.pdf')\\n\\n\\n #\\n # plot comparison with input spectrum\\n #\\n\\n plt.clf()\\n\\n if par['plateau']:\\n K = kernel_prestore(H, kernMat, G0);\\t\\n else:\\n K = kernel_prestore(H, kernMat);\\n\\n plt.loglog(t, Gexp,'o',t, K, 'k-')\\n plt.xlabel(r'$t$')\\n plt.ylabel(r'$G(t)$')\\n plt.tight_layout()\\n plt.savefig('output/Gfit.pdf')\\n\\n\\n #\\n # if lam not explicitly specified then print rho-eta.pdf\\n #\\n\\n try:\\n lam\\n except NameError:\\n print(\\\"lamC prespecified, so not printing rho-eta.pdf/dat\\\")\\n else:\\n plt.clf()\\n plt.scatter(rho, eta, marker='x')\\n plt.plot(rho, eta)\\n\\n\\n rhost = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(rho)))\\n etast = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(eta)))\\n\\n plt.plot(rhost, etast, 'o', color='k')\\n plt.xscale('log')\\n plt.yscale('log')\\n \\n #~ print(rhost, etast)\\n \\n plt.xlabel(r'$\\\\rho$')\\n plt.ylabel(r'$\\\\eta$')\\n plt.tight_layout()\\n plt.savefig('output/rho-eta.pdf')\\n\\n if par['verbose']:\\n print('done\\\\n(*) End\\\\n')\\n \\n return H, lamC\",\n \"def default_grid_feature_hp_kernel_config(defn):\\n defn = _validate_definition(defn)\\n config = {}\\n\\n grid = enumerate(zip(defn.models(), defn.hyperpriors()))\\n\\n for fi, (model, priors) in grid:\\n partials = copy.deepcopy(model.default_partial_hypergrid())\\n if not partials:\\n continue\\n\\n evals = []\\n for update_descs, fn in priors.iteritems():\\n if not hasattr(update_descs, '__iter__'):\\n update_descs = [update_descs]\\n keyidxs = []\\n for update_desc in update_descs:\\n key, idx = _parse_descriptor(update_desc, default=None)\\n keyidxs.append((key, idx))\\n\\n def func(raw, keyidxs):\\n s = 0.\\n for key, idx in keyidxs:\\n if idx is None:\\n s += raw[key]\\n else:\\n s += raw[key][idx]\\n return s\\n evals.append(lambda raw, keyidxs=keyidxs: func(raw, keyidxs))\\n\\n def jointprior(raw, evals):\\n return np.array([f(raw) for f in evals]).sum()\\n\\n config[fi] = {\\n 'hpdf': lambda raw, evals=evals: jointprior(raw, evals),\\n 'hgrid': partials,\\n }\\n\\n if not config:\\n return []\\n else:\\n return [('grid_feature_hp', config)]\",\n \"def one_iteration_step(self, tsm, tank, chp, kessel, cvalve, heizkurve, t_a, el_heat_status, actual_time, heatc_conf):\\n #print('\\\\n chp = {}; kessel = {}; t2 = {}; t3 = {}'.format(chp.get_status(), kessel.get_status(), self.t2, self.t3))\\n # combined heat and power unit - link outputs\\n wyn = chp.get_chp()\\n #self.t27 = wyn[1] # tin in °C = self.t1 = wyn[t1]\\n self.t26 = wyn[2] # tout in °C = chp.get_out_temp = wyn[2]\\n m3 = wyn[3] # mstr in kg/s \\n self.V_3 = m3 / utils.rho_fluid_water(self.t26, self.p_atm, 1) # volume flow incoming to chp from tank\\n V_chp = chp.get_volume_flow_at_output() # volume flow outoming from chp into tank\\n # combined heat and power unit - link inputs\\n chp.set_inp_temp(self.t27) # temperature incoming from tank to chp\\n\\n # ..............................................................\\n\\n # gas boiler - link outputs\\n wyn = kessel.get_kessel()\\n #self.t29 = wyn[1] # tin in °C - incoming into gas heater\\n self.t28 = wyn[2] # tout in °C - outcoming from gas heater\\n m4 = wyn[3] # mstr in kg/s - incoming into gas heater\\n self.V_4 = kessel.get_volume_flow_at_input()\\n V_kessel = kessel.get_volume_flow_at_output()\\n # gas boiler - link inputs\\n kessel.set_inp_temp(self.t29)\\n #kessel.calc_mass_flow()\\n\\n # ..............................................................\\n # at first no delay - just linking chp and heater\\n # delay due to the seuence of commands ie equal to the Timestep length\\n self.t27 = self.t1\\n self.t29 = self.t1\\n # ..............................................................\\n\\n # heating circuit\\n self.t23 = self.t20 # no delay assumed\\n #print('t20 = {}; t23 = {}'.format(self.t20, self.t23))\\n self.t25 = heizkurve.get_supply_temperature(t_a)\\n self.t24 = heizkurve.get_return_temperature(t_a)\\n heizkurve.calc_volume_flow()\\n\\n # comprehensive control algorithm - it stays\\n (m23, m25, m4) = self.control_internal_1(heizkurve, kessel, chp, cvalve, t_a, actual_time, m4, heatc_conf)\\n\\n m_bypass = m25 - m23\\n rho23 = utils.rho_fluid_water(self.t23, self.p_atm, 1)\\n V_23 = m23 / rho23 # in m3/s = kg/s / kg/m3\\n #print('V_23 = {}; m23 = {}; rho23 = {}; t23 = {}'.format(V_23,m23, rho23, self.t23))\\n m24 = m23\\n rho24 = utils.rho_fluid_water(self.t24, self.p_atm, 1)\\n V_24 = m24 / rho24\\n \\n # demand for domestic hot water\\n m22 = self.V_1 * utils.rho_fluid_water(self.t22, self.p_atm, 1) # in kg/s = m3/s * kg/m3\\n #m22 = 0.01 # kg/s\\n # ..............................................................\\n\\n t_ambient = 15.0\\n # storage tank - calculation\\n tank.calculate_storage_tank_obj(tsm, # time step manager\\n self.t23, # hk_inp_temp\\n V_23, # hk_inp_volfl_m3s\\n self.t24, # hk_out_temp\\n self.t27, # chp_inp_temp\\n self.t26, # chp_out_temp\\n self.V_3, # chp_inp_volfl_m3s\\n self.t29, # gb_inp_temp\\n self.t28, # gp_out_temp\\n self.V_4, # gb_inp_volfl_m3s\\n self.t22, # dhw_inp_temp\\n self.t21, # dhw_out_temp\\n self.V_1, # dhw_inp_volfl_m3s\\n el_heat_status, # el_heat_status\\n actual_time, # time in the timestamp format\\n t_ambient) # ambient temperature of the tank - defines heat losses to the outside\\n \\n self.t21 = tank.get_temp_dhw()\\n #self.t27 = \\n #self.t29 = \\n #self.t23 = \\n \\n # storage tank - linking\\n [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, \\n self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20] = tank.output_temperatures()\\n\\n # ..............................................................\\n # get rid of this part\\n #self.control_internal_2(chp, kessel, actual_time, m4)\\n # ..............................................................\\n heizwert_in_MJ_per_kg = 50.0 # kg/m3 N ~CH4\\n gas_density = 0.79 # kg/m3 N ~Erdgas\\n Z_boiler = kessel.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\\n self.Z_2 = chp.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\\n self.Z_1 = self.Z_2 + Z_boiler\\n \\n self.Wh1 = -1.0 * chp.get_el_prod()\\n self.Wh2 = tank.get_el_heater_consumption()\\n self.Wh3 = self.Wh1 + self.Wh2 + self.electricity_consumption_kWh\\n #print('END chp = {}; kessel = {}; heating = {}; t2 = {}; t3 = {};V1 = {}; V2 = {}; V3 = {}; V4 = {}; t_a = {}'.format(chp.get_status(), kessel.get_status(), heizkurve.get_status(), self.t2, self.t3, self.V_1, self.V_2, self.V_3, self.V_4, t_a))\",\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 Kgrid(struc, Kresol=0.10, dimension=3):\\n a, b, c, alpha, beta, gamma = struc.get_cell_lengths_and_angles()\\n vol = struc.get_volume()\\n dist = np.zeros(3);\\n dist[2] = np.abs(vol/(a*b*np.sin(np.radians(gamma))))\\n dist[1] = np.abs(vol/(a*c*np.sin(np.radians(beta))))\\n dist[0] = np.abs(vol/(b*c*np.sin(np.radians(alpha))))\\n Kpoints = np.ceil(1./(dist*Kresol))\\n if dimension == 2:\\n Kpoints[-1] = 1;\\n #print(a, b, c, alpha, beta, gamma)\\n #print(vol/(a*b*np.sin(gamma)), a*b, np.sin(gamma))\\n #print(vol/(a*c*np.sin(beta)), a*c, np.sin(beta))\\n #print(vol/(b*c*np.sin(alpha)), b*c, np.sin(alpha))\\n #print(Kpoints)\\n #import sys; sys.exit()\\n return Kpoints.astype(int)\",\n \"def plot_electrode_depth_profile(keyword_blk=keyword_blk, keyword_tank=keyword_tank, dir_tdt_tank=dir_tdt_tank,\\n ch_index = 1, range_ch= None,\\n speed_retract=speed_retract, binsize_dist=binsize_dist, range_ch_pos_rel=None,\\n tf_reverse_dist=tf_reverse_dist, total_distance=None, t_gauss_sigma_spcg = t_gauss_sigma_spcg,\\n tf_spectragram=tf_spectragram, tf_spectragram_interactive=tf_spectragram_interactive):\\n\\n \\\"\\\"\\\" ----- load data ----- \\\"\\\"\\\"\\n seg = load_blk(keyword_blk=keyword_blk, keyword_tank=keyword_tank, dir_tdt_tank=dir_tdt_tank)\\n\\n \\\"\\\"\\\" ----- use time and speed to infer depth ----- \\\"\\\"\\\"\\n t_range = np.array([seg.t_start, seg.t_stop])\\n if total_distance is not None:\\n t_range[1] = total_distance/speed_retract\\n dist_range = t_range*speed_retract\\n\\n \\\"\\\"\\\" ----- get spiking pattern ----- \\\"\\\"\\\"\\n spk_time = np.sort(np.concatenate([np.array(spktrn.times) for spktrn in seg.spiketrains if spktrn.annotations['channel_index']==ch_index]))\\n spk_dist = spk_time * speed_retract\\n spk_bin, dist_bin_edge = np.histogram(spk_dist, np.arange(dist_range[0], dist_range[1], binsize_dist))\\n dist_bin_center = (dist_bin_edge[:-1] + dist_bin_edge[1:]) / 2\\n if range_ch is not None:\\n list_spk_bin = []\\n for ch_cur in range_ch:\\n try:\\n spk_time_cur = np.sort(np.concatenate([np.array(spktrn.times) for spktrn in seg.spiketrains if\\n spktrn.annotations['channel_index'] == ch_cur]))\\n except:\\n spk_time_cur = np.array([])\\n spk_dist_cur = spk_time_cur * speed_retract\\n spk_bin_cur, _ = np.histogram(spk_dist_cur, np.arange(dist_range[0], dist_range[1], binsize_dist))\\n list_spk_bin.append(spk_bin_cur)\\n spk_bin_array = np.vstack(list_spk_bin)\\n\\n \\\"\\\"\\\" ----- compute spectrogram ----- \\\"\\\"\\\"\\n if tf_spectragram:\\n scale_factor = 10**6\\n lfp_sig = [anasig for anasig in seg.analogsignals if re.search('LFPs.*', anasig.name) and anasig.annotations['channel_index']==ch_index][0]\\n lfp_trace = np.ravel(lfp_sig) * scale_factor\\n lfp_fs = np.array(lfp_sig.sampling_rate)\\n lfp_ts = range(len(lfp_trace))/lfp_fs + np.array(lfp_sig.t_start)\\n if total_distance is not None:\\n lfp_ts = lfp_ts[lfp_ts<t_range[1]]\\n lfp_trace = lfp_trace[:len(lfp_ts)]\\n spcg, spcg_t, spcg_f = pna.ComputeSpectrogram(data=np.expand_dims(lfp_trace, axis=0),\\n fs=lfp_fs, t_ini=lfp_ts[0], t_bin=1.0, t_step=1.0, t_axis=1, f_lim=[0,100])\\n spcg = spcg[0,:,:]\\n if t_gauss_sigma_spcg is not None:\\n spcg = sp.ndimage.filters.gaussian_filter1d(spcg, sigma=t_gauss_sigma_spcg, axis=1)\\n spcg_dist = spcg_t * speed_retract\\n\\n \\\"\\\"\\\" ----- direction of distance axis ----- \\\"\\\"\\\"\\n if tf_reverse_dist: # top to bottom\\n dist_bin = np.flip(dist_bin_center, axis=0)\\n if tf_spectragram:\\n dist_spcg = np.flip(spcg_dist, axis=0)\\n else: # bottom to top\\n dist_bin = dist_bin_center\\n if tf_spectragram:\\n dist_spcg = spcg_dist\\n\\n \\\"\\\"\\\" ----- plot ----- \\\"\\\"\\\"\\n if tf_spectragram:\\n h_fig, h_ax = plt.subplots(2, 1, figsize=[8, 8], sharex=True, squeeze=False)\\n else:\\n h_fig, h_ax = plt.subplots(1, 1, figsize=[8, 4], sharex=True, squeeze=False)\\n\\n \\\"\\\"\\\" upper panel: spiking pattern \\\"\\\"\\\"\\n plt.axes(h_ax[0,0])\\n if range_ch is not None:\\n list_color = plt.cm.rainbow(np.linspace(0,1,len(range_ch)))\\n for i, ch_cur in enumerate(range_ch):\\n if range_ch_pos_rel is None:\\n dist_shift = 0\\n else:\\n dist_shift = range_ch_pos_rel[i]\\n plt.plot(dist_bin+dist_shift, spk_bin_array[i,:], color=list_color[i], linewidth=1, alpha=0.5)\\n plt.plot(dist_bin, spk_bin, color='k', linewidth=2)\\n plt.xlabel('distance, um')\\n plt.ylabel('spk count in {} um window'.format(binsize_dist))\\n plt.title('spiking pattern')\\n\\n \\\"\\\"\\\" lower panel: spectrogram \\\"\\\"\\\"\\n if tf_spectragram:\\n plt.axes(h_ax[1,0])\\n plt.pcolormesh(dist_spcg, spcg_f, np.log(spcg), cmap='inferno')\\n plt.xlabel('distance, um')\\n plt.ylabel('frequency, Hz')\\n plt.title('LFP spectragram')\\n\\n \\\"\\\"\\\" colorbar \\\"\\\"\\\"\\n ax_loc = h_ax[1, 0].get_position()\\n h_colorbar = plt.colorbar( cax = h_fig.add_axes([ax_loc.x1+0.02, ax_loc.y0, 0.02, ax_loc.y1-ax_loc.y0]))\\n\\n \\\"\\\"\\\" colorbar, interactive control widgets \\\"\\\"\\\"\\n if tf_spectragram_interactive:\\n clim_org_min, clim_org_max = h_colorbar.get_clim()\\n clim_range = clim_org_max - clim_org_min\\n h_slider_clim_min = mpl.widgets.Slider(ax=h_fig.add_axes([ax_loc.x0, 0.02, (ax_loc.x1 - ax_loc.x0) * 0.3, 0.02]),\\n label='c_min', valmin=clim_org_min-0.5*clim_range, valmax=clim_org_min+0.5*clim_range, valinit=clim_org_min)\\n h_slider_clim_max = mpl.widgets.Slider(ax=h_fig.add_axes([(ax_loc.x0+ax_loc.x1)*0.5, 0.02, (ax_loc.x1-ax_loc.x0)*0.3, 0.02]),\\n label='c_max', valmin=clim_org_max-0.5*clim_range, valmax=clim_org_max+0.5*clim_range, valinit=clim_org_max)\\n def update_clim_min(val):\\n plt.axes(h_ax[1,0])\\n plt.clim(vmin=val)\\n def update_clim_max(val):\\n plt.axes(h_ax[1, 0])\\n plt.clim(vmax=val)\\n h_slider_clim_min.on_changed(update_clim_min)\\n h_slider_clim_max.on_changed(update_clim_max)\\n\\n h_button_savefig = mpl.widgets.Button(ax=h_fig.add_axes([ax_loc.x1, 0.02, 0.05, 0.03]), label='save')\\n def savefig(event):\\n plt.savefig('{}/electrode_depth_profile_tank_{}.png'.format(path_save_fig, keyword_tank))\\n h_button_savefig.on_clicked(savefig)\\n h_ax[0,0].set_xlim([dist_bin.min(), dist_bin.max()])\\n plt.suptitle('electrode depth profile, tank {}'.format(keyword_tank))\\n\\n \\\"\\\"\\\" return results \\\"\\\"\\\"\\n return_dict = {'spk': (dist_bin, spk_bin), 'spcg': None, 'slider': None}\\n if tf_spectragram:\\n return_dict['spcg'] = (dist_spcg, spcg_f, spcg)\\n if tf_spectragram_interactive and tf_spectragram: # to return the widegets object is important, otherwise widgets do not work whtin functions\\n return_dict['widgets'] = (h_slider_clim_min, h_slider_clim_max, h_button_savefig)\\n\\n return return_dict\",\n \"def normal_modes_gHST(R, NL, KL, params, dispersion=[], spin_dir=[], sublattice_labels=[], b='hang', spring='auto',\\n pin='auto'):\\n try:\\n NP, NN = np.shape(NL)\\n except:\\n '''There is only one particle.'''\\n NP = 1\\n NN = 0\\n\\n M1 = np.zeros((2 * NP, 2 * NP))\\n M2 = np.zeros((2 * NP, 2 * NP))\\n if spring == 'auto':\\n spring = params['k'] * params['l'] ** 2 / (params['I3'] * np.abs(params['w3']))\\n # If there is more than one particle, and if the speeds vary from particle to particle,\\n # then make spring the same length as a dynamical matrix column\\n if len(spring) > 0:\\n if (abs(spring - spring[0]) > 1e-9).any():\\n # The rotation rates vary from particle to particle, so reshape\\n spring_new = np.zeros_like(spring)\\n dmyi = 0 # a new index ('dummy i')\\n for ii in range(NP):\\n # Since 2 dof for position of pivot of gHST, double the size\\n spring_new[dmyi] = spring[ii]\\n spring_new[dmyi + 1] = spring[ii]\\n dmyi += 2\\n else:\\n # the elements are all identical, so just keep the first one\\n spring = spring[0]\\n\\n if pin == 'auto':\\n gn = params['Mm'] * params['g']\\n pin = params['l'] * gn / (params['I3'] * np.abs(params['w3']))\\n # If there is more than one particle, and if the speeds vary from particle to particle,\\n # then make pin the same length as a dynamical matrix column\\n if len(pin) > 0:\\n if (abs(pin - pin[0]) > 1e-9).any():\\n # The rotation rates vary from particle to particle, so reshape\\n pin_new = np.zeros_like(pin)\\n dmyi = 0 # a new index ('dummy i')\\n for ii in range(NP):\\n # Since 2 dof for position of pivot of gHST, double the size\\n pin_new[dmyi] = pin[ii]\\n pin_new[dmyi + 1] = pin[ii]\\n dmyi += 2\\n else:\\n # the elements are all identical, so just keep the first one\\n pin = pin[0]\\n\\n m2_shape = np.shape(M2)\\n\\n if b == 'hang':\\n b = np.zeros(NP)\\n elif b == 'stand':\\n b = np.ones(NP)\\n\\n if spin_dir == []:\\n '''Assume antialigned with a, aligned with body axis 3'''\\n spin_dir = np.ones(NP)\\n\\n print 'Constructing dynamical matrix...'\\n for i in range(NP):\\n for nn in range(NN):\\n\\n ni = NL[i, nn] # the number of the gyroscope i is connected to (particle j)\\n k = KL[i, nn] # true connection?\\n\\n if len(dispersion) > 1:\\n disp = 1. / (1. + dispersion[i])\\n else:\\n disp = 1.\\n\\n diffx = R[ni, 0] - R[i, 0]\\n diffy = R[ni, 1] - R[i, 1]\\n alphaij = 0.\\n\\n rij_mag = np.sqrt(diffx ** 2 + diffy ** 2)\\n\\n if k != 0:\\n alphaij = np.arctan2(diffy, diffx)\\n\\n # for periodic systems, KL is -1 for particles on opposing boundaries\\n if KL[i, nn] == -1:\\n alphaij = (np.pi + alphaij) % (2 * pi)\\n\\n # What is this for?\\n if KL[i, nn] == -2: # will only happen on first or last gyro in a line\\n if i == 0 or i == (NP - 1):\\n print i, '--> NL=-2 for this particle'\\n yy = np.where(KL[i] == 1)\\n dx = R[NL[i, yy], 0] - R[NL[i, yy], 0]\\n dy = R[NL[i, yy], 1] - R[NL[i, yy], 1]\\n al = (np.arctan2(dy, dx)) % (2 * pi)\\n alphaij = np.pi - al\\n if i == 1:\\n alphaij = np.pi - ((90 / 2) * np.pi / 180.)\\n else:\\n alphaij = - ((90 / 2) * np.pi / 180.)\\n\\n Cos = np.cos(alphaij)\\n Sin = np.sin(alphaij)\\n\\n if abs(Cos) < 10E-8:\\n Cos = 0.0\\n\\n if abs(Sin) < 10E-8:\\n Sin = 0\\n\\n Cos2 = Cos ** 2\\n Sin2 = Sin ** 2\\n CosSin = Cos * Sin\\n\\n # -1 for aligned with a, 1 for aligned with 3.\\n # dir factor :== 1/(-1)^c = (-1)^c\\n dir_factor = spin_dir[i]\\n\\n if len(sublattice_labels) > 0:\\n if sublattice_labels[i] == 1:\\n extra_factor = 1. * del_A_B\\n # print self.del_A_B\\n elif sublattice_labels[i] == 0:\\n extra_factor = 1.\\n else:\\n extra_factor = 1.\\n else:\\n extra_factor = 1.\\n\\n M1[2 * i, 2 * i] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxi\\n M1[2 * i, 2 * i + 1] += -disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyi\\n M1[2 * i, 2 * ni] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxj\\n M1[2 * i, 2 * ni + 1] += disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyj\\n\\n # (y components)\\n M1[2 * i + 1, 2 * i] += disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxi\\n M1[2 * i + 1, 2 * i + 1] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyi\\n M1[2 * i + 1, 2 * ni] += -disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxj\\n M1[2 * i + 1, 2 * ni + 1] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyj\\n\\n # if i==0:\\n # print '\\\\n --- \\\\n added M1[2*i+1, 2*i] = ',disp*k*Cos2 *((-1)**b[i]) *dir_factor\\n # print 'dir_factor = ', dir_factor\\n # print 'k = ', k\\n # print 'else =', ((-1)**b[i]) *dir_factor\\n\\n # pinning/gravitational matrix\\n M2[2 * i, 2 * i + 1] = (1.) * disp * dir_factor * extra_factor\\n M2[2 * i + 1, 2 * i] = -(1.) * disp * dir_factor * extra_factor\\n\\n # self.pin_array.append(2*pi*1*extra_factor)\\n # Assumes:\\n # (-1)**c adot = - spring* (-1)**b SUM{ z x nij*(nij.(dri-drj)) } + pin\\n matrix = - (-spring * M1 + pin * M2)\\n\\n return matrix\",\n \"def Heston_fft(self,alpha,n,B,K):\\r\\n bt = time.time()\\r\\n r = self.r\\r\\n T = self.T\\r\\n S0 = self.S0\\r\\n N = 2**n\\r\\n Eta = B / N\\r\\n Lambda_Eta = 2 * math.pi / N\\r\\n Lambda = Lambda_Eta / Eta\\r\\n \\r\\n J = np.arange(1,N+1,dtype = complex)\\r\\n vj = (J-1) * Eta\\r\\n m = np.arange(1,N+1,dtype = complex)\\r\\n Beta = np.log(S0) - Lambda * N / 2\\r\\n km = Beta + (m-1) * Lambda\\r\\n \\r\\n ii = complex(0,1)\\r\\n \\r\\n Psi_vj = np.zeros(len(J),dtype = complex)\\r\\n \\r\\n for zz in range(0,N):\\r\\n u = vj[zz] - (alpha + 1) * ii\\r\\n numer = self.Heston_cf(u)\\r\\n denom = (alpha + vj[zz] * ii) * (alpha + 1 + vj[zz] * ii)\\r\\n \\r\\n Psi_vj [zz] = numer / denom\\r\\n \\r\\n # Compute FTT\\r\\n xx = (Eta/2) * Psi_vj * np.exp(-ii * Beta * vj) * (2 - self.dirac(J-1))\\r\\n zz = np.fft.fft(xx)\\r\\n \\r\\n # Option price\\r\\n Mul = np.exp(-alpha * np.array(km)) / np.pi\\r\\n zz2 = Mul * np.array(zz).real\\r\\n k_List = list(Beta + (np.cumsum(np.ones((N, 1))) - 1) * Lambda)\\r\\n Kt = np.exp(np.array(k_List))\\r\\n \\r\\n Kz = []\\r\\n Z = []\\r\\n for i in range(len(Kt)):\\r\\n if( Kt[i]>1e-16 )&(Kt[i] < 1e16)& ( Kt[i] != float(\\\"inf\\\"))&( Kt[i] != float(\\\"-inf\\\")) &( zz2[i] != float(\\\"inf\\\"))&(zz2[i] != float(\\\"-inf\\\")) & (zz2[i] is not float(\\\"nan\\\")):\\r\\n Kz += [Kt[i]]\\r\\n Z += [zz2[i]]\\r\\n tck = interpolate.splrep(Kz , np.real(Z))\\r\\n price = np.exp(-r*T)*interpolate.splev(K, tck).real\\r\\n et = time.time()\\r\\n \\r\\n runt = et-bt\\r\\n\\r\\n return(price,runt)\",\n \"def non_interacting_conductivity(self,\\n sigma=0.04,\\n freq_range=(0.0, 6.0, 1000),\\n imag_dielectric=False,\\n broadening='lorentz'):\\n cell_area = np.abs(float(np.cross(self.a1, self.a2)))*len(self.k_grid)\\n broad_fnc = get_broadening_function(broadening, sigma)\\n\\n frequency_grid = np.linspace(*freq_range)\\n energy_increment = np.abs(frequency_grid[1] - frequency_grid[0])\\n num_freqs, min_freq = len(frequency_grid), min(frequency_grid)\\n output_grid = np.zeros(num_freqs)\\n\\n energy_power = 1 + int(imag_dielectric)\\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\\n prefactor = prefactor/cell_area\\n\\n # Assuming x polarisation for now\\n position_dipole_matrix = self.construct_position_dipole_matrix()\\n\\n n_shift = self.n_spins*self.n_orbs\\n for idx1, kpt in enumerate(self.k_grid):\\n for s0 in range(self.n_spins):\\n velocity_matrix = self.load_velocity_matrix(idx1)\\n bands = self.exciton_obj.get_number_conduction_valence_bands(\\n idx1, s0\\n )\\n v_num, c_num = bands\\n eigvals = np.array(\\n self.file_storage['eigensystem']['eigenvalues'][idx1]\\n )\\n\\n j1 = n_shift*idx1 + (self.n_spins - 1)*s0*self.n_orbs\\n j2 = j1 + self.n_orbs\\n eigvecs = np.array(\\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\\n )\\n for v, c in product(range(v_num), range(c_num)):\\n cb_vector = eigvecs[:, v_num + c]\\n vb_vector = eigvecs[:, v]\\n cb_energy, vb_energy = eigvals[v_num + c], eigvals[v]\\n energy_diff = (cb_energy - vb_energy)\\n\\n energy_diff_pow = energy_diff**energy_power\\n matrix_elem = velocity_matrix_element(vb_vector,\\n cb_vector,\\n velocity_matrix)\\n if self.use_dipole_term:\\n position_dipole_term = get_position_dipole_element(\\n vb_vector,\\n cb_vector,\\n vb_energy,\\n cb_energy,\\n position_dipole_matrix\\n )\\n matrix_elem = matrix_elem + position_dipole_term\\n\\n main_term = np.abs(matrix_elem)**2/energy_diff_pow\\n closest_idx = (energy_diff - min_freq)//energy_increment\\n idx_reach = self.reach_multiplier*(sigma//energy_increment)\\n\\n lower_idx = max([closest_idx - idx_reach, 0])\\n upper_idx = min([closest_idx + idx_reach, num_freqs - 1])\\n\\n for idx2 in range(int(lower_idx), int(upper_idx)):\\n smearing = broad_fnc(energy_diff, frequency_grid[idx2])\\n output = prefactor*main_term*smearing\\n output_grid[idx2] += output\\n\\n return frequency_grid, output_grid\",\n \"def findScalingCoeffsMultiExp(self, PFC, lqCN, lqCF, lqPN, lqPF):\\n # Get R and Z vectors at the midplane\\n R_omp_sol = PFC.ep.g['lcfs'][:,0].max()\\n R_omp_min = R_omp_sol - 5.0*(lqPN + lqPF) #already in m\\n R_omp_max = R_omp_sol + 20.0*(lqCN + lqCF) #already in m\\n #if R_omp_max is outside EFIT grid, cap at maximum R of grid\\n if R_omp_max > max(PFC.ep.g['R']):\\n R_omp_max = max(PFC.ep.g['R']) #in meters now\\n R_omp = np.linspace(R_omp_min, R_omp_max, 1000)\\n Z_omp = np.zeros(R_omp.shape)\\n\\n\\n # Evaluate B at outboard midplane\\n Bp_omp = PFC.ep.BpFunc.ev(R_omp,Z_omp)\\n Bt_omp = PFC.ep.BtFunc.ev(R_omp,Z_omp)\\n B_omp = np.sqrt(Bp_omp**2 + Bt_omp**2)\\n\\n #Find coordinate transformation vector at midplane\\n psiaxis = PFC.ep.g['psiAxis']\\n psiedge = PFC.ep.g['psiSep']\\n deltaPsi = np.abs(psiedge - psiaxis)\\n gradPsi = Bp_omp*R_omp\\n xfm = gradPsi / deltaPsi\\n # transform hf width into flux space\\n lqPN_hat = lqPN*xfm\\n lqPF_hat = lqPF*xfm\\n lqCN_hat = lqCN*xfm\\n lqCF_hat = lqCF*xfm\\n\\n #Calculate flux at midplane using gfile\\n psiN = PFC.ep.psiFunc.ev(R_omp,Z_omp)\\n psi = psiN*(psiedge - psiaxis) + psiaxis\\n PFC.psiMinLCFS = PFC.ep.psiFunc.ev(R_omp_sol,0.0)\\n s_hat = psiN - PFC.psiMinLCFS\\n\\n #find locations in Private vs Common flux regions\\n useP = np.where(s_hat < 0.0)[0]\\n useC = np.where(s_hat >= 0.0)[0]\\n\\n #integral for SOL in flux space\\n if len(useP)>0:\\n qPN_hat = np.exp( s_hat[useP] / lqPN_hat[useP])\\n qPF_hat = np.exp( s_hat[useP] / lqPF_hat[useP])\\n #reinke method\\n #intPN = simps(qPN_hat / B_omp[useP], psi[useP])\\n #intPF = simps(qPF_hat / B_omp[useP], psi[useP])\\n #menard method\\n intPN = simps(qPN_hat, psi[useP])\\n intPF = simps(qPF_hat, psi[useP])\\n else:\\n qPN_hat = 0.0\\n qPF_hat = 0.0\\n intPN = 0.0\\n intPF = 0.0\\n\\n if len(useC)>0:\\n qCN_hat = np.exp(-s_hat[useC] / lqCN_hat[useC])\\n qCF_hat = np.exp(-s_hat[useC] / lqCF_hat[useC])\\n #reinke method\\n #intCN = simps(qCN_hat / B_omp[useC], psi[useC])\\n #intCF = simps(qCF_hat / B_omp[useC], psi[useC])\\n #menard method\\n intCN = simps(qCN_hat, psi[useC])\\n intCF = simps(qCF_hat, psi[useC])\\n else:\\n qCN_hat = 0.0\\n qCF_hat = 0.0\\n intCN = 0.0\\n intCF = 0.0\\n\\n P0 = 2*np.pi * (intCN*self.fracCN + intCF*self.fracCF +\\n intPN*self.fracPN + intPF*self.fracPF)\\n #account for nonphysical power\\n if P0 < 0: P0 = -P0\\n #Scale to input power\\n q0 = self.Psol/P0\\n\\n #old method left for reference (same math)\\n #q0 = (self.Psol/(2*np.pi)) / (intCN*self.fracCN + intCF*self.fracCF +\\n # intPN*self.fracPN + intPF*self.fracPF)\\n\\n return q0\",\n \"def init_kern_act(num_pitches):\\n\\n kern_act = []\\n\\n for i in range(num_pitches):\\n kern_act.append(Matern32(1, lengthscales=1.0, variance=3.5))\\n return kern_act\",\n \"def fit(self, spike_times, input_current, window, dt):\\n spks_in_window = self._get_spikes_in_window(spike_times, window, dt)\\n\\n # Compute and store summary metrics.\\n ISIs = [np.diff(x) for x in spks_in_window]\\n self.CV = [x.std() / x.mean() if len(x) > 0 else 0 for x in ISIs]\\n\\n self.f = np.array([len(x) for x in spks_in_window]) / (\\n 1e-3 * dt * (window[1] - window[0])\\n )\\n\\n self.I = input_current[\\n max(window[1] - 1000, window[0]) : (\\n window[1] - 10\\n ) # Offsets are to avoid boundary effects from stimulus edges.\\n ].mean(axis=0)\\n\\n self._rheobase_ind = np.where(self.f > 1e-8)[0][0]\\n self.rheobase = self.I[self._rheobase_ind]\\n self.freq_at_rheobase = self.f[self._rheobase_ind]\\n\\n self.freq_at_50 = self._get_interpolated_f_at_I(50.0)\\n\\n self.is_monotonic = self.is_monotonic_function(self.f)\\n self._linear_fit_coeffs = np.polyfit(\\n self.I[self._rheobase_ind :], self.f[self._rheobase_ind :], 1\\n )\\n self.gain = self._linear_fit_coeffs[0]\\n\\n self.spearman_rho, self.spearman_p = spearmanr(\\n self.I[self._rheobase_ind :], self.f[self._rheobase_ind :]\\n )\",\n \"def rk8(accel,m,r,h,v): \\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\\n\\n\\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \\n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \\n \\n return new_v8,new_r8\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\\n\\t\\t# Active K-rotor\\n\\t\\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\\n\\t\\tif len(rotors) == 0:\\n\\t\\t\\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\\n\\t\\t\\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\t# Other modes\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tQ0 = mode.getPartitionFunction(Tlist)\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\treturn Q\",\n \"def get_hbls_hbbl(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n z_u_r = self.grid_dict['z_u_r']\\n u = self.u\\n v = self.v\\n \\n v_upts = TTTW_func.v2u(v)\\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\\n\\n\\n\\n # CALCULATE swr_frac\\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\\n\\n\\n # WHOLE THING HAPPENS IN j loop through y-indices\\n \\n # INITIALIZE ARRAYS\\n self.kmo = np.zeros([Ly])\\n self.Cr = np.zeros([Ly])\\n self.kbl = np.empty([Ly],dtype='int')\\n self.C_h_MO = np.zeros([Ly])\\n self.Cr = np.zeros([Ly,N+1]) # sum term\\n self.FC = np.zeros([Ly,N+1])\\n self.swdk_r = np.zeros([Ly,N+1])\\n \\n self.zscale = np.zeros([Ly,N])\\n self.Kern = np.zeros([Ly,N])\\n\\n \\n # --> LOOP THROUGH Y-INDICES\\n for j in range(Ly):\\n if self.LIMIT_MO_DEPTH:\\n self.kmo[j] = 0\\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\\n \\n self.kbl[j] = 0\\n self.Cr[j,-1] = 0 # set top Cr\\n self.Cr[j,0] = 0 # set bottom Cr\\n \\n # SEARCH FOR MIXED LAYER DEPTH\\n self.FC[j,-1] = 0.\\n\\n\\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\\n for k in range(N-1,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n \\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n self.zscale[j,k_w] = zscale\\n if self.LMD_KPP:\\n if self.LMD_BKPP:\\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\\n else:\\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\\n else:\\n Kern = 1.\\n \\n\\n\\n self.Kern[j,k_w] = Kern\\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\\\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\\\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\\n\\n\\n #\\t\\tLOOP THAT FINDS BL DEPTH ##\\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \\n \\n if self.LMD_KPP:\\n #swdk_r only used in this function so don't need to be class attribute\\n # but for testing make it an attribute to see what it is\\n \\n # fortran equivlanet ===> k=N,1,-1 \\n for k in range(N,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n ###################################################################### \\n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\\n \\n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\\n \\n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\\n \\t\\t\\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\\n \\n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\\n \\n\\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\\n \\n\\n #######################################################################\\n \\n # SEARCH FOR hbls vertical level #\\n '''\\n kbl is specified at vertical w-level (via Cr which is at\\n vertical w-levels)\\n '''\\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\\n self.kbl[j] = k_w\\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\\n self.kmo[j] = k_w\\n\\n \\n #--> still in j-loop\\n #######################################################\\n \\n # \\t\\tGET SURFACE BOUNDARY LAYER DEPTH # \\n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\\n if self.kbl[j] > 0:\\n k_w = self.kbl[j]\\n k_r = k_w - 1 \\n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\\n \\n else:\\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\\\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\\n \\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] > 0:\\n k_w = self.kmo[j]\\n k_r = k_w-1\\n if k_w == N:\\n z_up = z_u_w[j,N]\\n cff_up = np.max([0,Bo[j]])\\n else:\\n z_up = z_r[j,k_w+1]\\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\\n \\n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \\n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\\\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\\\\n + self.C_h_MO[j] * (cff_dn - cff_up)\\n\\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\\n\\n\\n\\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\\n if self.LMD_BKPP:\\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\\n self.Cr[j,0] = 0.\\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\\n \\n #---> LOOP BOTTOM TO TOP\\n # FIND kbl for BBL\\n for k in range(1,N+1):\\n k_r = k-1\\n k_w = k \\n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\\n \\n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\\n self.kbl[j] = k_w \\n \\n\\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\\n if self.kbl[j] > 0 :\\n k_w = self.kbl[j] \\n k_r = k_w -1\\n if k_w == 1: # NO BBL CASE\\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\\n else:\\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\\\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]\",\n \"def BACF_optimized(params):\\n import math as m\\n import numpy as np\\n import cv2\\n import time\\n import matplotlib.pyplot as plt\\n import matplotlib.patches as patches\\n\\n from resizeDFT2 import resizeDFT2\\n from get_pixels import get_pixels\\n from get_features import get_features\\n from resp_newton import resp_newton\\n from get_subwindow_no_window import get_subwindow_no_window\\n\\n # Setting parameters\\n search_area_scale = params['search_area_scale'] # size of training/detection area proportional to the target size\\n output_sigma_factor = params['output_sigma_factor']\\n learning_rate = params['learning_rate']\\n filter_max_area = params['filter_max_area']\\n nScales = params['number_of_scales'] # number of scale resolutions to check\\n scale_step = params['scale_step']\\n interpolate_response = params['interpolate_response']\\n\\n features = params['t_features']\\n video_path = params['video_path']\\n s_frames = params['s_frames']\\n pos = np.floor(params['init_pos']) # initial centre-point (y by x) of target bounding box\\n target_sz = np.floor(params['wsize']) # initial height and height of target bounding box\\n\\n visualization = params['visualization']\\n num_frames = params['no_fram']\\n init_target_sz = target_sz\\n\\n # Set the features ratio to the feature-cell size\\n featureRatio = params['t_global']['cell_size']\\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\\n\\n # when the number of cells are small, choose a smaller cell size\\n if 'cell_selection_thresh' in params['t_global']:\\n if search_area < params['t_global']['cell_selection_thresh'] * filter_max_area:\\n params['t_global']['cell_size'] = min(featureRatio,\\n max(1, np.ceil(m.sqrt(np.prod(init_target_sz * search_area_scale) /\\n (params['t_global']['cell_selection_thresh'] *\\n filter_max_area)))))\\n featureRatio = params['t_global']['cell_size']\\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\\n\\n global_feat_params = params['t_global']\\n\\n if search_area > filter_max_area:\\n currentScaleFactor = m.sqrt(search_area / filter_max_area)\\n else:\\n currentScaleFactor = 1.0\\n\\n # target size at the initial scale\\n base_target_sz = target_sz / currentScaleFactor\\n\\n # window size, taking padding into account\\n if params['search_area_shape'] == 'proportional':\\n sz = np.floor(base_target_sz * search_area_scale) # proportional area, same aspect ratio as the target\\n elif params['search_area_shape'] == 'square':\\n sz = np.tile(m.sqrt(np.prod(base_target_sz * search_area_scale)), [1, 2]) # ignores target aspect ratio\\n elif params['search_area_shape'] == 'fix_padding':\\n sz = base_target_sz + m.sqrt(np.prod(base_target_sz * search_area_scale) +\\n (base_target_sz[0] - base_target_sz[1]) / 4) - \\\\\\n sum(base_target_sz) / 2 # const padding\\n else:\\n raise ValueError('Unknown \\\"search_area_shape\\\". Must be \\\"proportional\\\", \\\"square\\\", or \\\"fix_padding\\\".')\\n\\n # set the size to exactly match the cell size\\n sz = np.round(sz[0] / featureRatio) * featureRatio\\n use_sz = np.floor(sz / featureRatio)\\n\\n # construct the label function- correlation output, 2D gaussian function, with a peak located upon the target\\n # np.roll acts a circular shift operator. This is used to compute all possible patches in the entire frame\\n output_sigma = m.sqrt(np.prod(np.floor(base_target_sz / featureRatio))) * output_sigma_factor\\n rg = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1)/2) + 1),\\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\\n cg = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\\n int(-1 * np.floor((use_sz[1] - 1) / 2)))\\n [rs, cs] = np.meshgrid(rg, cg)\\n rs = rs.T\\n cs = cs.T\\n # y is the desired correlation response at each point within the size of the filter\\n y = np.exp(-0.5 * ((np.power(rs, 2) + np.power(cs, 2)) / np.power(output_sigma, 2)))\\n yf = np.fft.fft2(y) # fast fourier transform of y\\n\\n if interpolate_response == 1:\\n interp_sz = use_sz * featureRatio\\n else:\\n interp_sz = use_sz\\n\\n # construct cosine window\\n term1 = np.array([np.hanning(use_sz[0])])\\n term2 = np.array([np.hanning(use_sz[1])])\\n cos_window = np.matmul(term1.T, term2)\\n cos_window = cos_window.astype('float32')\\n\\n # Calculate feature dimension\\n try:\\n im = cv2.imread(video_path + '/img/' + s_frames[0])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n try:\\n im = cv2.imread(s_frames[0])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n im = cv2.imread(video_path + '/' + s_frames[0])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n\\n # Check to see if it is a color image or grayscale\\n if im.shape[2] == 3:\\n if np.all(np.equal(im[:,:,0], im[:,:,1])):\\n colorImage = False\\n else:\\n colorImage = True\\n else:\\n colorImage = False\\n \\n if im.shape[2] > 1 and colorImage is False:\\n im = im[:,:,0]\\n im = im.reshape([im.shape[0], im.shape[1], 1])\\n\\n # create scale factors to check for object at various scale resolutions\\n if nScales > 0:\\n scale_exp = np.arange(-1 * np.floor((nScales - 1) / 2), np.ceil((nScales - 1) / 2) + 1)\\n scaleFactors = scale_step ** scale_exp\\n min_scale_factor = scale_step ** np.ceil(m.log(max(np.divide(5, sz))) / m.log(scale_step))\\n max_scale_factor = scale_step ** np.floor(m.log(min(np.divide([im.shape[0],\\n im.shape[1]],\\n base_target_sz))) / m.log(scale_step))\\n\\n if interpolate_response >= 3:\\n # pre-computes the grid that is used for score optimization\\n ky = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1) / 2) + 1),\\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\\n kx = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\\n int(-1 * np.floor((use_sz[1] - 1) / 2))) # --> SAME AS MATLAB\\n kx = kx.T\\n newton_iterations = params['newton_iterations']\\n\\n # initialize the projection matrix (x,y,h,w)\\n rect_position = np.zeros([num_frames, 4])\\n\\n # allocate memory for multi-scale tracking\\n multires_pixel_template = np.zeros([int(sz[0]), int(sz[1]), im.shape[2], nScales], dtype=np.uint8)\\n small_filter_sz = np.floor(base_target_sz / featureRatio)\\n start_time = time.time()\\n\\n loop_frame = 0\\n for frame in range(0, len(s_frames)):\\n try:\\n im = cv2.imread(video_path + '/img/' + s_frames[frame])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n try:\\n im = cv2.imread(s_frames[frame])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n im = cv2.imread(video_path + '/' + s_frames[frame])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n\\n if im.shape[2] > 1 and colorImage is False:\\n im = im[:, :, 0]\\n im = im.reshape([im.shape[0], im.shape[1], 1])\\n\\n # do not estimate translation and scaling on the first frame, since we are just initializing the tracker\\n if frame > 0:\\n\\n # The filter is applied on multiple resolutions of the search area. This is used to determine any changes in\\n # scale of the target object\\n for scale_ind in range(0, nScales):\\n multires_pixel_template[:, :, :, scale_ind] = \\\\\\n get_pixels(im, pos, np.round(sz * currentScaleFactor * scaleFactors[scale_ind]), sz)\\n\\n feat_term2, _ = get_features(multires_pixel_template, features, global_feat_params, None)\\n xtf = np.zeros(feat_term2.shape, dtype=complex)\\n for p in range(0, feat_term2.shape[2]):\\n for n in range(0, feat_term2.shape[3]):\\n xtf[:,:,p,n] = np.fft.fft2(np.multiply(feat_term2[:,:,p,n], cos_window[:, :]))\\n responsef = np.sum(np.multiply(np.conj(g_f)[:, :, :, None], xtf), axis=2)\\n\\n # if we undersampled features, we want to interpolate the response to have the same size as the image patch\\n if interpolate_response == 2:\\n # use dynamic interp size\\n interp_sz = np.floor(y.shape * featureRatio * currentScaleFactor)\\n\\n responsef_padded = resizeDFT2(responsef, interp_sz)\\n\\n # Get the response in the spatial domain\\n response = np.zeros(responsef_padded.shape)\\n for n in range(0, responsef.shape[2]):\\n response[:,:,n] = np.real(np.fft.ifft2(responsef_padded[:,:,n])) # MAY HAVE AN ISSUE HERE NOT BEING SYMMETRIC -- therefore added real --> SAME AS MATLAB :D :)\\n\\n # find maximum peak\\n if interpolate_response == 3:\\n raise ValueError('Invalid parameter value for \\\"interpolate_response\\\"')\\n elif interpolate_response == 4:\\n [disp_row, disp_col, sind] = resp_newton(response, responsef_padded, newton_iterations, ky, kx, use_sz)\\n\\n # Check if the target has completely gone off the frame\\n if np.isnan(disp_row) or np.isnan(disp_col):\\n break\\n\\n # calculate translation vector\\n if interpolate_response == 0 or 3 or 4:\\n translation_vec = np.round(np.array([disp_row, disp_col]) * featureRatio *\\n currentScaleFactor * scaleFactors[sind])\\n elif interpolate_response == 1:\\n translation_vec = np.round([disp_row, disp_col] * currentScaleFactor * scaleFactors[sind])\\n elif interpolate_response == 2:\\n translation_vec = np.round([disp_row, disp_col] * scaleFactors[sind])\\n\\n # set the scale\\n currentScaleFactor = currentScaleFactor * scaleFactors[sind]\\n\\n # adjust to make sure we are not too large or too small\\n if currentScaleFactor < min_scale_factor:\\n currentScaleFactor = min_scale_factor\\n elif currentScaleFactor > max_scale_factor:\\n currentScaleFactor = max_scale_factor\\n\\n # update position\\n old_pos = pos\\n pos = pos + translation_vec\\n\\n # extract training sample image region\\n pixels = get_pixels(im, pos, np.round(sz*currentScaleFactor), sz)\\n\\n # extract features and perform windowing\\n feat_term, _ = get_features(pixels, features, global_feat_params, None)\\n xf = np.zeros([feat_term.shape[1], feat_term.shape[1], feat_term.shape[2]], dtype=complex)\\n for n in range(0, feat_term.shape[2]):\\n xf[:, :, n] = np.fft.fft2(np.multiply(feat_term[:, :, n, 0], cos_window[:, :]))\\n if frame == 0:\\n model_xf = xf\\n else:\\n model_xf = ((1 - learning_rate) * model_xf) + (learning_rate * xf)\\n\\n g_f = np.zeros(xf.shape)\\n g_f = g_f.astype('float32')\\n h_f = g_f\\n l_f = g_f\\n\\n # parameters from the original paper\\n mu = 1\\n betha = 10\\n mumax = 10000\\n i = 1\\n\\n T = np.prod(use_sz)\\n S_xx = np.sum(np.multiply(model_xf.conj(), model_xf), axis=2)\\n params['admm_iterations'] = 2\\n\\n while i <= params['admm_iterations']:\\n # Solve for G\\n B = S_xx + (T * mu)\\n S_lx = np.sum(np.multiply(model_xf.conj(), l_f), axis=2)\\n S_hx = np.sum(np.multiply(model_xf.conj(), h_f), axis=2)\\n\\n # equation (10) in original paper\\n g_f = (((1 / (T * mu)) * np.multiply(yf[:, :, None], model_xf)) - ((1 / mu) * l_f) + h_f) - \\\\\\n np.divide((((1 / (T * mu)) * np.multiply(model_xf, np.multiply(S_xx, yf)[:, :, None])) -\\n ((1 / mu) * np.multiply(model_xf, S_lx[:, :, None])) +\\n (np.multiply(model_xf, S_hx[:, :, None]))), B[:, :, None])\\n\\n # solve for H\\n # Equation (6) in original paper\\n h = np.zeros([g_f.shape[0], g_f.shape[1], g_f.shape[2]], dtype=complex)\\n for n in range(0, g_f.shape[2]):\\n h[:, :, n] = (T / ((mu * T) + params['admm_lambda'])) * np.fft.ifft2((mu * g_f[:, :, n]) + l_f[:, :, n])\\n\\n [sx, sy, h] = get_subwindow_no_window(h, np.floor(use_sz / 2), small_filter_sz)\\n t = np.zeros([int(use_sz[0]), int(use_sz[1]), h.shape[2]], dtype=complex)\\n t[int(sx[0]):int(sx[-1])+1, int(sy[0]):int(sy[-1])+1, :] = h\\n\\n h_f = np.zeros([t.shape[1], t.shape[1], t.shape[2]], dtype=complex)\\n for n in range(0, t.shape[2]):\\n h_f[:, :, n] = np.fft.fft2(t[:, :, n])\\n\\n # update L\\n l_f = l_f + (mu * (g_f - h_f))\\n\\n # update mu- betha = 10\\n mu = min(betha * mu, mumax)\\n i = i + 1\\n\\n target_sz = np.floor(base_target_sz * currentScaleFactor)\\n\\n # save position and calculate FPS\\n rect_position[loop_frame, :] = np.concatenate((pos[1::-1] - np.floor(target_sz[1::-1] / 2), target_sz[1::-1]))\\n\\n elapsed = time.time() - start_time\\n\\n # visualization\\n if visualization == 1:\\n rect_position_vis = np.concatenate((pos[1::-1] - (target_sz[1::-1] / 2), target_sz[1::-1]))\\n im_to_show = im / 255\\n if im_to_show.shape[2] == 1:\\n im_to_show = np.tile(im_to_show, [1, 1, 3]) # if grayscale, ensure it plots image in grayscale\\n if frame == 0:\\n fig, ax = plt.subplots(1, num='Tracking')\\n ax.imshow(im_to_show)\\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\\n linewidth=3, edgecolor='g', facecolor='none')\\n ax.add_patch(rect)\\n ax.annotate(str(frame + 1), [10, 10], color='c')\\n ax.axis('off') # remove axis values\\n ax.axis('image') # scale image appropriately\\n ax.set_position([0, 0, 1, 1])\\n fig.show()\\n fig.canvas.draw()\\n else:\\n ax.clear()\\n resp_sz = np.round(sz * currentScaleFactor * scaleFactors[scale_ind])\\n xs = np.floor(old_pos[1]) + (np.arange(1, resp_sz[1] + 1)) - np.floor(resp_sz[1] / 2)\\n ys = np.floor(old_pos[0]) + (np.arange(1, resp_sz[0] + 1)) - np.floor(resp_sz[0] / 2)\\n sc_ind = np.floor((nScales - 1) / 2)\\n\\n ax.imshow(im_to_show)\\n ax.axis('off') # remove axis values\\n ax.axis('image') # scale image appropriately\\n ax.set_position([0, 0, 1, 1])\\n im_overlay = np.fft.fftshift(response[:,:,int(sc_ind)])\\n ax.imshow(im_overlay, extent=[xs[0], xs[-1], ys[0], ys[-1]],\\n alpha=0.2, cmap='hsv')\\n rect.remove() # remove previous rectangle each time\\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\\n linewidth=3, edgecolor='g', facecolor='none')\\n ax.add_patch(rect)\\n frame_str = '# Frame: ' + str(loop_frame + 1) + ' / ' + str(num_frames)\\n FPS_str = 'FPS: ' + str(1 / (elapsed / loop_frame))\\n ax.annotate(frame_str, [20, 30], color='r', backgroundcolor='w')\\n ax.annotate(FPS_str, [20, 60], color='r', backgroundcolor='w', fontsize=16)\\n fig.show()\\n fig.canvas.draw() # used to update the plot in real-time\\n\\n loop_frame += 1\\n\\n # Save results\\n fps = loop_frame / elapsed\\n results = {'res': rect_position, 'fps': fps}\\n\\n return results\",\n \"def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 4th order calculation\\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\\n \\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n\\n # Calculate truncation error between 5th and 4th order\\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\\n \\n # Compare eps to emin and emax and update h accordingly\\n if np.max(eps) < emin:\\n if h*2.0 < hmax:\\n h *= 2.0\\n new_v = new_v5\\n new_r = new_r5 \\n \\n if np.max(eps) > emax:\\n if h/2.0 > hmin:\\n h /= 2.0\\n print h\\n # Error too large, call rk_adaptive again with smaller h\\n if recur < recurmax:\\n recur += 1\\n rk_adaptive(accel,m,r,h,v,recur)\\n new_v = new_v5\\n new_r = new_r5\\n \\n else:\\n new_v = new_v5\\n new_r = new_r5\\n \\n return new_v, new_r, h\",\n \"def set_voltages(): \\n #0) set parameters\\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\\n import pickle\\n with open(trapFile,'rb') as f:\\n trap = pickle.load(f)\\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\\n tc=trap.configuration\\n C = tc.multipoleControl\\n el = []\\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\\n if tc.trap_knobs != True:\\n return 'WARNING: You must run trap_knobs first!'\\n #2a) determine electrode voltages directly\\n elif multipoleControls: # note plurality to contrast from attribute\\n el = np.dot(C,coefs.T) # these are the electrode voltages\\n #2b) determine electrode volages indirectly\\n else:\\n charge = tc.charge\\n mass = tc.mass\\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\\n U2 = az*V0/8\\n U1 = U2+ax*V0/4\\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\\n U1p= np.sqrt(U1**2+U3**2/2)\\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\\n mCf = tc.multipoleCoefficients[1:9,:]\\n el = np.dot(mCf.T,inp) # these are the electrode voltages\\n el = np.real(el)\\n #3) regularize if set to do so\\n reg = 0\\n if reg: \\n C = el\\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\\n Lambda=Lambda[0]\\n el = el-(np.dot(tc.multipoleKernel,Lambda))\\n return el\",\n \"def WakeVorticityFromCt(r,Ct,R,U0,Omega):\\n if Omega==np.inf:\\n Omega=800 # TODO, implement infinite lambd formulae directly\\n Lambda=Omega*R/U0\\n bSwirl=Lambda<20\\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\\n Gamma = vk*np.pi*U0**2/Omega\\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)\",\n \"def WakeVorticityFromCt(r,Ct,R,U0,Omega):\\n if Omega==np.inf:\\n Omega=800 # TODO, implement infinite lambd formulae directly\\n Lambda=Omega*R/U0\\n bSwirl=Lambda<20\\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\\n Gamma = vk*np.pi*U0**2/Omega\\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)\",\n \"def homology_basis(bd, k, C=None, shortest=False, log=None):\\n L1, R1, S1, L1inv = smith_normal_form_mod2(bd[k])\\n L2, R2, S2, L2inv = smith_normal_form_mod2(bd[k + 1])\\n\\n rank1 = np.sum(S1)\\n rank2 = np.sum(S2)\\n nullity1 = S1.shape[1] - rank1\\n betti1 = S1.shape[1] - rank1 - rank2\\n cokernel2_dim = S1.shape[1] - rank2\\n\\n print(f'Summary: \\\\nrank{k} = {rank1}\\\\nrank{k+1} = {rank2}\\\\nnullity{k} = {nullity1}')\\n\\n ker1 = R1[:, rank1:]\\n im2 = L2inv[:, :rank2]\\n cokernel2 = L2inv[:, rank2:]\\n cokproj2 = L2[rank2:, :]\\n\\n proj = matmulreduce([cokernel2, cokproj2, ker1]).transpose()\\n ######\\n print(proj)\\n _, proj, _ = reduced_row_echelon_form_mod2(proj)\\n proj = np.array(proj)\\n proj = np.array([row for row in proj if np.any(row)])\\n # print(f'hom basis reps: {proj*1}\\\\n')\\n basis = []\\n if shortest:\\n shortest_basis = list()\\n for idx, bs in enumerate(proj):\\n shortest_basis.append(coset(im2, bs=bs, shortest=True))\\n if C:\\n basis = [interpret(C, sb) for sb in shortest_basis]\\n\\n proj = shortest_basis\\n else:\\n if C:\\n basis = interpret(C, proj)\\n else:\\n basis = proj\\n if log:\\n try:\\n logdict = pickle.load(open(log, 'rb'))\\n except:\\n logdict = dict()\\n logdict.update({'k': k,\\n f'betti{k}': betti1,\\n 'ker': ker1,\\n 'im': im2,\\n 'proj': proj,\\n 'basis': basis})\\n pickle.dump(logdict, open(log, 'wb'))\\n\\n return basis\",\n \"def genBzKnot(numofCV, degree):\\n numofKnots = numofCV + degree - 1\\n result = []\\n knot = 0\\n for i in range(numofKnots):\\n result.append(knot)\\n if(i%3 >= 2):\\n knot += 1\\n return result\",\n \"def computeB(linsys_setup):\\n datamaps, ninvs, beams, freqs, power_2d, precond_2d, clumaps, g_nu, \\\\\\n map_prop = linsys_setup\\n nx, ny, pixScaleX, pixScaleY = map_prop\\n nFreq = len(g_nu); nCluster = len(clumaps[0])\\n ksz = False\\n if len(clumaps)==2: ksz = True\\n \\n def computeCMBY(d0):\\n \\\"\\\"\\\"\\n For CMB, y = S^1/2 A N^-1 d, where S is CMB signal covariance matrix (Cl's)\\n \\\"\\\"\\\"\\n # N.B. Reshaping operations required to go between 2D pixel arrays and \\n # 1D vector (for linear system)\\n d2 = 0\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny,nx))\\n d1 *= ninvs[freq]\\n a_l = fft.fft(d1,axes=[-2,-1])\\n a_l *= beams[freq]*precond_2d\\n d1 = numpy.real(fft.ifft(a_l,axes=[-2,-1],normalize=True))\\n d1 = numpy.reshape(d1,(nx*ny))\\n d2 += d1\\n return d2\\n \\n def computeClusterY(d0):\\n \\\"\\\"\\\"\\n For cluster, y = F^T A^T N^-1 d, where F is TSZ spatial template for cluster.\\n \\\"\\\"\\\"\\n d2 = numpy.zeros(nCluster)\\n for ic in range(nCluster):\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny, nx))\\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[0][ic][freq] * g_nu[freq])\\n return d2\\n \\n def computeClusterKSZY(d0):\\n \\\"\\\"\\\"\\n For cluster, y = K^T A^T N^-1 d, where K is KSZ spatial template for cluster.\\n \\\"\\\"\\\"\\n d2 = numpy.zeros(nCluster)\\n for ic in range(nCluster):\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny, nx))\\n d2[ic] += numpy.sum(d1 * ninvs[freq] * clumaps[1][ic][freq])\\n return d2\\n \\n def computeMonopoleY(d0):\\n \\\"\\\"\\\"\\n Overall monopole amplitude.\\n \\\"\\\"\\\"\\n d2 = 0\\n for freq in range(nFreq):\\n d1 = d0[freq].data.copy().reshape((ny, nx))\\n d2 += numpy.sum(d1 * ninvs[freq])\\n return(d2)\\n \\n \\n # CMB realisation; convolve white noise map with beam and multiply by \\n # signal covmat S^1/2 in harmonic space\\n b0 = numpy.random.randn(ny,nx)\\n a_l = numpy.fft.fft2(b0, b0.shape)\\n a_l *= precond_2d * power_2d**(-0.5)\\n b0 = numpy.fft.irfft2(a_l, b0.shape)\\n \\n # Calculate per-band noise realisation.\\n # Multiply by pixel-space N^1/2, convolve with beam, and sum over \\n # cluster pixels to get RHS\\n b1 = 0; b4 = 0\\n b2 = numpy.zeros(nCluster)\\n if ksz: b3 = numpy.zeros(nCluster)\\n \\n for freq in range(nFreq):\\n _b = numpy.random.randn(ny,nx) * ninvs[freq]**0.5\\n a_l = numpy.fft.fft2(_b) * beams[freq] * precond_2d\\n b1 += numpy.fft.irfft2(a_l, _b.shape)\\n b4 += numpy.sum(_b)\\n for ic in range(nCluster):\\n b2[ic] += numpy.sum( _b * g_nu[freq] * clumaps[0][ic][freq] )\\n if ksz: b3[ic] += numpy.sum( _b * clumaps[1][ic][freq] )\\n\\n b0 = numpy.reshape(b0,(nx*ny))\\n b1 = numpy.reshape(b1,(nx*ny))\\n \\n\\n # Compute CMB and cluster data parts of b\\n b_CMB = computeCMBY(datamaps) + b0 + b1\\n b_mono = computeMonopoleY(datamaps) + b4\\n b_tsz = computeClusterY(datamaps) + b2\\n if ksz: b_ksz = computeClusterKSZY(datamaps) + b3\\n \\n # Return total b vector (Ncmbpix + 1 + (1|2)*Ncluster elements in vector)\\n b = numpy.append(b_CMB, b_mono)\\n b = numpy.append(b, b_tsz)\\n if ksz: b = numpy.append(b, b_ksz)\\n return b\",\n \"def compute_gain( hv, cv, thot, tcold):\\n\\n nData = len(cv) \\n epsilons = np.full( nData, EPSILON)\\n\\n # For full Temp calibration, a spectrum taken at high elevation, away from \\n # The galactic plan is used.\\n dv = hv - cv \\n dv = np.maximum( dv, epsilons)\\n hv = np.maximum( hv, epsilons)\\n\\n # use the comparison of hot and cold to get gain without trx contribution\\n gain = (thot - tcold)/dv\\n\\n trx = gain*cv \\n trx = trx - tcold # correct for cold load input in counts\\n\\n n6 = int(nData/6)\\n n56 = 5*n6\\n\\n trxmedian = np.median( trx[n6:n56])\\n gain = (thot + trxmedian)/hv\\n \\n return trxmedian, gain # channel by channel gain in K/counts\",\n \"def _ftl_jump(self, y, K, **kwargs):\\n\\n logger.debug(\\\"Re-initializing with K-means++ at K = {}\\\".format(K))\\n\\n # Initialize new centroids by k-means++\\n mixtures = []\\n mls = []\\n for z in range(30):\\n\\n mean = kmeans._k_init(y, K, kmeans.row_norms(y, squared=True),\\n kmeans.check_random_state(None))\\n\\n # Calculate weights by L2 distances to closest centers.\\n distance = np.sum((y[:, :, None] - mean.T)**2, axis=1).T\\n\\n N, D = y.shape\\n responsibility = np.zeros((K, N))\\n responsibility[np.argmin(distance, axis=0), np.arange(N)] = 1.0\\n\\n weight = responsibility.sum(axis=1)/N\\n\\n covariance = _estimate_covariance_matrix(y, responsibility, mean,\\n self.covariance_type, self.covariance_regularization)\\n\\n mixture = self.__class__(\\n threshold=self.threshold,\\n covariance_type=self.covariance_type,\\n max_em_iterations=self.max_em_iterations,\\n covariance_regularization=self.covariance_regularization)\\n\\n # Initialize it.\\n mixture.set_parameters(mean=mean, weight=weight, covariance=covariance)\\n\\n # Run E-M on the partial mixture.\\n R, meta = mixture._expectation_maximization(\\n y, parent_responsibility=responsibility)\\n raise UnsureError\\n\\n mixtures.append(mixture)\\n mls.append(meta[\\\"message_length\\\"])\\n\\n print(np.std(mls))\\n index = np.argmin(mls)\\n mixture = mixtures[index]\\n\\n #slogdet = np.sum(np.log(np.linalg.det(mixture.covariance)))\\n slogdet = np.sum(_slogdet(mixture.covariance, mixture.covariance_type))\\n self._proposed_mixtures.append(mixture)\\n self._mixture_predictors.append([\\n mixture.weight.size,\\n np.sum(np.log(mixture.weight)),\\n meta[\\\"log_likelihood\\\"],\\n slogdet,\\n -meta[\\\"log_likelihood\\\"] + (D+2)/2.0 * slogdet\\n ])\\n # TODO: Remove predictors that we don't use.\\n #self._slogs.append(np.linalg.det(mixture.covariance))\\n\\n return mixture, R, meta #(len(self._proposed_mixtures) - 1, R, meta)\\n\\n\\n raise a\\n\\n #self.set_parameters(\\n # weight=weight, mean=mean, covariance=covariance)\\n\\n #return responsibility\",\n \"def fit_full(self, K, epsilon=1e-3,power_ep=[1.,1.]):\\r\\n self.epsilon = epsilon\\r\\n self.eta, self.delta = power_ep\\r\\n\\r\\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\\r\\n mu = np.zeros(self.num_data)\\r\\n Sigma = K.copy()\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.num_data,dtype=float)\\r\\n self.v_ = np.empty(self.num_data,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.num_data,dtype=float)\\r\\n self.Z_hat = np.empty(self.num_data,dtype=float)\\r\\n phi = np.empty(self.num_data,dtype=float)\\r\\n mu_hat = np.empty(self.num_data,dtype=float)\\r\\n sigma2_hat = np.empty(self.num_data,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = self.epsilon + 1.\\r\\n epsilon_np2 = self.epsilon + 1.\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.num_data)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model.moments_match(self.data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\\r\\n B = np.eye(self.num_data) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\\r\\n L = jitchol(B)\\r\\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\\r\\n Sigma = K - np.dot(V.T,V)\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.num_data\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.num_data\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def ridge_cv(trn_fs, trn_data, val_fs=None, val_data=None, alphas=DEFAULT_ALPHAS, \\n n_resamps=10, n_splits=10, chunk_sz=5000, dtype=np.single,pthr=0.005,\\n square_alpha=False,is_verbose=False):\\n #def ridge_cv(model,data,n_splits=10,n_resamps=10,alpha=DEFAULT_ALPHAS,efficient=np.nan,):\\n # (trn_fs, trn_data, val_fs, val_data, alphas, nboots, chunklen, n_chunks, dtype=np.single, corrmin=0.2):\\n n_resp, n_voxels = trn_data.shape\\n _,n_channels = trn_fs.shape\\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\\n bestalphas = np.zeros((n_resamps, n_voxels)) ## Will hold the best alphas for each voxel\\n trn_idx,val_idx = _utils.contig_partition(trn_fs.shape[0],n_splits)\\n\\n Rcmats = np.zeros((n_voxels,len(alphas),n_resamps))\\n for iRpt,cvi in enumerate(np.random.permutation(n_splits)[:n_resamps]):\\n if is_verbose:\\n print('Running split %d/%d'%(iRpt+1,n_resamps))\\n ti,vi = trn_idx[cvi],val_idx[cvi]\\n trn_fs_split = trn_fs[ti,:]\\n val_fs_split = trn_fs[vi,:]\\n trn_data_split = trn_data[ti,:]\\n val_data_split = trn_data[vi,:]\\n \\n # Run ridge regression to estimate predictions (within training set) for different alphas\\n Rcmats[:,:,iRpt] = _fit_ridge_alpha(trn_fs_split, trn_data_split, val_fs_split, val_data_split, alphas,\\n dtype=dtype, chunk_sz=chunk_sz,pthr=pthr,square_alpha=square_alpha)\\n if is_verbose:\\n print(\\\"Finding best alpha...\\\")\\n ## Find best alpha for each voxel\\n #trncc_byvox = np.nansum(Rcmats,axis=2)/np.sum(np.logical_not(np.isnan(Rcmats)),axis=2)\\n trncc_byvox = np.nanmean(Rcmats,axis=2)\\n # Taking mean is BS: too many voxels poorly predicted, floor effect. \\n #mean_cv_corr = np.nanmean(mean_cv_corr_byvox,axis=0)\\n #bestalphaind = np.argmax(mean_cv_corr)\\n # Thus just count voxels over significance threshold (with a lenient threshold)\\n #print(len(vi))\\n sig_thresh = _sutils.pval2r(pthr,len(vi),is_two_sided=False)\\n n_sig_vox_byalpha = sum(trncc_byvox>sig_thresh)-sum(trncc_byvox<-sig_thresh)\\n bestalphaind = np.argmax(n_sig_vox_byalpha)\\n alpha = alphas[bestalphaind]\\n if is_verbose:\\n print(\\\"Best alpha = %0.3f\\\"%alpha)\\n \\n ## Find weights for each voxel\\n U,S,Vt = np.linalg.svd(trn_fs, full_matrices=False)\\n # Loop over groups of voxels\\n wt = np.zeros((n_channels,n_voxels),dtype=dtype)\\n\\n ###\\n if (not val_fs is None) and (not val_data is None):\\n # Validation data / model supplied implies we want predictions\\n do_pred = True\\n if np.sum(val_fs[:,0]) != val_fs.shape[0]:\\n warnings.warn('First column of val_fs is NOT all ones! Consider including a DC term!')\\n # Pre-allocate for predictions, with or without separate validation sequences to predict\\n is_rpts = np.ndim(val_data)==3\\n if is_rpts:\\n n_rpts,n_tps_val,n_voxels_val = val_data.shape\\n cc = np.zeros((n_rpts,n_voxels),dtype);\\n else:\\n n_rpts,(n_tps_val,n_voxels_val) = 0,val_data.shape\\n cc = np.zeros((n_voxels),dtype);\\n pred = np.zeros((n_tps_val,n_voxels_val),dtype)\\n else:\\n # No Validation data / model supplied\\n do_pred = False;\\n\\n if is_verbose:\\n predstr = ' and model predictions...' if do_pred else \\\"...\\\"\\n print('Computing weights'+predstr)\\n for iChunk in range(n_chunks):\\n if is_verbose:\\n print('Running chunk %d of %d...\\\\n'%(iChunk+1,n_chunks))\\n ChIdx = np.arange(chunk_sz) + chunk_sz*iChunk\\n ChIdx = ChIdx[ChIdx<n_voxels] # clip extra voxels in last run.\\n Ychunk = trn_data[:,ChIdx]\\n\\n UtYchunk = np.dot(U.T, np.nan_to_num(Ychunk))\\n if square_alpha:\\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha**2)), UtYchunk])\\n else:\\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha)), UtYchunk])\\n\\n ## Find test correlations if validation data is present\\n if do_pred:\\n # Compute correlations btw validation data and model prediction\\n pred[:,ChIdx] = val_fs.dot(wt[:,ChIdx]).astype(dtype) \\n nnpred = np.nan_to_num(pred[:,ChIdx])\\n if is_rpts:\\n # The transpose here is related to deep mysteries in python. See \\n cc[:,ChIdx] = np.vstack([_sutils.column_corr(nnpred,val_data[rpt,:,ChIdx].T) for rpt in range(n_rpts)])\\n else:\\n cc[ChIdx] = _sutils.column_corr(nnpred,val_data[:,ChIdx])\\n\\n # Output\\n out = dict(\\n weights=wt,\\n alpha=alpha,\\n n_sig_vox_byalpha=n_sig_vox_byalpha,\\n #trncc_byvox=trncc_byvox,f\\n #trncc_byvox_byalpha=Rcmats\\n )\\n if not val_data is None: \\n out['cc'] = cc\\n return out\",\n \"def pfit(Vrf,Vdc,X,Y,Z,Irf,Jrf,Krf):\\n #1) find dc potential\\n #from all_functions import plot_potential,p2d,trap_depth,find_saddle,exact_saddle\\n from project_parameters import charge,mass,driveAmplitude,Omega,debug,scale\\n #2) find pseudopotential\\n \\\"\\\"\\\"Gebhard, Oct 2010:\\n changed back to calculating field numerically in ppt2 instead directly\\n with bemsolver. this is because the slow bemsolver (new version) does not output EX, EY, EZ.\\\"\\\"\\\"\\n [Ey,Ex,Ez] = np.gradient(Vrf,abs(X[1]-X[0])/scale,abs(Y[1]-Y[0])/scale,abs(Z[1]-Z[0])/scale) # fortran indexing\\n Esq = Ex**2 + Ey**2 + Ez**2\\n #3) plotting pseudopotential, etc; outdated?\\n PseudoPhi = Esq*(charge**2)/(4*mass*Omega**2) \\n U = PseudoPhi+charge*Vdc # total trap potential\\n if debug.pfit:\\n# plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Ex,X,Y,Z,'1D plots','Ex','U_{ps} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Ey,X,Y,Z,'1D plots','Ey','U_{ps} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Ez,X,Y,Z,'1D plots','Ez','U_{ps} (eV)',[Irf,Jrf,Krf]) \\n# plot_potential(Esq,X,Y,Z,'1D plots','E**2','U_{ps} (eV)',[Irf,Jrf,Krf])\\n plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\\n plot_potential(PseudoPhi/charge,X,Y,Z,'1D plots','Pseudopotential','U_{ps} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Vdc,X,Y,Z,'1D plots','DC Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\\n plot_potential(U/charge,X,Y,Z,'1D plots','Trap Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\\n #4) determine trap frequencies and tilt in radial directions\\n Uxy = U[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]\\n MU = np.max(Uxy) # normalization factor, will be undone when calculating frequencies\\n Uxy = Uxy/MU \\n nx,ny,nz=X.shape[0],Y.shape[0],Z.shape[0]\\n x,y,z = np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz))\\n for i in range(nx):\\n for j in range(ny):\\n for k in range(nz):\\n x[i,j,k] = X[i]\\n y[i,j,k] = Y[j]\\n z[i,j,k] = Z[k]\\n dL = x[Irf+3,Jrf,Krf]-x[Irf,Jrf,Krf] # is this X? Originally x. Temporarily y so that dL not 0. Probably related to meshgrid or indexing.\\n xr = (x[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-x[Irf,Jrf,Krf])/dL \\n yr = (y[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-y[Irf,Jrf,Krf])/dL\\n [C1,C2,theta] = p2d(Uxy,xr,yr) \\n C1,C2,theta = C1[0],C2[0],theta[0] \\n fx = (1e3/dL)*np.sqrt(abs(2*C1*MU/(mass)))/(2*np.pi)\\n fy = (1e3/dL)*np.sqrt(abs(2*C2*MU/(mass)))/(2*np.pi)\\n #5) trap frequency in axial direction\\n Uz=U[Irf,Jrf,:] # old projection\\n l1 = np.max([Krf-6,1])\\n l2 = np.min([Krf+6,np.max(Z.shape)])\\n p = np.polyfit((Z[l1:l2+1]-Z[Krf])/dL,Uz[l1:l2+1],6)\\n fz = (1e3/dL)*np.sqrt(2*p[4]/mass)/(2*np.pi)\\n [Depth,Xe,Ye,Ze] = trap_depth(U/charge,X,Y,Z,Irf,Jrf,Krf) \\n return [fx,fy,fz,theta,Depth,Xe,Ye,Ze]\",\n \"def performance(N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"\\\"I have produced two plots. The first one p24.png compares the time taken\\n by solveFlunet with the three different RHS methods. We notice that the fastest\\n technique is using the RHS computed in Python. This can be explained by the \\n fact that in Python we have vectorized our calculations whereas in Fortran\\n we used a loop for our calculations. Secondly, we also notice that solveFlunet \\n is faster using the Fortran OMP code than using the Fortran code. This\\n is expected since we use two threads with the Fortran OMP code instead of \\n only one with the regular Fortran code. The second plot p25.png provides\\n the speedup of the Fortran OMP RHS compared to the Fortran RHS.\\n The speedup is less than 1 for small values of Nt but increases as Nt\\n increases. It goes up to 1.6 for larger sized problems, which is quite\\n satisfying. We can expect that it the speedup to reach 2 for even larger\\n problem sizes.\\n \\\"\\\"\\\"\\n #I have added as inputs N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w to\\n #be able to call initialize and solveFluNet\\n Nt = Ntmax/10\\n dt = Ntmax/10\\n Ntu = np.zeros(10)\\n \\n #tpy,tf90 and tf90OMP are the times for our different RHS\\n #methods\\n tpy = np.zeros(10)\\n tf90 = np.zeros(10)\\n tf90OMP = np.zeros(10)\\n \\n #speedup is the speedup of the Fortran OMP RHS compared\\n #to the Fortran RHS\\n speedup = np.zeros(10)\\n \\n for i in range(10):\\n #compute initial conditions\\n init,infnode,P = initialize(N0,L,Nt,True)\\n N = N0+Nt\\n \\n #time solveFluNet for the three different RHS\\n t0 = time()\\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,1)\\n t1 = time()\\n tpy[i] = t1-t0\\n t0 = time()\\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,2)\\n t1 = time()\\n tf90[i] = t1-t0\\n t0 = time()\\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,3)\\n t1 = time()\\n tf90OMP[i] = t1-t0\\n \\n #time the two Fortran RHS methods\\n t0 = time()\\n fn.rhs(P,init,1,a,b0,b1,g,k,w)\\n tRHS = time() - t0\\n t0 = time()\\n fn.rhs_omp(P,init,1,a,b0,b1,g,k,w,2)\\n tRHSOMP = time() - t0\\n speedup[i] = tRHS/tRHSOMP\\n \\n Ntu[i] = Nt\\n Nt = Nt+dt\\n \\n plt.figure()\\n plt.plot(Ntu,tpy,label='Time with Python RHS')\\n plt.plot(Ntu,tf90,label='Time with Fortran RHS')\\n plt.plot(Ntu,tf90OMP,label='Time with Fortran OMP RHS')\\n plt.legend(loc='best')\\n plt.title('performance Mathilde Duverger')\\n plt.xlabel('Nt')\\n plt.ylabel('Time of solveFluNet')\\n \\n plt.figure()\\n plt.plot(Ntu,speedup,label='Speedup for RHS')\\n plt.legend(loc='best')\\n plt.title('performance Mathilde Duverger')\\n plt.xlabel('Nt')\\n plt.ylabel('Speedup of the Fortran OMP code compared to the Fortran code')\\n plt.show()\",\n \"def _plot_ctc(self, save_path=None, topk=10):\\n if self.ctc_weight == 0:\\n return\\n if len(self.ctc.prob_dict.keys()) == 0:\\n return\\n from matplotlib import pyplot as plt\\n if save_path is not None and os.path.isdir(save_path):\\n shutil.rmtree(save_path)\\n os.mkdir(save_path)\\n elen = self.ctc.data_dict['elens'][-1]\\n probs = self.ctc.prob_dict['probs'][-1, :elen]\\n topk_ids = np.argsort(probs, axis=1)\\n plt.clf()\\n n_frames = probs.shape[0]\\n times_probs = np.arange(n_frames)\\n plt.figure(figsize=(20, 8))\\n for idx in set(topk_ids.reshape(-1).tolist()):\\n if idx == 0:\\n plt.plot(times_probs, probs[:, 0], ':', label='<blank>', color='grey')\\n else:\\n plt.plot(times_probs, probs[:, idx])\\n plt.xlabel(u'Time [frame]', fontsize=12)\\n plt.ylabel('Posteriors', fontsize=12)\\n plt.xticks(list(range(0, int(n_frames) + 1, 10)))\\n plt.yticks(list(range(0, 2, 1)))\\n plt.tight_layout()\\n if save_path is not None:\\n plt.savefig(os.path.join(save_path, 'prob.png'))\\n plt.close()\",\n \"def eclatGeneration(self, cList):\\n # to generate all\\n tidList = {}\\n key = list(cList.keys())\\n for i in range(0, len(key)):\\n nighbousItems=self.getNighboirItems(key[i])\\n for j in range(i + 1, len(key)):\\n # print(c[key[i]],c[key[j]])\\n if not key[j] in nighbousItems:\\n \\tcontinue\\n intersectionList = list(set(cList[key[i]]).intersection(set(cList[key[j]])))\\n itemList = []\\n itemList += key[i]\\n itemList += key[j]\\n if len(intersectionList) >= self.minSup:\\n itemList.sort()\\n if tuple(itemList) not in tidList:\\n tidList[tuple(set(itemList))] = intersectionList\\n return tidList\",\n \"def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\\n\\n # def Q_gen(I, R):\\n # w = I * I * R\\n # return w\\n\\n # def Q_rad_in(I_sun, A_s, a_s):\\n # w = I_sun * D * a_s\\n # return w\\n\\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\\n # w = htcoeff * A_s * (T_line - T_amb)\\n # return w\\n\\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\\n # return w\\n\\n def reynolds(V, D, v, Mair=1.103):\\n r = V * D / v\\n return r\\n\\n def nusselt(Re, Pr):\\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\\n c = (Re / 282000) ** (5.0/8.0)\\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\\n return n\\n\\n def air_prop(T_amb):\\n # temp v k Pr\\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\\n [250, 11.44e-6, 22.3e-3, 0.720],\\n [300, 15.89e-6, 26.3e-3, 0.707],\\n [350, 20.92e-6, 30.0e-3, 0.700],\\n [400, 26.41e-6, 33.8e-3, 0.690],\\n [450, 32.39e-6, 37.3e-3, 0.686],\\n [500, 38.79e-6, 40.7e-3, 0.684],\\n [550, 45.57e-6, 43.9e-3, 0.683],\\n [600, 52.69e-6, 46.9e-3, 0.685]])\\n\\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\\n 0, air_prop[:,1:])\\n return v, k, Pr\\n\\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\\n if 273 <= T_line <= 323:\\n R = ((R_lo + \\n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\\n *(T_line - T_range[0]))/N_cond)\\n elif T_line > 323:\\n R = ((R_mid + \\n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\\n *(T_line - T_range[1]))/N_cond)\\n else:\\n R = R_lo\\n print('Out of bounds')\\n return R\\n\\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\\n temp_factor = 1\\n wind_factor = 1\\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\\n\\n T_amb = T_amb*temp_factor\\n V = V*wind_factor\\n\\n v, k, Pr = air_prop(T_amb)\\n Re = reynolds(V, D, v)\\n htcoeff = nusselt(Re, Pr) * k / D\\n\\n def T_line(T_init):\\n \\n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\\n print R\\n\\n C4 = e_s * sigma * D * math.pi\\n C3 = 0.0\\n C2 = 0.0\\n C1 = htcoeff * D * math.pi\\n C0 = - ( I ** 2 * R\\n + I_sun * a_s * D\\n + htcoeff * D * math.pi * T_amb\\n + e_s * D * math.pi * sigma * (T_amb ** 4))\\n\\n return np.roots([C4, C3, C2, C1, C0])\\n\\n T_c = T_amb\\n \\n for i in range(n_iter):\\n T_arr = T_line(T_c)\\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\\n print T_c\\n\\n return T_c\",\n \"def solve(list_k, examples, out_path, centers_=None,\\n conf_num=None, out_minus=True, out_iterations=False):\\n\\n # start_centers = utils.get_centers()\\n dimension = len(examples[0][0])\\n # print (dimension)\\n N = len(examples) # print(N)\\n for k in list_k:\\n # sys.stderr.write(str(k) + \\\"\\\\n\\\")\\n h = np.zeros((N, k), dtype=np.float64)\\n # responsibilities.fill(1/float(k))\\n pi_k = np.zeros(k, dtype=np.float64)\\n pi_k.fill(1/float(k))\\n # print\\n configuration = False\\n if centers_ == None:\\n centers = utils.get_centers(k, examples)\\n else:\\n centers = centers_\\n configuration = True\\n\\n matrix = np.identity(dimension, dtype=np.float64)\\n matrices = np.array([matrix] * k)\\n # print (matrices)\\n log = calc_log(examples, centers, matrices, pi_k)\\n # print (log)\\n\\n # output stuff\\n num_iter = 0\\n # if k == 4:\\n # groups = [list([])] * k\\n groups = []\\n for i in range(k):\\n groups.append([])\\n probabilities = dict()\\n\\n # if k == 4:\\n # print (h)\\n # print (pi_k)\\n # print (matrices)\\n # print (centers)\\n\\n if out_iterations:\\n iter_out = open(out_path + \\\"em-kmeans.dat\\\", \\\"w\\\")\\n iter_out.write(\\\"#iteracije: log-izglednost\\\\n\\\")\\n iter_out.write(\\\"--\\\\n\\\")\\n iter_out.write(\\\"#0: %.2lf\\\\n\\\" % log)\\n # buffer_all = \\\"K = %d\\\\n\\\" % k\\n # number of members in a certain group\\n\\n while True:\\n num_iter += 1\\n group_count = [0] * k\\n # init = dict()\\n group_dicts = []\\n for i in range(k):\\n group_dicts.append({})\\n # group_dicts = [] * k\\n # E step\\n # print (num_iter)\\n # changed = 0\\n for i in range(N):\\n x = examples[i][0]\\n mi_j = centers[0][0]\\n sigma_j = matrices[0]\\n p = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[0]\\n h[i][0] = p\\n sum_h = h[i][0]\\n probabilities[i] = p\\n group = examples[i][1]\\n if group not in group_dicts[0]:\\n group_dicts[0][group] = 1\\n else:\\n group_dicts[0][group] += 1\\n\\n # if p > \\n group_count[0] += 1\\n examples[i][2] = 0\\n\\n for j in range(1,k):\\n mi_j = centers[j][0]\\n sigma_j = matrices[j]\\n # print (sigma_j)\\n p2 = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[j]\\n if p2 > p:\\n group_count[examples[i][2]] -= 1\\n group_dicts[examples[i][2]][group] -= 1\\n if group not in group_dicts[j]:\\n group_dicts[j][group] = 1\\n else:\\n group_dicts[j][group] += 1\\n examples[i][2] = j\\n group_count[j] += 1\\n p = p2\\n probabilities[i] = p\\n\\n h[i][j] = p2\\n sum_h += h[i][j]\\n\\n h[i] /= sum_h\\n probabilities[i] /= sum_h\\n # print (\\\"$$$$$$$\\\")\\n # M step\\n # if num_iter == 1:\\n # print (h)\\n # sys.exit(1)\\n for i in range(k):\\n new_mi = np.zeros(dimension, dtype=np.float64)\\n sum_h = 0.\\n new_sigma = np.zeros((dimension, dimension), dtype=np.float64)\\n\\n for j in range(N):\\n x = examples[j][0]\\n sum_h += h[j][i]\\n new_mi += h[j][i] * x\\n\\n new_mi /= sum_h\\n # if utils.euclid(new_mi, centers[i][0]) > EPS:\\n # changed = 1\\n centers[i] = (new_mi, centers[i][1], centers[i][2])\\n\\n # mi = np.matrix(new_mi)\\n mi = new_mi\\n for j in range(N):\\n x = examples[j][0]\\n # print ((x-mi).T * (x - mi))\\n diff = np.matrix(x - mi)\\n # print (diff.T * diff)\\n new_sigma += h[j][i] * (diff.T * diff)\\n # break\\n\\n new_sigma /= sum_h\\n matrices[i] = new_sigma\\n new_pi = sum_h / float(N)\\n pi_k[i] = new_pi\\n\\n # print (matrices)\\n # if num_iter == 1:\\n # sys.exit(1)\\n\\n new_log = calc_log(examples, centers, matrices, pi_k)\\n\\n # print (new_log)\\n if abs(new_log - log) < EPS:\\n break\\n log = new_log\\n # if k == 4:\\n # print (log)\\n if out_iterations:\\n iter_out.write(\\\"#%d: %.2lf\\\\n\\\" % (num_iter, log))\\n # if changed == 0:\\n # break\\n\\n # set the groups for K = 4\\n # print (groups)\\n if not configuration and not out_iterations:\\n if k == 4:\\n for i in range(N):\\n # print (examples[i][2])\\n # print (groups)\\n groups[examples[i][2]].append((examples[i][1], probabilities[i]))\\n\\n with open(out_path + \\\"/em-k4.dat\\\", \\\"a\\\") as f:\\n for i in range(k):\\n # print (len(groups[i]))\\n groups[i] = sorted(groups[i], key=lambda tup: tup[1], reverse=True)\\n f.write(\\\"Grupa %d:\\\\n\\\" % (i+1))\\n for j in range(len(groups[i])):\\n f.write(groups[i][j][0] + \\\" %.2lf\\\\n\\\" % groups[i][j][1])\\n if i < k-1:\\n f.write(\\\"--\\\\n\\\")\\n\\n with open(out_path + \\\"/em-all.dat\\\", \\\"a\\\") as f:\\n f.write(\\\"K = %d\\\\n\\\" % k)\\n for i in range(k):\\n f.write(\\\"c%d:\\\" % (i+1))\\n for j in range(dimension):\\n f.write(\\\" %.2lf\\\" % centers[i][0][j])\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"grupa %d: %d primjera\\\\n\\\" % ((i+1), group_count[i]))\\n f.write(\\\"#iter: %d\\\\n\\\" % num_iter)\\n f.write(\\\"log-izglednost: %.2lf\\\\n\\\" % log)\\n if k < 5:\\n f.write(\\\"--\\\\n\\\")\\n elif not out_iterations:\\n with open(out_path + \\\"/em-konf.dat\\\", \\\"a\\\") as f:\\n f.write(\\\"Konfiguracija %d:\\\\n\\\" % conf_num)\\n f.write(\\\"log-izglednost: %.2lf\\\\n\\\" % log)\\n f.write(\\\"#iteracija: %d\\\\n\\\" % num_iter)\\n if out_minus == True:\\n f.write(\\\"--\\\\n\\\")\\n # if i < k - 1:\\n else:\\n iter_out.write(\\\"--\\\\n\\\")\\n for i in range(len(group_dicts)):\\n iter_out.write(\\\"Grupa %d:\\\" % (i+1))\\n buff = \\\"\\\"\\n for key in group_dicts[i]:\\n buff += \\\" \\\" + key + \\\" %d\\\" % group_dicts[i][key] + \\\",\\\"\\n\\n buff = buff[:-1]\\n iter_out.write(buff + \\\"\\\\n\\\")\\n # pass\",\n \"def heatbasic(u0,T,K):\\n import numpy as np\\n N = len(u0)-1\\n\\n dx = 1.0/N;\\n dt = 0.1/K;\\n x = np.linspace(0,1,N+1)\\n\\n u = np.copy(u0)\\n\\n u_history = [u]\\n\\n A = np.zeros( (N+1,N+1) )\\n for i in range(1,N):\\n A[i,i-1] = 1;\\n A[i,i] = -2;\\n A[i,i+1] = 1\\n A = A * dt/(dx*dx)\\n A = A + np.eye(N+1)\\n A[0,0] = 0.0;\\n A[N,N] = 0.0;\\n\\n for k in range(K):\\n u = np.dot(A,u)\\n u_history.append(u)\\n\\n return u_history\",\n \"def decision_heatmaps(obs):\\n global model\\n assert obs > 4 and obs < 1788, \\\"Chosen observation is outside the range of the demonstration episode.\\\"\\n saved_observations = np.load('saved_observations.npy')\\n state = saved_observations[obs-3:obs+1]\\n state_batch = np.expand_dims(state, axis=0)\\n q_vals = model.compute_q_values(state)\\n print(q_vals)\\n decision = np.argmax(q_vals)\\n print(decision)\\n decision_encodings = ['None','Up','Right','Left','Down','Right-Up','Left-Up','Right-Down','Left-Down']\\n decision_node = model.model.output[:, decision]\\n last_conv_layer = model.model.layers[3]\\n grads = K.gradients(decision_node, last_conv_layer.output)[0]\\n pooled_grads = K.mean(grads, axis=(0,2,3))\\n frame = Image.fromarray(state[-1])\\n iterate = K.function([model.model.input],[pooled_grads, last_conv_layer.output[0]])\\n pooled_grads_value, conv_layer_output_value = iterate([state_batch])\\n for i in range(64):\\n conv_layer_output_value[i, :, :] *= pooled_grads_value[i]\\n\\n heatmap = np.mean(conv_layer_output_value, axis=0)\\n heatmap = np.maximum(heatmap, 0)\\n heatmap /= np.max(heatmap)\\n heatmap = cv2.resize(heatmap, (84, 84))\\n heatmap = np.uint8(255 * heatmap)\\n superimposed_img = heatmap * .3 + np.array(frame) * .35\\n\\n plt.xlabel(decision_encodings[decision])\\n plt.imshow(superimposed_img, cmap='gray')\\n plt.show()\",\n \"def lac(X, conts, k, nsteps=30, window_size=1):\\n dim = len(conts)\\n\\n #np.random.seed(42)\\n # Initialize parameters\\n priors = np.ones(k) / k\\n\\n\\n import sys; sys.stdout.flush()\\n if X is not None:\\n means, covars = initialize_sample_kmeans(X, k)\\n else:\\n means, covars = initialize_random(conts, k)\\n\\n #means, covars = initialize_kmeans(conts, k)\\n\\n w = [np.empty((k, len(c[0]),)) for c in conts]\\n\\n\\n for i in range(1, nsteps + 1):\\n for l, (c, cw) in enumerate(conts):\\n lower = l - window_size if l - window_size >= 0 else None\\n upper = l + window_size + 1 if l + window_size + 1 <= dim else None\\n dims = slice(lower, upper)\\n active_dim = min(l, window_size)\\n\\n x = c\\n\\n # E step\\n for j in range(k):\\n if any(np.abs(covars[j, dims]) < 1e-15):\\n assert False, 'covars should be fixed'\\n\\n det = covars[j, dims].prod()\\n inv_covars = 1. / covars[j, dims]\\n xn = x - means[j, dims]\\n factor = (2.0 * np.pi) ** (x.shape[1]/ 2.0) * det ** 0.5\\n w[l][j] = priors[j] * np.exp(np.sum(xn * inv_covars * xn, axis=1) * -.5) / factor\\n wsum = w[l].sum(axis=0)\\n wsum[wsum == 0] = 1.\\n w[l] /= wsum\\n\\n # M step\\n n = np.sum(w[l], axis=1)\\n priors = n / np.sum(n)\\n for j in range(k):\\n if n[j]:\\n mu = np.dot(w[l][j, :] * cw, x[:, active_dim]) / (w[l][j, :] * cw).sum()\\n\\n xn = x[:, active_dim] - mu\\n sigma = np.sum(xn ** 2 * w[l][j] * cw, axis=0) / (w[l][j, :] * cw).sum()\\n sigma = sigma if sigma > 1e-3 else 1e-3\\n\\n if np.isnan(mu).any() or np.isnan(sigma).any():\\n return w, means, covars, priors\\n else:\\n mu = means[j, l]\\n sigma = MIN_COVARIANCE\\n means[j, l] = mu\\n covars[j, l] = sigma\\n\\n # w = np.zeros((k, m))\\n # for j in range(k):\\n # if active[j]:\\n # det = covars[j].prod()\\n # inv_covars = 1. / covars[j]\\n # xn = X - means[j]\\n # factor = (2.0 * np.pi) ** (xn.shape[1] / 2.0) * det ** 0.5\\n # w[j] = priors[j] * exp(-.5 * np.sum(xn * inv_covars * xn, axis=1)) / factor\\n # w[active] /= w[active].sum(axis=0)\\n\\n return w, means, covars, priors\",\n \"def __init__(self, num_heads: int, size: int, size_v: int, dropout: float = 0.1):\\n super(ContMultiHeadedAttention, self).__init__()\\n\\n assert size % num_heads == 0\\n\\n self.head_size = head_size = size // num_heads\\n self.model_size = size\\n self.num_heads = num_heads\\n\\n self.k_layer = nn.Linear(size, num_heads * head_size)\\n self.v_layer = nn.Linear(size_v, num_heads * head_size)\\n self.q_layer = nn.Linear(size, num_heads * head_size)\\n\\n self.output_layer = nn.Linear(size, size_v)\\n self.softmax = nn.Softmax(dim=-1)\\n self.dropout = nn.Dropout(dropout)\",\n \"def cvstem(self):\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Cfun).parameters) == 1):\\n fun1 = self.Cfun\\n self.Cfun = lambda x,p: fun1(x)\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Gw).parameters) == 1):\\n fun2 = self.Gw\\n self.Gw = lambda x,p: fun2(x)\\n if self.iEC == \\\"est\\\":\\n self.c_over = self.matrix_2bound(self.Cfun)\\n self.g_over = self.matrix_2bound(self.Gw)\\n if (len(sig(self.Bw).parameters) == 1):\\n fun3 = self.Bw\\n self.Bw = lambda x,p: fun3(x)\\n self.b_over = self.matrix_2bound(self.Bw)\\n self.linesearch()\\n alp = self.alp_opt\\n Nx = self.Nx\\n Nsplit = 1\\n Np = int(Nx/Nsplit)\\n Nr = np.remainder(Nx,Nsplit)\\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\\n Nxp = self.n+self.n_p\\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\\n Ws_opt = []\\n chi_opt = 0\\n nu_opt = 0\\n print(\\\"========================================================\\\")\\n print(\\\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\\\")\\n print(\\\"========================================================\\\")\\n for p in range(Np):\\n if np.remainder(p,int(Np/10)) == 0:\\n print(\\\"# sampled metrics: \\\",p*Nsplit,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n if Nr != 0:\\n print(\\\"# samples metrics: \\\",Nx,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n self.xs_opt = xs_opt\\n self.ps_opt = ps_opt\\n self.Ws_opt = Ws_opt\\n self.chi_opt = chi_opt\\n self.nu_opt = nu_opt\\n if self.iEC == \\\"est\\\":\\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\\n print(\\\"Optimal steady-state estimation error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n elif self.iEC == \\\"con\\\":\\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\\n print(\\\"Optimal steady-state tracking error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n else:\\n raise ValueError('Invalid iEC: iEC = \\\"est\\\" or \\\"con\\\"')\\n self.M2cholM()\\n path = \\\"models/optvals/\\\"+self.fname\\n if os.path.exists(path) == False:\\n try:\\n os.makedirs(path)\\n except: \\n raise OSError(\\\"Creation of directory %s failed\\\" %path)\\n else:\\n print (\\\"Successfully created directory %s \\\" %path)\\n else:\\n print (\\\"Directory %s already exists\\\" %path)\\n np.save(path+\\\"/alp_opt.npy\\\",alp)\\n np.save(path+\\\"/chi_opt.npy\\\",self.chi_opt)\\n np.save(path+\\\"/nu_opt.npy\\\",self.nu_opt)\\n np.save(path+\\\"/Jcv_opt.npy\\\",self.Jcv_opt)\\n print(\\\"========================================================\\\")\\n print(\\\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\\\")\\n print(\\\"========================================================\\\\n\\\\n\\\")\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7132348","0.6019964","0.57076234","0.5255491","0.5208966","0.50486803","0.49962127","0.49387914","0.48546904","0.47602648","0.4752867","0.47441545","0.47350878","0.47301233","0.4673184","0.46208584","0.46154496","0.46078372","0.45996413","0.45746738","0.45490754","0.45487642","0.45442307","0.45353246","0.45340708","0.45209375","0.45183653","0.45058867","0.45010424","0.44981733","0.44851926","0.44656497","0.44509873","0.44371048","0.44345427","0.44291908","0.44286814","0.44209436","0.44200638","0.44110748","0.44091466","0.4407582","0.4403442","0.439916","0.4396259","0.437807","0.4375097","0.43715245","0.4356215","0.4343306","0.4343306","0.43326208","0.43325734","0.43321744","0.43270874","0.43268585","0.4323852","0.43165988","0.42950383","0.4294074","0.42903143","0.42874303","0.4275606","0.42675236","0.42653394","0.42624202","0.42611057","0.42589846","0.42559046","0.42544034","0.42536873","0.42438206","0.42428976","0.42371258","0.4236766","0.42359596","0.42349106","0.4234269","0.4228184","0.42243233","0.42227823","0.42227823","0.4222717","0.42064938","0.4206103","0.42060298","0.4205462","0.42053246","0.42026618","0.42003202","0.41970915","0.41881278","0.41880113","0.41861087","0.4184006","0.4180094","0.41717935","0.41710275","0.4166868","0.41650277"],"string":"[\n \"0.7132348\",\n \"0.6019964\",\n \"0.57076234\",\n \"0.5255491\",\n \"0.5208966\",\n \"0.50486803\",\n \"0.49962127\",\n \"0.49387914\",\n \"0.48546904\",\n \"0.47602648\",\n \"0.4752867\",\n \"0.47441545\",\n \"0.47350878\",\n \"0.47301233\",\n \"0.4673184\",\n \"0.46208584\",\n \"0.46154496\",\n \"0.46078372\",\n \"0.45996413\",\n \"0.45746738\",\n \"0.45490754\",\n \"0.45487642\",\n \"0.45442307\",\n \"0.45353246\",\n \"0.45340708\",\n \"0.45209375\",\n \"0.45183653\",\n \"0.45058867\",\n \"0.45010424\",\n \"0.44981733\",\n \"0.44851926\",\n \"0.44656497\",\n \"0.44509873\",\n \"0.44371048\",\n \"0.44345427\",\n \"0.44291908\",\n \"0.44286814\",\n \"0.44209436\",\n \"0.44200638\",\n \"0.44110748\",\n \"0.44091466\",\n \"0.4407582\",\n \"0.4403442\",\n \"0.439916\",\n \"0.4396259\",\n \"0.437807\",\n \"0.4375097\",\n \"0.43715245\",\n \"0.4356215\",\n \"0.4343306\",\n \"0.4343306\",\n \"0.43326208\",\n \"0.43325734\",\n \"0.43321744\",\n \"0.43270874\",\n \"0.43268585\",\n \"0.4323852\",\n \"0.43165988\",\n \"0.42950383\",\n \"0.4294074\",\n \"0.42903143\",\n \"0.42874303\",\n \"0.4275606\",\n \"0.42675236\",\n \"0.42653394\",\n \"0.42624202\",\n \"0.42611057\",\n \"0.42589846\",\n \"0.42559046\",\n \"0.42544034\",\n \"0.42536873\",\n \"0.42438206\",\n \"0.42428976\",\n \"0.42371258\",\n \"0.4236766\",\n \"0.42359596\",\n \"0.42349106\",\n \"0.4234269\",\n \"0.4228184\",\n \"0.42243233\",\n \"0.42227823\",\n \"0.42227823\",\n \"0.4222717\",\n \"0.42064938\",\n \"0.4206103\",\n \"0.42060298\",\n \"0.4205462\",\n \"0.42053246\",\n \"0.42026618\",\n \"0.42003202\",\n \"0.41970915\",\n \"0.41881278\",\n \"0.41880113\",\n \"0.41861087\",\n \"0.4184006\",\n \"0.4180094\",\n \"0.41717935\",\n \"0.41710275\",\n \"0.4166868\",\n \"0.41650277\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6103077"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88350,"cells":{"query":{"kind":"string","value":"Fit `Nvib` harmonic oscillator and `Nrot` hindered internal rotor modes to the provided dimensionless heat capacities `Cvlist` at temperatures `Tlist` in K. This method assumes that there are enough heat capacity points provided that the vibrational frequencies can be fit directly, but the hindered rotors must be combined into a single \"pseudorotor\"."},"document":{"kind":"string","value":"def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # Bounds for harmonic oscillator frequencies\n for i in range(Nvib):\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # Bounds for pseudo-hindered rotor frequency and barrier height\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n # Initial guesses within each mode type must be distinct or else the\n # optimization will fail\n x0 = numpy.zeros(Nvib + 2, numpy.float64)\n # Initial guess for harmonic oscillator frequencies\n if Nvib > 0:\n x0[0] = 200.0\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\n # Initial guess for hindered rotor frequencies and barrier heights\n x0[Nvib] = 100.0\n x0[Nvib+1] = 300.0\n\n # Execute the optimization\n fit = PseudoRotorFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n vib = list(x[0:Nvib])\n hind = []\n for i in range(Nrot):\n hind.append((x[Nvib], x[Nvib+1]))\n\n return vib, hind"},"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 fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # Bounds for harmonic oscillator frequencies\n for i in range(Nvib):\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # Bounds for hindered rotor frequencies and barrier heights\n for i in range(Nrot):\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n # Initial guesses within each mode type must be distinct or else the\n # optimization will fail\n x0 = numpy.zeros(Nvib + 2*Nrot, numpy.float64)\n # Initial guess for harmonic oscillator frequencies\n if Nvib > 0:\n x0[0] = 200.0\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\n # Initial guess for hindered rotor frequencies and barrier heights\n if Nrot > 0:\n x0[Nvib] = 100.0\n x0[Nvib+1] = 100.0\n for i in range(1, Nrot):\n x0[Nvib+2*i] = x0[Nvib+2*i-2] + 20.0\n x0[Nvib+2*i+1] = x0[Nvib+2*i-1] + 100.0\n\n # Execute the optimization\n fit = DirectFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n vib = list(x[0:Nvib])\n hind = []\n for i in range(Nrot):\n hind.append((x[Nvib+2*i], x[Nvib+2*i+1]))\n\n return vib, hind","def fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # x[0] corresponds to the first harmonic oscillator (real) frequency\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # x[1] corresponds to the degeneracy of the second harmonic oscillator\n bounds.append((1.0, float(Nvib - 2)))\n # x[2] corresponds to the second harmonic oscillator pseudo-frequency\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # x[3] corresponds to the third harmonic oscillator pseudo-frequency\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # x[4] corresponds to the hindered rotor pseudo-frequency\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n # x[5] corresponds to the hindered rotor pseudo-barrier\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n x0 = numpy.zeros(6, numpy.float64) # Initial guess\n x0[0] = 300.0\n x0[1] = float(math.floor((Nvib - 1) / 2.0))\n x0[2] = 800.0\n x0[3] = 1600.0\n x0[4] = 100.0\n x0[5] = 300.0\n\n # Execute the optimization\n fit = PseudoFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n Nvib2 = int(round(x[1]))\n Nvib3 = Nvib - Nvib2 - 1\n if Nvib2 < 0 or Nvib2 > Nvib-1 or Nvib3 < 0 or Nvib3 > Nvib-1:\n raise StatmechFitError('Invalid degeneracies {0} and {1} fitted for pseudo-frequencies.'.format(Nvib2, Nvib3))\n\n vib = [x[0]]\n for i in range(Nvib2): vib.append(x[2])\n for i in range(Nvib3): vib.append(x[3])\n hind = []\n for i in range(Nrot):\n hind.append((x[4], x[5]))\n\n return vib, hind","def define_potts_helper_functions(k):\n\n @njit\n def calc_observables(X, k=k):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n\n Returns\n -------\n ndarray\n Dimensions (n_samples, n_observables).\n \"\"\"\n\n n = X.shape[1]\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\n \n # average orientation (magnetization)\n # note that fields for the third state are often set to 0\n counter = 0\n for i in range(k):\n for j in range(n):\n Y[:,counter] = X[:,j]==i\n counter += 1\n \n # pairwise correlations\n for i in range(n-1):\n for j in range(i+1, n):\n Y[:,counter] = X[:,i]==X[:,j]\n counter += 1\n \n return Y\n\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n multipliers : ndarray of dtype np.float64\n\n Returns\n -------\n ndarray\n Energies of each observable.\n \"\"\"\n\n return -calc_observables(X, k).dot(multipliers)\n\n def mch_approximation(sample, dlamda, calc_e=calc_e):\n \"\"\"Function for making MCH approximation step for Potts model.\n \n Parameters\n ----------\n sample : ndarray\n Of dimensions (n_sample, n_spins).\n dlamda : ndarray\n Change in parameters.\n \n Returns\n -------\n ndarray\n Predicted correlations.\n \"\"\"\n\n dE = calc_e(sample, dlamda)\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \n assert not ((predsisj<0).any() or\n (predsisj>(1+1e-10)).any()),\"Predicted values are beyond limits, (%E,%E)\"%(predsisj.min(),\n predsisj.max())\n return predsisj\n\n return calc_e, calc_observables, mch_approximation","def specific_heat(Ekinv,n0,N,t0):\n Cv = np.zeros(10)\n for i in range(10):\n avg_K_squared = (1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]))**2\n FluctK = 1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]**2) - avg_K_squared\n Cv[i] = -1 / (FluctK/ avg_K_squared * 3 * N / 2 - 1) * 3 * N / 2\n return Cv","def weak_repulsion(Cents,a,k, CV_matrix,n_c,L):\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\n displacement = np.mod(Cents - CCW + L/2,L) - L/2\n rij = np.sqrt(displacement[:,:,0]**2 + displacement[:,:,1]**2)\n norm_disp = (displacement.T/rij.T).T\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\n V_soft = V_soft_CW + V_soft_CCW\n F_soft = np.zeros((n_c, 2))\n for i in range(3):\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\n return F_soft","def weak_repulsion_boundary(Cents,a,k, CV_matrix,n_c,n_C):\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\n CCW_displacement = Cents - CCW\n rij = np.sqrt(CCW_displacement[:,:,0]**2 + CCW_displacement[:,:,1]**2)\n norm_disp = (CCW_displacement.T/rij.T).T\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\n V_soft = V_soft_CW + V_soft_CCW\n F_soft = np.zeros((n_c, 2))\n for i in range(3):\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\n F_soft[n_C:] = 0\n return F_soft","def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\n # We move from an array to a list of 2d-array for the competition over each template:\n\n cp=cps[0]\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\n new_cp = 1\n\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\n # update for fixed point:\n new_cp += w_inpIdx*x_eq\n # saving values\n layerEq[inpIdx] = x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n layerEq[inpIdx] = x_eq\n\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n new_cp += Inhib2/(E0*cp)*x_eq\n\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\n diff_cps = np.zeros(cps.shape)\n if new_cp>=1:\n diff_cps[0] = cp - new_cp\n else:\n diff_cps[0] = 10**3\n for l,m in enumerate(masks):\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\n return diff_cps","def non_max_suppression_kneron(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\n if prediction.dtype is torch.float16:\n prediction = prediction.float() # to FP32\n\n nc = prediction[0].shape[1] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Settings\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_det = 300 # maximum number of detections per image\n time_limit = 10.0 # seconds to quit after\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\n\n t = time.time()\n output = [None] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n\n\n # If none remain process next image\n n = x.shape[0] # number of boxes\n if not n:\n continue\n\n # Sort by confidence\n # x = x[x[:, 4].argsort(descending=True)]\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n # Sort by confidence\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\n x = x[ind_Sort_by_confidence][:top_k_num] #\n # cross classes nms\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n break # time limit exceeded\n\n return output","def error_specific_heat(Cv):\n ncv = 10\n tcv = np.linspace(0,50,ncv) \n \n chi = auto_correlation(tcv,Cv,ncv)\n tau_fit = curve_fit(exp,tcv,chi)\n tau = tau_fit[0]\n\n error_Cv = error(tau,ncv,Cv,tcv) \n\n return error_Cv","def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\n # get activation for each seperated vc\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\n max_ch_index = max_ch_index.view(-1, L) # n, L\n\n all_activation_vcs = []\n\n for i in range(len(integrate_activation_vc)):\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\n all_activation_vcs.append(integrate_activation_vc_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n print(f\"unique_vc_i {unique_vc_i.shape}\")\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\n activate_vc_i[index_vc_i, :] = 0.\n all_activation_vcs.append(activate_vc_i)\n \n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\n \n # decompose each mask \n all_masks = []\n for i in range(len(sim_map_max)):\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\n all_masks.append(sim_map_max_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\n vc_sim_map_max_i[index_vc_i] = 0.\n all_masks.append(vc_sim_map_max_i)\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\n\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\"\n\n return all_activation_vcs, all_masks","def grid_visibilities_parallel(self, visibilities,min_attenuation = 1e-10, N = 120):\n\n #Find out the number of frequencies to process per thread\n nfreq = len(self.frequencies)\n numperthread = int(np.ceil(nfreq/self.n_obs))\n offset = 0\n nfreqstart = np.zeros(self.n_obs,dtype=int)\n nfreqend = np.zeros(self.n_obs,dtype=int)\n infreq = np.zeros(self.n_obs,dtype=int)\n for i in range(self.n_obs):\n nfreqstart[i] = offset\n nfreqend[i] = offset + numperthread\n\n if(i==self.n_obs-1):\n infreq[i] = nfreq - offset\n else:\n infreq[i] = numperthread\n\n offset+=numperthread\n\n # Set the last process to the number of frequencies\n nfreqend[-1] = nfreq\n\n processes = []\n\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\n \n centres = (ugrid[1:] + ugrid[:-1]) / 2\n \n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\n\n\n if(os.path.exists(self.datafile[0][:-4]+\".kernel_weights.npy\")):\n kernel_weights = np.load(self.datafile[0][:-4]+\".kernel_weights.npy\")\n else:\n kernel_weights=None\n \n if kernel_weights is None:\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\n\n visgrid_buff_real = []\n visgrid_buff_imag = []\n weights_buff = []\n\n #Lets split this array up into chunks\n for i in range(self.n_obs):\n\n visgrid_buff_real.append(multiprocessing.RawArray(np.sctype2char(visgrid.real),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\n visgrid_buff_imag.append(multiprocessing.RawArray(np.sctype2char(visgrid.imag),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\n visgrid_tmp_real = np.frombuffer(visgrid_buff_real[i])\n visgrid_tmp_imag = np.frombuffer(visgrid_buff_imag[i])\n visgrid_tmp_real = visgrid[:,:,nfreqstart[i]:nfreqend[i]].real.flatten()\n visgrid_tmp_imag = visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag.flatten()\n\n\n if(kernel_weights is None):\n weights_buff.append(multiprocessing.RawArray(np.sctype2char(weights),weights[:,:,nfreqstart[i]:nfreqend[i]].size))\n weights_tmp = np.frombuffer(weights_buff[i])\n weights_tmp = weights[:,:,nfreqstart[i]:nfreqend[i]]\n else:\n weights_buff.append(None)\n\n processes.append(multiprocessing.Process(target=self._grid_visibilities_buff,args=(self.n_uv,visgrid_buff_real[i],visgrid_buff_imag[i],weights_buff[i], visibilities[:,nfreqstart[i]:nfreqend[i]],self.frequencies[nfreqstart[i]:nfreqend[i]],self.baselines,centres,self._instr_core.sigma(self.frequencies[nfreqstart[i]:nfreqend[i]]),min_attenuation, N) ))\n\n for p in processes:\n p.start()\n\n for p in processes:\n p.join()\n\n for i in range(self.n_obs):\n\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].real = np.frombuffer(visgrid_buff_real[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag = np.frombuffer(visgrid_buff_imag[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n\n if(kernel_weights is None):\n weights[:,:,nfreqstart[i]:nfreqend[i]] = np.frombuffer(weights_buff[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n\n if kernel_weights is None:\n kernel_weights = weights\n \n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\n\n return visgrid,kernel_weights","def Boltzchoice(LFnum, energylist, RNs):\n # transform list to energy values in kT according to experimental\n # affinities and the energy window allowed by the threshold\n energylist = cf.y0 + np.array(energylist) * cf.m\n # calculate norm of initial list\n Norm = sum([math.exp(-ener) for ener in energylist])\n # calculate initial probability vector\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\n # list to catch indices of selected cells\n selected = []\n # cells to be picked: determined by the lesser of #waiters and #LFs\n cellpick = min(len(energylist), LFnum)\n while len(selected) < cellpick:\n bins = np.cumsum(probs)\n ind = np.digitize(RNs.getR(), bins)\n selected.append(ind)\n # now, set the probability of the selected cell to 0 and renormalise\n # the remaining probability vector\n newNorm = Norm - math.exp(-energylist[ind])\n probs[ind] = 0\n probs = probs * Norm / newNorm\n Norm = newNorm\n\n return selected","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def define_pseudo_potts_helper_functions(n, k):\n\n assert n>1\n assert k>1\n\n @njit\n def get_multipliers_r(r, multipliers, n=n, k=k):\n \"\"\"Return r's field and all couplings to spin r.\n\n Parameters\n ----------\n r : int\n multipliers : ndarray\n All fields and couplings concatenated together.\n\n Returns\n -------\n ndarray\n Relevant multipliers.\n list\n Index of where multipliers appear in full multipliers array.\n \"\"\"\n \n ix = [r+n*i for i in range(k)]\n multipliersr = np.zeros(k-1+n)\n for i in range(k):\n multipliersr[i] = multipliers[r+n*i]\n\n # fill in the couplings\n ixcounter = k\n for i in range(n):\n if i!=r:\n if i<r:\n ix.append( sub_to_ind(n, i, r) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n else:\n ix.append( sub_to_ind(n, r, i) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n ixcounter += 1\n return multipliersr, ix\n\n @njit\n def calc_observables_r(r, X, n=n, k=k):\n \"\"\"Return the observables relevant for calculating the conditional probability of\n spin r.\n\n Parameters\n ----------\n r : int\n Spin index.\n X : ndarray\n Data samples of dimensions (n_samples, n_dim).\n\n Returns\n -------\n ndarray\n observables\n list of ndarray\n observables if spin r were to occupy all other possible states\n ndarray\n Each col details the occupied by spin r in each array of the previous return\n value, i.e., the first col of this array tells me what r has been changed to\n in the first array in the above list.\n \"\"\"\n\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n # keep another copy of observables where the spin iterates thru all other possible states\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n for i in range(k-1)]\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\n \n # for each data sample in X\n for rowix in range(X.shape[0]):\n counter = 0\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\n for i in range(k):\n if X[rowix,r]==i:\n obs[rowix,i] = 1\n else:\n otherobs[counter][rowix,i] = 1\n otherstates[rowix,counter] = i\n counter += 1\n ixcounter = k\n \n for i in range(n-1):\n for j in range(i+1,n):\n if i==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\n kcounter += 1\n ixcounter += 1\n elif j==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\n kcounter += 1\n ixcounter += 1\n return obs, otherobs, otherstates\n\n return get_multipliers_r, calc_observables_r","def CLOMPR(task,sketch,featureMap,K,bounds,dimensions_to_consider=None, nb_cat_per_dim=None,nIterations=None, nRepetitions=1, ftol=1e-6, verbose=0 ):\n\n ## 0) Defining all the tools we need\n ####################################\n ## 0.1) Handle input\n\n ## 0.1.1) task name\n if task.lower() in [\"km\",\"ckm\",\"kmeans\",\"k-means\"]:\n task = \"kmeans\"\n task_finetuning = \"kmeans\"\n elif task.lower() in [\"gmm\",\"gaussian mixture model\"]:\n task = \"gmm\"\n task_finetuning = \"gmm\"\n elif task.lower() in [\"gmm-nondiag\"]:\n task = \"gmm\"\n task_finetuning = \"gmm-nondiag\"\n else:\n raise ValueError('The task argument does not match one of the available options.')\n\n ## 0.1.2) sketch feature function\n if isinstance(featureMap,SimpleFeatureMap):\n d_all = featureMap.d\n m = featureMap.m\n else:\n raise ValueError('The featureMap argument does not match one of the supported formats.')\n\n # Restrict the dimension\n if dimensions_to_consider is None:\n dimensions_to_consider = np.arange(d_all)\n dimensions_to_ignore = np.delete(np.arange(d_all), dimensions_to_consider)\n d = dimensions_to_consider.size\n \n # Pre-compute sketch of unused dimensions\n z_to_ignore = fourierSketchOfBox(bounds.T,featureMap,nb_cat_per_dim, dimensions_to_consider = dimensions_to_ignore)\n # Compensate the normalization constant and the dithering which will be taken into account in the centroid sketch\n z_to_ignore = z_to_ignore/(featureMap(np.zeros(d_all))) # giving zeros yields the dithering and the c_norm\n \n # Restrict the featureMap for the centroids\n Phi = copy(featureMap) # Don't touch to the inital map, Phi is featureMap restricted to relevant dims\n Phi.d = d\n Phi.Omega = featureMap.Omega[dimensions_to_consider]\n \n ## 0.1.3) nb of iterations\n if nIterations is None:\n nIterations = 2*K # By default: CLOMP-*R* (repeat twice)\n \n ## 0.1.4) Bounds of the optimization problems\n if bounds is None:\n lowb = -np.ones(d) # by default data is assumed normalized\n uppb = +np.ones(d)\n if verbose > 0: print(\"WARNING: data is assumed to be normalized in [-1,+1]^d\")\n else:\n lowb = bounds[0][dimensions_to_consider]\n uppb = bounds[1][dimensions_to_consider] # Bounds for one centroid\n\n # Format the bounds for the optimization solver\n if task_finetuning == \"kmeans\":\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the centroids\n elif task_finetuning == \"gmm\":\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\n elif task_finetuning == \"gmm-nondiag\":\n # Usual bounds of GMM\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\n \n # Bounds for the nondiagonal problem\n boundstheta_finetuning = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n varianceUpperBound = ((uppb-lowb).max()/2)**2\n\n _lowb_var = -varianceUpperBound*np.ones((d,d))\n np.fill_diagonal(_lowb_var, varianceLowerBound)\n _uppb_var = +varianceUpperBound*np.ones((d,d))\n\n _boundsvar = np.append(_lowb_var.reshape(-1),_uppb_var.reshape(-1)).reshape(2,d**2).T.tolist()\n for _i in _boundsvar: boundstheta_finetuning.append(_i) # bounds for the variance\n \n\n ## 0.1.5) Misc. initializations\n # Chosen method for the optimization solver\n opt_method = 'L-BFGS-B' # could also consider 'TNC'\n # Separated real and imaginary part of the sketch\n sketch_ri = np.r_[sketch.real, sketch.imag]\n if task == \"kmeans\":\n thetadim = d\n elif task == \"gmm\":\n thetadim = 2*d\n elif task == \"gmm-nondiag\":\n thetadim = d*(d+1)\n\n\n ## THE ACTUAL ALGORITHM\n #######################\n bestResidualNorm = np.inf \n bestTheta = None\n bestalpha = None\n for iRun in range(nRepetitions):\n \n ## 1) Initialization\n r = sketch # residual\n Theta = np.empty([0,thetadim]) # Theta is a nbAtoms-by-atomDimension array\n A = np.empty([m,0]) # Contains the sketches of the atoms\n\n ## 2) Main optimization\n for i in range(nIterations):\n ## 2.1] Step 1 : find new atom theta most correlated with residual\n # Initialize the new atom\n if task == \"kmeans\":\n th_0 = np.random.uniform(lowb,uppb)\n elif task == \"gmm\":\n mu0 = np.random.uniform(lowb,uppb) # initial mean\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\n th_0 = _stackAtom(\"gmm\",mu0,sig0)\n \n elif task == \"gmm-nondiag\":\n # Solve once for diagonal\n mu0 = np.random.uniform(lowb,uppb) # initial mean\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\n th_0 = _stackAtom(\"gmm\",mu0,sig0)\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(\"gmm\",Phi,th,r,z_to_ignore,verbose),\n x0 = th_0, method=opt_method, jac=True,\n bounds=boundstheta_gmm)\n\n (mu0,sig0) = _destackAtom(\"gmm\",sol.x,d)\n\n th_0 = _stackAtom(\"gmm-nondiag\",mu0,np.diag(sig0))\n\n # And solve with LBFGS \n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(task,Phi,th,r,z_to_ignore,verbose),\n x0 = th_0, method=opt_method, jac=True,\n bounds=boundstheta)\n new_theta = sol.x\n \n if task == \"gmm-nondiag\":\n new_theta = _makeGMMfeasible(new_theta,d)\n\n ## 2.2] Step 2 : add it to the support\n Theta = np.append(Theta,[new_theta],axis=0)\n A = np.c_[A,_sketchAtom(task,Phi,new_theta,z_to_ignore)] # Add a column to the A matrix\n\n ## 2.3] Step 3 : if necessary, hard-threshold to nforce sparsity\n if Theta.shape[0] > K:\n norms = np.linalg.norm(A,axis=0)\n norms[np.where(norms < 1e-15)[0]] = 1e-15 # Avoid /0\n A_norm = A/norms # normalize, unlike step 4\n A_normri = np.r_[A_norm.real, A_norm.imag] \n (beta,_) = nnls(A_normri,sketch_ri) # non-negative least squares\n index_to_delete = np.argmin(beta)\n Theta = np.delete(Theta, index_to_delete, axis=0)\n A = np.delete(A, index_to_delete, axis=1)\n if index_to_delete == K:\n continue # No gain to be expected wrt previous iteration\n\n ## 2.4] Step 4 : project to find weights\n Ari = np.r_[A.real, A.imag]\n (alpha,_) = nnls(Ari,sketch_ri) # non-negative least squares\n\n\n\n ## 2.5] Step 5\n p0 = _stackTheta(task,Theta,alpha) # Initialize at current solution \n # Compute the bounds for step 5 : boundsOfOneAtom * numberAtoms then boundsOneWeight * numberAtoms\n boundsThetaAlpha = boundstheta * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\n # Solve\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task,Phi,p,sketch,z_to_ignore),\n x0 = p0, method=opt_method, jac=True,\n bounds=boundsThetaAlpha, options={'ftol': ftol}) \n (Theta,alpha) = _destackTheta(task,sol.x,Phi.d)\n \n # Make covariances feasible\n if task == \"gmm-nondiag\":\n for k in range(Theta.shape[0]):\n Theta[k] = _makeGMMfeasible(Theta[k],d)\n\n # The atoms have changed: we must re-compute A\n A = np.empty([m,0])\n for theta_i in Theta:\n Apthi = _sketchAtom(task,Phi,theta_i,z_to_ignore)\n A = np.c_[A,Apthi]\n # Update residual\n r = sketch - A@alpha\n\n ## 3) Finalization boundstheta_finetuning\n # Last optimization with the default (fine-grained) tolerance\n if task_finetuning == \"gmm-nondiag\":\n if verbose > 0: print('finetuning')\n Theta_new = np.zeros((K,d*(d+1))) # Expand to have full cov matrix\n for k in range(K):\n (mu,sig2) = _destackAtom(\"gmm\",Theta[k],d)\n # put current sol on the diagonal of full covariance matrix\n Theta_new[k] = _stackAtom(\"gmm-nondiag\",mu,np.diag(sig2))\n Theta = Theta_new # overwrite\n \n boundsThetaAlpha = boundstheta_finetuning * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\n \n if task_finetuning == \"gmm-nondiag\" or ftol >= 1e-8:\n p0 = _stackTheta(task_finetuning,Theta,alpha)\n \n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task_finetuning,Phi,p,sketch,z_to_ignore),\n x0 = p0, method=opt_method, jac=True,\n bounds=boundsThetaAlpha) # Here ftol is much smaller\n (Theta,alpha) = _destackTheta(task_finetuning,sol.x,Phi.d) \n \n \n # Normalize alpha\n alpha /= np.sum(alpha)\n \n \n runResidualNorm = np.linalg.norm(sketch - A@alpha)\n if verbose>1: print('Run {}, residual norm is {} (best: {})'.format(iRun,runResidualNorm,bestResidualNorm))\n if runResidualNorm <= bestResidualNorm:\n bestResidualNorm = runResidualNorm\n bestTheta = Theta\n bestalpha = alpha\n \n ## FORMAT OUTPUT\n if task == \"kmeans\":\n return (bestalpha,bestTheta)\n elif task == \"gmm\" or task == \"gmm-nondiag\":\n return _ThetasToGMM(task_finetuning,bestTheta,bestalpha)\n\n return None","def grid_visibilities(self, visibilities, N = 120):\n logger.info(\"Gridding the visibilities\")\n\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\n\n centres = (ugrid[1:] + ugrid[:-1]) / 2\n\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\n\n if(os.path.exists(self.datafile[0][:-4]+\".kernel_weights.npy\")):\n kernel_weights = np.load(self.datafile[0][:-4]+\".kernel_weights.npy\")\n else:\n kernel_weights=None\n\n if kernel_weights is None:\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\n\n for jj, freq in enumerate(self.frequencies):\n u_bl = (self.baselines[:,0] * freq / const.c).value\n v_bl = (self.baselines[:,1] * freq / const.c).value\n\n beam, indx_u, indx_v = self.fourierBeam(centres, u_bl, v_bl, freq, N=N)\n for kk in range(len(indx_u)):\n visgrid[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk]) * visibilities[kk,jj]\n\n if kernel_weights is None:\n weights[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk])\n\n if kernel_weights is None:\n kernel_weights = weights\n\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\n\n return visgrid,kernel_weights","def optimize_force_field_parameters_Cv_FWHM(cgmodel, file_list, temperature_list, param_bounds_dict,\n frame_begin=0, frame_end=-1, sample_spacing=1, sparsify_stride=1, output_data='output.nc',\n verbose=False, n_cpu=12, min_eff_samples=50,\n n_trial_boot=200, num_intermediate_states=0, plotfile='optimize_FWHM_iterations.pdf',\n min_method='TNC'):\n\n # Parse the force field parameter change dict:\n x0 = []\n param_names = []\n bounds = []\n units = []\n \n for key,value in param_bounds_dict.items():\n # value should be [(bound_lo, bound_hi)]\n # key should be a valid force field parameter name\n param_names.append(key)\n # Every parameter except periodicity should have units\n # For now, changing periodicity is not supported.\n \n # TODO: add support for sums of periodic torsion terms\n units.append(value[0].unit)\n bounds.append((value[0].value_in_unit(units[-1]),value[1].value_in_unit(units[-1])))\n # Use mean value as starting guess:\n x0.append((value[1].value_in_unit(units[-1])+value[0].value_in_unit(units[-1]))/2)\n\n if verbose:\n print(f'param_names: {param_names}')\n print(f'unit: {units}')\n print(f'bounds: {bounds}')\n print(f'x0: {x0}')\n\n def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n \"\"\"\n Objective function to be minimized\n \"\"\"\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)\n\n # Run optimization:\n\n # if len(param_names) == 1:\n # # Do scalar optimization:\n # opt_results = minimize_scalar(get_reeval_FWHM, x0,\n # args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\n # frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\n # method='bounded',\n # bounds=[bounds[0][0],bounds[0][1]],\n # options={'maxiter': 25},\n # )\n\n # else:\n # Do multivariate optimization:\n opt_results = minimize(get_reeval_FWHM, x0, jac='2-point',\n args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\n frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\n method=min_method,\n bounds=bounds,\n options={'maxfun': 25, 'finite_diff_rel_step': 0.005, 'eta': 0.5}, # This should be user input\n ) \n \n # TODO: plot the heat capacity curves at each iteration, and make a plot of all FWHM_values \n\n # Construct dictionary of optimal parameters:\n opt_param_dict = {} \n \n k = 0\n for key,value in param_bounds_dict.items():\n opt_param_dict[key] = opt_results.x[k] * units[k]\n k += 1\n \n return opt_param_dict, opt_results","def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\n max_cp = 1\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n max_cp += w_inpIdx*X0[inpIdx]\n # saving values\n layerEq[inpIdx] = X0[inpIdx]\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n layerEq[inpIdx] = x_eq\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n max_cp += firstComplex + Inhib2/E0*x_eq\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n max_cp += Inhib2/E0*x_eq\n return max_cp","def fit_full(self,K):\r\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\r\n mu = np.zeros(self.N)\r\n Sigma = K.copy()\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.N,dtype=float)\r\n self.v_ = np.empty(self.N,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.N,dtype=float)\r\n self.Z_hat = np.empty(self.N,dtype=float)\r\n phi = np.empty(self.N,dtype=float)\r\n mu_hat = np.empty(self.N,dtype=float)\r\n sigma2_hat = np.empty(self.N,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = self.epsilon + 1.\r\n epsilon_np2 = self.epsilon + 1.\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.N)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\r\n mu = np.dot(Sigma,self.v_tilde)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\r\n B = np.eye(self.N) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\r\n L = jitchol(B)\r\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\r\n Sigma = K - np.dot(V.T,V)\r\n mu = np.dot(Sigma,self.v_tilde)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def spec_helm_decomp(k,Cu,Cv,GM=False):\n dk = k[1]-k[0]\n s = np.log(k)\n\n Fphi = np.zeros_like(Cu)\n Fpsi = np.zeros_like(Cu)\n Cphi = np.zeros_like(Cu)\n Cpsi = np.zeros_like(Cu)\n\n # assume GM for decomposing into wave and vortex\n if GM:\n gm = np.load(\"/Users/crocha/Projects/dp_spectra/GM/gm_omega_star.npz\")\n f2omg2 = gm['rgm']\n ks = gm['k']*1.e3\n\n for i in range(s.size-1):\n\n ds = np.diff(s[i:])\n\n sh = sinh(s[i]-s[i:])\n ch = cosh(s[i]-s[i:])\n\n # the function to integrate\n Fp = Cu[i:]*sh + Cv[i:]*ch\n Fs = Cv[i:]*sh + Cu[i:]*ch\n\n # integrate using Simpson's rule\n Fpsi[i] = integrate.simps(Fs,s[i:])\n Fphi[i] = integrate.simps(Fp,s[i:])\n\n # zero out unphysical values\n Fpsi[Fpsi < 0.] = 0.\n Fphi[Fphi < 0.] = 0.\n\n # compute rotational and divergent components\n Cpsi = Fpsi - Fphi + Cu\n Cphi = Fphi - Fpsi + Cv\n\n if GM:\n\n f2omg2i = np.interp(k,ks,f2omg2)\n\n Cv_w = f2omg2i*Fphi - Fpsi + Cv\n Cv_v = Cv - Cv_w\n \n kdkromg = diff_central(ks, f2omg2)\n kdkromg = np.interp(k,ks[1:-1],kdkromg)\n\n dFphi = diff_central(k, Fphi)\n #dFphi = np.gradient(Fphi,k)\n dFphi = np.interp(k,k[1:-1],dFphi.real)\n E_w = Fphi - k*dFphi\n\n Cu_w = -k*kdkromg*Fphi + f2omg2i*(-Fpsi+Cv) + Fphi\n Cu_v = Cu - Cu_w\n\n Cb_w = E_w - (Cu_w + Cv_w)/2.\n\n return Cpsi,Cphi, Cu_w,Cv_w, Cu_v,Cv_v, E_w, Cb_w\n\n else:\n return Cpsi,Cphi","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\n mask, max_iter=100, init=None,\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\n\n # shape of image box\n \n alpha = 1\n\n flat_mask = mask.ravel()\n volume_shape = mask.shape\n H_size = len(Hurst_init)\n\n if lipschitz_constant == 0:\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\n\n #init[\"z\"] = Hurst_init.copy()\n #init[\"t\"] = 1\n #ini[\"stepsize\"] = 1 / lipschitz_constant\n\n def total_energy(x):\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\n\n def unmaskvec(w):\n return _unmask(w, mask)\n\n def maskvec(w):\n return w[flat_mask]\n\n def f1_grad(x):\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\n\n def f2_prox(w, stepsize, dgap_tol, init):\n out, info = _prox_tvl1(unmaskvec(w),\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\n dgap_tol=dgap_tol, init=unmaskvec(init),\n max_iter=prox_max_iter, fista = False,\n verbose=verbose)\n #pdb.set_trace()\n return maskvec(out.ravel()), info\n\n w, obj, init = mfista(\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\n max_iter=max_iter, callback=None)\n \n return w, obj, init","def WakeVorticityFromCirculation_Cont(r_cp,Gamma_cp,R,U0,Omega,bSwirl,method='analytical',bHighThrustCorr=True):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cp[0]==0:\n r_cp[0]=r_cp[1]*0.5;\n # Non dimensional parameters\n k = Omega*Gamma_cp/(np.pi*U0**2)\n vr_bar = r_cp/R \n lambda_r = Omega*r_cp/U0\n # Finding inductions\n a,a_prime,misc= InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method=method,bHighThrustCorr=bHighThrustCorr)\n # Computing convection\n misc['Vz'] = U0*(1-2*a)\n misc['h'] = misc['Vz']*2*np.pi/(Omega*(1+2*a_prime))\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n # Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n gamma_t = - Gamma_tilde/misc['h']\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = 0\n Gamma_r = 0\n return gamma_t,gamma_l,Gamma_r,misc","def vote_for_k(utilities, k):\n utilities = np.asarray(utilities)\n n_cands = utilities.shape[1]\n if k == 'half':\n # \"It is interesting to observe that the vote-for-k and vote-for-(n-k)\n # voting systems are equally effective.\"\n # So for 7 candidates, we could use either k=4 or k=3 (= 7//2)\n # TODO: Though this seems only true with infinite voters?\n k = n_cands // 2\n elif -n_cands < k < 0:\n k = n_cands + k\n elif not 0 < k < n_cands:\n raise ValueError(f'k of {k} not possible with {n_cands} candidates')\n\n # Efficiently get indices of top k candidates for each voter\n # https://stackoverflow.com/a/23734295/125507\n # TODO: How are tied utilities handled, such as top 2 with 3 tied? Random?\n top_k = np.argpartition(utilities, -k, axis=1)[:, -k:]\n\n # Create blank ballots\n approvals = np.zeros(utilities.shape, np.uint8)\n\n # Fill in approvals\n # TODO: Not sure if this is the most efficient way\n approvals[np.arange(len(approvals))[:, np.newaxis], top_k] = 1\n return approvals","def tuto_kernel_overview(optimize=True, plot=True):\r\n ker1 = GPy.kern.rbf(1) # Equivalent to ker1 = GPy.kern.rbf(input_dim=1, variance=1., lengthscale=1.)\r\n ker2 = GPy.kern.rbf(input_dim=1, variance = .75, lengthscale=2.)\r\n ker3 = GPy.kern.rbf(1, .5, .5)\r\n\r\n print ker2\r\n\r\n if plot:\r\n ker1.plot()\r\n ker2.plot()\r\n ker3.plot()\r\n\r\n k1 = GPy.kern.rbf(1,1.,2.)\r\n k2 = GPy.kern.Matern32(1, 0.5, 0.2)\r\n\r\n # Product of kernels\r\n k_prod = k1.prod(k2) # By default, tensor=False\r\n k_prodtens = k1.prod(k2,tensor=True)\r\n\r\n # Sum of kernels\r\n k_add = k1.add(k2) # By default, tensor=False\r\n k_addtens = k1.add(k2,tensor=True)\r\n\r\n k1 = GPy.kern.rbf(1,1.,2)\r\n k2 = GPy.kern.periodic_Matern52(1,variance=1e3, lengthscale=1, period = 1.5, lower=-5., upper = 5)\r\n\r\n k = k1 * k2 # equivalent to k = k1.prod(k2)\r\n print k\r\n\r\n # Simulate sample paths\r\n X = np.linspace(-5,5,501)[:,None]\r\n Y = np.random.multivariate_normal(np.zeros(501),k.K(X),1)\r\n\r\n k1 = GPy.kern.rbf(1)\r\n k2 = GPy.kern.Matern32(1)\r\n k3 = GPy.kern.white(1)\r\n\r\n k = k1 + k2 + k3\r\n print k\r\n\r\n k.constrain_positive('.*var')\r\n k.constrain_fixed(np.array([1]),1.75)\r\n k.tie_params('.*len')\r\n k.unconstrain('white')\r\n k.constrain_bounded('white',lower=1e-5,upper=.5)\r\n print k\r\n\r\n k_cst = GPy.kern.bias(1,variance=1.)\r\n k_mat = GPy.kern.Matern52(1,variance=1., lengthscale=3)\r\n Kanova = (k_cst + k_mat).prod(k_cst + k_mat,tensor=True)\r\n print Kanova\r\n\r\n # sample inputs and outputs\r\n X = np.random.uniform(-3.,3.,(40,2))\r\n Y = 0.5*X[:,:1] + 0.5*X[:,1:] + 2*np.sin(X[:,:1]) * np.sin(X[:,1:])\r\n\r\n # Create GP regression model\r\n m = GPy.models.GPRegression(X, Y, Kanova)\r\n\r\n if plot:\r\n fig = pb.figure(figsize=(5,5))\r\n ax = fig.add_subplot(111)\r\n m.plot(ax=ax)\r\n\r\n pb.figure(figsize=(20,3))\r\n pb.subplots_adjust(wspace=0.5)\r\n axs = pb.subplot(1,5,1)\r\n m.plot(ax=axs)\r\n pb.subplot(1,5,2)\r\n pb.ylabel(\"= \",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,3)\r\n m.plot(ax=axs, which_parts=[False,True,False,False])\r\n pb.ylabel(\"cst +\",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,4)\r\n m.plot(ax=axs, which_parts=[False,False,True,False])\r\n pb.ylabel(\"+ \",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,5)\r\n pb.ylabel(\"+ \",rotation='horizontal',fontsize='30')\r\n m.plot(ax=axs, which_parts=[False,False,False,True])\r\n\r\n return(m)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def ghosal_edge(img,Ks,thr=1,thrmax=0.995,lmin = 0.5,phimin=1.4,thresholding=True, debug=False):\n\ttotaltime = time.time()\n\tkerneltime = time.time()\n\t# Ks must be odd\n\tif Ks%2 != 1:\n\t\tprint(\"Ks must be odd! Continuing with Ks = Ks-1\")\n\t\tKs = Ks-1\n\t# define the rectangular kernels\n\t#Vc00 = np.zeros((Ks,Ks),dtype=complex)\n\tVc11 = np.zeros((Ks,Ks),dtype=complex)\n\tVc20 = np.zeros((Ks,Ks),dtype=complex)\n\tofs = 1 *(1-1/Ks) # offset for centering kernel around 0,0\n\tfor i in range(Ks):\n\t\tfor j in range(Ks):\n\t\t\tKx = 2*j/Ks-ofs # limits of integration between -1 and 1\n\t\t\tKy = 2*i/Ks-ofs\n\t\t\tif Kx**2+Ky**2 <= 1: # only a circle\n\t\t\t\t#Vc00[i,j] = 1 # the conjugate of V00\n\t\t\t\tVc11[i,j] = Kx-Ky*1j # ...\n\t\t\t\tVc20[i,j] = 2*Kx**2+2*Ky**2-1\n\tkerneltime = time.time() - kerneltime\n\t\n\t# Kernel Plots\n\t#\tVCplot = Vc00\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Vc11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Vc20\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\t# do the convolution with the images to get the zernike moments\n\tAnorm = lambda n : (n+1)/np.pi\t# a normalization value\n\tconvolvetime = time.time()\n\t#A00 = scig.convolve2d(img,Vc00,mode='same')\n\t#\tA11 = Anorm(1)*scig.convolve2d(img,Vc11,mode='same')\n\t#\tA20 = Anorm(2)*scig.convolve2d(img,Vc20,mode='same')\n\tA11 = Anorm(1)*scig.oaconvolve(img,Vc11,mode='same')\n\tA20 = Anorm(2)*scig.oaconvolve(img,Vc20,mode='same')\n\tconvolvetime = time.time() - convolvetime\n\t# Plot Zernike moments\n\t#\tVCplot = A00\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = A11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = A20\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\tparamstime = time.time()\n\t# calculate the edge paramters\n\t#\ttanphi = np.imag(A11)/np.real(A11)\n\t#\tphi = np.arctan(tanphi)\n\t#\tcosphi = np.cos(phi)\n\t#\tsinphi = cosphi*tanphi\n\t#\tAl11 = np.real(A11)*cosphi+np.imag(A11)*sinphi\n\t\n\tphi = np.arctan(np.imag(A11)/np.real(A11))\n\tAl11 = np.real(A11)*np.cos(phi)+np.imag(A11)*np.sin(phi)\n\t\n\t#\tAl11 = A11*np.exp(-phi*1j)\n\tl = A20/Al11 # A20 has no imaginary component so A20 = A'20\n\n\tk = 3*Al11/(2*(1-l**2)**(3/2))\n\tparamstime = time.time() - paramstime\n\t\n\t# Plot edge paramters\n\t#\tVCplot = phi\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real phi\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag phi\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Al11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A\\'11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A\\'11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = l\n\t#\tplt.pcolormesh(np.real(VCplot))#,vmin=-5,vmax=5\n\t#\tplt.title(\"real l\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot)) # ,vmin=-5,vmax=5\n\t#\tplt.title(\"imag l\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = k\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real k\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag k\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\t\n\ttreattime = time.time()\n\tif thresholding==True:\n\t\t# do the thresholding\n\t\tif (thrmax<0)&(thr>0):\n\t\t\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])\n\t\telif thrmax>0:\n\t\t\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])&(abs(k)<knorm[1])\n\t\telif thr<0:\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)\n\t\t\tknorm = np.sort(k[idx].flatten())[int(thr)]\n\t\t\tidx = idx&(abs(k)>abs(knorm))\n\t\tne = np.sum(idx)\n\telif thresholding==False:\n\t\traise ValueError(\"this option is not still uncer development\")\n\t\t# no thresholding\n\t\tidx = np.ones(np.shape(l),dtype=bool)\n\t\tne =np.sum(idx)\n\telse:\n\t\traise ValueError(\"thresholding should be boolean\")\n\t\n\t# put all detected points in a vector of (x,y) values\n\tedg = np.zeros((ne,2))\n\torg = np.zeros((ne,2))\n\tnx,ny = np.shape(img)\n\te = 0\n\tfor i in range(nx):\n\t\tfor j in range(ny):\n\t\t\tif idx[i,j]:\n\t\t\t\tedg[e]=np.array([i,j]) + l[i,j]*Ks/2*np.array(\n\t\t\t\t\t[np.sin(phi[i,j]),-np.cos(phi[i,j])])\n\t\t\t\torg[e]=np.array([i,j])\n\t\t\t\te +=1\n\ttreattime = time.time() - treattime\n\ttotaltime = time.time() - totaltime\n\tprint(\"total %0.5f\tconvolution %0.5f\tthresholding %0.5f\tparamters %0.5f\tkernel %0.5f\"%(totaltime,convolvetime,treattime,paramstime,kerneltime))\n\t\n\tif debug==True:\n\t\treturn edg, org, k, l, phi\n\telse:\n\t\treturn edg, org","def HKS(evals,evects, time_list,scaled=False):\n evals_s = np.asarray(evals).flatten()\n t_list = np.asarray(time_list).flatten()\n\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\n\n if scaled:\n inv_scaling = coefs.sum(1) # (num_T)\n return (1/inv_scaling)[None,:] * natural_HKS\n\n else:\n return natural_HKS","def normal_modes_gHST(R, NL, KL, params, dispersion=[], spin_dir=[], sublattice_labels=[], b='hang', spring='auto',\n pin='auto'):\n try:\n NP, NN = np.shape(NL)\n except:\n '''There is only one particle.'''\n NP = 1\n NN = 0\n\n M1 = np.zeros((2 * NP, 2 * NP))\n M2 = np.zeros((2 * NP, 2 * NP))\n if spring == 'auto':\n spring = params['k'] * params['l'] ** 2 / (params['I3'] * np.abs(params['w3']))\n # If there is more than one particle, and if the speeds vary from particle to particle,\n # then make spring the same length as a dynamical matrix column\n if len(spring) > 0:\n if (abs(spring - spring[0]) > 1e-9).any():\n # The rotation rates vary from particle to particle, so reshape\n spring_new = np.zeros_like(spring)\n dmyi = 0 # a new index ('dummy i')\n for ii in range(NP):\n # Since 2 dof for position of pivot of gHST, double the size\n spring_new[dmyi] = spring[ii]\n spring_new[dmyi + 1] = spring[ii]\n dmyi += 2\n else:\n # the elements are all identical, so just keep the first one\n spring = spring[0]\n\n if pin == 'auto':\n gn = params['Mm'] * params['g']\n pin = params['l'] * gn / (params['I3'] * np.abs(params['w3']))\n # If there is more than one particle, and if the speeds vary from particle to particle,\n # then make pin the same length as a dynamical matrix column\n if len(pin) > 0:\n if (abs(pin - pin[0]) > 1e-9).any():\n # The rotation rates vary from particle to particle, so reshape\n pin_new = np.zeros_like(pin)\n dmyi = 0 # a new index ('dummy i')\n for ii in range(NP):\n # Since 2 dof for position of pivot of gHST, double the size\n pin_new[dmyi] = pin[ii]\n pin_new[dmyi + 1] = pin[ii]\n dmyi += 2\n else:\n # the elements are all identical, so just keep the first one\n pin = pin[0]\n\n m2_shape = np.shape(M2)\n\n if b == 'hang':\n b = np.zeros(NP)\n elif b == 'stand':\n b = np.ones(NP)\n\n if spin_dir == []:\n '''Assume antialigned with a, aligned with body axis 3'''\n spin_dir = np.ones(NP)\n\n print 'Constructing dynamical matrix...'\n for i in range(NP):\n for nn in range(NN):\n\n ni = NL[i, nn] # the number of the gyroscope i is connected to (particle j)\n k = KL[i, nn] # true connection?\n\n if len(dispersion) > 1:\n disp = 1. / (1. + dispersion[i])\n else:\n disp = 1.\n\n diffx = R[ni, 0] - R[i, 0]\n diffy = R[ni, 1] - R[i, 1]\n alphaij = 0.\n\n rij_mag = np.sqrt(diffx ** 2 + diffy ** 2)\n\n if k != 0:\n alphaij = np.arctan2(diffy, diffx)\n\n # for periodic systems, KL is -1 for particles on opposing boundaries\n if KL[i, nn] == -1:\n alphaij = (np.pi + alphaij) % (2 * pi)\n\n # What is this for?\n if KL[i, nn] == -2: # will only happen on first or last gyro in a line\n if i == 0 or i == (NP - 1):\n print i, '--> NL=-2 for this particle'\n yy = np.where(KL[i] == 1)\n dx = R[NL[i, yy], 0] - R[NL[i, yy], 0]\n dy = R[NL[i, yy], 1] - R[NL[i, yy], 1]\n al = (np.arctan2(dy, dx)) % (2 * pi)\n alphaij = np.pi - al\n if i == 1:\n alphaij = np.pi - ((90 / 2) * np.pi / 180.)\n else:\n alphaij = - ((90 / 2) * np.pi / 180.)\n\n Cos = np.cos(alphaij)\n Sin = np.sin(alphaij)\n\n if abs(Cos) < 10E-8:\n Cos = 0.0\n\n if abs(Sin) < 10E-8:\n Sin = 0\n\n Cos2 = Cos ** 2\n Sin2 = Sin ** 2\n CosSin = Cos * Sin\n\n # -1 for aligned with a, 1 for aligned with 3.\n # dir factor :== 1/(-1)^c = (-1)^c\n dir_factor = spin_dir[i]\n\n if len(sublattice_labels) > 0:\n if sublattice_labels[i] == 1:\n extra_factor = 1. * del_A_B\n # print self.del_A_B\n elif sublattice_labels[i] == 0:\n extra_factor = 1.\n else:\n extra_factor = 1.\n else:\n extra_factor = 1.\n\n M1[2 * i, 2 * i] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxi\n M1[2 * i, 2 * i + 1] += -disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyi\n M1[2 * i, 2 * ni] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxj\n M1[2 * i, 2 * ni + 1] += disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyj\n\n # (y components)\n M1[2 * i + 1, 2 * i] += disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxi\n M1[2 * i + 1, 2 * i + 1] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyi\n M1[2 * i + 1, 2 * ni] += -disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxj\n M1[2 * i + 1, 2 * ni + 1] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyj\n\n # if i==0:\n # print '\\n --- \\n added M1[2*i+1, 2*i] = ',disp*k*Cos2 *((-1)**b[i]) *dir_factor\n # print 'dir_factor = ', dir_factor\n # print 'k = ', k\n # print 'else =', ((-1)**b[i]) *dir_factor\n\n # pinning/gravitational matrix\n M2[2 * i, 2 * i + 1] = (1.) * disp * dir_factor * extra_factor\n M2[2 * i + 1, 2 * i] = -(1.) * disp * dir_factor * extra_factor\n\n # self.pin_array.append(2*pi*1*extra_factor)\n # Assumes:\n # (-1)**c adot = - spring* (-1)**b SUM{ z x nij*(nij.(dri-drj)) } + pin\n matrix = - (-spring * M1 + pin * M2)\n\n return matrix","def showCortexImg(pV,nV):\n # object arrays of the positive and negative images\n pos_cort_img = np.empty(8, dtype=object)\n neg_cort_img = np.empty(8, dtype=object)\n for t in range(8):\n # cortical mapping functions\n lpos, rpos = cortex.cort_img(pV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\n lneg, rneg = cortex.cort_img(nV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\n pos_cort_img[t] = np.concatenate((np.rot90(lpos),np.rot90(rpos,k=3)),axis=1)\n neg_cort_img[t] = np.concatenate((np.rot90(lneg),np.rot90(rneg,k=3)),axis=1)\n # stack all images into a grid\n posRGcort = np.vstack((pos_cort_img[:4]))\n negRGcort = np.vstack((neg_cort_img[:4]))\n posYBcort = np.vstack((pos_cort_img[4:]))\n negYBcort = np.vstack((neg_cort_img[4:]))\n mergecort = np.concatenate((posRGcort,negRGcort,posYBcort,negYBcort),axis=1)\n return mergecort","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","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 estimate_opt_eff(self, iv_fn_hot, iv_fn_cold,t_hot=293.,t_cold=77.,\n channels = None, dPdT_lim=(0.,0.5)):\n ivs_hot = np.load(iv_fn_hot).item()\n ivs_cold = np.load(iv_fn_cold).item()\n \n iv_fn_raw_hot = iv_fn_hot.split('.')[0] + '_raw_data.npy'\n iv_fn_raw_cold = iv_fn_cold.split('.')[0] + '_raw_data.npy'\n\n ivs_raw_hot = np.load(iv_fn_raw_hot).item()\n ivs_raw_cold = np.load(iv_fn_raw_cold).item()\n \n basename_hot = ivs_raw_hot['basename']\n basename_cold = ivs_raw_cold['basename']\n\n #band = ivs_raw_hot['band']\n #assert ivs_raw_cold['band'] == band, \\\n # 'Files must contain IVs from the same band'\n group = ivs_raw_hot['bias group']\n assert ivs_raw_cold['bias group'], \\\n 'Files must contain IVs from the same bias group'\n \n import matplotlib.pyplot as plt\n plot_dir = self.plot_dir\n\n dT = t_hot - t_cold\n dPdT_list = []\n n_outliers = 0\n for ch in ivs_hot:\n if channels is not None:\n if ch not in channels:\n continue\n elif not isinstance(ch,np.int64):\n continue\n \n if ch not in ivs_cold:\n continue\n \n P_hot = ivs_hot[ch]['P']\n P_cold = ivs_cold[ch]['P']\n R_hot = ivs_hot[ch]['R']\n R_cold = ivs_cold[ch]['R']\n Ptrans_hot = ivs_hot[ch]['Ptrans']\n Ptrans_cold = ivs_cold[ch]['Ptrans']\n if Ptrans_hot is None or Ptrans_cold is None:\n print('Missing in-transition electrical powers for Ch. %i' % (ch))\n continue\n dPdT = (Ptrans_cold - Ptrans_hot)/dT\n self.log('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\n if dPdT_lim is not None:\n if dPdT >= dPdT_lim[0] and dPdT <= dPdT_lim[1]:\n dPdT_list.append(dPdT)\n else:\n n_outliers += 1\n else:\n dPdT_list.append(dPdT)\n\n fig_pr,ax_pr = plt.subplots(1,sharex=True)\n ax_pr.set_xlabel(r'$R_\\mathrm{TES}$ [$\\Omega$]')\n ax_pr.set_ylabel(r'$P_\\mathrm{TES}$ [pW]')\n label_hot = '%s: %.0f K' % (basename_hot,t_hot)\n label_cold = '%s: %.0f K' % (basename_cold,t_cold)\n ax_pr.axhline(y=Ptrans_hot,linestyle = '--',color = 'b')\n ax_pr.axhline(y=Ptrans_cold,linestyle = '--',color = 'r')\n ax_pr.plot(R_hot,P_hot,label=label_hot,color='b')\n ax_pr.plot(R_cold,P_cold,label=label_cold,color='r')\n ax_pr.legend(loc='best')\n fig_pr.suptitle('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\n ax_pr.grid()\n \n plot_name = basename_hot + '_' + basename_cold + '_optEff_g{}_ch{:03}.png'.format(group, ch)\n plot_filename = os.path.join(plot_dir, plot_name)\n self.log('Saving optical-efficiency plot to {}'.format(plot_filename))\n plt.savefig(plot_filename,bbox_inches='tight', dpi=300)\n plt.close()\n\n plt.figure()\n plt.hist(dPdT_list,edgecolor='k')\n plt.xlabel('dP/dT [pW/K]')\n plt.grid()\n dPdT_median = np.median(dPdT_list)\n plt.title('Group {}, median = {:.3f} pW/K ({} outliers not plotted)'.format(group,dPdT_median,n_outliers))\n plot_name = basename_hot + '_' + basename_cold + '_dPdT_hist_g{}.png'.format(group)\n hist_filename = os.path.join(plot_dir,plot_name)\n self.log('Saving optical-efficiency histogram to {}'.format(hist_filename))\n plt.savefig(hist_filename,bbox_inches='tight',dpi=300)\n plt.close()","def plot_dispersion(kpts, enk):\n\n # Lattice constant and reciprocal lattice vectors\n # b1 = 2 pi/a (kx - ky + kz)\n # b2 = 2 pi/a (kx + ky - kz)\n # b3 = 2 pi/a (-kx + ky + kz)\n a = 5.556 # [A]\n b1 = (2 * np.pi / a) * np.array([1, -1, 1])\n b2 = (2 * np.pi / a) * np.array([1, 1, -1])\n b3 = (2 * np.pi / a) * np.array([-1, 1, 1])\n\n # L point in BZ is given by 0.5*b1 + 0.5*b2 + 0.5*b3\n # X point in BZ is given by 0.5*b2 + 0.5*b3\n lpoint = 0.5 * (b1 + b2 + b3)\n xpoint = 0.5 * (b2 + b3)\n\n # We can find kpoints along a path just by considering a dot product with lpoint and xpoint vectors.\n # Any kpoints with angle smaller than some tolerance are considered on the path and we can plot their frequencies\n deg2rad = 2 * np.pi / 360\n ang_tol = 1 * deg2rad # 1 degree in radians\n\n print(list(kpts))\n\n enkonly = np.array(enk['energy [Ryd]'])[:, np.newaxis]\n enkinds = np.array(enk['q_inds'])\n kptsonly = np.array(kpts[['kx [1/A]', 'ky [1/A]', 'kz [1/A]']]) / (2 * np.pi / a)\n kptsinds = np.array(kpts['q_inds'])\n kptsmag = np.linalg.norm(kptsonly, axis=1)[:, np.newaxis]\n\n dot_l = np.zeros(len(kpts))\n dot_x = np.zeros(len(kpts))\n\n # Separate assignment for gamma point to avoid divide by zero error\n nongamma = kptsmag != 0\n dot_l[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, lpoint[:, np.newaxis])[nongamma],\n kptsmag[nongamma]) / np.linalg.norm(lpoint)\n dot_x[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, xpoint[:, np.newaxis])[nongamma],\n kptsmag[nongamma]) / np.linalg.norm(xpoint)\n dot_l[np.squeeze(kptsmag == 0)] = 0\n dot_x[np.squeeze(kptsmag == 0)] = 0\n\n lpath = np.logical_or(np.arccos(dot_l) < ang_tol, np.squeeze(kptsmag == 0))\n xpath = np.logical_or(np.arccos(dot_x) < ang_tol, np.squeeze(kptsmag == 0))\n\n linds = kptsinds[lpath]\n xinds = kptsinds[xpath]\n lkmag = kptsmag[lpath]\n xkmag = kptsmag[xpath]\n\n plt.figure()\n\n for i, ki in enumerate(linds):\n energies = enkonly[enkinds == ki, 0]\n thiskmag = lkmag[i]\n if len(energies) > 1:\n veck = np.ones((len(energies), 1)) * thiskmag\n plt.plot(veck, energies, '.', color='C0')\n else:\n plt.plot(thiskmag, energies, '.', color='C0')\n\n for i, ki in enumerate(xinds):\n energies = enkonly[enkinds == ki, 0]\n thiskmag = lkmag[i]\n if len(energies) > 1:\n veck = np.ones((len(energies), 1)) * thiskmag\n plt.plot(-1 * veck, energies, '.', color='C1')\n else:\n plt.plot(-1 * thiskmag, energies, '.', color='C1')\n\n plt.xlabel('k magnitude')\n plt.ylabel('Energy in Ry')","def hcn_kn(Y,t,voltage_clamp_func,voltage_clamp_params):\n\n v = voltage_clamp_func(t,voltage_clamp_params)\n n_s = Y[0]\n n_f = Y[1]\n\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\n ninf_f = ninf_s\n\n if v > -70.0:\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\n else:\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\n\n dns = (ninf_s - n_s)/tau_ns\n dnf = (ninf_f - n_f)/tau_nf\n\n return [dns, dnf]","def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cyl is None:\n r_cyl = np.zeros(r_cp.shape)\n if len(r_cyl)==1:\n r_cyl=np.array([R])\n else:\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\n else:\n r_cyl = np.asarray(r_cyl).ravel()\n misc={}\n # --- Checks\n if np.amax(r_cyl) < np.amax(r_cp):\n warnings.warn('Cylinders are assumed to enclose the control points')\n import pdb; pdb.set_trace()\n if r_cyl[0] == 0:\n raise Exception('First cylinder at 0, impossible')\n\n ## Interpolating Circulation on the control points\n Gamma_cp = Gamma_cp * nB # IMPORTANT\n lambda_rcp = Omega*r_cp/U0\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\n ## Some init\n\n n = len(r_cyl)\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n # --- Case 1: Using k / ct to determine gamma\n # Using a_prime to correct Ct\n # Tangential convection velocity\n if not bTanInd_k:\n ap_cyl_conv = 0 * Gamma_cp\n else:\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\n # See Equation (26) of [1]: a'_c,i = (\\Gamma_i+\\Gamma_i+1)/(4 pi Omega R_i^2)\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\n # --- Allocation\n b = np.zeros(n) # Cummulative sum of gamma_bar\n S = np.zeros(n) # Term under the square root\n Sbis = np.zeros(n) # Term under the square root, account\n Ctrot = np.zeros(n)\n Ctrot_loc = np.zeros(n)\n Cti = np.zeros(n)\n Cteff = np.zeros(n)\n gamma_t_bar = np.zeros(n)\n # --- Init\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\n lambda_R = Omega * r_cyl / U0\n # Looping through radii in reversed order\n for i in np.arange(n-1,-1,-1):\n if i==n-1:\n b[i] = 1\n S[i] = 1 - C[i]\n Sbis[i] = 1 - C[i]\n Ctrot[i] = 0\n Ctrot_loc[i] = 0\n else:\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\n if not bSwirl:\n Ctrot[i] = 0\n Cti[i] = k_r[i]\n else:\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\n Sbis[i] = 1 - Cteff[i]\n if bSwirl :\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\n else:\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \n# print('b',b,'S',S)\n if bHighThrustCorr:\n if (Cteff[i] > Ct_c):\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\n #if np.abs(imag(gamma_t_bar(i))) > 0:\n # gamma_t_bar[i] = - b[i] + 0\n Vc = U0 * (b + gamma_t_bar / 2)\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\n\n\n # Analytical 1\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\n a_1=a_1[-1::-1]\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\n a=a_1;\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\n # # Analytical 2\n # a_2=-(gamma_t_hat/2)/U0;\n # a=a_2;\n #else\n # a=a_1;\n #end\n if bSwirl:\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\n else:\n a_prime=a*0\n\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n misc['h'] = h\n\n # --- Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n #gamma_t = - Gamma_tilde/h\n gamma_t = gamma_t_bar * U0\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = None\n Gamma_r = None\n\n return gamma_t,gamma_l,Gamma_r, misc","def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cyl is None:\n r_cyl = np.zeros(r_cp.shape)\n if len(r_cyl)==1:\n r_cyl=np.array([R])\n else:\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\n else:\n r_cyl = np.asarray(r_cyl).ravel()\n misc={}\n # --- Checks\n if np.amax(r_cyl) < np.amax(r_cp):\n warnings.warn('Cylinders are assumed to enclose the control points')\n import pdb; pdb.set_trace()\n if r_cyl[0] == 0:\n raise Exception('First cylinder at 0, impossible')\n\n ## Interpolating Circulation on the control points\n Gamma_cp = Gamma_cp * nB # IMPORTANT\n lambda_rcp = Omega*r_cp/U0\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\n ## Some init\n\n n = len(r_cyl)\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n # --- Case 1: Using k / ct to determine gamma\n # Using a_prime to correct Ct\n # Tangential convection velocity\n if not bTanInd_k:\n ap_cyl_conv = 0 * Gamma_cp\n else:\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\n # See Equation (26) of [1]: a'_c,i = (\\Gamma_i+\\Gamma_i+1)/(4 pi Omega R_i^2)\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\n # --- Allocation\n b = np.zeros(n) # Cummulative sum of gamma_bar\n S = np.zeros(n) # Term under the square root\n Sbis = np.zeros(n) # Term under the square root, account\n Ctrot = np.zeros(n)\n Ctrot_loc = np.zeros(n)\n Cti = np.zeros(n)\n Cteff = np.zeros(n)\n gamma_t_bar = np.zeros(n)\n # --- Init\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\n lambda_R = Omega * r_cyl / U0\n # Looping through radii in reversed order\n for i in np.arange(n-1,-1,-1):\n if i==n-1:\n b[i] = 1\n S[i] = 1 - C[i]\n Sbis[i] = 1 - C[i]\n Ctrot[i] = 0\n Ctrot_loc[i] = 0\n else:\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\n if not bSwirl:\n Ctrot[i] = 0\n Cti[i] = k_r[i]\n else:\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\n Sbis[i] = 1 - Cteff[i]\n if bSwirl :\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\n else:\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \n# print('b',b,'S',S)\n if bHighThrustCorr:\n if (Cteff[i] > Ct_c):\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\n #if np.abs(imag(gamma_t_bar(i))) > 0:\n # gamma_t_bar[i] = - b[i] + 0\n Vc = U0 * (b + gamma_t_bar / 2)\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\n\n\n # Analytical 1\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\n a_1=a_1[-1::-1]\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\n a=a_1;\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\n # # Analytical 2\n # a_2=-(gamma_t_hat/2)/U0;\n # a=a_2;\n #else\n # a=a_1;\n #end\n if bSwirl:\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\n else:\n a_prime=a*0\n\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n misc['h'] = h\n\n # --- Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n #gamma_t = - Gamma_tilde/h\n gamma_t = gamma_t_bar * U0\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = None\n Gamma_r = None\n\n return gamma_t,gamma_l,Gamma_r, misc","def WakeVorticityFromCt(r,Ct,R,U0,Omega):\n if Omega==np.inf:\n Omega=800 # TODO, implement infinite lambd formulae directly\n Lambda=Omega*R/U0\n bSwirl=Lambda<20\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\n Gamma = vk*np.pi*U0**2/Omega\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)","def WakeVorticityFromCt(r,Ct,R,U0,Omega):\n if Omega==np.inf:\n Omega=800 # TODO, implement infinite lambd formulae directly\n Lambda=Omega*R/U0\n bSwirl=Lambda<20\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\n Gamma = vk*np.pi*U0**2/Omega\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)","def attach_to_controller(self, controller):\r\n\r\n def cv_amp(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n return np.std(amps) / np.mean(amps) if len(amps) >= 1 else 0\r\n\r\n def cum_amp_drift(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n # return cum_feat(amps) if len(amps) >= 2 else 0\r\n return np.sum(np.abs(np.diff(amps))) / len(amps) if len(amps) >= 2 else 0\r\n\r\n def cum_depth_drift(cluster_id):\r\n depths = controller.model.spike_depths[controller.get_spike_ids(cluster_id)].data\r\n # return cum_feat(depths) if len(depths) >= 2 else 0\r\n return np.sum(np.abs(np.diff(depths))) / len(depths) if len(depths) >= 2 else 0\r\n\r\n def cv_fr(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n fr = bb.singlecell.firing_rate(ts, hist_win=0.01, fr_win=0.25)\r\n return np.std(fr) / np.mean(fr) if len(fr) >= 1 else 0\r\n\r\n def frac_isi_viol(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n frac_isi_viol, _, _ = isi_viol(ts, rp=0.002)\r\n return frac_isi_viol\r\n\r\n def frac_missing_spikes(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n try:\r\n frac_missing_spks, _, _ = feat_cutoff(\r\n amps, spks_per_bin=10, sigma=4, min_num_bins=50)\r\n except:\r\n frac_missing_spks = np.NAN\r\n return frac_missing_spks\r\n\r\n def fp_estimate(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n return fp_est(ts, rp=0.002)\r\n\r\n def presence_ratio(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n pr, _ = pres_ratio(ts, hist_win=10)\r\n return pr\r\n\r\n def presence_ratio_std(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n pr, pr_bins = pres_ratio(ts, hist_win=10)\r\n return pr / np.std(pr_bins)\r\n\r\n def refp_viol(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n return FP_RP(ts)\r\n\r\n def n_cutoff(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n return noise_cutoff(amps, quartile_length=.25)\r\n\r\n def mean_amp_true(cluster_id):\r\n # Three cases: raw data\r\n\r\n # THIS APPROACH WORKS FOR BOTH SAMPLE WAVEFORMS AND RAW DATA\r\n # Specify 100 waveforms to average over, but may be less in the case where in the subset\r\n # of sample waveforms it doesn't contain 100 samples for specific cluster\r\n\r\n # N.B. These waveforms are median subtracted and have a high pass applied\r\n waveforms = controller._get_waveforms_with_n_spikes(\r\n cluster_id, 100)['data'].data\r\n\r\n # This way finds (max-min) on each channel, and then for each waveform finds the\r\n # maximum (max-min) on any channel and averages these\r\n # For each sample waveform find value on channel that has largest (max-min)\r\n p2p = np.max((np.max(waveforms, axis=1) - np.min(waveforms, axis=1)), axis=1)\r\n # Find mean p2p across all available sample waveforms\r\n p2p_mean = np.mean(p2p)\r\n\r\n # Alternative way\r\n # This way finds (max-min) on each channel, on each channel averages across all sample\r\n # waveforms and then finds the channel with the maximum average value\r\n p2p_mean_alt = np.max(np.mean(np.max(waveforms, axis=1) - np.min(waveforms, axis=1),\r\n axis=0))\r\n\r\n # Approach 2\r\n # Only works for sample waveforms\r\n # For non median subtracted and no high pass can access sample waveforms like this\r\n # spike_ids = controller.get_spike_ids(cluster_id).data\r\n # # Find which of the spike ids are in the subset of sample waveforms\r\n # _, _, idx = np.intersect1d(spike_ids,\r\n # controller.model.spike_waveforms['spike_ids'].data,\r\n # return_indices=True)\r\n # # Sample waveforms that are available for this cluster\r\n # # Shape of waveforms (n_waveforms, n_samples, n_channels)\r\n # # where len(idx) == n_waveforms\r\n # waveforms = controller.model.spike_waveforms['waveforms'][idx].data\r\n\r\n # RAW DATA CASE\r\n\r\n return p2p_mean\r\n\r\n # no waveforms\r\n\r\n # def ptp_sigma(cluster_id):\r\n # this also requires checking 3 cases above.\r\n\r\n def m_label(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n amps = controller.get_amplitudes(cluster_id).data\r\n metrics_label = int(FP_RP(ts) and noise_cutoff(amps, quartile_length=.25) < 20)\r\n return metrics_label\r\n # if amplitudes are correct (i.e. raw data or sample wfs exist):\r\n #metrics_label = (FP_RP(ts) and noise_cutoff(amps,quartile_length=.25)<20 and np.mean(amps)>50)\r\n\r\n # Use this dictionary to define custom cluster metrics.\r\n # We memcache the function so that cluster metrics are only computed once and saved\r\n # within the session, and also between sessions (the memcached values are also saved\r\n # on disk).\r\n controller.cluster_metrics['cv_amp'] = controller.context.memcache(cv_amp)\r\n controller.cluster_metrics['cum_amp_drift'] = controller.context.memcache(cum_amp_drift)\r\n\r\n # NOTE: the branch of phylib which defines model.spike_depths is not working yet\r\n # controller.cluster_metrics['cum_depth_drift'] = controller.context.memcache(\r\n # cum_depth_drift)\r\n\r\n controller.cluster_metrics['cv_fr'] = controller.context.memcache(cv_fr)\r\n controller.cluster_metrics['frac_isi_viol'] = controller.context.memcache(frac_isi_viol)\r\n controller.cluster_metrics['frac_missing_spikes'] = controller.context.memcache(\r\n frac_missing_spikes)\r\n controller.cluster_metrics['fp_estimate'] = controller.context.memcache(fp_estimate)\r\n controller.cluster_metrics['presence_ratio'] = controller.context.memcache(presence_ratio)\r\n controller.cluster_metrics['presence_ratio_std'] = controller.context.memcache(\r\n presence_ratio_std)\r\n controller.cluster_metrics['refp_viol'] = controller.context.memcache(refp_viol)\r\n controller.cluster_metrics['noise_cutoff'] = controller.context.memcache(n_cutoff)\r\n controller.cluster_metrics['mean_amp'] = controller.context.memcache(mean_amp_true)\r\n controller.cluster_metrics['metrics_label'] = controller.context.memcache(m_label)","def ridge_joint(trn_fs,trn_data,alphas,val_fs=None,val_data=None,square_alphas=False,chunk_sz=5000,is_verbose=True):\n\n n_resp, n_voxels = trn_data.shape\n n_channels = np.sum([tfs.shape[1] for tfs in trn_fs])\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\n\n if square_alphas:\n alphas = [a**2 for a in alphas]\n\n num_train_points = float(list(trn_data.shape)[0])\n num_val_points = float(list(val_data.shape)[0])\n\n n_abc = [np.minimum(*t_fs.shape) for t_fs in trn_fs]\n ######################################################################################\n ### --- First up: compute modified covariance matrix & scaled/rotated stimulus --- ###\n ######################################################################################\n # Perform SVD on training sets for all three models \n if is_verbose:\n print(\"computing SVD\")\n U_trn,W_trn,Vt_trn = [],[],[]\n for t_fs in trn_fs:\n uu,ww,vv = np.linalg.svd(trn_stim_A, full_matrices=False)\n U_trn.append(uu)\n W_trn.append(ww)\n Vt_trn.append(vv)\n\n # The square of Ws (the singular values from the SVD) are the eigenvalues of the covariance matrix but have not been divided by n-1.\n L = [ww**2/float(num_train_points-1) for ww in W_trn]\n\n ### --- IDK WTF. Ask Wendino. --- ###\n ## to change: make sure that Ws are in the right units (divided by n-1) when bootstrapping, so that alphas are already in correct units\n ## at that point you can change the lines below and not divide alpha by (n-1)\n # TO DO: make this more than one line for clarity.\n w_alpha_trn = [np.diag(np.sqrt(1./(LL + aa)/(num_train_points-1))) for LL,aa in zip(L,alphas)]\n #w1_alpha_trn = sqrt(1./(L1+ alphas_A2[0]/(num_train_points-1))) \n #w1_alpha_trn = diag(w1_alpha_trn) #%turn it from an array to a matrix\n\n # Create & combine rotated & scaled stimulus space \n X_prime_trn_t = [ww.dot(vv).dot(t_fs) for ww,vv,t_fs in zip(W_trn,Vt_trn,trn_fs)]\n #S1_prime_trn_t = np.dot(np.dot(w1_alpha_trn, Vt1_trn), trn_stim_A.T) #w1_alpha_trn = 1200x1200, Vt1_trn = 1200x1200, trn_stim_A.T = 1200x3737\n Xcomb_prime_trn_t = np.vstack(X_prime_trn_t)\n\n # Create & modify covariance matrix\n stim_cov_mat_r = X_prime_trn_t.dot(X_prime_trn_t.T) / float(num_train_points-1)\n cov_diag = np.sqrt(np.diag(stim_cov_mat_r))\n full_mat_cov_diag = np.tile(cov_diag, [cov_diag.shape[0], 1])\n # re-do w/ simpler syntax?\n all_divisor = np.multiply(full_mat_cov_diag.T, full_mat_cov_diag) \n corr_mat_r = np.divide(stim_cov_mat_r, all_divisor)\n\n ### --- Clean up the correlation matrix to have zeros where we know they exist and use that data to set a threshold --- ###\n idx_ct = np.cumsum([0]+n_abc)\n idxs = [(a,b) for a,b in zip(idx_ct[:-1],idx_ct[1:])]\n # Block diagonal components of covariance matrix\n for n,(ii,jj) in zip(n_abc,idxs):\n corr_mat_r[ii:jj] = np.eye(n)\n # Off-diagonal elements: ignore for now? \n #for i1,i2 in zip(idxs[:-1],idxs[1:]):\n # (ii,jj),(kk,ll) = i1,i2\n \n\n # ##### --- WORKING HERE - SEE IPYTHON NOTEBOOK --- #########\n # upper_right_corr = np.ravel(corr_mat_r[0:nA, nA:])\n # middle_right_corr = np.ravel(corr_mat_r[nA:(nA+nB),(nA+nB):])\n # right_corr = np.hstack([upper_right_corr, middle_right_corr])\n # s_right_corr = argsort(right_corr)\n # # WTF is this?\n # #corr_cutoff = 954 # WH magic number; something to do with the fact that it's needless to have \n # # ALL the block-diagonal diagonals, since we have limited data\n # #goodcorrs_idx = np.hstack([s_right_corr[0:corr_cutoff], s_right_corr[-1:-(corr_cutoff+1):-1]])\n\n # new_right_corrs = np.squeeze(np.zeros([s_right_corr.shape[0],1]))\n # #new_right_corrs[goodcorrs_idx] = right_corr[goodcorrs_idx]\n # new_upper_right_corrs = np.reshape(new_right_corrs[0:(nB+nC)*nA],[nA,nB+nC])\n # new_lower_left_corrs = new_upper_right_corrs.T\n # new_middle_right_corrs = np.reshape(new_right_corrs[(nB+nC)*nA:],[nB,nC])\n # new_middle_left_corrs = new_middle_right_corrs.T\n\n # ##NEED TO CHANGE THIS: REMOVE HARDCODED MATRIX SIZES\n # new_corr_mat_r = copy.copy(corr_mat_r)\n # new_corr_mat_r[0:nA, nA:]= new_upper_right_corrs\n # new_corr_mat_r[nA:(nA+nB), (nA+nB):] = new_middle_right_corrs\n # new_corr_mat_r[(nA+nB):, nA:(nA+nB)]= new_middle_left_corrs # More like bottom middle\n # new_corr_mat_r[nA:,0:nA] = new_lower_left_corrs # \n # new_corr_mat_r[0:nA,0:nA]= np.identity(nA)\n # new_corr_mat_r[nA:(nA+nB), nA:(nA+nB)] = np.identity(nB)\n # new_corr_mat_r[(nA+nB):,(nA+nB):] = np.identity(nC)\n\n #perform eigenvalue decomposition (WHAT FOR? delete this?)\n #w, v = np.linalg.eigh(new_corr_mat_r)\n # Invert modified covariance matrix\n #corr_r_inv = np.linalg.inv(new_corr_mat_r)\n corr_r_inv = np.linalg.inv(corr_mat_r)\n #for \n ##create filter\n dot1 = np.dot(X_prime_trn_t, trn_data) #precompute for speed\n dot2 = np.dot(corr_r_inv, dot1) #precompute for speed\n # Weights\n h_123_prime = np.divide(dot2, (float(num_train_points-1)))\n\n\n ##create estimated responses from training data\n #r_hat = np.dot(X_prime_trn_t.T, h_123_prime) # not usually done...\n #if do_pred:\n #validation set results\n val_stim_A_prime = np.dot(np.dot(w1_alpha_r, Vt1_r), val_stim_A.T)\n val_stim_B_prime = np.dot(np.dot(w2_alpha_r, Vh2_r), val_stim_B.T)\n val_stim_C_prime = np.dot(np.dot(w3_alpha_r, Vh3_r), val_stim_C.T)\n #S1_prime = S1_prime[0:200,:]\n #S2_prime = S2_prime[0:200,:]\n\n S123_val_prime_t = np.vstack([val_stim_A_prime, val_stim_B_prime, val_stim_C_prime])\n\n #create validation set correlations\n r_hat_val = np.dot(S123_val_prime_t.T, h_123_prime)\n\n\n #look at performance\n valcorr = _sutils.column_corr(r_hat_val, val_data)\n out = dict(\n #weights=wt,\n #alphas=alphas,\n #n_sig_vox_byalpha=n_sig_vox_byalpha,\n cc=valcorr\n )\n return out","def init_kern_act(num_pitches):\n\n kern_act = []\n\n for i in range(num_pitches):\n kern_act.append(Matern32(1, lengthscales=1.0, variance=3.5))\n return kern_act","def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\n \n # INPUTS FROM TTTW SYSTEM\n self.b = b #buoyancy field: [Ly,N]\n self.u = u # x-component of velocity [Ly,N]\n self.v = v # y-component of velocity [Ly+1,N]\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\n self.grid_dict = grid_dict #gridded data\n self.f = f #coriolis parameter\n # KPP-SPECIFIC VARIABLES \n self.hbls = np.zeros([self.b.shape[0]])\n self.hbbl = np.zeros([self.b.shape[0]])\n self.ustar = []\n self.bvf = [] \n self.kmo = []\n self.C_h_MO = []\n self.kbl = []\n self.Cr = [] \n self.Fc = []\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\n self.dt = dt","def hcn_tf(Y,t,voltage_clamp_func,voltage_clamp_params):\n \n v = voltage_clamp_func(t,voltage_clamp_params)\n n_s = Y[0]\n n_f = Y[1]\n \n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\n ninf_f = ninf_s\n\n if v > -70.0:\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\n else:\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\n\n dns = (ninf_s - n_s)/tau_ns\n dnf = (ninf_f - n_f)/tau_nf\n \n return [dns, dnf]","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def __init__(self, num_heads: int, size: int, size_v: int, dropout: float = 0.1):\n super(ContMultiHeadedAttention, self).__init__()\n\n assert size % num_heads == 0\n\n self.head_size = head_size = size // num_heads\n self.model_size = size\n self.num_heads = num_heads\n\n self.k_layer = nn.Linear(size, num_heads * head_size)\n self.v_layer = nn.Linear(size_v, num_heads * head_size)\n self.q_layer = nn.Linear(size, num_heads * head_size)\n\n self.output_layer = nn.Linear(size, size_v)\n self.softmax = nn.Softmax(dim=-1)\n self.dropout = nn.Dropout(dropout)","def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \n N_res=30):\n x_eps = 0.3 # shift from Dirac point\n x_res = 20\n kx_int = 0 + x_eps # -np.pi\n kx_fin = 4*np.pi/3 + x_eps\n Dx = (kx_fin - kx_int)/x_res\n\n y_res = 20\n ky_int = 0 # -np.pi\n ky_fin = 2*np.pi/np.sqrt(3)\n Dy = (ky_fin - ky_int)/y_res\n\n Nd = self.Nd # dimension of the Hamiltonian\n Dk = np.array([Dx,Dy], float)\n\n LF = np.zeros((Nd), dtype=complex)\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n sumN = np.zeros((Nd), dtype=complex)\n E_k = np.zeros((Nd), dtype=complex)\n chernN = np.zeros((Nd), dtype=complex)\n\n # Loop over kx\n for ix in range(x_res):\n kx = kx_int + ix*Dx\n\n # Loop over ky\n for iy in range(y_res):\n ky = ky_int + iy*Dy\n\n k_vec = np.array([kx,ky], float)\n\n LF, E_k = self.latF(k_vec, Dk, self.delta)\n\n sumN += LF\n\n # # save data for plotting\n LF_arr[:,ix,iy] = LF.imag\n\n E_arr[:,ix,iy] = np.sort(E_k.real)\n\n # End of ky Loop\n # End of kx Loop\n\n chernN = sumN.imag/(2*np.pi)\n print(\"Chern number bands are (%.3f, %.3f) \" \n %(chernN[0], chernN[1]))\n print(\"Sum of all bands Chern Number is %.2f \" %(sum(chernN)))\n return chernN, E_arr\n #################### ","def component_func(B, C, F, list_funcs, len_kegg, threshold=0.05):\n\n size_label = 18\n size_tick = 18\n sns.set_style(\"darkgrid\")\n\n list_funcs = list_funcs[0:len_kegg]\n B = B[0:len_kegg]\n C = C[0:len_kegg]\n\n idx_p = [idx*2+0 for idx in range(B.shape[1]/2)]\n idx_m = [idx*2+1 for idx in range(B.shape[1]/2)]\n is_p = F[:,idx_p].mean(axis=1) - F[:,idx_m].mean(axis=1) > threshold\n is_m = F[:,idx_m].mean(axis=1) - F[:,idx_p].mean(axis=1) > threshold\n is_p = [idx for idx, val in enumerate(is_p) if val]\n is_m = [idx for idx, val in enumerate(is_m) if val]\n is_n = [idx for idx in range(C.shape[1]) if (idx not in is_p) and (idx not in is_m)]\n\n fig = plt.figure(figsize=(6, 6))\n\n for idx_c in range(C.shape[1]):\n clone_num = idx_c +1\n if idx_c in is_p:\n color=\"green\"\n label = \"C\"+str(clone_num)+\"|P\"\n elif idx_c in is_m:\n color=\"red\"\n label = \"C\"+str(clone_num)+\"|M\"\n else:\n color = \"royalblue\"\n label = \"C\"+str(clone_num)\n\n if clone_num in [1]:\n marker = \"$1$\"\n elif clone_num in [2]:\n marker = \"$2$\"\n elif clone_num in [3]:\n marker = \"$3$\"\n elif clone_num in [4]:\n marker = \"$4$\"\n elif clone_num in [5]:\n marker = \"$5$\"\n elif clone_num in [6]:\n marker = \"$6$\"\n else:\n print(\"error\")\n plt.plot(C[:,idx_c],range(len_kegg), color=color, marker=marker, markersize=10, linestyle=\"\",label=label, alpha=0.5)\n\n plt.yticks(range(len_kegg), list_funcs)\n plt.xlabel(\"Pathway strength\", fontsize=size_label)\n plt.legend()\n plt.tick_params(labelsize=size_tick-4)\n plt.show()\n ##fig.savefig(\"figures/fig7compfunc.pdf\", bbox_inches=\"tight\")","def config_hog_search(self, img):\n img = img.astype(np.float32)/255 # scale image: (png: 0-1, jpg: 0-255)\n img_crop = img[self.ys[0]:self.ys[1], :, :] # crop img to relative dimensions (ROI)\n clr_trf = cvf.transform_colorspace(img_crop, self.color_space) # transform color space from RGB\n clr_trf = cvu.scale_image(clr_trf, self.scale) # scale rather than selecting diffferent window sizes\n ch1, ch2, ch3 = [clr_trf[:,:,ch] for ch in range(3)] # HOG operates on per channel basis\n\n # get hog features as multi-dimensional array per channel for the entire image\n params={'orient':self.orient, 'pix_per_cell':self.pix_per_cell, 'cells_per_block':self.cells_per_block}\n params.update({'vis':False, 'feature_vec':False})\n hog1,hog2,hog3 = [cvf.get_hog_features(ch, **params) for ch in ([ch1,ch2,ch3])]\n # block configurations\n self.nfeat_per_block = self.orient*self.cells_per_block**2\n self.nblocks_per_window = (self.window //self.pix_per_cell) -1\n # number_blocks: define number of hog cells across an image according to channel dimensions\n # number_steps: define number of steps to occur across hog array to extract features\n rows, cols = ch1.shape[:2]\n number_blocks = lambda max_dim, pix_per_cell: (max_dim // pix_per_cell) -1\n number_steps = lambda nblocks, nblocks_window, cells_step: (nblocks - nblocks_window)//cells_step\n self.nxblocks, self.nyblocks = number_blocks(cols, self.pix_per_cell), number_blocks(rows, self.pix_per_cell)\n nxsteps, nysteps = \\\n [number_steps(it, self.nblocks_per_window, self.cells_per_step) for it in (self.nxblocks, self.nyblocks) ]\n return clr_trf, (nxsteps, nysteps), (hog1,hog2,hog3)","def demo3(image_paths, arch, topk, stride, n_batches, output_dir, cuda):\n\n device = get_device(cuda)\n\n # Synset words\n classes = get_classtable()\n\n # Model from torchvision\n model = models.__dict__[arch](pretrained=True)\n model = torch.nn.DataParallel(model)\n model.to(device)\n model.eval()\n\n # Images\n images, _ = load_images(image_paths)\n images = torch.stack(images).to(device)\n\n print(\"Occlusion Sensitivity:\")\n\n patche_sizes = [10, 15, 25, 35, 45, 90]\n\n logits = model(images)\n probs = F.softmax(logits, dim=1)\n probs, ids = probs.sort(dim=1, descending=True)\n\n for i in range(topk):\n for p in patche_sizes:\n print(\"Patch:\", p)\n sensitivity = occlusion_sensitivity(\n model, images, ids[:, [i]], patch=p, stride=stride, n_batches=n_batches\n )\n\n # Save results as image files\n for j in range(len(images)):\n print(\"\\t#{}: {} ({:.5f})\".format(j, classes[ids[j, i]], probs[j, i]))\n\n # save_sensitivity(\n # filename=osp.join(\n # output_dir,\n # \"{}-{}-sensitivity-{}-{}.png\".format(\n # j, arch, p, classes[ids[j, i]]\n # ),\n # ),\n # maps=sensitivity[j],\n # )","def optical_kernels(K, J, Lxy, fmax, num):\n\n df = 1/Lxy\n\n # Compute TCC\n TCC, f = trans_cross_coeff(K, J, df, fmax)\n \n # Convert to 2D matrix\n N = f.size\n TCCm = np.reshape(np.reshape(TCC, (N, N, -1)), (N**2, -1))\n\n # Compute largest eigenvalues and eigenvectors\n w, v = scipy.linalg.eigh(TCCm, eigvals=(N**2 - num, N**2 - 1))\n w = np.flip(w, 0)\n v = np.flip(v, 1)\n\n # Get real-space optical kernels\n phi = []\n for i in range(num):\n Phi = np.fft.ifftshift(np.reshape(v[:,i], [N, N]))\n #phi.append(np.fft.fftshift(np.fft.ifft2(Phi)))\n phi.append(np.fft.ifft2(Phi))\n \n return w, phi","def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n pad=np.random.rand(nspad)/100\n trc_norm=trc/np.amax(np.abs(trc))\n trc_norm_padded=np.hstack((pad,trc_norm))\n trc_entropy=self.entropy(trc_norm_padded,50)\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\n for i,j in enumerate(trc):\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def build_param_grid(self, C_list:list=[0.1, 1, 10, 100], gamma_list:list=[1, 0.1, 0.01, 0.001], kernel_list:list=['rbf']):\n ans = {}\n ans['C'] = C_list\n ans['gamma'] = gamma_list\n ans['kernel'] = kernel_list\n self.param_grid = ans\n return ans","def dispersion_1(ztop, vp, vs, rh,\n Waves, Types, Modes, Freqs,\n h = 0.005, dcl = 0.005, dcr = 0.005, keepnans = False):\n waves, types, modes, freqs = igroupbywtm(Waves, Types, Modes, Freqs)\n values = dispersion(ztop, vp, vs, rh, \\\n waves, types, modes, freqs,\n h = h, dcl = dcl, dcr = dcr)\n\n for w, t, m, F, V in groupbywtm(waves, types, modes, freqs, values, keepnans = keepnans):\n yield w, t, m, F, V","def default_grid_feature_hp_kernel_config(defn):\n defn = _validate_definition(defn)\n config = {}\n\n grid = enumerate(zip(defn.models(), defn.hyperpriors()))\n\n for fi, (model, priors) in grid:\n partials = copy.deepcopy(model.default_partial_hypergrid())\n if not partials:\n continue\n\n evals = []\n for update_descs, fn in priors.iteritems():\n if not hasattr(update_descs, '__iter__'):\n update_descs = [update_descs]\n keyidxs = []\n for update_desc in update_descs:\n key, idx = _parse_descriptor(update_desc, default=None)\n keyidxs.append((key, idx))\n\n def func(raw, keyidxs):\n s = 0.\n for key, idx in keyidxs:\n if idx is None:\n s += raw[key]\n else:\n s += raw[key][idx]\n return s\n evals.append(lambda raw, keyidxs=keyidxs: func(raw, keyidxs))\n\n def jointprior(raw, evals):\n return np.array([f(raw) for f in evals]).sum()\n\n config[fi] = {\n 'hpdf': lambda raw, evals=evals: jointprior(raw, evals),\n 'hgrid': partials,\n }\n\n if not config:\n return []\n else:\n return [('grid_feature_hp', config)]","def one_iteration_step(self, tsm, tank, chp, kessel, cvalve, heizkurve, t_a, el_heat_status, actual_time, heatc_conf):\n #print('\\n chp = {}; kessel = {}; t2 = {}; t3 = {}'.format(chp.get_status(), kessel.get_status(), self.t2, self.t3))\n # combined heat and power unit - link outputs\n wyn = chp.get_chp()\n #self.t27 = wyn[1] # tin in °C = self.t1 = wyn[t1]\n self.t26 = wyn[2] # tout in °C = chp.get_out_temp = wyn[2]\n m3 = wyn[3] # mstr in kg/s \n self.V_3 = m3 / utils.rho_fluid_water(self.t26, self.p_atm, 1) # volume flow incoming to chp from tank\n V_chp = chp.get_volume_flow_at_output() # volume flow outoming from chp into tank\n # combined heat and power unit - link inputs\n chp.set_inp_temp(self.t27) # temperature incoming from tank to chp\n\n # ..............................................................\n\n # gas boiler - link outputs\n wyn = kessel.get_kessel()\n #self.t29 = wyn[1] # tin in °C - incoming into gas heater\n self.t28 = wyn[2] # tout in °C - outcoming from gas heater\n m4 = wyn[3] # mstr in kg/s - incoming into gas heater\n self.V_4 = kessel.get_volume_flow_at_input()\n V_kessel = kessel.get_volume_flow_at_output()\n # gas boiler - link inputs\n kessel.set_inp_temp(self.t29)\n #kessel.calc_mass_flow()\n\n # ..............................................................\n # at first no delay - just linking chp and heater\n # delay due to the seuence of commands ie equal to the Timestep length\n self.t27 = self.t1\n self.t29 = self.t1\n # ..............................................................\n\n # heating circuit\n self.t23 = self.t20 # no delay assumed\n #print('t20 = {}; t23 = {}'.format(self.t20, self.t23))\n self.t25 = heizkurve.get_supply_temperature(t_a)\n self.t24 = heizkurve.get_return_temperature(t_a)\n heizkurve.calc_volume_flow()\n\n # comprehensive control algorithm - it stays\n (m23, m25, m4) = self.control_internal_1(heizkurve, kessel, chp, cvalve, t_a, actual_time, m4, heatc_conf)\n\n m_bypass = m25 - m23\n rho23 = utils.rho_fluid_water(self.t23, self.p_atm, 1)\n V_23 = m23 / rho23 # in m3/s = kg/s / kg/m3\n #print('V_23 = {}; m23 = {}; rho23 = {}; t23 = {}'.format(V_23,m23, rho23, self.t23))\n m24 = m23\n rho24 = utils.rho_fluid_water(self.t24, self.p_atm, 1)\n V_24 = m24 / rho24\n \n # demand for domestic hot water\n m22 = self.V_1 * utils.rho_fluid_water(self.t22, self.p_atm, 1) # in kg/s = m3/s * kg/m3\n #m22 = 0.01 # kg/s\n # ..............................................................\n\n t_ambient = 15.0\n # storage tank - calculation\n tank.calculate_storage_tank_obj(tsm, # time step manager\n self.t23, # hk_inp_temp\n V_23, # hk_inp_volfl_m3s\n self.t24, # hk_out_temp\n self.t27, # chp_inp_temp\n self.t26, # chp_out_temp\n self.V_3, # chp_inp_volfl_m3s\n self.t29, # gb_inp_temp\n self.t28, # gp_out_temp\n self.V_4, # gb_inp_volfl_m3s\n self.t22, # dhw_inp_temp\n self.t21, # dhw_out_temp\n self.V_1, # dhw_inp_volfl_m3s\n el_heat_status, # el_heat_status\n actual_time, # time in the timestamp format\n t_ambient) # ambient temperature of the tank - defines heat losses to the outside\n \n self.t21 = tank.get_temp_dhw()\n #self.t27 = \n #self.t29 = \n #self.t23 = \n \n # storage tank - linking\n [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, \n self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20] = tank.output_temperatures()\n\n # ..............................................................\n # get rid of this part\n #self.control_internal_2(chp, kessel, actual_time, m4)\n # ..............................................................\n heizwert_in_MJ_per_kg = 50.0 # kg/m3 N ~CH4\n gas_density = 0.79 # kg/m3 N ~Erdgas\n Z_boiler = kessel.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\n self.Z_2 = chp.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\n self.Z_1 = self.Z_2 + Z_boiler\n \n self.Wh1 = -1.0 * chp.get_el_prod()\n self.Wh2 = tank.get_el_heater_consumption()\n self.Wh3 = self.Wh1 + self.Wh2 + self.electricity_consumption_kWh\n #print('END chp = {}; kessel = {}; heating = {}; t2 = {}; t3 = {};V1 = {}; V2 = {}; V3 = {}; V4 = {}; t_a = {}'.format(chp.get_status(), kessel.get_status(), heizkurve.get_status(), self.t2, self.t3, self.V_1, self.V_2, self.V_3, self.V_4, t_a))","def model(**params):\n N_frb = 0\n vs = []\n hs = []\n cs = []\n ncands = []\n\n for cand in candlist:\n c_res = calculate_metric_terms(\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\n )\n t, frb_found, h, c, v = c_res\n vs.append(v)\n hs.append(h)\n cs.append(c)\n ncands.append(t)\n\n if frb_found:\n N_frb += 1\n\n vs = np.array(vs)\n hs = np.array(hs)\n cs = np.array(cs)\n c_avg = np.average(cs, axis=0, weights=ncands)\n h_avg = np.average(hs, axis=0, weights=ncands)\n v_avg = np.average(vs, axis=0, weights=ncands)\n recall = N_frb / len(vs)\n score = v_avg * recall\n\n return score","def main():\n # Directory where the DICOM files are being stored (in this\n input_path = './Inputs/valve'\n\n # Original image from the filepath\n img_original = read_image(input_path)\n\n # Image with smoothing applied to reduce noise\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\n\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\n\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \"blood\" without cardiac tissue,\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\n # valve tissue from the rest - all we need is the overlap of the two labels\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\n\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\n\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\n x_mid = df['x'].mean()\n y_mid = df['y'].mean()\n df = get_df_from_img(labels_valve_filtered)\n distance_df = df.drop('z', axis=1)\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\n labels = fit.labels_\n df['label'] = pd.Series(labels)\n counts = df['label'].value_counts().to_dict()\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Use a segmentation-based clustering algorithm to attempt to find each valve\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\n\n left, right = (label_segments[0], label_segments[1])\n if x_max[0] > x_max[1]:\n left, right = right, left\n\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\n # this can be done by every z value\n left_points = {'x': [], 'y': [], 'z': []}\n right_points = {'x': [], 'y': [], 'z': []}\n zlen = len(sitk.GetArrayFromImage(left))\n for z in xrange(zlen):\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\n if len(left_df['y']) > 0:\n index = left_df['y'].idxmin()\n row = left_df.iloc[index]\n left_points['x'].append(int(row['x']))\n left_points['y'].append(int(row['y']))\n left_points['z'].append(z)\n\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\n if len(right_df['x']) > 0:\n index = right_df['x'].idxmax()\n row = right_df.iloc[index]\n right_points['x'].append(int(row['x']))\n right_points['y'].append(int(row['y']))\n right_points['z'].append(z)\n\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\n # points\n final_left = pd.DataFrame.from_dict(left_points)\n final_right = pd.DataFrame.from_dict(right_points)\n print('Coordinates for one side of the ring')\n print(final_left)\n print('\\n\\nCoordinates for the other side of the ring')\n print(final_right)\n\n final_image = make_empty_img_from_img(left)\n x = left_points['x'] + right_points['x']\n y = left_points['y'] + right_points['y']\n z = left_points['z'] + right_points['z']\n for x, y, z in zip(x, y, z):\n final_image.SetPixel(x, y, z, 1)\n\n show_all(img_smooth, final_image)","def predit_vehicles(img, windows,\n scaler = None,\n classifier = None,\n decision = DECISION_THRESHOLD,\n view=True,\n save_path=None,\n prefix=None,\n debug=True):\n car_features_list = []\n for window in windows:\n sub_img = cv2.resize(\n get_sub_image(img, window), CLASSIFIER_IMG_SIZE)\n one_features = extract_one_features(\n sub_img,\n cspace=CSPACE, spatial_size=(32, 32),\n hist_bins=32, hist_range=(0, 256),\n orient=ORIENTS_HOG, pix_per_cell=PIX_PER_CELL,\n cell_per_block=CELLS_PER_BLOCK,\n hog_channel=HOG_CHANNEL)\n car_features_list.append(\n # scaler.transform(np.asarray(one_features, dtype=np.float64)))\n one_features)\n scaled_list = scaler.fit_transform(car_features_list)\n #if view:\n # show_features(scaled_list)\n decs = classifier.decision_function(scaled_list)\n #predicts = classifier.predict(scaled_list)\n #predicts_bool = predicts.astype(np.bool)\n\n car_windows = []\n #for p, w in zip(predicts_bool, windows):\n # if p:\n for d, w in zip(decs, windows):\n if (d > decision): ## positive decision threshold\n # print (\"dec\", d)\n car_windows.append(w)\n #if view:\n # show_grid_view(img, car_windows)\n if save_path is not None:\n save_sub_images(img, car_windows,\n path=save_path,\n prefix=prefix,\n size=CLASSIFIER_IMG_SIZE)\n return car_windows","def init_stitch(N):\n\tif N is None:\n\t\tN = np.int32(HII_DIM) #prepare for stitching\n\tMETA_GRID_SIZE = DIM/N\n\tM = np.int32(HII_DIM/META_GRID_SIZE)\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN/DIM)\n\tprint 'scale', scale\n\tHII_scale = np.float32(BOX_LEN/HII_DIM)\n\tshape = (DIM,DIM,N)\n\tstitch_grid_size = (DIM/(block_size[0]),\n\t\t\t\t\t\tDIM/(block_size[0]),\n\t\t\t\t\t\tN/(block_size[0]))\n\tHII_stitch_grid_size = (HII_DIM/(block_size[0]),\n\t\t\t\t\t\tHII_DIM/(block_size[0]),\n\t\t\t\t\t\tM/(block_size[0]))\n\t#ratio of large box to small size\n\tkernel_source = open(cmd_folder+\"/initialize_stitch.cu\").read()\n\tkernel_code = kernel_source % {\n\n\t\t'DELTAK': DELTA_K,\n\t\t'DIM': DIM, \n\t\t'VOLUME': VOLUME,\n\t\t'META_BLOCKDIM': N\n\t}\n\tmain_module = nvcc.SourceModule(kernel_code)\n\tinit_stitch = main_module.get_function(\"init_kernel\")\n\tHII_filter = main_module.get_function(\"HII_filter\")\n\tsubsample_kernel = main_module.get_function(\"subsample\")\n\tvelocity_kernel = main_module.get_function(\"set_velocity\")\n\tpspec_texture = main_module.get_texref(\"pspec\")\n\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\n\tplan2d = Plan((np.int64(DIM), np.int64(DIM)), dtype=np.complex64)\n\tplan1d = Plan((np.int64(DIM)), dtype=np.complex64)\n\tprint \"init pspec\"\n\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\n\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\n\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\n\t#hbox_large = pyfftw.empty_aligned((DIM, DIM, DIM), dtype='complex64')\n\thbox_large = np.zeros((DIM, DIM, DIM), dtype=np.complex64)\n\t#hbox_small = np.zeros(HII_shape, dtype=np.float32)\n\t#hbox_large = n\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\n\t# Set up pinned memory for transfer\n\t#largebox_hs = cuda.aligned_empty(shape=shape, dtype=np.float32, alignment=resource.getpagesize())\n\tlargebox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.float32)\n\tlargecbox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.complex64)\n\n\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\n\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\n\tprint \"init boxes\"\n\tfor meta_z in xrange(META_GRID_SIZE):\n\t\t# MRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=meta_x*N**3)\n\t\tinit_stitch(largebox_d, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\n\t\tinit_stitch(largebox_d_imag, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\n\t\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\n\t\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\n\t\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\n\t\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\n\t\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largecbox_pin.copy()\n\t#if want to get velocity need to use this\n\tif True:\n\t\tprint \"saving kbox\"\n\t\tnp.save(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN), hbox_large)\n\n\tprint \"Executing FFT on device\"\n\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\n\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\n\tprint hbox_large.dtype\n\tprint \"Finished FFT on device\"\n\tnp.save(parent_folder+\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN), hbox_large)\n\t\n\tif True:\n\t\tprint \"loading kbox\"\n\t\thbox_large = np.load(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN))\n\tfor meta_z in xrange(META_GRID_SIZE):\n\t\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\n\t\t#cuda.memcpy_htod_async(largebox_d, largebox_pin)\n\t\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\tHII_filter(largebox_d, DIM, np.int32(meta_z), ZERO, smoothR, block=block_size, grid=stitch_grid_size);\n\t\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largebox_d.get_async()\n\t#import IPython; IPython.embed()\n\tprint \"Executing FFT on host\"\n\t#hbox_large = hifft(hbox_large).astype(np.complex64).real\n\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\n\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\n\tprint \"Finished FFT on host\"\n\t#import IPython; IPython.embed()\n\n\t# for meta_x in xrange(META_GRID_SIZE):\n\t# \tfor meta_y in xrange(META_GRID_SIZE):\n\t# \t\tfor meta_z in xrange(META_GRID_SIZE):\n\t# \t\t\tlargebox_d = gpuarray.to_gpu(hbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N])\n\t# \t\t\tHII_filter(largebox_d, N, np.int32(meta_x), np.int32(meta_y), np.int32(meta_z), ZERO, smoothR, block=block_size, grid=grid_size);\n\t# \t\t\thbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N] = largebox_d.get()\n\t#plan = Plan(shape, dtype=np.complex64)\n\t#plan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\n\n\t# This saves a large resolution deltax\n\n\t\n\tprint \"downsampling\"\n\tsmallbox_d = gpuarray.zeros((HII_DIM,HII_DIM,M), dtype=np.float32)\n\tfor meta_z in xrange(META_GRID_SIZE):\n\t\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\n\t\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\n\t\t#largebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\tlargebox_d /= scale**3 #\n\t\tsubsample_kernel(largebox_d, smallbox_d, DIM, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size) #subsample in real space\n\t\thbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallbox_d.get_async()\n\tnp.save(parent_folder+\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(HII_DIM, BOX_LEN), hbox_small)\n\t#import IPython; IPython.embed()\n\n\n\t# To get velocities: reload the k-space box\n\thbox_large = np.load(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN))\n\thvbox_large = np.zeros((DIM, DIM, DIM), dtype=np.float32)\n\thvbox_small = np.zeros(HII_shape, dtype=np.float32)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tlargevbox_d = gpuarray.zeros((DIM,DIM,N), dtype=np.complex64)\n\tsmallvbox_d = gpuarray.zeros((HII_DIM, HII_DIM, M), dtype=np.float32)\n\tfor num, mode in enumerate(['x', 'y', 'z']):\n\t\tfor meta_z in xrange(META_GRID_SIZE):\n\t\t\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\t\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\t\t\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(meta_z), np.int32(num), block=block_size, grid=stitch_grid_size)\n\t\t\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=stitch_grid_size)\n\t\t\tprint hvbox_large.shape, largevbox_d.shape\n\t\t\thvbox_large[:, :, meta_z*N:(meta_z+1)*N] = largevbox_d.get_async()\n\t\thvbox_large = fft_stitch(N, plan2d, plan1d, hvbox_large, largevbox_d).real\n\t\tfor meta_z in xrange(META_GRID_SIZE):\n\t\t\tlargevbox_d = gpuarray.to_gpu_async(hvbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\t\tsubsample_kernel(largevbox_d.real, smallvbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size)\n\t\t\thvbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallvbox_d.get_async()\n\t\tnp.save(parent_folder+\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\".format(mode, HII_DIM, BOX_LEN), smallvbox_d.get())\n\n\treturn","def weight_list_rsexecute_workflow(vis_list, model_imagelist, gcfcf=None, weighting='uniform', robustness=0.0,\n **kwargs):\n if gcfcf is None:\n gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(m, oversampling=1) for m in model_imagelist]\n \n def grid_wt(vis, model, g):\n if vis is not None:\n if model is not None:\n griddata = create_griddata_from_image(model, vis)\n if isinstance(vis, BlockVisibility):\n griddata = grid_blockvisibility_weight_to_griddata(vis, griddata, g[0][1])\n else:\n griddata = grid_visibility_weight_to_griddata(vis, griddata, g[0][1])\n \n return griddata\n else:\n return None\n else:\n return None\n \n weight_list = [rsexecute.execute(grid_wt, pure=True, nout=1)(vis_list[i], model_imagelist[i],\n gcfcf)\n for i in range(len(vis_list))]\n \n merged_weight_grid = rsexecute.execute(griddata_merge_weights, nout=1)(weight_list)\n merged_weight_grid = rsexecute.persist(merged_weight_grid, broadcast=True)\n \n def re_weight(vis, model, gd, g):\n if gd is not None:\n if vis is not None:\n # Ensure that the griddata has the right axes so that the convolution\n # function mapping works\n agd = create_griddata_from_image(model, vis)\n agd.data = gd[0].data\n if isinstance(vis, BlockVisibility):\n vis = griddata_blockvisibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\n else:\n vis = griddata_visibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\n return vis\n else:\n return None\n else:\n return vis\n \n result = [rsexecute.execute(re_weight, nout=1)\n (v, model_imagelist[i], merged_weight_grid, gcfcf)\n for i, v in enumerate(vis_list)]\n \n return rsexecute.optimize(result)","def getPartitionFunction(self, Tlist):\n\t\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\n\t\t# Active K-rotor\n\t\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\n\t\tif len(rotors) == 0:\n\t\t\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\n\t\t\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\t# Other modes\n\t\tfor mode in self.modes:\n\t\t\tQ0 = mode.getPartitionFunction(Tlist)\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\treturn Q","def init():\n\tN = np.int32(DIM) #prepare for stitching\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN)/DIM\n\tHII_scale = np.float32(BOX_LEN)/HII_DIM\n\tshape = (N,N,N)\n\t\n\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\n\n\tkernel_source = open(cmd_folder+\"/initialize.cu\").read()\n\tkernel_code = kernel_source % {\n\n\t\t'DELTAK': DELTA_K,\n\t\t'VOLUME': VOLUME,\n\t\t'DIM': DIM\n\t}\n\tmain_module = nvcc.SourceModule(kernel_code)\n\tinit_kernel = main_module.get_function(\"init_kernel\")\n\tHII_filter = main_module.get_function(\"HII_filter\")\n\tadj_complex_conj = main_module.get_function(\"adj_complex_conj\")\n\tsubsample_kernel = main_module.get_function(\"subsample\")\n\tvelocity_kernel = main_module.get_function(\"set_velocity\")\n\tpspec_texture = main_module.get_texref(\"pspec\")\n\n\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\n\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\n\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\n\n\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\n\tinit_kernel(largebox_d, np.int32(DIM), block=block_size, grid=grid_size)\n\n\t#import IPython; IPython.embed()\n\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\n\tinit_kernel(largebox_d_imag, np.int32(DIM), block=block_size, grid=grid_size)\n\n\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\n\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\n\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\n\n\t#adj_complex_conj(largebox_d, DIM, block=block_size, grid=grid_size)\n\tlargebox = largebox_d.get()\n\t#np.save(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc\".format(DIM, BOX_LEN), largebox)\n\n\t#save real space box before smoothing\n\tplan = Plan(shape, dtype=np.complex64)\n\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\tlargebox_d /= scale**3\n\tnp.save(parent_folder+\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(DIM, BOX_LEN), largebox_d.real.get_async())\n\n\t#save real space box after smoothing and subsampling\n\t# host largebox is still in k space, no need to reload from disk\n\tlargebox_d = gpuarray.to_gpu(largebox)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tHII_filter(largebox_d, N, ZERO, smoothR, block=block_size, grid=grid_size);\n\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\tlargebox_d /= scale**3\n\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\n\tsubsample_kernel(largebox_d.real, smallbox_d, N, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_grid_size) #subsample in real space\n\tnp.save(parent_folder+\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(HII_DIM, BOX_LEN), smallbox_d.get_async())\n\n\t# reload the k-space box for velocity boxes\n\tlargebox_d = gpuarray.to_gpu(largebox)\n\t\n\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tlargevbox_d = gpuarray.zeros((DIM,DIM,DIM), dtype=np.complex64)\n\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\n\tfor num, mode in enumerate(['x', 'y', 'z']):\n\t\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(num), block=block_size, grid=grid_size)\n\t\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=grid_size)\n\t\tplan.execute(largevbox_d, inverse=True)\n\t\tlargevbox_d /= scale**3\n\t\t#import IPython; IPython.embed()\n\t\tsubsample_kernel(largevbox_d.real, smallbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_grid_size)\n\t\tnp.save(parent_folder+\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\".format(mode, HII_DIM, BOX_LEN), smallbox_d.get())\n\n\treturn","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def ridge_cv(trn_fs, trn_data, val_fs=None, val_data=None, alphas=DEFAULT_ALPHAS, \n n_resamps=10, n_splits=10, chunk_sz=5000, dtype=np.single,pthr=0.005,\n square_alpha=False,is_verbose=False):\n #def ridge_cv(model,data,n_splits=10,n_resamps=10,alpha=DEFAULT_ALPHAS,efficient=np.nan,):\n # (trn_fs, trn_data, val_fs, val_data, alphas, nboots, chunklen, n_chunks, dtype=np.single, corrmin=0.2):\n n_resp, n_voxels = trn_data.shape\n _,n_channels = trn_fs.shape\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\n bestalphas = np.zeros((n_resamps, n_voxels)) ## Will hold the best alphas for each voxel\n trn_idx,val_idx = _utils.contig_partition(trn_fs.shape[0],n_splits)\n\n Rcmats = np.zeros((n_voxels,len(alphas),n_resamps))\n for iRpt,cvi in enumerate(np.random.permutation(n_splits)[:n_resamps]):\n if is_verbose:\n print('Running split %d/%d'%(iRpt+1,n_resamps))\n ti,vi = trn_idx[cvi],val_idx[cvi]\n trn_fs_split = trn_fs[ti,:]\n val_fs_split = trn_fs[vi,:]\n trn_data_split = trn_data[ti,:]\n val_data_split = trn_data[vi,:]\n \n # Run ridge regression to estimate predictions (within training set) for different alphas\n Rcmats[:,:,iRpt] = _fit_ridge_alpha(trn_fs_split, trn_data_split, val_fs_split, val_data_split, alphas,\n dtype=dtype, chunk_sz=chunk_sz,pthr=pthr,square_alpha=square_alpha)\n if is_verbose:\n print(\"Finding best alpha...\")\n ## Find best alpha for each voxel\n #trncc_byvox = np.nansum(Rcmats,axis=2)/np.sum(np.logical_not(np.isnan(Rcmats)),axis=2)\n trncc_byvox = np.nanmean(Rcmats,axis=2)\n # Taking mean is BS: too many voxels poorly predicted, floor effect. \n #mean_cv_corr = np.nanmean(mean_cv_corr_byvox,axis=0)\n #bestalphaind = np.argmax(mean_cv_corr)\n # Thus just count voxels over significance threshold (with a lenient threshold)\n #print(len(vi))\n sig_thresh = _sutils.pval2r(pthr,len(vi),is_two_sided=False)\n n_sig_vox_byalpha = sum(trncc_byvox>sig_thresh)-sum(trncc_byvox<-sig_thresh)\n bestalphaind = np.argmax(n_sig_vox_byalpha)\n alpha = alphas[bestalphaind]\n if is_verbose:\n print(\"Best alpha = %0.3f\"%alpha)\n \n ## Find weights for each voxel\n U,S,Vt = np.linalg.svd(trn_fs, full_matrices=False)\n # Loop over groups of voxels\n wt = np.zeros((n_channels,n_voxels),dtype=dtype)\n\n ###\n if (not val_fs is None) and (not val_data is None):\n # Validation data / model supplied implies we want predictions\n do_pred = True\n if np.sum(val_fs[:,0]) != val_fs.shape[0]:\n warnings.warn('First column of val_fs is NOT all ones! Consider including a DC term!')\n # Pre-allocate for predictions, with or without separate validation sequences to predict\n is_rpts = np.ndim(val_data)==3\n if is_rpts:\n n_rpts,n_tps_val,n_voxels_val = val_data.shape\n cc = np.zeros((n_rpts,n_voxels),dtype);\n else:\n n_rpts,(n_tps_val,n_voxels_val) = 0,val_data.shape\n cc = np.zeros((n_voxels),dtype);\n pred = np.zeros((n_tps_val,n_voxels_val),dtype)\n else:\n # No Validation data / model supplied\n do_pred = False;\n\n if is_verbose:\n predstr = ' and model predictions...' if do_pred else \"...\"\n print('Computing weights'+predstr)\n for iChunk in range(n_chunks):\n if is_verbose:\n print('Running chunk %d of %d...\\n'%(iChunk+1,n_chunks))\n ChIdx = np.arange(chunk_sz) + chunk_sz*iChunk\n ChIdx = ChIdx[ChIdx<n_voxels] # clip extra voxels in last run.\n Ychunk = trn_data[:,ChIdx]\n\n UtYchunk = np.dot(U.T, np.nan_to_num(Ychunk))\n if square_alpha:\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha**2)), UtYchunk])\n else:\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha)), UtYchunk])\n\n ## Find test correlations if validation data is present\n if do_pred:\n # Compute correlations btw validation data and model prediction\n pred[:,ChIdx] = val_fs.dot(wt[:,ChIdx]).astype(dtype) \n nnpred = np.nan_to_num(pred[:,ChIdx])\n if is_rpts:\n # The transpose here is related to deep mysteries in python. See \n cc[:,ChIdx] = np.vstack([_sutils.column_corr(nnpred,val_data[rpt,:,ChIdx].T) for rpt in range(n_rpts)])\n else:\n cc[ChIdx] = _sutils.column_corr(nnpred,val_data[:,ChIdx])\n\n # Output\n out = dict(\n weights=wt,\n alpha=alpha,\n n_sig_vox_byalpha=n_sig_vox_byalpha,\n #trncc_byvox=trncc_byvox,f\n #trncc_byvox_byalpha=Rcmats\n )\n if not val_data is None: \n out['cc'] = cc\n return out","def compute_gain( hv, cv, thot, tcold):\n\n nData = len(cv) \n epsilons = np.full( nData, EPSILON)\n\n # For full Temp calibration, a spectrum taken at high elevation, away from \n # The galactic plan is used.\n dv = hv - cv \n dv = np.maximum( dv, epsilons)\n hv = np.maximum( hv, epsilons)\n\n # use the comparison of hot and cold to get gain without trx contribution\n gain = (thot - tcold)/dv\n\n trx = gain*cv \n trx = trx - tcold # correct for cold load input in counts\n\n n6 = int(nData/6)\n n56 = 5*n6\n\n trxmedian = np.median( trx[n6:n56])\n gain = (thot + trxmedian)/hv\n \n return trxmedian, gain # channel by channel gain in K/counts","def model(cp_list,cp_now):\r\n global record\r\n distance_threshold = 0.5\r\n model_path = \"trained_knn_model.clf\"\r\n \r\n # Load a trained KNN model (if one was passed in)\r\n with open(model_path, 'rb') as f:\r\n knn_clf = pickle.load(f)\r\n\r\n for X_img in cp_list:\r\n # Load image file and find face locations\r\n X_face_locations = face_recognition.face_locations(X_img)\r\n\r\n # If no faces are found in the image, return an empty result.\r\n if len(X_face_locations) == 0:\r\n return []\r\n\r\n # Find encodings for faces in the test iamge\r\n faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)\r\n\r\n # Use the KNN model to find the best matches for the test face\r\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\r\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]\r\n # Predict classes and remove classifications that aren't within the threshold\r\n for pred, rec in zip(knn_clf.predict(faces_encodings), are_matches):\r\n if rec:\r\n name = pred\r\n else:\r\n name = \"unknown\"\r\n if name not in record:\r\n end = datetime.now()\r\n record.append(name)\r\n record_time.append(end-cp_now)","def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\n pi, ids = induced_distribution(hmsm, 0, level)\n\n discrete_free_energy = np.ndarray(pi.shape)\n for i, id in enumerate(ids):\n discrete_free_energy[i] = \\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\n boltzmann = np.exp(-discrete_free_energy/kT)\n boltzmann *= (1/np.sum(boltzmann))\n return D_KL(boltzmann, pi)","def kick_from_eccentric_tides(self):\n\n inv_r_7 = self.inv_r**7\n r0_5 = self.pair[0].radius ** 5\n r1_5 = self.pair[1].radius ** 5\n m0_2 = self.pair[0].mass * self.pair[0].mass\n m1_2 = self.pair[1].mass * self.pair[1].mass\n\n ftr = -3.0 * inv_r_7 * constants.G * ((m1_2 * r0_5 * self.pair[0].kaps + m0_2 * r1_5 * self.pair[1].kaps) + # Non-dissipative\n 3 * self.inv_r * self.rdot_mag *\n (m1_2 * r0_5 * self.pair[0].kaps * self.pair[0].taulag\n + m0_2 * r1_5 * self.pair[1].kaps * self.pair[1].taulag)) # Dissipative\n\n hutforce = ftr * self.inv_r * self.pos\n kick0 = (1.0 / self.pair[0].mass) * hutforce * self.dt\n kick1 = (-1.0 / self.pair[1].mass) * hutforce * self.dt\n\n self.pair[0].velocity += kick0\n self.pair[1].velocity += kick1","def kViterbi(crf_obj, emissions, topK, mask):\n assert topK >=1\n if topK == 1:\n seq_length = emissions.size(1)\n best_path = crf_obj.decode(emissions, mask)\n observation = pad_seq(best_path, seq_length, crf_obj.batch_first, 0)\n best_probs = calculate_prob_byObser(crf_obj, emissions, observation, mask)\n return best_path, best_probs.squeeze()\n\n crf_obj._validate(emissions, mask=mask)\n if mask is None:\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\n if crf_obj.batch_first:\n emissions = emissions.transpose(0, 1)\n mask = mask.transpose(0, 1)\n normalizer = crf_obj._compute_normalizer(emissions, mask)\n # ===============start main part========================\n # emissions: (seq_length, batch_size, num_tags)\n # mask: (seq_length, batch_size)\n assert emissions.dim() == 3 and mask.dim() == 2\n assert emissions.shape[:2] == mask.shape\n assert emissions.size(2) == crf_obj.num_tags\n assert mask[0].all()\n\n seq_length, batch_size = mask.shape\n\n # Start transition and first emission\n # score is a tensor of size(batch_size, num_tags, topK) where for each\n # batch, value at tags i and top j stores the scores of the j-th best tag\n # sequence so far that ends with tag i\n #\n # pre_states saves the previous tag where the j-th best path that ends with tag i currently\n score = emissions.new_zeros((seq_length, batch_size, crf_obj.num_tags, topK))\n score[0,:,:,0] = crf_obj.start_transitions + emissions[0] # batch x num_tags\n\n pre_states = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\n for i in range(crf_obj.num_tags):\n for b in range(batch_size):\n for k in range(topK):\n pre_states[0,b,i,k] = i # should be start transition\n\n # The ranking of multiple paths through same state\n rank = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\n for t in range(1, seq_length):\n next_score_list = []\n for k in range(topK):\n broadcast_score = score[t-1,:,:,k].unsqueeze(2) #(batch_size, num_tags, 1)\n broadcast_emissions = emissions[t].unsqueeze(1) #(batch_size, 1, num_tags)\n\n # Compute the score tensor of size (batch_size, num_tags, num_tags)\n # where for each sample, entry at row i and column j stores\n # the sum of scores of all possible tag sequences so far that end\n # with transitioning from tag i to tag j and emitting\n # shape: (batch_size, num_tags, num_tags)\n next_score = broadcast_score + crf_obj.transitions + broadcast_emissions\n next_score_list.append(next_score)\n\n for b in range(batch_size):\n if mask[t,b]:\n for cur_state in range(crf_obj.num_tags):\n h = []\n for pre_state in range(crf_obj.num_tags):\n for k in range(topK):\n heapq.heappush(h, (-1*next_score_list[k][b, pre_state, cur_state], pre_state))\n\n # Get the sorted list\n h_sorted = [heapq.heappop(h) for _ in range(topK)] #get topK path into cur_state\n # We need to keep a ranking if a path crosses a state more than once\n rankDict = dict()\n # Retain the topK scoring paths\n for k in range(topK):\n score[t, b, cur_state, k] = score[t, b, cur_state, k] + (h_sorted[k][0].data * -1)\n pre_states[t, b, cur_state, k] = h_sorted[k][1]\n state = h_sorted[k][1]\n if state in rankDict:\n rankDict[state] = rankDict[state]+1\n else:\n rankDict[state] = 0\n rank[t, b, cur_state, k] = rankDict[state]\n else:\n for cur_state in range(crf_obj.num_tags):\n for k in range(topK):\n score[t, b, cur_state, k]=score[t-1, b, cur_state, k]\n\n\n batch_path = []\n batch_path_prob = []\n seq_ends = mask.long().sum(dim=0) - 1 # seq_len x batch # assume seq_ends=8, seq_len=9\n for b in range(batch_size):\n h = []\n for cur_state in range(crf_obj.num_tags):\n for k in range(topK):\n heapq.heappush(h, ( -1 * (score[seq_ends[b], b, cur_state, k]+crf_obj.end_transitions[cur_state]),\n cur_state, k))\n h_sorted = [heapq.heappop(h) for _ in range(topK)]\n k_list = np.zeros((topK, seq_ends[b]+1), int) # k x 9\n k_list_probs = list()\n for k in range(topK):\n prob = h_sorted[k][0]\n state = h_sorted[k][1]\n rankK = h_sorted[k][2]\n\n k_list_probs.append((prob*-1)-(normalizer[b]))\n k_list[k][seq_ends[b]] = state # assign index 8 == last one\n for t in range(seq_ends[b]-1, -1, -1): # t = 7,6,5,4,3,2,1,0\n nextState = k_list[k][t+1]\n preState = pre_states[t+1, b, nextState, rankK]\n k_list[k][t] = preState\n rankK = rank[t+1,b,nextState,rankK]\n batch_path.append(k_list.tolist())\n batch_path_prob.append(k_list_probs)\n if crf_obj.batch_first:\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions.transpose(0,1), mask.transpose(0,1), topK)\n else:\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions, mask, topK)\n return batch_path, batch_probs","def metro_ising(L, T, h):\n\n lattice = transform_lattice(np.random.rand(N + 2, N + 2)) # +2 because of periodic bounds\n ising_chain = [lattice]\n m = 0\n\n for i in range(L):\n rand_row = np.random.choice(index)\n rand_col = np.random.choice(index)\n\n if H(ising_chain[i], rand_row, rand_col, h, T):\n new_lattice = ising_chain[i].copy()\n new_lattice[rand_row][rand_col] *= -1\n ising_chain.append(transform_lattice(new_lattice))\n else:\n ising_chain.append(ising_chain[i])\n\n m += np.sum(ising_chain[i][1:N + 1, 1:N + 1]) # magnetization\n\n return m","def cifarnet(images, candidate, N, F, num_classes=10, is_training=False,\n dropout_keep_prob=0.5,\n prediction_fn=slim.softmax,\n scope='CifarNet'):\n end_points = {}\n assert len(candidate) == 20\n\n with tf.variable_scope(scope, 'CifarNet', [images]):\n net = images\n cell_id = -2\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n for i in xrange(N):\n net = build_cell(end_points, cell_id, candidate, F, stride = 1, scope = 'Normal_cell_{}'.format(cell_id),is_training=is_training)\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n net = build_cell(end_points, cell_id, candidate, F, stride = 2, scope = 'Reduction_cell_{}'.format(cell_id),is_training=is_training)\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n F = F * 2\n\n for i in xrange(N):\n net = build_cell(end_points, cell_id, candidate, F, stride = 1, scope = 'Normal_cell_{}'.format(cell_id),is_training=is_training)\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n net = build_cell(end_points, cell_id, candidate, F, stride = 2, scope = 'Reduction_cell_{}'.format(cell_id),is_training=is_training)\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n F = F * 2\n\n for i in xrange(N):\n net = build_cell(end_points, cell_id, candidate, F, stride = 1, scope = 'Normal_cell_{}'.format(cell_id),is_training=is_training)\n end_points['cell_{}'.format(cell_id)] = net\n cell_id += 1\n\n net = tf.reduce_mean(net, [1, 2], name='global_pool', keep_dims=False)\n\n if not num_classes:\n return net, end_points\n logits = slim.fully_connected(net, num_classes,\n biases_initializer=tf.zeros_initializer(),\n weights_initializer=trunc_normal(1/192.0),\n weights_regularizer=None,\n activation_fn=None,\n scope='logits',\n trainable = is_training)\n\n end_points['Logits'] = logits\n end_points['Predictions'] = prediction_fn(logits, scope='Predictions')\n\n return logits, end_points","def set_voltages(): \n #0) set parameters\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\n import pickle\n with open(trapFile,'rb') as f:\n trap = pickle.load(f)\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\n tc=trap.configuration\n C = tc.multipoleControl\n el = []\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\n if tc.trap_knobs != True:\n return 'WARNING: You must run trap_knobs first!'\n #2a) determine electrode voltages directly\n elif multipoleControls: # note plurality to contrast from attribute\n el = np.dot(C,coefs.T) # these are the electrode voltages\n #2b) determine electrode volages indirectly\n else:\n charge = tc.charge\n mass = tc.mass\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\n U2 = az*V0/8\n U1 = U2+ax*V0/4\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\n U1p= np.sqrt(U1**2+U3**2/2)\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\n mCf = tc.multipoleCoefficients[1:9,:]\n el = np.dot(mCf.T,inp) # these are the electrode voltages\n el = np.real(el)\n #3) regularize if set to do so\n reg = 0\n if reg: \n C = el\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\n Lambda=Lambda[0]\n el = el-(np.dot(tc.multipoleKernel,Lambda))\n return el","def compute_autocorrelation_rlzn_ensemble(fopen_list, te):\n print 'Compute the autocorrelation'\n\n # initialize components of rho\n sumuu = 0.0\n sumvv = 0.0\n\n psiuu = 0.0\n psivv = 0.0\n\n sumup2 = 0.0\n sumvp2 = 0.0\n\n # get characteristics of mean velocity field\n fbs = netCDF4.Dataset('buoyancySurface.nc','r')\n lonCell = fbs.variables['lonCell']\n latCell = fbs.variables['latCell']\n lon = np.degrees(np.mod(lonCell[:]+np.pi,2*np.pi)-np.pi)\n lat = np.degrees(latCell[:])\n hull = spatial.ConvexHull(np.vstack((lon,lat)).T) \n triang = Triangulation(lon,lat)\n buoy_surf_zonal = fbs.variables['buoyancySurfaceVelocityZonal']\n buoy_surf_merid = fbs.variables['buoyancySurfaceVelocityMeridional']\n\n \n # build up layers for interpolation of particle layers\n interp_zonal = []\n interp_merid = []\n nlayers = len(fbs.dimensions['nBuoyancySurfaces'])\n for alayer in np.arange(nlayers):\n interp_zonal.append(LinearTriInterpolator(triang, buoy_surf_zonal[0,:,alayer]))\n interp_merid.append(LinearTriInterpolator(triang, buoy_surf_merid[0,:,alayer]))\n\n for num, afile in enumerate(fopen_list):\n print 'working on %d' % num\n # interpolate mean velocities onto points for the computation\n x = afile.variables['xParticle'][:te,:]\n y = afile.variables['yParticle'][:te,:]\n z = afile.variables['zParticle'][:te,:]\n latr, lonr = proj_lat_long(x,y,z)\n latr = np.degrees(latr)\n lonr = np.degrees(lonr)\n\n ubar = np.zeros(x.shape)\n vbar = np.zeros(x.shape)\n nparticle_layer = x.shape[1]/nlayers\n for alayer in np.arange(nlayers):\n ps = np.arange(alayer*nparticle_layer,(alayer+1)*nparticle_layer)\n ubar[:,ps] = interp_zonal[alayer](lonr[:,ps],latr[:,ps])\n vbar[:,ps] = interp_merid[alayer](lonr[:,ps],latr[:,ps])\n\n # compute portions of autocorrelation\n u = afile.variables['lonVel'][:te,:]\n up = u - ubar\n up0 = up[0,:]\n\n v = afile.variables['latVel'][:te,:]\n vp = v - vbar\n vp0 = vp[0,:]\n\n sumuu += up0*up\n sumvv += vp0*vp\n\n psiuu += up0*up0\n psivv += vp0*vp0\n \n sumup2 += np.nanmean(up**2.0, axis=0)\n sumvp2 += np.nanmean(vp**2.0, axis=0)\n \n\n fbs.close()\n\n # note division by psi removes need to divide the sums by the number of realizations\n sumuu /= psiuu \n sumvv /= psivv\n\n sumup2 /= len(fopen_list)\n sumvp2 /= len(fopen_list)\n\n print 'done'\n\n return sumuu, sumvv, sumup2, sumvp2, lonr[0,:], latr[0,:], lon, lat, hull","def ALIGNF(km_list, ky):\n n_feat = len(km_list)\n\n #km_list_copy = []\n # center the kernel first\n #for i in range(n_feat):\n # km_list_copy.append(center(km_list[i].copy()))\n #ky_copy = center(ky.copy())\n\n\n a = np.zeros(n_feat)\n for i in range(n_feat):\n a[i] = f_dot(km_list[i], ky)\n\n M = np.zeros((n_feat, n_feat))\n for i in range(n_feat):\n for j in range(i,n_feat):\n M[i,j] = f_dot(km_list[i],km_list[j])\n M[j,i] = M[i,j]\n\n Q = 2*M\n C = -2*a\n\n Q = Q + np.diag(np.ones(n_feat)*1e-8)\n\n ################################################\n # Using mosek to solve the quadratice programming\n\n # Set upper diagonal element to zeros, mosek only accept lower triangle\n iu = np.triu_indices(n_feat,1)\n Q[iu] = 0\n\n # start solving with mosek\n inf = 0.0\n env = mosek.Env()\n env.set_Stream(mosek.streamtype.log, streamprinter)\n\n # Create a task \n task = env.Task()\n task.set_Stream(mosek.streamtype.log, streamprinter)\n\n # Set up bound for variables \n bkx = [mosek.boundkey.lo]* n_feat\n blx = [0.0] * n_feat\n #bkx = [mosek.boundkey.fr]* n_feat\n #blx = [-inf] * n_feat\n bux = [+inf] * n_feat\n\n numvar = len(bkx)\n\n task.appendvars(numvar)\n\n for j in range(numvar):\n task.putcj(j,C[j])\n task.putvarbound(j,bkx[j],blx[j],bux[j])\n\n # Set up quadratic objective \n inds = np.nonzero(Q)\n qsubi = inds[0].tolist()\n qsubj = inds[1].tolist()\n qval = Q[inds].tolist()\n\n # Input quadratic objective \n task.putqobj(qsubi,qsubj,qval)\n\n # Input objective sense (minimize/mximize) \n task.putobjsense(mosek.objsense.minimize)\n\n task.optimize()\n\n # Print a summary containing information \n # about the solution for debugging purposes \n task.solutionsummary(mosek.streamtype.msg)\n\n solsta = task.getsolsta(mosek.soltype.itr)\n if (solsta == mosek.solsta.optimal or\n solsta == mosek.solsta.near_optimal):\n # Output a solution \n xx = np.zeros(numvar, float)\n task.getxx(mosek.soltype.itr, xx)\n #xx = xx/np.linalg.norm(xx)\n return xx\n else:\n print solsta\n xx = np.zeros(numvar, float)\n task.getxx(mosek.soltype.itr, xx)\n #xx = xx/np.linalg.norm(xx)\n return xx","def getContSpec(par):\n # read input\n if par['verbose']:\n print('\\n(*) Start\\n(*) Loading Data File: {}...'.format(par['GexpFile']))\n\n # t, Gexp = GetExpData(par['GexpFile'])\n t, Gexp, wexp = GetExpData(par['GexpFile'])\n\n if par['verbose']:\n print('(*) Initial Set up...', end=\"\")\n \n # Set up some internal variables\n n = len(t)\n ns = par['ns'] # discretization of 'tau'\n\n tmin = t[0];\n tmax = t[n-1];\n \n # determine frequency window\n if par['FreqEnd'] == 1:\n smin = np.exp(-np.pi/2) * tmin; smax = np.exp(np.pi/2) * tmax\t\t\n elif par['FreqEnd'] == 2:\n smin = tmin; smax = tmax\t\t\t\t\n elif par['FreqEnd'] == 3:\n smin = np.exp(+np.pi/2) * tmin; smax = np.exp(-np.pi/2) * tmax\t\t\n\n hs = (smax/smin)**(1./(ns-1))\n s = smin * hs**np.arange(ns)\n \n kernMat = getKernMat(s, t)\n tic = time.time()\n \n # get an initial guess for Hgs, G0\n if par['plateau']:\n Hgs, G0 = InitializeH(Gexp, wexp, s, kernMat, np.min(Gexp))\t\t\n else:\n Hgs = InitializeH(Gexp, wexp, s, kernMat)\n \n if par['verbose']:\n te = time.time() - tic\n print('\\t({0:.1f} seconds)\\n(*) Building the L-curve ...'.format(te), end=\"\")\t\n tic = time.time()\n\n # Find Optimum Lambda with 'lcurve'\n if par['lamC'] == 0:\n if par['plateau']:\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par, G0)\n else:\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par)\n else:\n lamC = par['lamC']\n\n if par['verbose']:\n te = time.time() - tic\n print('({1:.1f} seconds)\\n(*) Extracting CRS, ...\\n\\t... lamC = {0:0.3e}; '.\n format(lamC, te), end=\"\")\n \n tic = time.time()\n\n # Get the best spectrum\t\n if par['plateau']:\n H, G0 = getH(lamC, Gexp, wexp, Hgs, kernMat, G0);\n print('G0 = {0:0.3e} ...'.format(G0), end=\"\")\n else:\n H = getH(lamC, Gexp, wexp, Hgs, kernMat);\n\n #----------------------\n # Print some datafiles\n #----------------------\n\n if par['verbose']:\n te = time.time() - tic\n print('done ({0:.1f} seconds)\\n(*) Writing and Printing, ...'.format(te), end=\"\")\n\n # Save inferred G(t)\n if par['plateau']:\n K = kernel_prestore(H, kernMat, G0);\t\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e', header='G0 = {0:0.3e}'.format(G0))\n else:\n K = kernel_prestore(H, kernMat);\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e')\n \n np.savetxt('output/Gfit.dat', np.c_[t, K], fmt='%e')\n\n # print Hlam, rho-eta, and logP if lcurve has been visited\n if par['lamC'] == 0:\n if os.path.exists(\"output/Hlam.dat\"):\n os.remove(\"output/Hlam.dat\")\n \n fHlam = open('output/Hlam.dat','ab')\n for i, lamb in enumerate(lam):\n np.savetxt(fHlam, Hlam[:,i])\t\n fHlam.close()\t\n\n # print logP\n np.savetxt('output/logPlam.dat', np.c_[lam, logP])\n \n # print rho-eta\n np.savetxt('output/rho-eta.dat', np.c_[lam, rho, eta], fmt='%e')\n\n #------------\n # Graphing\n #------------\n\n if par['plotting']:\n\n # plot spectrum \"H.pdf\" with errorbars\n plt.clf()\n\n plt.semilogx(s,H,'o-')\n plt.xlabel(r'$s$')\n plt.ylabel(r'$H(s)$')\n\n # error bounds are only available if lcurve has been implemented\n if par['lamC'] == 0:\n plam = np.exp(logP); plam = plam/np.sum(plam)\t\t\t\n Hm = np.zeros(len(s))\n Hm2 = np.zeros(len(s))\n cnt = 0\n for i in range(len(lam)):\t\n #~ Hm += plam[i]*Hlam[:,i]\n #~ Hm2 += plam[i]*Hlam[:,i]**2\n # count all spectra within a threshold\n if plam[i] > 0.1:\n Hm += Hlam[:,i]\n Hm2 += Hlam[:,i]**2\n cnt += 1\n\n Hm = Hm/cnt\n dH = np.sqrt(Hm2/cnt - Hm**2)\n\n plt.semilogx(s,Hm+2.5*dH, c='gray', alpha=0.5)\n plt.semilogx(s,Hm-2.5*dH, c='gray', alpha=0.5)\n\n plt.tight_layout()\n plt.savefig('output/H.pdf')\n\n\n #\n # plot comparison with input spectrum\n #\n\n plt.clf()\n\n if par['plateau']:\n K = kernel_prestore(H, kernMat, G0);\t\n else:\n K = kernel_prestore(H, kernMat);\n\n plt.loglog(t, Gexp,'o',t, K, 'k-')\n plt.xlabel(r'$t$')\n plt.ylabel(r'$G(t)$')\n plt.tight_layout()\n plt.savefig('output/Gfit.pdf')\n\n\n #\n # if lam not explicitly specified then print rho-eta.pdf\n #\n\n try:\n lam\n except NameError:\n print(\"lamC prespecified, so not printing rho-eta.pdf/dat\")\n else:\n plt.clf()\n plt.scatter(rho, eta, marker='x')\n plt.plot(rho, eta)\n\n\n rhost = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(rho)))\n etast = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(eta)))\n\n plt.plot(rhost, etast, 'o', color='k')\n plt.xscale('log')\n plt.yscale('log')\n \n #~ print(rhost, etast)\n \n plt.xlabel(r'$\\rho$')\n plt.ylabel(r'$\\eta$')\n plt.tight_layout()\n plt.savefig('output/rho-eta.pdf')\n\n if par['verbose']:\n print('done\\n(*) End\\n')\n \n return H, lamC","def solve(list_k, examples, out_path, centers_=None,\n conf_num=None, out_minus=True, out_iterations=False):\n\n # start_centers = utils.get_centers()\n dimension = len(examples[0][0])\n # print (dimension)\n N = len(examples) # print(N)\n for k in list_k:\n # sys.stderr.write(str(k) + \"\\n\")\n h = np.zeros((N, k), dtype=np.float64)\n # responsibilities.fill(1/float(k))\n pi_k = np.zeros(k, dtype=np.float64)\n pi_k.fill(1/float(k))\n # print\n configuration = False\n if centers_ == None:\n centers = utils.get_centers(k, examples)\n else:\n centers = centers_\n configuration = True\n\n matrix = np.identity(dimension, dtype=np.float64)\n matrices = np.array([matrix] * k)\n # print (matrices)\n log = calc_log(examples, centers, matrices, pi_k)\n # print (log)\n\n # output stuff\n num_iter = 0\n # if k == 4:\n # groups = [list([])] * k\n groups = []\n for i in range(k):\n groups.append([])\n probabilities = dict()\n\n # if k == 4:\n # print (h)\n # print (pi_k)\n # print (matrices)\n # print (centers)\n\n if out_iterations:\n iter_out = open(out_path + \"em-kmeans.dat\", \"w\")\n iter_out.write(\"#iteracije: log-izglednost\\n\")\n iter_out.write(\"--\\n\")\n iter_out.write(\"#0: %.2lf\\n\" % log)\n # buffer_all = \"K = %d\\n\" % k\n # number of members in a certain group\n\n while True:\n num_iter += 1\n group_count = [0] * k\n # init = dict()\n group_dicts = []\n for i in range(k):\n group_dicts.append({})\n # group_dicts = [] * k\n # E step\n # print (num_iter)\n # changed = 0\n for i in range(N):\n x = examples[i][0]\n mi_j = centers[0][0]\n sigma_j = matrices[0]\n p = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[0]\n h[i][0] = p\n sum_h = h[i][0]\n probabilities[i] = p\n group = examples[i][1]\n if group not in group_dicts[0]:\n group_dicts[0][group] = 1\n else:\n group_dicts[0][group] += 1\n\n # if p > \n group_count[0] += 1\n examples[i][2] = 0\n\n for j in range(1,k):\n mi_j = centers[j][0]\n sigma_j = matrices[j]\n # print (sigma_j)\n p2 = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[j]\n if p2 > p:\n group_count[examples[i][2]] -= 1\n group_dicts[examples[i][2]][group] -= 1\n if group not in group_dicts[j]:\n group_dicts[j][group] = 1\n else:\n group_dicts[j][group] += 1\n examples[i][2] = j\n group_count[j] += 1\n p = p2\n probabilities[i] = p\n\n h[i][j] = p2\n sum_h += h[i][j]\n\n h[i] /= sum_h\n probabilities[i] /= sum_h\n # print (\"$$$$$$$\")\n # M step\n # if num_iter == 1:\n # print (h)\n # sys.exit(1)\n for i in range(k):\n new_mi = np.zeros(dimension, dtype=np.float64)\n sum_h = 0.\n new_sigma = np.zeros((dimension, dimension), dtype=np.float64)\n\n for j in range(N):\n x = examples[j][0]\n sum_h += h[j][i]\n new_mi += h[j][i] * x\n\n new_mi /= sum_h\n # if utils.euclid(new_mi, centers[i][0]) > EPS:\n # changed = 1\n centers[i] = (new_mi, centers[i][1], centers[i][2])\n\n # mi = np.matrix(new_mi)\n mi = new_mi\n for j in range(N):\n x = examples[j][0]\n # print ((x-mi).T * (x - mi))\n diff = np.matrix(x - mi)\n # print (diff.T * diff)\n new_sigma += h[j][i] * (diff.T * diff)\n # break\n\n new_sigma /= sum_h\n matrices[i] = new_sigma\n new_pi = sum_h / float(N)\n pi_k[i] = new_pi\n\n # print (matrices)\n # if num_iter == 1:\n # sys.exit(1)\n\n new_log = calc_log(examples, centers, matrices, pi_k)\n\n # print (new_log)\n if abs(new_log - log) < EPS:\n break\n log = new_log\n # if k == 4:\n # print (log)\n if out_iterations:\n iter_out.write(\"#%d: %.2lf\\n\" % (num_iter, log))\n # if changed == 0:\n # break\n\n # set the groups for K = 4\n # print (groups)\n if not configuration and not out_iterations:\n if k == 4:\n for i in range(N):\n # print (examples[i][2])\n # print (groups)\n groups[examples[i][2]].append((examples[i][1], probabilities[i]))\n\n with open(out_path + \"/em-k4.dat\", \"a\") as f:\n for i in range(k):\n # print (len(groups[i]))\n groups[i] = sorted(groups[i], key=lambda tup: tup[1], reverse=True)\n f.write(\"Grupa %d:\\n\" % (i+1))\n for j in range(len(groups[i])):\n f.write(groups[i][j][0] + \" %.2lf\\n\" % groups[i][j][1])\n if i < k-1:\n f.write(\"--\\n\")\n\n with open(out_path + \"/em-all.dat\", \"a\") as f:\n f.write(\"K = %d\\n\" % k)\n for i in range(k):\n f.write(\"c%d:\" % (i+1))\n for j in range(dimension):\n f.write(\" %.2lf\" % centers[i][0][j])\n f.write(\"\\n\")\n f.write(\"grupa %d: %d primjera\\n\" % ((i+1), group_count[i]))\n f.write(\"#iter: %d\\n\" % num_iter)\n f.write(\"log-izglednost: %.2lf\\n\" % log)\n if k < 5:\n f.write(\"--\\n\")\n elif not out_iterations:\n with open(out_path + \"/em-konf.dat\", \"a\") as f:\n f.write(\"Konfiguracija %d:\\n\" % conf_num)\n f.write(\"log-izglednost: %.2lf\\n\" % log)\n f.write(\"#iteracija: %d\\n\" % num_iter)\n if out_minus == True:\n f.write(\"--\\n\")\n # if i < k - 1:\n else:\n iter_out.write(\"--\\n\")\n for i in range(len(group_dicts)):\n iter_out.write(\"Grupa %d:\" % (i+1))\n buff = \"\"\n for key in group_dicts[i]:\n buff += \" \" + key + \" %d\" % group_dicts[i][key] + \",\"\n\n buff = buff[:-1]\n iter_out.write(buff + \"\\n\")\n # pass","def fit(self):\n N = self.data.shape\n prev_k = 1\n k_lst = []\n k_list = self.tt_ranks.copy()\n if self.model=='tt': depth = len(N)-1\n elif self.model=='tk': depth = len(N)\n\n for axis in range(depth):\n if self.global_rank==0: print('Decomposing for stage=',axis+1)\n if self.model=='tt':\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([prev_k * N[axis], -1])\n elif self.model=='tk':\n k_lst.append(prev_k)\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([N[axis], np.product(k_lst)*np.product(N[axis+1:])])\n\n if np.any(k_list) != False:\n self.this_k = k_list[axis]\n else:\n if self.global_rank==0: print('Estimating rank now with SVD...')\n self.this_k = self.determine_rank(self.data, self.err)\n\n if self.routine=='nmf':\n self.params.k = self.this_k\n if self.global_rank==0: print('Performing NMF for TN stage=',axis+1)\n W, H, rel_error = PyNMF(self.data, factors=None, params=self.params).fit()\n\n elif self.routine=='svd':\n if self.global_rank == 0: print('Performing SVD for TN stage=', axis + 1)\n singularValues, U, V,rel_error = self.compute_svd(self.data,self.this_k)\n S = np.diag(singularValues)\n W = U\n H = S @ V\n\n if self.model=='tt':\n self.factors.append(np.reshape(W, (prev_k, N[axis], self.this_k)))\n elif self.model=='tk':\n self.factors.append(W)\n if axis==depth-1:\n H_final = np.hstack((self.comm.allgather(H)))\n if self.model=='tk':\n k_lst.append(self.this_k)\n H_final = np.reshape(H_final,k_lst[1:])\n # H_final = np.hstack((block_idx_rank_H_tran(H_final,1, self.size)))\n self.factors.append(H_final)\n self.rel_error.append(rel_error)\n prev_k = self.this_k\n fpath = 'data/H_factor.zarr'\n self.data = tn_data_operations(self.comm1,fpath,H).lazy_store_file()","def fit_FITC(self, Kmm, Kmn, Knn_diag):\r\n num_inducing = Kmm.shape[0]\r\n\r\n \"\"\"\r\n Prior approximation parameters:\r\n q(f|X) = int_{df}{N(f|KfuKuu_invu,diag(Kff-Qff)*N(u|0,Kuu)} = N(f|0,Sigma0)\r\n Sigma0 = diag(Knn-Qnn) + Qnn, Qnn = Knm*Kmmi*Kmn\r\n \"\"\"\r\n Lm = jitchol(Kmm)\r\n Lmi = chol_inv(Lm)\r\n Kmmi = np.dot(Lmi.T,Lmi)\r\n P0 = Kmn.T\r\n KmnKnm = np.dot(P0.T, P0)\r\n KmmiKmn = np.dot(Kmmi,P0.T)\r\n Qnn_diag = np.sum(P0.T*KmmiKmn,-2)\r\n Diag0 = Knn_diag - Qnn_diag\r\n R0 = jitchol(Kmmi).T\r\n\r\n \"\"\"\r\n Posterior approximation: q(f|y) = N(f| mu, Sigma)\r\n Sigma = Diag + P*R.T*R*P.T + K\r\n mu = w + P*Gamma\r\n \"\"\"\r\n self.w = np.zeros(self.N)\r\n self.Gamma = np.zeros(num_inducing)\r\n mu = np.zeros(self.N)\r\n P = P0.copy()\r\n R = R0.copy()\r\n Diag = Diag0.copy()\r\n Sigma_diag = Knn_diag\r\n RPT0 = np.dot(R0,P0.T)\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(g|mu_,sigma2_) = Product{q_i(g|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.N,dtype=float)\r\n self.v_ = np.empty(self.N,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.N,dtype=float)\r\n self.Z_hat = np.empty(self.N,dtype=float)\r\n phi = np.empty(self.N,dtype=float)\r\n mu_hat = np.empty(self.N,dtype=float)\r\n sigma2_hat = np.empty(self.N,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = 1\r\n epsilon_np2 = 1\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.N)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma_diag[i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma_diag[i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma_diag[i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma_diag[i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n dtd1 = Delta_tau*Diag[i] + 1.\r\n dii = Diag[i]\r\n Diag[i] = dii - (Delta_tau * dii**2.)/dtd1\r\n pi_ = P[i,:].reshape(1,num_inducing)\r\n P[i,:] = pi_ - (Delta_tau*dii)/dtd1 * pi_\r\n Rp_i = np.dot(R,pi_.T)\r\n RTR = np.dot(R.T,np.dot(np.eye(num_inducing) - Delta_tau/(1.+Delta_tau*Sigma_diag[i]) * np.dot(Rp_i,Rp_i.T),R))\r\n R = jitchol(RTR).T\r\n self.w[i] += (Delta_v - Delta_tau*self.w[i])*dii/dtd1\r\n self.Gamma += (Delta_v - Delta_tau*mu[i])*np.dot(RTR,P[i,:].T)\r\n RPT = np.dot(R,P.T)\r\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\r\n mu = self.w + np.dot(P,self.Gamma)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Iplus_Dprod_i = 1./(1.+ Diag0 * self.tau_tilde)\r\n Diag = Diag0 * Iplus_Dprod_i\r\n P = Iplus_Dprod_i[:,None] * P0\r\n safe_diag = np.where(Diag0 < self.tau_tilde, self.tau_tilde/(1.+Diag0*self.tau_tilde), (1. - Iplus_Dprod_i)/Diag0)\r\n L = jitchol(np.eye(num_inducing) + np.dot(RPT0,safe_diag[:,None]*RPT0.T))\r\n R,info = dtrtrs(L,R0,lower=1)\r\n RPT = np.dot(R,P.T)\r\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\r\n self.w = Diag * self.v_tilde\r\n self.Gamma = np.dot(R.T, np.dot(RPT,self.v_tilde))\r\n mu = self.w + np.dot(P,self.Gamma)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def setCtrls(self, fks, ik, upv):\n # type: (list[str], str, str) -> None\n\n self.fkCtrls = [self._getNode(x) for x in fks]\n self.fkTargets = [self._getMth(x) for x in fks]\n\n self.ikCtrl = self._getNode(ik)\n self.ikTarget = self._getMth(ik)\n\n self.upvCtrl = self._getNode(upv)\n self.upvTarget = self._getMth(upv)\n\n self.ikRotCtrl = self._getNode(ik.replace(\"_ik_\", \"_rot_\"))\n self.ikRotTarget = self.ikTarget","def mtvsolverbis(Hurstaest_init, yij, varyj, nj, j1, j2,\n mask, max_iter=100, init=None,\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\n l=1, l1_ratio=0, wtype=1, lipschitz_constant=0):\n\n # shape of image box\n \n alpha = 1\n\n flat_mask = mask.ravel()\n volume_shape = mask.shape\n H_size = len(Hurstaest_init)\n\n if lipschitz_constant == 0:\n lipschitz_constant = H_size * lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\n\n #init[\"z\"] = Hurst_init.copy()\n #init[\"t\"] = 1\n #ini[\"stepsize\"] = 1 / lipschitz_constant\n\n def total_energy(estimation):\n return fbis(estimation, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(estimation[:H_size / 2],\n mask))\n\n def unmaskvec(estimation):\n return _unmask(estimation, mask)\n\n def maskvec(estimation):\n return estimation[flat_mask]\n\n def f1_grad(estimation):\n return gradfbis(estimation, yij, varyj, nj, j1, j2, wtype)\n\n def f2_prox(estimation, stepsize, dgap_tol, init):\n lenw = len(estimation)\n Hurst = estimation[lenw / 2:]\n init = unmaskvec(init[:lenw / 2]) if not init is None else init\n\n out, info = _prox_tvl1(unmaskvec(Hurst),\n weight=(l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\n dgap_tol=dgap_tol, init=init,\n max_iter=prox_max_iter, fista = False,\n verbose=verbose)\n #pdb.set_trace()\n return np.concatenate((maskvec(out.ravel()),estimation[lenw / 2:])), info\n\n w, obj, init = mfista(\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\n max_iter=max_iter, callback=None)\n \n return w, obj, init","def rk5(accel,m,r,h,v):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n \n return new_v5, new_r5","def HPI_update(task, subject, block, data, precision='0.5cm', opt='start', reject_head_mvt=True):\r\n \r\n #==============================================================================\r\n hc_path = op.join(Analysis_path, task, 'meg', 'Coregistration', subject)\r\n #==============================================================================\r\n \r\n # Find the .hc file corresponding to this block\r\n hc_files = glob.glob(op.join(hc_path, '*{}*_{}*.hc'.format(precision,block)))\r\n hc_file = ''\r\n if len(hc_files) > 1:\r\n for hc in hc_files:\r\n if not opt and not '+' in hc:\r\n hc_file = hc\r\n continue\r\n if opt and opt in hc:\r\n hc_file = hc\r\n continue\r\n if not hc_file:\r\n hc_file = hc_files[0]\r\n warnings.warn(\"Multiple .hc files found, none matching the desired option. Using {}.\".format(hc_file))\r\n else:\r\n hc_file = hc_files[0]\r\n \r\n bs_fname = hc_file[:-3] + '-bad.segments' + block\r\n bads = False\r\n if os.stat(bs_fname).st_size > 0:\r\n bad_segments = pd.read_table(bs_fname, header=None)\r\n bads = True\r\n \r\n # Read and load the content of the .hc file \r\n#==============================================================================\r\n with open(hc_file) as f:\r\n content = f.readlines()\r\n\r\n content = [x.strip() for x in content] \r\n \r\n Nasion_ctf = [0,0,0,1]\r\n Left_ctf = [0,0,0,1]\r\n Right_ctf = [0,0,0,1]\r\n \r\n Nasion_ctf[0] = float(content[25].strip('x = '))\r\n Nasion_ctf[1] = float(content[26].strip('y = '))\r\n Nasion_ctf[2] = float(content[27].strip('z = '))\r\n \r\n Left_ctf[0] = float(content[29].strip('x = '))\r\n Left_ctf[1] = float(content[30].strip('y = '))\r\n Left_ctf[2] = float(content[31].strip('z = '))\r\n \r\n Right_ctf[0] = float(content[33].strip('x = '))\r\n Right_ctf[1] = float(content[34].strip('y = '))\r\n Right_ctf[2] = float(content[35].strip('z = '))\r\n#==============================================================================\r\n \r\n \r\n # CTF -> Neuromag Coordinate transformation matrix\r\n#==============================================================================\r\n ctf_head_trans = data.info['ctf_head_t']['trans']\r\n \r\n # New Neuromag coordinates\r\n \r\n Nasion_head = np.dot(ctf_head_trans, Nasion_ctf)*0.01\r\n \r\n Left_head = np.dot(ctf_head_trans, Left_ctf)*0.01\r\n \r\n Right_head = np.dot(ctf_head_trans, Right_ctf)*0.01\r\n#==============================================================================\r\n \r\n \r\n \r\n # DEV <-> CTF Coordinate transformation matrix\r\n#==============================================================================\r\n dev_ctf_trans = data.info['dev_ctf_t']['trans']\r\n ctf_dev_trans = inv(dev_ctf_trans)\r\n \r\n # New Dev coordinates \r\n \r\n Nasion_dev = np.dot(ctf_dev_trans, Nasion_ctf)*0.01\r\n \r\n Left_dev = np.dot(ctf_dev_trans, Left_ctf)*0.01\r\n \r\n Right_dev = np.dot(ctf_dev_trans, Right_ctf)*0.01\r\n#==============================================================================\r\n \r\n \r\n \r\n # UPDATE THE INFO 'hpi_results' DATA WITH NEW DEV COORDINATES\r\n#==============================================================================\r\n for i in range(len(data.info['hpi_results'][0]['dig_points'])):\r\n \r\n #Just checking it's the right kind of digitizer ...\r\n if data.info['hpi_results'][0]['dig_points'][i]['kind'] == 1:\r\n \r\n #Left, Nasion, Right\r\n if data.info['hpi_results'][0]['dig_points'][i]['ident'] == 1:\r\n \r\n data.info['hpi_results'][0]['dig_points'][i]['r'] = Left_dev[:3]\r\n #data.info['hpi_results'][0]['dig_points'][i]['coord_frame'] = 1\r\n \r\n if data.info['hpi_results'][0]['dig_points'][i]['ident'] == 2:\r\n \r\n data.info['hpi_results'][0]['dig_points'][i]['r'] = Nasion_dev[:3]\r\n #data.info['hpi_results'][0]['dig_points'][i]['coord_frame'] = 1\r\n \r\n if data.info['hpi_results'][0]['dig_points'][i]['ident'] == 3:\r\n \r\n data.info['hpi_results'][0]['dig_points'][i]['r'] = Right_dev[:3]\r\n #data.info['hpi_results'][0]['dig_points'][i]['coord_frame'] = 1\r\n#==============================================================================\r\n \r\n \r\n \r\n # UPDATE THE INFO 'dig' DATA WITH NEUROMAG HEAD COORDINATES\r\n#==============================================================================\r\n for i in range(len(data.info['dig'])):\r\n \r\n #Just checking it's the right kind of digitizer ...\r\n if data.info['dig'][i]['kind'] == 1:\r\n \r\n #Left, Nasion, Right\r\n if data.info['dig'][i]['ident'] == 1:\r\n \r\n data.info['dig'][i]['r'] = Left_head[:3]\r\n data.info['dig'][i]['coord_frame'] = 4\r\n \r\n if data.info['dig'][i]['ident'] == 2:\r\n \r\n data.info['dig'][i]['r'] = Nasion_head[:3]\r\n data.info['dig'][i]['coord_frame'] = 4\r\n \r\n if data.info['dig'][i]['ident'] == 3:\r\n \r\n data.info['dig'][i]['r'] = Right_head[:3]\r\n data.info['dig'][i]['coord_frame'] = 4\r\n#==============================================================================\r\n \r\n if bads and reject_head_mvt:\r\n# for i in range(len(bad_segments)):\r\n new_annot = mne.Annotations(bad_segments.get_values()[:,0], np.diff(bad_segments.get_values()).ravel(), ['bad head mvt'] * bad_segments.get_values().shape[0])\r\n if data.annotations:\r\n for onset, duration, description in zip(new_annot.onset, new_annot.duration, new_annot.description):\r\n data.annotations.append(onset, duration, description)\r\n else:\r\n data.annotations = new_annot\r\n# events = data.events[:,0]/data.info['sfreq'] #extract event timing\r\n# data.drop(np.logical_and(bad_segments.iloc[i][0] < events + data.times[-1], events + data.times[0] < bad_segments.iloc[i][1]), reason = 'head_movement')\r\n# #reject the epoch if it ends after the beginning of the bad segment, and starts before the end of the bad segment\r\n \r\n return data","def set_kbest_features_list(data_dict, features_list):\n \n print \" --- \"\n\n k_best = get_k_best(data_dict,features_list,len(features_list)-1)\n \n ### Sort the k_best features in descending order\n arr_features = []\n print \"sorted k_best:\"\n for key, value in sorted(k_best.iteritems(), key=lambda (k,v): (v,k), reverse=True):\n print \"%s: %s\" % (key, value)\n arr_features.append(key)\n\n print \"---\"\n poi = [\"poi\"]\n features_list = poi\n features_list += arr_features\n\n print \"---\"\n print \"features List: \"\n print features_list\n print(\"Number of features in k_best: \",len(features_list))\n print \" \"\n\n return features_list","def camb_XPk(self,\n z = 0.,\n k = np.logspace(-4., 2., 1001),\n nonlinear = False,\n halofit = 'mead2020',\n var_1 = ['tot'],\n var_2 = ['tot'],\n share_delta_neff = True,\n **kwargs\n ):\n\n # Neutrino part\n nu_mass_eigen = len(np.unique([mm for mm in self.M_nu])) if np.any(self.M_nu!=0.) else 0\n nu_mass_numbers = [list(self.M_nu).count(x) for x in set(list(self.M_nu))]\n nu_mass_numbers = sorted(nu_mass_numbers,reverse=True) if np.any(self.M_nu!=0.) else [0]\n # Set parameters\n cambparams = {\n 'num_nu_massive': self.massive_nu,\n 'num_nu_massless': self.massless_nu,\n 'nu_mass_eigenstates': nu_mass_eigen, \n 'nu_mass_numbers': nu_mass_numbers,\n 'nnu': self.N_eff,\n 'omnuh2': self.omega_nu_tot,\n 'ombh2': self.omega_b,\n 'omch2': self.omega_cdm+self.omega_wdm_tot,\n 'omk': self.Omega_K,\n 'H0': 100.*self.h,\n 'As': self.As,\n 'ns': self.ns,\n 'w': self.w0,\n 'wa': self.wa,\n 'TCMB': self.T_cmb,\n 'tau': self.tau,\n 'share_delta_neff':True,\n 'dark_energy_model':'DarkEnergyPPF'}\n # kwargs\n for key, value in kwargs.items():\n if not key in cambparams: cambparams[key] = value\n params = camb.set_params(**cambparams)\n\n # Redshifts and scales\n k = np.atleast_1d(k)\n nk = len(k)\n z = np.atleast_1d(z)\n nz = len(z)\n if nz > 3: spline = 'cubic'\n else: spline = 'linear'\n\n # Possible components to use\n components = {'tot' : 'delta_tot',\n 'cdm' : 'delta_cdm',\n 'b' : 'delta_baryon',\n 'nu' : 'delta_nu',\n 'cb' : 'delta_nonu',\n 'gamma': 'delta_photon',\n 'v_cdm': 'v_newtonian_cdm',\n 'v_b' : 'v_newtonian_baryon',\n 'Phi' : 'Weyl'}\n\n # Number of points (according to logint)\n npoints = int(100*np.log10(k.max()/k.min()))\n dlogk = 2.*np.log10(k.max()/k.min())/npoints\n\n # Halofit version\n if nonlinear == True:\n #camb.nonlinear.Halofit(halofit_version = halofit)\n params.NonLinearModel.set_params(halofit_version=halofit)\n params.NonLinear = camb.model.NonLinear_both\n\n # Initialize power spectrum as a dictionary and compute it\n pk = {}\n params.set_matter_power(redshifts = z, kmax = k.max()*10**dlogk, silent = True,accurate_massive_neutrino_transfers=True)\n results = camb.get_results(params)\n\n # Fill the power spectrum array\n for c1 in var_1:\n for c2 in var_2:\n string = c1+'-'+c2\n kh, zz, ppkk = results.get_matter_power_spectrum(minkh = k.min()*10.**-dlogk,\n maxkh = k.max()*10**dlogk,\n npoints = npoints,\n var1 = components[c1],\n var2 = components[c2])\n\n pk[string] = np.zeros((nz,nk))\n for iz in range(nz):\n lnpower = si.InterpolatedUnivariateSpline(kh,np.log(ppkk[iz]),k=3,ext=0, check_finite=False)\n pk[string][iz] = np.exp(lnpower(k))\n \n #if nz != 1:\n # power = si.interp2d(kh, zz, ppkk, kind = spline)\n # pk[string] = power(k, z)\n # pk[string] = np.nan_to_num(pk[string])\n #else:\n # power = si.interp1d(kh, ppkk, kind = spline)\n # pk[string] = power(k)\n # pk[string] = np.nan_to_num(pk[string])\n\n return k, pk","def evolve(self, k_vec, Nt,**kwargs):\n \n M_eff = np.eye((self.Nd), dtype=complex) # aux matrix\n T = 1.\n for it in range(Nt):\n \n # update the Hamiltonian for time-inteval\n self.updateH(k_vec, it)\n\n # return eigenenergies and vectors\n E_k, U = lg.eig(self.H_kc) \n\n # U^-1 * exp(H_d) U\n U_inv = lg.inv(U)\n\n # construct a digonal matrix out of a vector\n M1 = (np.exp(-1.j*E_k*T) * U_inv.T).T\n\n #MM = np.dot(U_inv,np.dot(H_M, U))\n MM = np.dot(U,M1)\n M_eff = np.dot(M_eff,MM)\n # end of loop\n Ek, Uk = lg.eig( M_eff )\n idx = (np.log(Ek).imag).argsort()\n Efl_k = np.log(Ek).imag[idx]\n Ufl_k = Uk[idx]\n return Efl_k, Ufl_k","def non_interacting_conductivity(self,\n sigma=0.04,\n freq_range=(0.0, 6.0, 1000),\n imag_dielectric=False,\n broadening='lorentz'):\n cell_area = np.abs(float(np.cross(self.a1, self.a2)))*len(self.k_grid)\n broad_fnc = get_broadening_function(broadening, sigma)\n\n frequency_grid = np.linspace(*freq_range)\n energy_increment = np.abs(frequency_grid[1] - frequency_grid[0])\n num_freqs, min_freq = len(frequency_grid), min(frequency_grid)\n output_grid = np.zeros(num_freqs)\n\n energy_power = 1 + int(imag_dielectric)\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\n prefactor = prefactor/cell_area\n\n # Assuming x polarisation for now\n position_dipole_matrix = self.construct_position_dipole_matrix()\n\n n_shift = self.n_spins*self.n_orbs\n for idx1, kpt in enumerate(self.k_grid):\n for s0 in range(self.n_spins):\n velocity_matrix = self.load_velocity_matrix(idx1)\n bands = self.exciton_obj.get_number_conduction_valence_bands(\n idx1, s0\n )\n v_num, c_num = bands\n eigvals = np.array(\n self.file_storage['eigensystem']['eigenvalues'][idx1]\n )\n\n j1 = n_shift*idx1 + (self.n_spins - 1)*s0*self.n_orbs\n j2 = j1 + self.n_orbs\n eigvecs = np.array(\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\n )\n for v, c in product(range(v_num), range(c_num)):\n cb_vector = eigvecs[:, v_num + c]\n vb_vector = eigvecs[:, v]\n cb_energy, vb_energy = eigvals[v_num + c], eigvals[v]\n energy_diff = (cb_energy - vb_energy)\n\n energy_diff_pow = energy_diff**energy_power\n matrix_elem = velocity_matrix_element(vb_vector,\n cb_vector,\n velocity_matrix)\n if self.use_dipole_term:\n position_dipole_term = get_position_dipole_element(\n vb_vector,\n cb_vector,\n vb_energy,\n cb_energy,\n position_dipole_matrix\n )\n matrix_elem = matrix_elem + position_dipole_term\n\n main_term = np.abs(matrix_elem)**2/energy_diff_pow\n closest_idx = (energy_diff - min_freq)//energy_increment\n idx_reach = self.reach_multiplier*(sigma//energy_increment)\n\n lower_idx = max([closest_idx - idx_reach, 0])\n upper_idx = min([closest_idx + idx_reach, num_freqs - 1])\n\n for idx2 in range(int(lower_idx), int(upper_idx)):\n smearing = broad_fnc(energy_diff, frequency_grid[idx2])\n output = prefactor*main_term*smearing\n output_grid[idx2] += output\n\n return frequency_grid, output_grid","def multi_head_attention(queries, keys, values, attn_bias, d_key, d_value, d_model, pos_enc,\n n_head=1, dropout_rate=0., cache=None, static_kv=False):\n keys = queries if keys is None else keys\n values = keys if values is None else values\n if not (len(queries.shape) == len(keys.shape) == len(values.shape) == 3):\n raise ValueError(\n \"Inputs: quries, keys and values should all be 3-D tensors.\"\n )\n\n def __compute_qkv(queries, keys, values, n_head, d_key, d_value):\n \"\"\"\n Add linear projection to queries, keys, and values.\n \"\"\"\n q = layers.fc(input=queries, size=d_key * n_head,\n bias_attr=False, num_flatten_dims=2)\n fc_layer = wrap_layer_with_block(\n layers.fc, fluid.default_main_program().current_block().parent_idx\n ) if cache is not None and static_kv else layers.fc\n k = fc_layer(input=keys, size=d_key * n_head,\n bias_attr=False, num_flatten_dims=2)\n v = fc_layer(input=values, size=d_value * n_head,\n bias_attr=False, num_flatten_dims=2)\n return q, k, v\n\n def __split_heads_qkv(queries, keys, values, n_head, d_key, d_value)\n \"\"\"\n Reshape input tensors at the last dimension to split multi-heads\n and then transpose. Specifically, transform the input tensor with shape\n [bs, max_sequence_length, n_head * hidden_dim] to the output tensor\n with shape [bs, n_head, max_sequence_length, hidden_dim].\n \"\"\"\n # The value 0 in shape attr means copying the corresponding dimension\n # size of the input as the output dimension size.\n reshaped_q = layers.reshape(\n x=queries, shape=[0, 0, n_head, d_key], inplace=True)\n # permute the dimensions into:\n # [batch_size, n_head, max_sequence_len, hidden_size_per_head]\n q = layers.transpose(x=reshaped_q, perm=[0, 2, 1, 3])\n # For encoder-decoder attention in inference, insert the ops and vars\n # into global block to use as cache among beam search.\n reshape_layer = wrap_layer_with_block(\n layers.reshape,\n fluid.default_main_program().current_block(\n ).parent_idx) if cache is not None and static_kv else layers.reshape\n transpose_layer = wrap_layer_with_block(\n layers.transpose,\n fluid.default_main_program().current_block().\n parent_idx) if cache is not None and static_kv else layers.transpose\n reshaped_k = reshape_layer(\n x=keys, shape=[0, 0, n_head, d_key], inplace=True)\n k = transpose_layer(x=reshaped_k, perm=[0, 2, 1, 3])\n reshaped_v = reshape_layer(\n x=values, shape=[0, 0, n_head, d_value], inplace=True)\n v = transpose_layer(x=reshaped_v, perm=[0, 2, 1, 3])\n\n if cache is not None: # only for faster inference\n cache_, i = cache\n if static_kv: # For encoder-decoder attention in inference\n cache_k, cache_v = cache_[\"static_k\"], cache_[\"static_v\"]\n # To init the static_k and static_v in global block.\n static_cache_init = wrap_layer_with_block(\n layers.assign,\n fluid.default_main_program().current_block().parent_idx)\n static_cache_init(\n k,\n fluid.default_main_program().global_block().var(\n \"static_k_%d\" % i))\n static_cache_init(\n v,\n fluid.default_main_program().global_block().var(\n \"static_v_%d\" % i))\n k, v = cache_k, cache_v\n else: # For decoder self-attention in inference\n # use cache and concat time steps.\n cache_k, cache_v = cache_[\"k\"], cache_[\"v\"]\n k = layers.concat([cache_k, k], axis=2)\n v = layers.concat([cache_v, v], axis=2)\n cache_[\"k\"], cache_[\"v\"] = (k, v)\n return q, k, v\n\n def __combine_heads(x):\n \"\"\"\n Transpose and then reshape the last two dimensions of inpunt tensor x\n so that it becomes one dimension, which is reverse to __split_heads.\n \"\"\"\n if len(x.shape) != 4:\n raise ValueError(\"Input(x) should be a 4-D Tensor.\")\n\n trans_x = layers.transpose(x, perm=[0, 2, 1, 3])\n # The value 0 in shape attr means copying the corresponding dimension\n # size of the input as the output dimension size.\n return layers.reshape(\n x=trans_x,\n shape=[0, 0, trans_x.shape[2] * trans_x.shape[3]],\n inplace=True)\n \n def _shift(BD):\n \"\"\"\n -3 -2 -1 0 1 2\n -3 -2 -1 0 1 2\n -3 -2 -1 0 1 2\n\n to\n 0 1 2\n -1 0 1\n -2 -1 0\n\n :param BD: batch_size x n_head x max_len x 2max_len\n :return: batch_size x n_head x max_len x max_len\n \"\"\"\n bsz, n_head, max_len, _ = BD.size()\n zero_pad = layers.zeros(shape=(bsz, n_head, max_len, 1))\n BD = layers.reshape(x=layers.concat([BD, zero_pad], axis=-1),\n shape=(bsz, n_head, -1, max_len))\n BD = layers.reshape(x=BD[:, :, :-1], shape=(bsz, n_head, max_len, -1))\n BD = BD[:, :, :, max_len:]\n return BD\n\n def _transpose_shift(E):\n \"\"\"\n -3 -2 -1 0 1 2\n -30 -20 -10 00 10 20\n -300 -200 -100 000 100 200\n\n to\n 0 -10 -200\n 1 00 -100\n 2 10 000\n\n\n :param E: batch_size x n_head x max_len x 2max_len\n :return: batch_size x n_head x max_len x max_len\n \"\"\"\n bsz, n_head, max_len, _ = E.size()\n zero_pad = layers.zeros(shape=(bsz, n_head, max_len, 1))\n E = layers.reshape(x=layers.concat([E, zero_pad], axis=-1),\n shape=(bsz, n_head, -1, max_len))\n indice = layers.arange(start=0, end=max_len, dtype=int)\n E = layers.index_select(input=E, index=indice, dim=-2)\n E = layers.transpose(E, perm=[0, 1, 3, 2])\n return E\n\n def scaled_dot_product_attention(q, k, v, pos_enc, attn_bias, d_key, dropout_rate):\n \"\"\"\n Scaled Dot-Product Attention\n\n Change:\n - Different from the original one.\n We will remove the scale factor math: \\sqrt{d_k} according to the paper.\n - Bias for attention and position encoding are added.\n \n \"\"\"\n # product = layers.matmul(x=q, y=k, transpose_y=True, alpha=d_key**-0.5)\n\n # now q, k should be shaped like\n # [batch_size, n_head, max_sequence_len, hidden_size_per_head]\n # pos_enc should be shaped like [2 X l, head_dim], and head_dim = d_key\n max_sequence_len = q.shape[2]\n \n r_r_bias = layers.create_parameter(shape=(n_head, d_key)) # [n_head, head_dim]\n r_w_bias = layers.create_parameter(shape=(n_head, d_key)) # [n_head, head_dim]\n rw_head_q = q + r_r_bias[:, None] # [batch, n_head, max_sequence_len, head_dim]\n AC = layers.matmul(x=rw_head_q, y=k, transpose_y=True) # [batch, n_head, max_sequence_len, max_seqence_len]\n \n # position bias for each head, shaped like [n_head, 2 X max_sequence_len].\n # Then add two dimensions at `batch` and `maxlen`.\n D_ = layers.matmul(x=r_w_bias, y=pos_enc, transpose_y=True)[None, :, None]\n # position bias for each query, shaped like [batch, n_head, max_len, 2 X max_len]\n B_ = layers.matmul(x=q, y=pos_enc, transpose_y=True)\n # bias for each key, shaped like [batch, n_head, max_len, 2 X max_len]\n E_ = layers.matmul(x=k, y=pos_enc, transpose_y=True)\n \n # shaped like [batch, n_head, max_len, 2 X max_len]\n # change it to [batch, n_head, max_len, max_len]\n BD = B_ + D_\n BDE = _shift(BD) + _transpose_shift(E_)\n product = AC + BDE\n\n # product = layers.matmul(x=q, y=k, transposed_y=True, alpha=1.0) + \\\n # layers.matmul(x=q, y=pos_enc, transposed_y=True) +\\\n # layers.transpose(x=last_two, perm=[0, 1, 3, 2])\n if attn_bias:\n product += attn_bias\n weights = layers.softmax(product)\n if dropout_rate:\n weights = layers.dropout(\n weights,\n dropout_prob=dropout_rate,\n seed=dropout_seed,\n is_test=False)\n out = layers.matmul(weights, v)\n return out\n\n q, k, v = __compute_qkv(queries, keys, values, n_head, d_key, d_value)\n q, k, v = __split_heads_qkv(q, k, v, n_head, d_key, d_value)\n\n ctx_multiheads = scaled_dot_product_attention(q, k, v, pos_enc, attn_bias, d_key,\n dropout_rate)\n\n out = __combine_heads(ctx_multiheads)\n\n # Project back to the model size.\n proj_out = layers.fc(input=out,\n size=d_model,\n bias_attr=False,\n num_flatten_dims=2)\n return proj_out","def pfit(Vrf,Vdc,X,Y,Z,Irf,Jrf,Krf):\n #1) find dc potential\n #from all_functions import plot_potential,p2d,trap_depth,find_saddle,exact_saddle\n from project_parameters import charge,mass,driveAmplitude,Omega,debug,scale\n #2) find pseudopotential\n \"\"\"Gebhard, Oct 2010:\n changed back to calculating field numerically in ppt2 instead directly\n with bemsolver. this is because the slow bemsolver (new version) does not output EX, EY, EZ.\"\"\"\n [Ey,Ex,Ez] = np.gradient(Vrf,abs(X[1]-X[0])/scale,abs(Y[1]-Y[0])/scale,abs(Z[1]-Z[0])/scale) # fortran indexing\n Esq = Ex**2 + Ey**2 + Ez**2\n #3) plotting pseudopotential, etc; outdated?\n PseudoPhi = Esq*(charge**2)/(4*mass*Omega**2) \n U = PseudoPhi+charge*Vdc # total trap potential\n if debug.pfit:\n# plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Ex,X,Y,Z,'1D plots','Ex','U_{ps} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Ey,X,Y,Z,'1D plots','Ey','U_{ps} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Ez,X,Y,Z,'1D plots','Ez','U_{ps} (eV)',[Irf,Jrf,Krf]) \n# plot_potential(Esq,X,Y,Z,'1D plots','E**2','U_{ps} (eV)',[Irf,Jrf,Krf])\n plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\n plot_potential(PseudoPhi/charge,X,Y,Z,'1D plots','Pseudopotential','U_{ps} (eV)',[Irf,Jrf,Krf])\n# plot_potential(Vdc,X,Y,Z,'1D plots','DC Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\n plot_potential(U/charge,X,Y,Z,'1D plots','Trap Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\n #4) determine trap frequencies and tilt in radial directions\n Uxy = U[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]\n MU = np.max(Uxy) # normalization factor, will be undone when calculating frequencies\n Uxy = Uxy/MU \n nx,ny,nz=X.shape[0],Y.shape[0],Z.shape[0]\n x,y,z = np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz))\n for i in range(nx):\n for j in range(ny):\n for k in range(nz):\n x[i,j,k] = X[i]\n y[i,j,k] = Y[j]\n z[i,j,k] = Z[k]\n dL = x[Irf+3,Jrf,Krf]-x[Irf,Jrf,Krf] # is this X? Originally x. Temporarily y so that dL not 0. Probably related to meshgrid or indexing.\n xr = (x[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-x[Irf,Jrf,Krf])/dL \n yr = (y[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-y[Irf,Jrf,Krf])/dL\n [C1,C2,theta] = p2d(Uxy,xr,yr) \n C1,C2,theta = C1[0],C2[0],theta[0] \n fx = (1e3/dL)*np.sqrt(abs(2*C1*MU/(mass)))/(2*np.pi)\n fy = (1e3/dL)*np.sqrt(abs(2*C2*MU/(mass)))/(2*np.pi)\n #5) trap frequency in axial direction\n Uz=U[Irf,Jrf,:] # old projection\n l1 = np.max([Krf-6,1])\n l2 = np.min([Krf+6,np.max(Z.shape)])\n p = np.polyfit((Z[l1:l2+1]-Z[Krf])/dL,Uz[l1:l2+1],6)\n fz = (1e3/dL)*np.sqrt(2*p[4]/mass)/(2*np.pi)\n [Depth,Xe,Ye,Ze] = trap_depth(U/charge,X,Y,Z,Irf,Jrf,Krf) \n return [fx,fy,fz,theta,Depth,Xe,Ye,Ze]","def Heston_fft(self,alpha,n,B,K):\r\n bt = time.time()\r\n r = self.r\r\n T = self.T\r\n S0 = self.S0\r\n N = 2**n\r\n Eta = B / N\r\n Lambda_Eta = 2 * math.pi / N\r\n Lambda = Lambda_Eta / Eta\r\n \r\n J = np.arange(1,N+1,dtype = complex)\r\n vj = (J-1) * Eta\r\n m = np.arange(1,N+1,dtype = complex)\r\n Beta = np.log(S0) - Lambda * N / 2\r\n km = Beta + (m-1) * Lambda\r\n \r\n ii = complex(0,1)\r\n \r\n Psi_vj = np.zeros(len(J),dtype = complex)\r\n \r\n for zz in range(0,N):\r\n u = vj[zz] - (alpha + 1) * ii\r\n numer = self.Heston_cf(u)\r\n denom = (alpha + vj[zz] * ii) * (alpha + 1 + vj[zz] * ii)\r\n \r\n Psi_vj [zz] = numer / denom\r\n \r\n # Compute FTT\r\n xx = (Eta/2) * Psi_vj * np.exp(-ii * Beta * vj) * (2 - self.dirac(J-1))\r\n zz = np.fft.fft(xx)\r\n \r\n # Option price\r\n Mul = np.exp(-alpha * np.array(km)) / np.pi\r\n zz2 = Mul * np.array(zz).real\r\n k_List = list(Beta + (np.cumsum(np.ones((N, 1))) - 1) * Lambda)\r\n Kt = np.exp(np.array(k_List))\r\n \r\n Kz = []\r\n Z = []\r\n for i in range(len(Kt)):\r\n if( Kt[i]>1e-16 )&(Kt[i] < 1e16)& ( Kt[i] != float(\"inf\"))&( Kt[i] != float(\"-inf\")) &( zz2[i] != float(\"inf\"))&(zz2[i] != float(\"-inf\")) & (zz2[i] is not float(\"nan\")):\r\n Kz += [Kt[i]]\r\n Z += [zz2[i]]\r\n tck = interpolate.splrep(Kz , np.real(Z))\r\n price = np.exp(-r*T)*interpolate.splev(K, tck).real\r\n et = time.time()\r\n \r\n runt = et-bt\r\n\r\n return(price,runt)","def cvstem(self):\n if (self.iEC == \"est\") and (len(sig(self.Cfun).parameters) == 1):\n fun1 = self.Cfun\n self.Cfun = lambda x,p: fun1(x)\n if (self.iEC == \"est\") and (len(sig(self.Gw).parameters) == 1):\n fun2 = self.Gw\n self.Gw = lambda x,p: fun2(x)\n if self.iEC == \"est\":\n self.c_over = self.matrix_2bound(self.Cfun)\n self.g_over = self.matrix_2bound(self.Gw)\n if (len(sig(self.Bw).parameters) == 1):\n fun3 = self.Bw\n self.Bw = lambda x,p: fun3(x)\n self.b_over = self.matrix_2bound(self.Bw)\n self.linesearch()\n alp = self.alp_opt\n Nx = self.Nx\n Nsplit = 1\n Np = int(Nx/Nsplit)\n Nr = np.remainder(Nx,Nsplit)\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\n Nxp = self.n+self.n_p\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\n Ws_opt = []\n chi_opt = 0\n nu_opt = 0\n print(\"========================================================\")\n print(\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\")\n print(\"========================================================\")\n for p in range(Np):\n if np.remainder(p,int(Np/10)) == 0:\n print(\"# sampled metrics: \",p*Nsplit,\"...\")\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n if Nr != 0:\n print(\"# samples metrics: \",Nx,\"...\")\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n self.xs_opt = xs_opt\n self.ps_opt = ps_opt\n self.Ws_opt = Ws_opt\n self.chi_opt = chi_opt\n self.nu_opt = nu_opt\n if self.iEC == \"est\":\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\n print(\"Optimal steady-state estimation error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n elif self.iEC == \"con\":\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\n print(\"Optimal steady-state tracking error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n else:\n raise ValueError('Invalid iEC: iEC = \"est\" or \"con\"')\n self.M2cholM()\n path = \"models/optvals/\"+self.fname\n if os.path.exists(path) == False:\n try:\n os.makedirs(path)\n except: \n raise OSError(\"Creation of directory %s failed\" %path)\n else:\n print (\"Successfully created directory %s \" %path)\n else:\n print (\"Directory %s already exists\" %path)\n np.save(path+\"/alp_opt.npy\",alp)\n np.save(path+\"/chi_opt.npy\",self.chi_opt)\n np.save(path+\"/nu_opt.npy\",self.nu_opt)\n np.save(path+\"/Jcv_opt.npy\",self.Jcv_opt)\n print(\"========================================================\")\n print(\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\")\n print(\"========================================================\\n\\n\")\n pass","def g0_hz(sp,cal_Veff = 5e-3, V_pi = None, askFit = True,T = 293,PM_calib_file = \"M:\\\\phaseModulationCalibrations\\\\V_pi1550.spe\"):#V_pi = 7.1\n \n cal_Veff = addDefaultUnit(cal_Veff,V)\n T = addDefaultUnit(T,K)\n f = sp.fitter\n if not isinstance(sp.fitter,fit.FitterLorentzAndGauss):\n if askFit:\n yn = \"dummy\"\n while yn is not \"y\":\n yn = raw_input(\"spectrum %s was fitted with model %s. refit it with model \\\"LorentzGauss\\\"(y/n)?\"%(sp.name,f.ID_STR))\n if yn ==\"n\":\n raise ValueError(\"spectrum should be fitted with LorentzGauss for determining effective mass\")\n sp.fit(model = \"LorentzGauss\")\n\n\n if V_pi == None:\n f = load(PM_calib_file)\n V_pi = utils.misc.interpFromPlottable(f,sp[\"x0_2_hz\"])\n else:\n V_pi = 7.1\n V_pi = addDefaultUnit(V_pi,V)\n print \"value of V_pi used is \" + str(V_pi)\n\n ratio = sp[\"area_2\"]/sp[\"area\"]\n \n phi0 = np.pi*cal_Veff*sqrt(2)/V_pi\n \n# omega = 2.0*np.pi*cst.c/(lambda_nm*1e-9)\n\n Omega = 2.0*np.pi*sp[\"x0_2_hz\"]*Hz\n\n nbar = k*T/(hbar*Omega)\n g0 = ((Omega**2*phi0**2)/(4*nbar*ratio))**.5/(2*pi)\n yn = raw_input(\"would you like results to be pasted in Origin to be copied in clipboard? [y]/n\")\n if yn is not \"n\":\n #import utils\n utils.misc.copyToClipboard(str(sp[\"x0_hz\"]*1e-6) +\"\\t\"+str(sp[\"gamma_hz\"]) + \"\\t\"+\"0\" +\"\\t\"+ str(g0.asNumber()))\n return g0","def dispersion_2(ztop, vp, vs, rh, Curves,\n h=0.005, dcl=0.005, dcr=0.005, keepnans=False):\n Waves, Types, Modes, Freqs = zip(*Curves)\n for w, t, m, F, V in dispersion_1(\\\n ztop, vp, vs, rh,\n Waves, Types, Modes, Freqs,\n h=h, dcl=dcl, dcr=dcr, keepnans=keepnans):\n yield w, t, m, F, V","def non_max_suppression(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\n # print('conf_thres',conf_thres)\n if prediction.dtype is torch.float16:\n prediction = prediction.float() # to FP32\n\n nc = prediction[0].shape[1] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Settings\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_det = 300 # maximum number of detections per image\n time_limit = 10.0 # seconds to quit after\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\n\n t = time.time()\n output = [None] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n\n\n # If none remain process next image\n n = x.shape[0] # number of boxes\n if not n:\n continue\n\n # Sort by confidence\n # x = x[x[:, 4].argsort(descending=True)]\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n # # Sort by confidence\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\n x = x[ind_Sort_by_confidence][:top_k_num] #\n # cross classes nms\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n # if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)\n # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\n # iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\n # weights = iou * scores[None] # box weights\n # x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes\n # if redundant:\n # i = i[iou.sum(1) > 1] # require redundancy\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n break # time limit exceeded\n\n return output","def compute_mixing_coefficients_surf(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n\n # SET UP NEW MIXING COEFFICIENT ARRAYS\n self.Kv_surf = np.zeros([Ly,N+1])\n self.Kt_surf = np.zeros([Ly,N+1])\n \n self.ghat = np.zeros([Ly,N+1])\n \n\n #################################\n # \tSURFACE KPP\n ################################\n #---> j-loop\n \n self.wm2 = []\n self.ws2 = []\n self.sigma_y = []\n for j in range(Ly):\n #--> k-loop (top to kbl[j])\n # in fortran k=N-1,kbl(j),-1\n for k in range(N-1,self.kbl[j]-1,-1):\n k_w = k\n k_r = k-1\n\n Bfsfc = self.Bfsfc_bl[j]\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\n \n # CALCULATE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm2.append(wm)\n self.ws2.append(ws)\n # COMPUTE VERTICAL MIXING COEFFICIENTS\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\n self.sigma1 = sigma #for debugging\n if j == 25: \n self.sigma_y.append(sigma)\n a1 = sigma - 2.\n a2 = 3.-2.*sigma\n a3 = sigma - 1.\n\n if sigma < 0.07:\n cff = 0.5 * (sigma-0.07)**2/0.07\n else:\n cff = 0\n \n \n if k == N-1: \n self.wm_debug = wm\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\n\n if k == N-1:\n self.ws_debug = ws\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n \n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\n #---> end k-loop \n if self.LMD_NONLOCAL:\n if Bfsfc < 0:\n self.ghat[j,k_w] = 0\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\n else:\n self.ghat[j,k_w] = 0.\n\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \n if self.LMD_CONVEC and self.MLCONVEC: \n for k in range(N-1,int(self.kbl[j]-1),-1):\n k_w = k\n k_r = k -1\n\n if self.bvf[j,k_w] < 0:\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\n\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\n # IF BKPP IS SWITCHED OFF!!\n for k in range(int(self.kbl[j]-1),-1,-1):\n k_w = k\n k_r = k -1\n if self.LMD_NONLOCAL:\n self.ghat[j,k_w] = 0\n if self.LMD_CONVEC and self.LMD_BKPP == False:\n if self.bvf[j,k_w] < 0:\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\n \n\n #---> end j-loop","def solve_system_for_vv_harmonic_weak_Maass_waveforms_new(H, W, N=None, gr=False, cn=False, verbose=0):\n V = W['V']\n Ms = W['Ms']\n Mf = W['Mf']\n # WR=W['WR']\n X = H.multiplier()\n WM = H.multiplier().weil_module()\n nc = W['nc']\n Ml = Mf - Ms + 1\n get_reduced_matrix = gr\n verbose = H._verbose\n comp_norm = cn\n r = W['r'] # WM.rank()\n if verbose > 0:\n print(\"Ml={0}\".format(Ml))\n print(\"nv={0}\".format(nc))\n # if W['sym_type']==1:\n # setD=range(WM.rank()/2+1) # 0,1,...,N\n # #setD=range(WR.N+1) # 0,1,...,N\n # elif W['sym_type']==-1:\n # setD=range(1,WM.rank()/2) # 1,2,...,N-1 (since -0=0 and -N=N)\n setD = X.D()\n Ds = setD[0]\n num_comp = nc * r\n if num_comp != len(setD):\n raise Exception(\" Wrong dimension of input matrix! r={0},nc={1},setD={2}\".format(r, nc, setD))\n if V.ncols() != Ml * num_comp or V.nrows() != Ml * num_comp:\n raise Exception(\" Wrong dimension of input matrix!\")\n if N is None:\n SetCs = [[]]\n Vals = [{}]\n for b in WM.basis():\n if WM.Q(b) == 0:\n SetCs[0].append((b, 0))\n Vals[0][(b, 0)] = 0\n comp_dim = 1\n else:\n SetCs = N['SetCs']\n Vals = N['Vals']\n comp_dim = N['comp_dim']\n\n # for a in Vals.keys():\n # Vals[a]=mpmath.mp.mpc(Vals[a])\n if Ms < 0:\n use_sym = 0\n else:\n use_sym = 1\n if verbose > 0:\n print(\"Before SetCs={0}\".format(SetCs))\n if use_sym == 1:\n if len(SetCs[0]) > 0:\n num_set = 0\n for (r, m) in SetCs[0]:\n if r in X.D(): # )_as_int:\n num_set = num_set + 1\n else:\n num_set = len(SetCs[0])\n t = V[0, 0]\n CF = MPComplexField(H._prec)\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(comp_dim))\n RHS = Matrix_complex_dense(MS, 0, True, True)\n # if W.has_key('RHS'):\n # if(W['RHS'].ncols()!=comp_dim):\n # raise ValueError,\"Inum_comporrect number of right hand sides!\"\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(Ml * num_comp - num_set))\n LHS = Matrix_complex_dense(MS, 0, True, True)\n if verbose > 0:\n print(\"Ml={0}\".format(Ml))\n print(\"num_set={0}\".format(num_set))\n print(\"num_comp={0}\".format(num_comp))\n print(\"SetCs={0}\".format(SetCs))\n print(\"setD={0}\".format(setD))\n print(\"Vals={0}\".format(Vals))\n print(\"V.rows={0}\".format(V.nrows()))\n print(\"V.cols={0}\".format(V.ncols()))\n print(\"LHS.rows={0}\".format(LHS.nrows()))\n print(\"LHS.cols={0}\".format(LHS.ncols()))\n print(\"RHS.rows={0}\".format(RHS.nrows()))\n print(\"RHS.cols={0}\".format(RHS.ncols()))\n print(\"use_sym={0}\".format(use_sym))\n print(\"N={0}\".format(N))\n\n num_rhs = 0\n if 'RHS' in W:\n num_rhs = W['RHS'].ncols()\n else:\n num_rhs = 1\n if num_rhs != 1 and num_rhs != comp_dim:\n raise ValueError(\"Need same number of right hand sides (or just one) as the number of set coefficients!\")\n\n if V.nrows() != num_comp * Ml:\n raise ArithmeticError(\" Matrix does not have correct size!\")\n roffs = 0\n for a in range(num_comp):\n for n in range(Ms, Mf + 1):\n r = a * Ml + n - Ms\n if SetCs[0].count((a + Ds, n)) > 0 and a + Ds in setD:\n # print \" set row a,n=\",a,n\n roffs = roffs + 1\n continue\n for fn_j in range(comp_dim):\n # ztmp=CF(ztmp.real(),ztmp.imag())\n if verbose > 3:\n print(\"fn_j={0}\".format(fn_j))\n print(\"r,roffs={0},{1},{2}\".format(r, roffs, r - roffs))\n if num_rhs == comp_dim:\n rhs_j = fn_j\n else:\n rhs_j = 0\n if 'RHS' in W:\n RHS[r - roffs, fn_j] = -W['RHS'][r, rhs_j]\n else:\n RHS[r - roffs, fn_j] = 0\n for (i, cset) in SetCs[fn_j]:\n if i in setD:\n v = Vals[fn_j][(i, cset)]\n # k = i*Ml+cset-Ms\n k = (i - Ds) * Ml + cset - Ms\n if verbose > 3:\n print(\"fi,cset={0},{1}\".format(i, cset))\n print(\"r,k={0},{1}\".format(r, k))\n tmp = CF(v) * V[r, k]\n RHS[r - roffs, fn_j] = RHS[r - roffs, fn_j] - tmp\n coffs = 0\n for b in range(num_comp):\n for l in range(Ms, Mf + 1):\n k = b * Ml + l - Ms\n if SetCs[0].count((b + Ds, l)) > 0 and b + Ds in setD:\n coffs = coffs + 1\n continue\n if verbose > 3:\n print(\"r,k={0},{1}\".format(r, k))\n print(\"r-roffs,k-coffs={0},{1}\".format(r - roffs, k - coffs))\n LHS[r - roffs, k - coffs] = V[r, k]\n # print \"LHS[\",r,k,\"]=\",LHS[r-roffs,k-coffs]\n # else:\n # LHS = V\n # RHS = -W['RHS']\n if get_reduced_matrix:\n return [LHS, RHS]\n maxit = 100\n i = 0\n done = False\n dps0 = CF.prec()\n while (not done and i <= maxit):\n try:\n Q, R = LHS.qr_decomposition()\n done = True\n except ZeroDivisionError:\n t = int(ceil(-log(smallest_inf_norm(LHS), 10)))\n dps = t + 5 * i\n i = i + 1\n print(\"raising number of digits to:{0}\".format(dps))\n LHS.set_prec(dps)\n # raise ZeroDivisionError,\"Need higher precision! Use > %s digits!\" % t\n if i >= maxit:\n raise ZeroDivisionError(\"Can not raise precision enough to solve system! Should need > {0} digits! and {1} digits was not enough!\".format(t, dps))\n if comp_norm:\n max_norm = LHS.norm()\n for j in range(LHS.rows):\n # y=mpmath_ctx.matrix(LHS.rows,int(1)); y[j,0]=1\n y = Vector_complex_dense(vector(CF, LHS.rows).parent(), 0)\n y[j] = 1\n TMP = RHS.solve(b) # pmath_ctx.U_solve(A, b)\n tmpnorm = max(list(map(abs, TMP)))\n if(tmpnorm > max_norm):\n max_norm = tmpnorm\n print(\"max norm of V^-1={0}\".format(max_norm))\n X = dict()\n for fn_j in range(comp_dim):\n X[fn_j] = dict() # mpmath.matrix(int(Ml),int(1))\n # b = mpmath_ctx.L_solve(A, RHS.column(fn_j), p)\n v = RHS.column(fn_j)\n print(\"len(B)={0}\".format(len(v)))\n TMP = LHS.solve(v)\n # TMP = mpmath_ctx.U_solve(A, b)\n roffs = 0\n # res = mpmath_ctx.norm(mpmath_ctx.residual(LHS, TMP, RHS.column(fn_j)))\n res = (LHS * TMP - v).norm()\n print(\"res(\", fn_j, \")={0}\".format(res))\n for ai in range(num_comp):\n X[fn_j][ai] = dict()\n for n in range(Ms, Mf + 1):\n ni = Ml * ai + n - Ms\n if SetCs[fn_j].count((ai + Ds, n)) > 0 and ai + Ds in setD:\n roffs = roffs + 1\n X[fn_j][ai][n] = CF(Vals[fn_j][(ai + Ds, n)])\n continue\n # if verbose>0:\n # print \"ni-roffs=\",ni-roffs\n X[fn_j][ai][n] = TMP[ni - roffs]\n return X","def _fit_multiple(self, X, y, configurations, bracket_num):\n device_used = self.device\n if device_used == 'cuda':\n device_used += f':{self.gpu_ids[bracket_num % self.n_device]}'\n list_toTrain_model = []\n best_config_by_round = []\n\n for i in tqdm(range(bracket_num + 1), desc=f'Bracket {bracket_num}', position=(self.max_rounds-bracket_num), leave=True):\n for contender in range(self.brackets[bracket_num][i]['ni']):\n self.brackets[bracket_num][i]['contenders'][contender] = dict.fromkeys([\n 'hparams', 'score'])\n self.brackets[bracket_num][i]['contenders'][contender]['hparams'] = configurations[contender]['hparams']\n model = self.create_model(\n self.estimator,\n random_state=self.random_state,\n epoch=self.brackets[bracket_num][i]['ri'],\n device=device_used,\n log_path=self.log_path,\n **configurations[contender]['hparams']\n )\n verbose = 0\n list_toTrain_model.append(\n (model, X, y, self.scoring, self.cv, self.n_jobs_cv, verbose))\n\n torch.multiprocessing.set_start_method('spawn', force=True)\n with MyPool(self.n_jobs_model) as p:\n list_toTrain_score = p.starmap(\n self.get_mean_cv_score, list_toTrain_model)\n\n for contender in range(self.brackets[bracket_num][i]['ni']):\n self.brackets[bracket_num][i]['contenders'][contender]['score'] = list_toTrain_score[contender]\n\n configurations = self.get_top_k(\n self.brackets[bracket_num][i]['contenders'],\n k=max(math.floor(\n self.brackets[bracket_num][i]['ni']/self.factor), 1)\n )\n\n best_config = configurations[0].copy()\n best_config_by_round.append({\n 'bracket': bracket_num,\n 'round': i,\n 'epoch': int(self.brackets[bracket_num][i]['ri']),\n **best_config\n })\n\n return best_config_by_round","def convert2EbnerParam(joblib,list_prefix,directory):\n \n key=[p[0] for p in joblib]\n element=[p[1] for p in joblib]\n\n \n listSlice=element[key.index('listSlice')] #list of slice\n parameters=element[key.index('EvolutionParameters')][-1,:,:] #estimated paramters of the registration\n rejectedSlice=element[key.index('RejectedSlices')] #rejected slices\n\n \n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\n \n for i_slice in range(len(listSlice)): \n slicei=listSlice[i_slice]\n slicei.set_parameters(parameters[i_slice,:]) #set parameters to the last estimated parameters\n \n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\n\n for n in range(len(images)): #for each stack\n \n imagen = images[n]\n \n for i_slice in range(len(images[n])): #for each slices (in each stacks)\n \n slicei=imagen[i_slice]\n s = (slicei.get_orientation(),slicei.get_index_slice())\n \n if s not in rejectedSlice:\n dimension=3\n X,Y,Z= slicei.get_slice().get_fdata().shape\n center= -slicei.get_center()\n centerMat = np.eye(4)\n centerMat[0:3,3] = center[0:3]\n invcenterMat = np.eye(4)\n invcenterMat[0:3,3] = -center[0:3] \n p = slicei.get_parameters()\n matrix = mat @ centerMat @ rigidMatrix([p[0],p[1],p[2],p[3],p[4],p[5]]) @ invcenterMat @ mat\n test = sitk.AffineTransform(dimension)\n test.SetMatrix(matrix[0:3,0:3].flatten())\n test.SetTranslation(matrix[0:3,3])\n images_index = slicei.get_index_image()\n sitk.WriteTransform(test,\"%s/%s_slice%d.tfm\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\n #else:\n #print(s)"],"string":"[\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # Bounds for harmonic oscillator frequencies\\n for i in range(Nvib):\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # Bounds for hindered rotor frequencies and barrier heights\\n for i in range(Nrot):\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n # Initial guesses within each mode type must be distinct or else the\\n # optimization will fail\\n x0 = numpy.zeros(Nvib + 2*Nrot, numpy.float64)\\n # Initial guess for harmonic oscillator frequencies\\n if Nvib > 0:\\n x0[0] = 200.0\\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\\n # Initial guess for hindered rotor frequencies and barrier heights\\n if Nrot > 0:\\n x0[Nvib] = 100.0\\n x0[Nvib+1] = 100.0\\n for i in range(1, Nrot):\\n x0[Nvib+2*i] = x0[Nvib+2*i-2] + 20.0\\n x0[Nvib+2*i+1] = x0[Nvib+2*i-1] + 100.0\\n\\n # Execute the optimization\\n fit = DirectFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n vib = list(x[0:Nvib])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[Nvib+2*i], x[Nvib+2*i+1]))\\n\\n return vib, hind\",\n \"def fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # x[0] corresponds to the first harmonic oscillator (real) frequency\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # x[1] corresponds to the degeneracy of the second harmonic oscillator\\n bounds.append((1.0, float(Nvib - 2)))\\n # x[2] corresponds to the second harmonic oscillator pseudo-frequency\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # x[3] corresponds to the third harmonic oscillator pseudo-frequency\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # x[4] corresponds to the hindered rotor pseudo-frequency\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n # x[5] corresponds to the hindered rotor pseudo-barrier\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n x0 = numpy.zeros(6, numpy.float64) # Initial guess\\n x0[0] = 300.0\\n x0[1] = float(math.floor((Nvib - 1) / 2.0))\\n x0[2] = 800.0\\n x0[3] = 1600.0\\n x0[4] = 100.0\\n x0[5] = 300.0\\n\\n # Execute the optimization\\n fit = PseudoFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n Nvib2 = int(round(x[1]))\\n Nvib3 = Nvib - Nvib2 - 1\\n if Nvib2 < 0 or Nvib2 > Nvib-1 or Nvib3 < 0 or Nvib3 > Nvib-1:\\n raise StatmechFitError('Invalid degeneracies {0} and {1} fitted for pseudo-frequencies.'.format(Nvib2, Nvib3))\\n\\n vib = [x[0]]\\n for i in range(Nvib2): vib.append(x[2])\\n for i in range(Nvib3): vib.append(x[3])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[4], x[5]))\\n\\n return vib, hind\",\n \"def define_potts_helper_functions(k):\\n\\n @njit\\n def calc_observables(X, k=k):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n\\n Returns\\n -------\\n ndarray\\n Dimensions (n_samples, n_observables).\\n \\\"\\\"\\\"\\n\\n n = X.shape[1]\\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\\n \\n # average orientation (magnetization)\\n # note that fields for the third state are often set to 0\\n counter = 0\\n for i in range(k):\\n for j in range(n):\\n Y[:,counter] = X[:,j]==i\\n counter += 1\\n \\n # pairwise correlations\\n for i in range(n-1):\\n for j in range(i+1, n):\\n Y[:,counter] = X[:,i]==X[:,j]\\n counter += 1\\n \\n return Y\\n\\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n multipliers : ndarray of dtype np.float64\\n\\n Returns\\n -------\\n ndarray\\n Energies of each observable.\\n \\\"\\\"\\\"\\n\\n return -calc_observables(X, k).dot(multipliers)\\n\\n def mch_approximation(sample, dlamda, calc_e=calc_e):\\n \\\"\\\"\\\"Function for making MCH approximation step for Potts model.\\n \\n Parameters\\n ----------\\n sample : ndarray\\n Of dimensions (n_sample, n_spins).\\n dlamda : ndarray\\n Change in parameters.\\n \\n Returns\\n -------\\n ndarray\\n Predicted correlations.\\n \\\"\\\"\\\"\\n\\n dE = calc_e(sample, dlamda)\\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \\n assert not ((predsisj<0).any() or\\n (predsisj>(1+1e-10)).any()),\\\"Predicted values are beyond limits, (%E,%E)\\\"%(predsisj.min(),\\n predsisj.max())\\n return predsisj\\n\\n return calc_e, calc_observables, mch_approximation\",\n \"def specific_heat(Ekinv,n0,N,t0):\\n Cv = np.zeros(10)\\n for i in range(10):\\n avg_K_squared = (1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]))**2\\n FluctK = 1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]**2) - avg_K_squared\\n Cv[i] = -1 / (FluctK/ avg_K_squared * 3 * N / 2 - 1) * 3 * N / 2\\n return Cv\",\n \"def weak_repulsion(Cents,a,k, CV_matrix,n_c,L):\\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\\n displacement = np.mod(Cents - CCW + L/2,L) - L/2\\n rij = np.sqrt(displacement[:,:,0]**2 + displacement[:,:,1]**2)\\n norm_disp = (displacement.T/rij.T).T\\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\\n V_soft = V_soft_CW + V_soft_CCW\\n F_soft = np.zeros((n_c, 2))\\n for i in range(3):\\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\\n return F_soft\",\n \"def weak_repulsion_boundary(Cents,a,k, CV_matrix,n_c,n_C):\\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\\n CCW_displacement = Cents - CCW\\n rij = np.sqrt(CCW_displacement[:,:,0]**2 + CCW_displacement[:,:,1]**2)\\n norm_disp = (CCW_displacement.T/rij.T).T\\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\\n V_soft = V_soft_CW + V_soft_CCW\\n F_soft = np.zeros((n_c, 2))\\n for i in range(3):\\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\\n F_soft[n_C:] = 0\\n return F_soft\",\n \"def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\\n # We move from an array to a list of 2d-array for the competition over each template:\\n\\n cp=cps[0]\\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\\n new_cp = 1\\n\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\\n # update for fixed point:\\n new_cp += w_inpIdx*x_eq\\n # saving values\\n layerEq[inpIdx] = x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n layerEq[inpIdx] = x_eq\\n\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n\\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n new_cp += Inhib2/(E0*cp)*x_eq\\n\\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\\n diff_cps = np.zeros(cps.shape)\\n if new_cp>=1:\\n diff_cps[0] = cp - new_cp\\n else:\\n diff_cps[0] = 10**3\\n for l,m in enumerate(masks):\\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\\n return diff_cps\",\n \"def non_max_suppression_kneron(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\\n if prediction.dtype is torch.float16:\\n prediction = prediction.float() # to FP32\\n\\n nc = prediction[0].shape[1] - 5 # number of classes\\n xc = prediction[..., 4] > conf_thres # candidates\\n\\n # Settings\\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\\n max_det = 300 # maximum number of detections per image\\n time_limit = 10.0 # seconds to quit after\\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\\n\\n t = time.time()\\n output = [None] * prediction.shape[0]\\n for xi, x in enumerate(prediction): # image index, image inference\\n # Apply constraints\\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\\n x = x[xc[xi]] # confidence\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\\n box = xywh2xyxy(x[:, :4])\\n\\n # Detections matrix nx6 (xyxy, conf, cls)\\n if multi_label:\\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\\n else: # best class only\\n conf, j = x[:, 5:].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\\n\\n\\n\\n # If none remain process next image\\n n = x.shape[0] # number of boxes\\n if not n:\\n continue\\n\\n # Sort by confidence\\n # x = x[x[:, 4].argsort(descending=True)]\\n\\n # Batched NMS\\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\\n # Sort by confidence\\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\\n x = x[ind_Sort_by_confidence][:top_k_num] #\\n # cross classes nms\\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n\\n\\n output[xi] = x[i]\\n if (time.time() - t) > time_limit:\\n break # time limit exceeded\\n\\n return output\",\n \"def error_specific_heat(Cv):\\n ncv = 10\\n tcv = np.linspace(0,50,ncv) \\n \\n chi = auto_correlation(tcv,Cv,ncv)\\n tau_fit = curve_fit(exp,tcv,chi)\\n tau = tau_fit[0]\\n\\n error_Cv = error(tau,ncv,Cv,tcv) \\n\\n return error_Cv\",\n \"def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\\n # get activation for each seperated vc\\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\\n max_ch_index = max_ch_index.view(-1, L) # n, L\\n\\n all_activation_vcs = []\\n\\n for i in range(len(integrate_activation_vc)):\\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\\n all_activation_vcs.append(integrate_activation_vc_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n print(f\\\"unique_vc_i {unique_vc_i.shape}\\\")\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\\n activate_vc_i[index_vc_i, :] = 0.\\n all_activation_vcs.append(activate_vc_i)\\n \\n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\\n \\n # decompose each mask \\n all_masks = []\\n for i in range(len(sim_map_max)):\\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\\n all_masks.append(sim_map_max_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\\n vc_sim_map_max_i[index_vc_i] = 0.\\n all_masks.append(vc_sim_map_max_i)\\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\\n\\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\\\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\\\"\\n\\n return all_activation_vcs, all_masks\",\n \"def grid_visibilities_parallel(self, visibilities,min_attenuation = 1e-10, N = 120):\\n\\n #Find out the number of frequencies to process per thread\\n nfreq = len(self.frequencies)\\n numperthread = int(np.ceil(nfreq/self.n_obs))\\n offset = 0\\n nfreqstart = np.zeros(self.n_obs,dtype=int)\\n nfreqend = np.zeros(self.n_obs,dtype=int)\\n infreq = np.zeros(self.n_obs,dtype=int)\\n for i in range(self.n_obs):\\n nfreqstart[i] = offset\\n nfreqend[i] = offset + numperthread\\n\\n if(i==self.n_obs-1):\\n infreq[i] = nfreq - offset\\n else:\\n infreq[i] = numperthread\\n\\n offset+=numperthread\\n\\n # Set the last process to the number of frequencies\\n nfreqend[-1] = nfreq\\n\\n processes = []\\n\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\\n \\n centres = (ugrid[1:] + ugrid[:-1]) / 2\\n \\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\\n\\n\\n if(os.path.exists(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")):\\n kernel_weights = np.load(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")\\n else:\\n kernel_weights=None\\n \\n if kernel_weights is None:\\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\\n\\n visgrid_buff_real = []\\n visgrid_buff_imag = []\\n weights_buff = []\\n\\n #Lets split this array up into chunks\\n for i in range(self.n_obs):\\n\\n visgrid_buff_real.append(multiprocessing.RawArray(np.sctype2char(visgrid.real),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\\n visgrid_buff_imag.append(multiprocessing.RawArray(np.sctype2char(visgrid.imag),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\\n visgrid_tmp_real = np.frombuffer(visgrid_buff_real[i])\\n visgrid_tmp_imag = np.frombuffer(visgrid_buff_imag[i])\\n visgrid_tmp_real = visgrid[:,:,nfreqstart[i]:nfreqend[i]].real.flatten()\\n visgrid_tmp_imag = visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag.flatten()\\n\\n\\n if(kernel_weights is None):\\n weights_buff.append(multiprocessing.RawArray(np.sctype2char(weights),weights[:,:,nfreqstart[i]:nfreqend[i]].size))\\n weights_tmp = np.frombuffer(weights_buff[i])\\n weights_tmp = weights[:,:,nfreqstart[i]:nfreqend[i]]\\n else:\\n weights_buff.append(None)\\n\\n processes.append(multiprocessing.Process(target=self._grid_visibilities_buff,args=(self.n_uv,visgrid_buff_real[i],visgrid_buff_imag[i],weights_buff[i], visibilities[:,nfreqstart[i]:nfreqend[i]],self.frequencies[nfreqstart[i]:nfreqend[i]],self.baselines,centres,self._instr_core.sigma(self.frequencies[nfreqstart[i]:nfreqend[i]]),min_attenuation, N) ))\\n\\n for p in processes:\\n p.start()\\n\\n for p in processes:\\n p.join()\\n\\n for i in range(self.n_obs):\\n\\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].real = np.frombuffer(visgrid_buff_real[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag = np.frombuffer(visgrid_buff_imag[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n\\n if(kernel_weights is None):\\n weights[:,:,nfreqstart[i]:nfreqend[i]] = np.frombuffer(weights_buff[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n\\n if kernel_weights is None:\\n kernel_weights = weights\\n \\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\\n\\n return visgrid,kernel_weights\",\n \"def Boltzchoice(LFnum, energylist, RNs):\\n # transform list to energy values in kT according to experimental\\n # affinities and the energy window allowed by the threshold\\n energylist = cf.y0 + np.array(energylist) * cf.m\\n # calculate norm of initial list\\n Norm = sum([math.exp(-ener) for ener in energylist])\\n # calculate initial probability vector\\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\\n # list to catch indices of selected cells\\n selected = []\\n # cells to be picked: determined by the lesser of #waiters and #LFs\\n cellpick = min(len(energylist), LFnum)\\n while len(selected) < cellpick:\\n bins = np.cumsum(probs)\\n ind = np.digitize(RNs.getR(), bins)\\n selected.append(ind)\\n # now, set the probability of the selected cell to 0 and renormalise\\n # the remaining probability vector\\n newNorm = Norm - math.exp(-energylist[ind])\\n probs[ind] = 0\\n probs = probs * Norm / newNorm\\n Norm = newNorm\\n\\n return selected\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def define_pseudo_potts_helper_functions(n, k):\\n\\n assert n>1\\n assert k>1\\n\\n @njit\\n def get_multipliers_r(r, multipliers, n=n, k=k):\\n \\\"\\\"\\\"Return r's field and all couplings to spin r.\\n\\n Parameters\\n ----------\\n r : int\\n multipliers : ndarray\\n All fields and couplings concatenated together.\\n\\n Returns\\n -------\\n ndarray\\n Relevant multipliers.\\n list\\n Index of where multipliers appear in full multipliers array.\\n \\\"\\\"\\\"\\n \\n ix = [r+n*i for i in range(k)]\\n multipliersr = np.zeros(k-1+n)\\n for i in range(k):\\n multipliersr[i] = multipliers[r+n*i]\\n\\n # fill in the couplings\\n ixcounter = k\\n for i in range(n):\\n if i!=r:\\n if i<r:\\n ix.append( sub_to_ind(n, i, r) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n else:\\n ix.append( sub_to_ind(n, r, i) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n ixcounter += 1\\n return multipliersr, ix\\n\\n @njit\\n def calc_observables_r(r, X, n=n, k=k):\\n \\\"\\\"\\\"Return the observables relevant for calculating the conditional probability of\\n spin r.\\n\\n Parameters\\n ----------\\n r : int\\n Spin index.\\n X : ndarray\\n Data samples of dimensions (n_samples, n_dim).\\n\\n Returns\\n -------\\n ndarray\\n observables\\n list of ndarray\\n observables if spin r were to occupy all other possible states\\n ndarray\\n Each col details the occupied by spin r in each array of the previous return\\n value, i.e., the first col of this array tells me what r has been changed to\\n in the first array in the above list.\\n \\\"\\\"\\\"\\n\\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n # keep another copy of observables where the spin iterates thru all other possible states\\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n for i in range(k-1)]\\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\\n \\n # for each data sample in X\\n for rowix in range(X.shape[0]):\\n counter = 0\\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\\n for i in range(k):\\n if X[rowix,r]==i:\\n obs[rowix,i] = 1\\n else:\\n otherobs[counter][rowix,i] = 1\\n otherstates[rowix,counter] = i\\n counter += 1\\n ixcounter = k\\n \\n for i in range(n-1):\\n for j in range(i+1,n):\\n if i==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\\n kcounter += 1\\n ixcounter += 1\\n elif j==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\\n kcounter += 1\\n ixcounter += 1\\n return obs, otherobs, otherstates\\n\\n return get_multipliers_r, calc_observables_r\",\n \"def CLOMPR(task,sketch,featureMap,K,bounds,dimensions_to_consider=None, nb_cat_per_dim=None,nIterations=None, nRepetitions=1, ftol=1e-6, verbose=0 ):\\n\\n ## 0) Defining all the tools we need\\n ####################################\\n ## 0.1) Handle input\\n\\n ## 0.1.1) task name\\n if task.lower() in [\\\"km\\\",\\\"ckm\\\",\\\"kmeans\\\",\\\"k-means\\\"]:\\n task = \\\"kmeans\\\"\\n task_finetuning = \\\"kmeans\\\"\\n elif task.lower() in [\\\"gmm\\\",\\\"gaussian mixture model\\\"]:\\n task = \\\"gmm\\\"\\n task_finetuning = \\\"gmm\\\"\\n elif task.lower() in [\\\"gmm-nondiag\\\"]:\\n task = \\\"gmm\\\"\\n task_finetuning = \\\"gmm-nondiag\\\"\\n else:\\n raise ValueError('The task argument does not match one of the available options.')\\n\\n ## 0.1.2) sketch feature function\\n if isinstance(featureMap,SimpleFeatureMap):\\n d_all = featureMap.d\\n m = featureMap.m\\n else:\\n raise ValueError('The featureMap argument does not match one of the supported formats.')\\n\\n # Restrict the dimension\\n if dimensions_to_consider is None:\\n dimensions_to_consider = np.arange(d_all)\\n dimensions_to_ignore = np.delete(np.arange(d_all), dimensions_to_consider)\\n d = dimensions_to_consider.size\\n \\n # Pre-compute sketch of unused dimensions\\n z_to_ignore = fourierSketchOfBox(bounds.T,featureMap,nb_cat_per_dim, dimensions_to_consider = dimensions_to_ignore)\\n # Compensate the normalization constant and the dithering which will be taken into account in the centroid sketch\\n z_to_ignore = z_to_ignore/(featureMap(np.zeros(d_all))) # giving zeros yields the dithering and the c_norm\\n \\n # Restrict the featureMap for the centroids\\n Phi = copy(featureMap) # Don't touch to the inital map, Phi is featureMap restricted to relevant dims\\n Phi.d = d\\n Phi.Omega = featureMap.Omega[dimensions_to_consider]\\n \\n ## 0.1.3) nb of iterations\\n if nIterations is None:\\n nIterations = 2*K # By default: CLOMP-*R* (repeat twice)\\n \\n ## 0.1.4) Bounds of the optimization problems\\n if bounds is None:\\n lowb = -np.ones(d) # by default data is assumed normalized\\n uppb = +np.ones(d)\\n if verbose > 0: print(\\\"WARNING: data is assumed to be normalized in [-1,+1]^d\\\")\\n else:\\n lowb = bounds[0][dimensions_to_consider]\\n uppb = bounds[1][dimensions_to_consider] # Bounds for one centroid\\n\\n # Format the bounds for the optimization solver\\n if task_finetuning == \\\"kmeans\\\":\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the centroids\\n elif task_finetuning == \\\"gmm\\\":\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\\n elif task_finetuning == \\\"gmm-nondiag\\\":\\n # Usual bounds of GMM\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\\n \\n # Bounds for the nondiagonal problem\\n boundstheta_finetuning = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n varianceUpperBound = ((uppb-lowb).max()/2)**2\\n\\n _lowb_var = -varianceUpperBound*np.ones((d,d))\\n np.fill_diagonal(_lowb_var, varianceLowerBound)\\n _uppb_var = +varianceUpperBound*np.ones((d,d))\\n\\n _boundsvar = np.append(_lowb_var.reshape(-1),_uppb_var.reshape(-1)).reshape(2,d**2).T.tolist()\\n for _i in _boundsvar: boundstheta_finetuning.append(_i) # bounds for the variance\\n \\n\\n ## 0.1.5) Misc. initializations\\n # Chosen method for the optimization solver\\n opt_method = 'L-BFGS-B' # could also consider 'TNC'\\n # Separated real and imaginary part of the sketch\\n sketch_ri = np.r_[sketch.real, sketch.imag]\\n if task == \\\"kmeans\\\":\\n thetadim = d\\n elif task == \\\"gmm\\\":\\n thetadim = 2*d\\n elif task == \\\"gmm-nondiag\\\":\\n thetadim = d*(d+1)\\n\\n\\n ## THE ACTUAL ALGORITHM\\n #######################\\n bestResidualNorm = np.inf \\n bestTheta = None\\n bestalpha = None\\n for iRun in range(nRepetitions):\\n \\n ## 1) Initialization\\n r = sketch # residual\\n Theta = np.empty([0,thetadim]) # Theta is a nbAtoms-by-atomDimension array\\n A = np.empty([m,0]) # Contains the sketches of the atoms\\n\\n ## 2) Main optimization\\n for i in range(nIterations):\\n ## 2.1] Step 1 : find new atom theta most correlated with residual\\n # Initialize the new atom\\n if task == \\\"kmeans\\\":\\n th_0 = np.random.uniform(lowb,uppb)\\n elif task == \\\"gmm\\\":\\n mu0 = np.random.uniform(lowb,uppb) # initial mean\\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\\n th_0 = _stackAtom(\\\"gmm\\\",mu0,sig0)\\n \\n elif task == \\\"gmm-nondiag\\\":\\n # Solve once for diagonal\\n mu0 = np.random.uniform(lowb,uppb) # initial mean\\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\\n th_0 = _stackAtom(\\\"gmm\\\",mu0,sig0)\\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(\\\"gmm\\\",Phi,th,r,z_to_ignore,verbose),\\n x0 = th_0, method=opt_method, jac=True,\\n bounds=boundstheta_gmm)\\n\\n (mu0,sig0) = _destackAtom(\\\"gmm\\\",sol.x,d)\\n\\n th_0 = _stackAtom(\\\"gmm-nondiag\\\",mu0,np.diag(sig0))\\n\\n # And solve with LBFGS \\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(task,Phi,th,r,z_to_ignore,verbose),\\n x0 = th_0, method=opt_method, jac=True,\\n bounds=boundstheta)\\n new_theta = sol.x\\n \\n if task == \\\"gmm-nondiag\\\":\\n new_theta = _makeGMMfeasible(new_theta,d)\\n\\n ## 2.2] Step 2 : add it to the support\\n Theta = np.append(Theta,[new_theta],axis=0)\\n A = np.c_[A,_sketchAtom(task,Phi,new_theta,z_to_ignore)] # Add a column to the A matrix\\n\\n ## 2.3] Step 3 : if necessary, hard-threshold to nforce sparsity\\n if Theta.shape[0] > K:\\n norms = np.linalg.norm(A,axis=0)\\n norms[np.where(norms < 1e-15)[0]] = 1e-15 # Avoid /0\\n A_norm = A/norms # normalize, unlike step 4\\n A_normri = np.r_[A_norm.real, A_norm.imag] \\n (beta,_) = nnls(A_normri,sketch_ri) # non-negative least squares\\n index_to_delete = np.argmin(beta)\\n Theta = np.delete(Theta, index_to_delete, axis=0)\\n A = np.delete(A, index_to_delete, axis=1)\\n if index_to_delete == K:\\n continue # No gain to be expected wrt previous iteration\\n\\n ## 2.4] Step 4 : project to find weights\\n Ari = np.r_[A.real, A.imag]\\n (alpha,_) = nnls(Ari,sketch_ri) # non-negative least squares\\n\\n\\n\\n ## 2.5] Step 5\\n p0 = _stackTheta(task,Theta,alpha) # Initialize at current solution \\n # Compute the bounds for step 5 : boundsOfOneAtom * numberAtoms then boundsOneWeight * numberAtoms\\n boundsThetaAlpha = boundstheta * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\\n # Solve\\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task,Phi,p,sketch,z_to_ignore),\\n x0 = p0, method=opt_method, jac=True,\\n bounds=boundsThetaAlpha, options={'ftol': ftol}) \\n (Theta,alpha) = _destackTheta(task,sol.x,Phi.d)\\n \\n # Make covariances feasible\\n if task == \\\"gmm-nondiag\\\":\\n for k in range(Theta.shape[0]):\\n Theta[k] = _makeGMMfeasible(Theta[k],d)\\n\\n # The atoms have changed: we must re-compute A\\n A = np.empty([m,0])\\n for theta_i in Theta:\\n Apthi = _sketchAtom(task,Phi,theta_i,z_to_ignore)\\n A = np.c_[A,Apthi]\\n # Update residual\\n r = sketch - A@alpha\\n\\n ## 3) Finalization boundstheta_finetuning\\n # Last optimization with the default (fine-grained) tolerance\\n if task_finetuning == \\\"gmm-nondiag\\\":\\n if verbose > 0: print('finetuning')\\n Theta_new = np.zeros((K,d*(d+1))) # Expand to have full cov matrix\\n for k in range(K):\\n (mu,sig2) = _destackAtom(\\\"gmm\\\",Theta[k],d)\\n # put current sol on the diagonal of full covariance matrix\\n Theta_new[k] = _stackAtom(\\\"gmm-nondiag\\\",mu,np.diag(sig2))\\n Theta = Theta_new # overwrite\\n \\n boundsThetaAlpha = boundstheta_finetuning * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\\n \\n if task_finetuning == \\\"gmm-nondiag\\\" or ftol >= 1e-8:\\n p0 = _stackTheta(task_finetuning,Theta,alpha)\\n \\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task_finetuning,Phi,p,sketch,z_to_ignore),\\n x0 = p0, method=opt_method, jac=True,\\n bounds=boundsThetaAlpha) # Here ftol is much smaller\\n (Theta,alpha) = _destackTheta(task_finetuning,sol.x,Phi.d) \\n \\n \\n # Normalize alpha\\n alpha /= np.sum(alpha)\\n \\n \\n runResidualNorm = np.linalg.norm(sketch - A@alpha)\\n if verbose>1: print('Run {}, residual norm is {} (best: {})'.format(iRun,runResidualNorm,bestResidualNorm))\\n if runResidualNorm <= bestResidualNorm:\\n bestResidualNorm = runResidualNorm\\n bestTheta = Theta\\n bestalpha = alpha\\n \\n ## FORMAT OUTPUT\\n if task == \\\"kmeans\\\":\\n return (bestalpha,bestTheta)\\n elif task == \\\"gmm\\\" or task == \\\"gmm-nondiag\\\":\\n return _ThetasToGMM(task_finetuning,bestTheta,bestalpha)\\n\\n return None\",\n \"def grid_visibilities(self, visibilities, N = 120):\\n logger.info(\\\"Gridding the visibilities\\\")\\n\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\\n\\n centres = (ugrid[1:] + ugrid[:-1]) / 2\\n\\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\\n\\n if(os.path.exists(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")):\\n kernel_weights = np.load(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")\\n else:\\n kernel_weights=None\\n\\n if kernel_weights is None:\\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\\n\\n for jj, freq in enumerate(self.frequencies):\\n u_bl = (self.baselines[:,0] * freq / const.c).value\\n v_bl = (self.baselines[:,1] * freq / const.c).value\\n\\n beam, indx_u, indx_v = self.fourierBeam(centres, u_bl, v_bl, freq, N=N)\\n for kk in range(len(indx_u)):\\n visgrid[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk]) * visibilities[kk,jj]\\n\\n if kernel_weights is None:\\n weights[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk])\\n\\n if kernel_weights is None:\\n kernel_weights = weights\\n\\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\\n\\n return visgrid,kernel_weights\",\n \"def optimize_force_field_parameters_Cv_FWHM(cgmodel, file_list, temperature_list, param_bounds_dict,\\n frame_begin=0, frame_end=-1, sample_spacing=1, sparsify_stride=1, output_data='output.nc',\\n verbose=False, n_cpu=12, min_eff_samples=50,\\n n_trial_boot=200, num_intermediate_states=0, plotfile='optimize_FWHM_iterations.pdf',\\n min_method='TNC'):\\n\\n # Parse the force field parameter change dict:\\n x0 = []\\n param_names = []\\n bounds = []\\n units = []\\n \\n for key,value in param_bounds_dict.items():\\n # value should be [(bound_lo, bound_hi)]\\n # key should be a valid force field parameter name\\n param_names.append(key)\\n # Every parameter except periodicity should have units\\n # For now, changing periodicity is not supported.\\n \\n # TODO: add support for sums of periodic torsion terms\\n units.append(value[0].unit)\\n bounds.append((value[0].value_in_unit(units[-1]),value[1].value_in_unit(units[-1])))\\n # Use mean value as starting guess:\\n x0.append((value[1].value_in_unit(units[-1])+value[0].value_in_unit(units[-1]))/2)\\n\\n if verbose:\\n print(f'param_names: {param_names}')\\n print(f'unit: {units}')\\n print(f'bounds: {bounds}')\\n print(f'x0: {x0}')\\n\\n def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n \\\"\\\"\\\"\\n Objective function to be minimized\\n \\\"\\\"\\\"\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\\n\\n # Run optimization:\\n\\n # if len(param_names) == 1:\\n # # Do scalar optimization:\\n # opt_results = minimize_scalar(get_reeval_FWHM, x0,\\n # args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\\n # frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\\n # method='bounded',\\n # bounds=[bounds[0][0],bounds[0][1]],\\n # options={'maxiter': 25},\\n # )\\n\\n # else:\\n # Do multivariate optimization:\\n opt_results = minimize(get_reeval_FWHM, x0, jac='2-point',\\n args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\\n frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\\n method=min_method,\\n bounds=bounds,\\n options={'maxfun': 25, 'finite_diff_rel_step': 0.005, 'eta': 0.5}, # This should be user input\\n ) \\n \\n # TODO: plot the heat capacity curves at each iteration, and make a plot of all FWHM_values \\n\\n # Construct dictionary of optimal parameters:\\n opt_param_dict = {} \\n \\n k = 0\\n for key,value in param_bounds_dict.items():\\n opt_param_dict[key] = opt_results.x[k] * units[k]\\n k += 1\\n \\n return opt_param_dict, opt_results\",\n \"def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\\n max_cp = 1\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n max_cp += w_inpIdx*X0[inpIdx]\\n # saving values\\n layerEq[inpIdx] = X0[inpIdx]\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n layerEq[inpIdx] = x_eq\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n max_cp += firstComplex + Inhib2/E0*x_eq\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n max_cp += Inhib2/E0*x_eq\\n return max_cp\",\n \"def fit_full(self,K):\\r\\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\\r\\n mu = np.zeros(self.N)\\r\\n Sigma = K.copy()\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.N,dtype=float)\\r\\n self.v_ = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.N,dtype=float)\\r\\n self.Z_hat = np.empty(self.N,dtype=float)\\r\\n phi = np.empty(self.N,dtype=float)\\r\\n mu_hat = np.empty(self.N,dtype=float)\\r\\n sigma2_hat = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = self.epsilon + 1.\\r\\n epsilon_np2 = self.epsilon + 1.\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.N)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\\r\\n B = np.eye(self.N) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\\r\\n L = jitchol(B)\\r\\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\\r\\n Sigma = K - np.dot(V.T,V)\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def spec_helm_decomp(k,Cu,Cv,GM=False):\\n dk = k[1]-k[0]\\n s = np.log(k)\\n\\n Fphi = np.zeros_like(Cu)\\n Fpsi = np.zeros_like(Cu)\\n Cphi = np.zeros_like(Cu)\\n Cpsi = np.zeros_like(Cu)\\n\\n # assume GM for decomposing into wave and vortex\\n if GM:\\n gm = np.load(\\\"/Users/crocha/Projects/dp_spectra/GM/gm_omega_star.npz\\\")\\n f2omg2 = gm['rgm']\\n ks = gm['k']*1.e3\\n\\n for i in range(s.size-1):\\n\\n ds = np.diff(s[i:])\\n\\n sh = sinh(s[i]-s[i:])\\n ch = cosh(s[i]-s[i:])\\n\\n # the function to integrate\\n Fp = Cu[i:]*sh + Cv[i:]*ch\\n Fs = Cv[i:]*sh + Cu[i:]*ch\\n\\n # integrate using Simpson's rule\\n Fpsi[i] = integrate.simps(Fs,s[i:])\\n Fphi[i] = integrate.simps(Fp,s[i:])\\n\\n # zero out unphysical values\\n Fpsi[Fpsi < 0.] = 0.\\n Fphi[Fphi < 0.] = 0.\\n\\n # compute rotational and divergent components\\n Cpsi = Fpsi - Fphi + Cu\\n Cphi = Fphi - Fpsi + Cv\\n\\n if GM:\\n\\n f2omg2i = np.interp(k,ks,f2omg2)\\n\\n Cv_w = f2omg2i*Fphi - Fpsi + Cv\\n Cv_v = Cv - Cv_w\\n \\n kdkromg = diff_central(ks, f2omg2)\\n kdkromg = np.interp(k,ks[1:-1],kdkromg)\\n\\n dFphi = diff_central(k, Fphi)\\n #dFphi = np.gradient(Fphi,k)\\n dFphi = np.interp(k,k[1:-1],dFphi.real)\\n E_w = Fphi - k*dFphi\\n\\n Cu_w = -k*kdkromg*Fphi + f2omg2i*(-Fpsi+Cv) + Fphi\\n Cu_v = Cu - Cu_w\\n\\n Cb_w = E_w - (Cu_w + Cv_w)/2.\\n\\n return Cpsi,Cphi, Cu_w,Cv_w, Cu_v,Cv_v, E_w, Cb_w\\n\\n else:\\n return Cpsi,Cphi\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurst_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(x):\\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\\n\\n def unmaskvec(w):\\n return _unmask(w, mask)\\n\\n def maskvec(w):\\n return w[flat_mask]\\n\\n def f1_grad(x):\\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(w, stepsize, dgap_tol, init):\\n out, info = _prox_tvl1(unmaskvec(w),\\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=unmaskvec(init),\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return maskvec(out.ravel()), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def WakeVorticityFromCirculation_Cont(r_cp,Gamma_cp,R,U0,Omega,bSwirl,method='analytical',bHighThrustCorr=True):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cp[0]==0:\\n r_cp[0]=r_cp[1]*0.5;\\n # Non dimensional parameters\\n k = Omega*Gamma_cp/(np.pi*U0**2)\\n vr_bar = r_cp/R \\n lambda_r = Omega*r_cp/U0\\n # Finding inductions\\n a,a_prime,misc= InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method=method,bHighThrustCorr=bHighThrustCorr)\\n # Computing convection\\n misc['Vz'] = U0*(1-2*a)\\n misc['h'] = misc['Vz']*2*np.pi/(Omega*(1+2*a_prime))\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n # Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n gamma_t = - Gamma_tilde/misc['h']\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = 0\\n Gamma_r = 0\\n return gamma_t,gamma_l,Gamma_r,misc\",\n \"def vote_for_k(utilities, k):\\n utilities = np.asarray(utilities)\\n n_cands = utilities.shape[1]\\n if k == 'half':\\n # \\\"It is interesting to observe that the vote-for-k and vote-for-(n-k)\\n # voting systems are equally effective.\\\"\\n # So for 7 candidates, we could use either k=4 or k=3 (= 7//2)\\n # TODO: Though this seems only true with infinite voters?\\n k = n_cands // 2\\n elif -n_cands < k < 0:\\n k = n_cands + k\\n elif not 0 < k < n_cands:\\n raise ValueError(f'k of {k} not possible with {n_cands} candidates')\\n\\n # Efficiently get indices of top k candidates for each voter\\n # https://stackoverflow.com/a/23734295/125507\\n # TODO: How are tied utilities handled, such as top 2 with 3 tied? Random?\\n top_k = np.argpartition(utilities, -k, axis=1)[:, -k:]\\n\\n # Create blank ballots\\n approvals = np.zeros(utilities.shape, np.uint8)\\n\\n # Fill in approvals\\n # TODO: Not sure if this is the most efficient way\\n approvals[np.arange(len(approvals))[:, np.newaxis], top_k] = 1\\n return approvals\",\n \"def tuto_kernel_overview(optimize=True, plot=True):\\r\\n ker1 = GPy.kern.rbf(1) # Equivalent to ker1 = GPy.kern.rbf(input_dim=1, variance=1., lengthscale=1.)\\r\\n ker2 = GPy.kern.rbf(input_dim=1, variance = .75, lengthscale=2.)\\r\\n ker3 = GPy.kern.rbf(1, .5, .5)\\r\\n\\r\\n print ker2\\r\\n\\r\\n if plot:\\r\\n ker1.plot()\\r\\n ker2.plot()\\r\\n ker3.plot()\\r\\n\\r\\n k1 = GPy.kern.rbf(1,1.,2.)\\r\\n k2 = GPy.kern.Matern32(1, 0.5, 0.2)\\r\\n\\r\\n # Product of kernels\\r\\n k_prod = k1.prod(k2) # By default, tensor=False\\r\\n k_prodtens = k1.prod(k2,tensor=True)\\r\\n\\r\\n # Sum of kernels\\r\\n k_add = k1.add(k2) # By default, tensor=False\\r\\n k_addtens = k1.add(k2,tensor=True)\\r\\n\\r\\n k1 = GPy.kern.rbf(1,1.,2)\\r\\n k2 = GPy.kern.periodic_Matern52(1,variance=1e3, lengthscale=1, period = 1.5, lower=-5., upper = 5)\\r\\n\\r\\n k = k1 * k2 # equivalent to k = k1.prod(k2)\\r\\n print k\\r\\n\\r\\n # Simulate sample paths\\r\\n X = np.linspace(-5,5,501)[:,None]\\r\\n Y = np.random.multivariate_normal(np.zeros(501),k.K(X),1)\\r\\n\\r\\n k1 = GPy.kern.rbf(1)\\r\\n k2 = GPy.kern.Matern32(1)\\r\\n k3 = GPy.kern.white(1)\\r\\n\\r\\n k = k1 + k2 + k3\\r\\n print k\\r\\n\\r\\n k.constrain_positive('.*var')\\r\\n k.constrain_fixed(np.array([1]),1.75)\\r\\n k.tie_params('.*len')\\r\\n k.unconstrain('white')\\r\\n k.constrain_bounded('white',lower=1e-5,upper=.5)\\r\\n print k\\r\\n\\r\\n k_cst = GPy.kern.bias(1,variance=1.)\\r\\n k_mat = GPy.kern.Matern52(1,variance=1., lengthscale=3)\\r\\n Kanova = (k_cst + k_mat).prod(k_cst + k_mat,tensor=True)\\r\\n print Kanova\\r\\n\\r\\n # sample inputs and outputs\\r\\n X = np.random.uniform(-3.,3.,(40,2))\\r\\n Y = 0.5*X[:,:1] + 0.5*X[:,1:] + 2*np.sin(X[:,:1]) * np.sin(X[:,1:])\\r\\n\\r\\n # Create GP regression model\\r\\n m = GPy.models.GPRegression(X, Y, Kanova)\\r\\n\\r\\n if plot:\\r\\n fig = pb.figure(figsize=(5,5))\\r\\n ax = fig.add_subplot(111)\\r\\n m.plot(ax=ax)\\r\\n\\r\\n pb.figure(figsize=(20,3))\\r\\n pb.subplots_adjust(wspace=0.5)\\r\\n axs = pb.subplot(1,5,1)\\r\\n m.plot(ax=axs)\\r\\n pb.subplot(1,5,2)\\r\\n pb.ylabel(\\\"= \\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,3)\\r\\n m.plot(ax=axs, which_parts=[False,True,False,False])\\r\\n pb.ylabel(\\\"cst +\\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,4)\\r\\n m.plot(ax=axs, which_parts=[False,False,True,False])\\r\\n pb.ylabel(\\\"+ \\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,5)\\r\\n pb.ylabel(\\\"+ \\\",rotation='horizontal',fontsize='30')\\r\\n m.plot(ax=axs, which_parts=[False,False,False,True])\\r\\n\\r\\n return(m)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def ghosal_edge(img,Ks,thr=1,thrmax=0.995,lmin = 0.5,phimin=1.4,thresholding=True, debug=False):\\n\\ttotaltime = time.time()\\n\\tkerneltime = time.time()\\n\\t# Ks must be odd\\n\\tif Ks%2 != 1:\\n\\t\\tprint(\\\"Ks must be odd! Continuing with Ks = Ks-1\\\")\\n\\t\\tKs = Ks-1\\n\\t# define the rectangular kernels\\n\\t#Vc00 = np.zeros((Ks,Ks),dtype=complex)\\n\\tVc11 = np.zeros((Ks,Ks),dtype=complex)\\n\\tVc20 = np.zeros((Ks,Ks),dtype=complex)\\n\\tofs = 1 *(1-1/Ks) # offset for centering kernel around 0,0\\n\\tfor i in range(Ks):\\n\\t\\tfor j in range(Ks):\\n\\t\\t\\tKx = 2*j/Ks-ofs # limits of integration between -1 and 1\\n\\t\\t\\tKy = 2*i/Ks-ofs\\n\\t\\t\\tif Kx**2+Ky**2 <= 1: # only a circle\\n\\t\\t\\t\\t#Vc00[i,j] = 1 # the conjugate of V00\\n\\t\\t\\t\\tVc11[i,j] = Kx-Ky*1j # ...\\n\\t\\t\\t\\tVc20[i,j] = 2*Kx**2+2*Ky**2-1\\n\\tkerneltime = time.time() - kerneltime\\n\\t\\n\\t# Kernel Plots\\n\\t#\\tVCplot = Vc00\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Vc11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Vc20\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\t# do the convolution with the images to get the zernike moments\\n\\tAnorm = lambda n : (n+1)/np.pi\\t# a normalization value\\n\\tconvolvetime = time.time()\\n\\t#A00 = scig.convolve2d(img,Vc00,mode='same')\\n\\t#\\tA11 = Anorm(1)*scig.convolve2d(img,Vc11,mode='same')\\n\\t#\\tA20 = Anorm(2)*scig.convolve2d(img,Vc20,mode='same')\\n\\tA11 = Anorm(1)*scig.oaconvolve(img,Vc11,mode='same')\\n\\tA20 = Anorm(2)*scig.oaconvolve(img,Vc20,mode='same')\\n\\tconvolvetime = time.time() - convolvetime\\n\\t# Plot Zernike moments\\n\\t#\\tVCplot = A00\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = A11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = A20\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\tparamstime = time.time()\\n\\t# calculate the edge paramters\\n\\t#\\ttanphi = np.imag(A11)/np.real(A11)\\n\\t#\\tphi = np.arctan(tanphi)\\n\\t#\\tcosphi = np.cos(phi)\\n\\t#\\tsinphi = cosphi*tanphi\\n\\t#\\tAl11 = np.real(A11)*cosphi+np.imag(A11)*sinphi\\n\\t\\n\\tphi = np.arctan(np.imag(A11)/np.real(A11))\\n\\tAl11 = np.real(A11)*np.cos(phi)+np.imag(A11)*np.sin(phi)\\n\\t\\n\\t#\\tAl11 = A11*np.exp(-phi*1j)\\n\\tl = A20/Al11 # A20 has no imaginary component so A20 = A'20\\n\\n\\tk = 3*Al11/(2*(1-l**2)**(3/2))\\n\\tparamstime = time.time() - paramstime\\n\\t\\n\\t# Plot edge paramters\\n\\t#\\tVCplot = phi\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real phi\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag phi\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Al11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A\\\\'11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A\\\\'11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = l\\n\\t#\\tplt.pcolormesh(np.real(VCplot))#,vmin=-5,vmax=5\\n\\t#\\tplt.title(\\\"real l\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot)) # ,vmin=-5,vmax=5\\n\\t#\\tplt.title(\\\"imag l\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = k\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real k\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag k\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\t\\n\\ttreattime = time.time()\\n\\tif thresholding==True:\\n\\t\\t# do the thresholding\\n\\t\\tif (thrmax<0)&(thr>0):\\n\\t\\t\\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])\\n\\t\\telif thrmax>0:\\n\\t\\t\\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])&(abs(k)<knorm[1])\\n\\t\\telif thr<0:\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)\\n\\t\\t\\tknorm = np.sort(k[idx].flatten())[int(thr)]\\n\\t\\t\\tidx = idx&(abs(k)>abs(knorm))\\n\\t\\tne = np.sum(idx)\\n\\telif thresholding==False:\\n\\t\\traise ValueError(\\\"this option is not still uncer development\\\")\\n\\t\\t# no thresholding\\n\\t\\tidx = np.ones(np.shape(l),dtype=bool)\\n\\t\\tne =np.sum(idx)\\n\\telse:\\n\\t\\traise ValueError(\\\"thresholding should be boolean\\\")\\n\\t\\n\\t# put all detected points in a vector of (x,y) values\\n\\tedg = np.zeros((ne,2))\\n\\torg = np.zeros((ne,2))\\n\\tnx,ny = np.shape(img)\\n\\te = 0\\n\\tfor i in range(nx):\\n\\t\\tfor j in range(ny):\\n\\t\\t\\tif idx[i,j]:\\n\\t\\t\\t\\tedg[e]=np.array([i,j]) + l[i,j]*Ks/2*np.array(\\n\\t\\t\\t\\t\\t[np.sin(phi[i,j]),-np.cos(phi[i,j])])\\n\\t\\t\\t\\torg[e]=np.array([i,j])\\n\\t\\t\\t\\te +=1\\n\\ttreattime = time.time() - treattime\\n\\ttotaltime = time.time() - totaltime\\n\\tprint(\\\"total %0.5f\\tconvolution %0.5f\\tthresholding %0.5f\\tparamters %0.5f\\tkernel %0.5f\\\"%(totaltime,convolvetime,treattime,paramstime,kerneltime))\\n\\t\\n\\tif debug==True:\\n\\t\\treturn edg, org, k, l, phi\\n\\telse:\\n\\t\\treturn edg, org\",\n \"def HKS(evals,evects, time_list,scaled=False):\\n evals_s = np.asarray(evals).flatten()\\n t_list = np.asarray(time_list).flatten()\\n\\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\\n\\n if scaled:\\n inv_scaling = coefs.sum(1) # (num_T)\\n return (1/inv_scaling)[None,:] * natural_HKS\\n\\n else:\\n return natural_HKS\",\n \"def normal_modes_gHST(R, NL, KL, params, dispersion=[], spin_dir=[], sublattice_labels=[], b='hang', spring='auto',\\n pin='auto'):\\n try:\\n NP, NN = np.shape(NL)\\n except:\\n '''There is only one particle.'''\\n NP = 1\\n NN = 0\\n\\n M1 = np.zeros((2 * NP, 2 * NP))\\n M2 = np.zeros((2 * NP, 2 * NP))\\n if spring == 'auto':\\n spring = params['k'] * params['l'] ** 2 / (params['I3'] * np.abs(params['w3']))\\n # If there is more than one particle, and if the speeds vary from particle to particle,\\n # then make spring the same length as a dynamical matrix column\\n if len(spring) > 0:\\n if (abs(spring - spring[0]) > 1e-9).any():\\n # The rotation rates vary from particle to particle, so reshape\\n spring_new = np.zeros_like(spring)\\n dmyi = 0 # a new index ('dummy i')\\n for ii in range(NP):\\n # Since 2 dof for position of pivot of gHST, double the size\\n spring_new[dmyi] = spring[ii]\\n spring_new[dmyi + 1] = spring[ii]\\n dmyi += 2\\n else:\\n # the elements are all identical, so just keep the first one\\n spring = spring[0]\\n\\n if pin == 'auto':\\n gn = params['Mm'] * params['g']\\n pin = params['l'] * gn / (params['I3'] * np.abs(params['w3']))\\n # If there is more than one particle, and if the speeds vary from particle to particle,\\n # then make pin the same length as a dynamical matrix column\\n if len(pin) > 0:\\n if (abs(pin - pin[0]) > 1e-9).any():\\n # The rotation rates vary from particle to particle, so reshape\\n pin_new = np.zeros_like(pin)\\n dmyi = 0 # a new index ('dummy i')\\n for ii in range(NP):\\n # Since 2 dof for position of pivot of gHST, double the size\\n pin_new[dmyi] = pin[ii]\\n pin_new[dmyi + 1] = pin[ii]\\n dmyi += 2\\n else:\\n # the elements are all identical, so just keep the first one\\n pin = pin[0]\\n\\n m2_shape = np.shape(M2)\\n\\n if b == 'hang':\\n b = np.zeros(NP)\\n elif b == 'stand':\\n b = np.ones(NP)\\n\\n if spin_dir == []:\\n '''Assume antialigned with a, aligned with body axis 3'''\\n spin_dir = np.ones(NP)\\n\\n print 'Constructing dynamical matrix...'\\n for i in range(NP):\\n for nn in range(NN):\\n\\n ni = NL[i, nn] # the number of the gyroscope i is connected to (particle j)\\n k = KL[i, nn] # true connection?\\n\\n if len(dispersion) > 1:\\n disp = 1. / (1. + dispersion[i])\\n else:\\n disp = 1.\\n\\n diffx = R[ni, 0] - R[i, 0]\\n diffy = R[ni, 1] - R[i, 1]\\n alphaij = 0.\\n\\n rij_mag = np.sqrt(diffx ** 2 + diffy ** 2)\\n\\n if k != 0:\\n alphaij = np.arctan2(diffy, diffx)\\n\\n # for periodic systems, KL is -1 for particles on opposing boundaries\\n if KL[i, nn] == -1:\\n alphaij = (np.pi + alphaij) % (2 * pi)\\n\\n # What is this for?\\n if KL[i, nn] == -2: # will only happen on first or last gyro in a line\\n if i == 0 or i == (NP - 1):\\n print i, '--> NL=-2 for this particle'\\n yy = np.where(KL[i] == 1)\\n dx = R[NL[i, yy], 0] - R[NL[i, yy], 0]\\n dy = R[NL[i, yy], 1] - R[NL[i, yy], 1]\\n al = (np.arctan2(dy, dx)) % (2 * pi)\\n alphaij = np.pi - al\\n if i == 1:\\n alphaij = np.pi - ((90 / 2) * np.pi / 180.)\\n else:\\n alphaij = - ((90 / 2) * np.pi / 180.)\\n\\n Cos = np.cos(alphaij)\\n Sin = np.sin(alphaij)\\n\\n if abs(Cos) < 10E-8:\\n Cos = 0.0\\n\\n if abs(Sin) < 10E-8:\\n Sin = 0\\n\\n Cos2 = Cos ** 2\\n Sin2 = Sin ** 2\\n CosSin = Cos * Sin\\n\\n # -1 for aligned with a, 1 for aligned with 3.\\n # dir factor :== 1/(-1)^c = (-1)^c\\n dir_factor = spin_dir[i]\\n\\n if len(sublattice_labels) > 0:\\n if sublattice_labels[i] == 1:\\n extra_factor = 1. * del_A_B\\n # print self.del_A_B\\n elif sublattice_labels[i] == 0:\\n extra_factor = 1.\\n else:\\n extra_factor = 1.\\n else:\\n extra_factor = 1.\\n\\n M1[2 * i, 2 * i] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxi\\n M1[2 * i, 2 * i + 1] += -disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyi\\n M1[2 * i, 2 * ni] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxj\\n M1[2 * i, 2 * ni + 1] += disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyj\\n\\n # (y components)\\n M1[2 * i + 1, 2 * i] += disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxi\\n M1[2 * i + 1, 2 * i + 1] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyi\\n M1[2 * i + 1, 2 * ni] += -disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxj\\n M1[2 * i + 1, 2 * ni + 1] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyj\\n\\n # if i==0:\\n # print '\\\\n --- \\\\n added M1[2*i+1, 2*i] = ',disp*k*Cos2 *((-1)**b[i]) *dir_factor\\n # print 'dir_factor = ', dir_factor\\n # print 'k = ', k\\n # print 'else =', ((-1)**b[i]) *dir_factor\\n\\n # pinning/gravitational matrix\\n M2[2 * i, 2 * i + 1] = (1.) * disp * dir_factor * extra_factor\\n M2[2 * i + 1, 2 * i] = -(1.) * disp * dir_factor * extra_factor\\n\\n # self.pin_array.append(2*pi*1*extra_factor)\\n # Assumes:\\n # (-1)**c adot = - spring* (-1)**b SUM{ z x nij*(nij.(dri-drj)) } + pin\\n matrix = - (-spring * M1 + pin * M2)\\n\\n return matrix\",\n \"def showCortexImg(pV,nV):\\n # object arrays of the positive and negative images\\n pos_cort_img = np.empty(8, dtype=object)\\n neg_cort_img = np.empty(8, dtype=object)\\n for t in range(8):\\n # cortical mapping functions\\n lpos, rpos = cortex.cort_img(pV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\\n lneg, rneg = cortex.cort_img(nV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\\n pos_cort_img[t] = np.concatenate((np.rot90(lpos),np.rot90(rpos,k=3)),axis=1)\\n neg_cort_img[t] = np.concatenate((np.rot90(lneg),np.rot90(rneg,k=3)),axis=1)\\n # stack all images into a grid\\n posRGcort = np.vstack((pos_cort_img[:4]))\\n negRGcort = np.vstack((neg_cort_img[:4]))\\n posYBcort = np.vstack((pos_cort_img[4:]))\\n negYBcort = np.vstack((neg_cort_img[4:]))\\n mergecort = np.concatenate((posRGcort,negRGcort,posYBcort,negYBcort),axis=1)\\n return mergecort\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\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 estimate_opt_eff(self, iv_fn_hot, iv_fn_cold,t_hot=293.,t_cold=77.,\\n channels = None, dPdT_lim=(0.,0.5)):\\n ivs_hot = np.load(iv_fn_hot).item()\\n ivs_cold = np.load(iv_fn_cold).item()\\n \\n iv_fn_raw_hot = iv_fn_hot.split('.')[0] + '_raw_data.npy'\\n iv_fn_raw_cold = iv_fn_cold.split('.')[0] + '_raw_data.npy'\\n\\n ivs_raw_hot = np.load(iv_fn_raw_hot).item()\\n ivs_raw_cold = np.load(iv_fn_raw_cold).item()\\n \\n basename_hot = ivs_raw_hot['basename']\\n basename_cold = ivs_raw_cold['basename']\\n\\n #band = ivs_raw_hot['band']\\n #assert ivs_raw_cold['band'] == band, \\\\\\n # 'Files must contain IVs from the same band'\\n group = ivs_raw_hot['bias group']\\n assert ivs_raw_cold['bias group'], \\\\\\n 'Files must contain IVs from the same bias group'\\n \\n import matplotlib.pyplot as plt\\n plot_dir = self.plot_dir\\n\\n dT = t_hot - t_cold\\n dPdT_list = []\\n n_outliers = 0\\n for ch in ivs_hot:\\n if channels is not None:\\n if ch not in channels:\\n continue\\n elif not isinstance(ch,np.int64):\\n continue\\n \\n if ch not in ivs_cold:\\n continue\\n \\n P_hot = ivs_hot[ch]['P']\\n P_cold = ivs_cold[ch]['P']\\n R_hot = ivs_hot[ch]['R']\\n R_cold = ivs_cold[ch]['R']\\n Ptrans_hot = ivs_hot[ch]['Ptrans']\\n Ptrans_cold = ivs_cold[ch]['Ptrans']\\n if Ptrans_hot is None or Ptrans_cold is None:\\n print('Missing in-transition electrical powers for Ch. %i' % (ch))\\n continue\\n dPdT = (Ptrans_cold - Ptrans_hot)/dT\\n self.log('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\\n if dPdT_lim is not None:\\n if dPdT >= dPdT_lim[0] and dPdT <= dPdT_lim[1]:\\n dPdT_list.append(dPdT)\\n else:\\n n_outliers += 1\\n else:\\n dPdT_list.append(dPdT)\\n\\n fig_pr,ax_pr = plt.subplots(1,sharex=True)\\n ax_pr.set_xlabel(r'$R_\\\\mathrm{TES}$ [$\\\\Omega$]')\\n ax_pr.set_ylabel(r'$P_\\\\mathrm{TES}$ [pW]')\\n label_hot = '%s: %.0f K' % (basename_hot,t_hot)\\n label_cold = '%s: %.0f K' % (basename_cold,t_cold)\\n ax_pr.axhline(y=Ptrans_hot,linestyle = '--',color = 'b')\\n ax_pr.axhline(y=Ptrans_cold,linestyle = '--',color = 'r')\\n ax_pr.plot(R_hot,P_hot,label=label_hot,color='b')\\n ax_pr.plot(R_cold,P_cold,label=label_cold,color='r')\\n ax_pr.legend(loc='best')\\n fig_pr.suptitle('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\\n ax_pr.grid()\\n \\n plot_name = basename_hot + '_' + basename_cold + '_optEff_g{}_ch{:03}.png'.format(group, ch)\\n plot_filename = os.path.join(plot_dir, plot_name)\\n self.log('Saving optical-efficiency plot to {}'.format(plot_filename))\\n plt.savefig(plot_filename,bbox_inches='tight', dpi=300)\\n plt.close()\\n\\n plt.figure()\\n plt.hist(dPdT_list,edgecolor='k')\\n plt.xlabel('dP/dT [pW/K]')\\n plt.grid()\\n dPdT_median = np.median(dPdT_list)\\n plt.title('Group {}, median = {:.3f} pW/K ({} outliers not plotted)'.format(group,dPdT_median,n_outliers))\\n plot_name = basename_hot + '_' + basename_cold + '_dPdT_hist_g{}.png'.format(group)\\n hist_filename = os.path.join(plot_dir,plot_name)\\n self.log('Saving optical-efficiency histogram to {}'.format(hist_filename))\\n plt.savefig(hist_filename,bbox_inches='tight',dpi=300)\\n plt.close()\",\n \"def plot_dispersion(kpts, enk):\\n\\n # Lattice constant and reciprocal lattice vectors\\n # b1 = 2 pi/a (kx - ky + kz)\\n # b2 = 2 pi/a (kx + ky - kz)\\n # b3 = 2 pi/a (-kx + ky + kz)\\n a = 5.556 # [A]\\n b1 = (2 * np.pi / a) * np.array([1, -1, 1])\\n b2 = (2 * np.pi / a) * np.array([1, 1, -1])\\n b3 = (2 * np.pi / a) * np.array([-1, 1, 1])\\n\\n # L point in BZ is given by 0.5*b1 + 0.5*b2 + 0.5*b3\\n # X point in BZ is given by 0.5*b2 + 0.5*b3\\n lpoint = 0.5 * (b1 + b2 + b3)\\n xpoint = 0.5 * (b2 + b3)\\n\\n # We can find kpoints along a path just by considering a dot product with lpoint and xpoint vectors.\\n # Any kpoints with angle smaller than some tolerance are considered on the path and we can plot their frequencies\\n deg2rad = 2 * np.pi / 360\\n ang_tol = 1 * deg2rad # 1 degree in radians\\n\\n print(list(kpts))\\n\\n enkonly = np.array(enk['energy [Ryd]'])[:, np.newaxis]\\n enkinds = np.array(enk['q_inds'])\\n kptsonly = np.array(kpts[['kx [1/A]', 'ky [1/A]', 'kz [1/A]']]) / (2 * np.pi / a)\\n kptsinds = np.array(kpts['q_inds'])\\n kptsmag = np.linalg.norm(kptsonly, axis=1)[:, np.newaxis]\\n\\n dot_l = np.zeros(len(kpts))\\n dot_x = np.zeros(len(kpts))\\n\\n # Separate assignment for gamma point to avoid divide by zero error\\n nongamma = kptsmag != 0\\n dot_l[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, lpoint[:, np.newaxis])[nongamma],\\n kptsmag[nongamma]) / np.linalg.norm(lpoint)\\n dot_x[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, xpoint[:, np.newaxis])[nongamma],\\n kptsmag[nongamma]) / np.linalg.norm(xpoint)\\n dot_l[np.squeeze(kptsmag == 0)] = 0\\n dot_x[np.squeeze(kptsmag == 0)] = 0\\n\\n lpath = np.logical_or(np.arccos(dot_l) < ang_tol, np.squeeze(kptsmag == 0))\\n xpath = np.logical_or(np.arccos(dot_x) < ang_tol, np.squeeze(kptsmag == 0))\\n\\n linds = kptsinds[lpath]\\n xinds = kptsinds[xpath]\\n lkmag = kptsmag[lpath]\\n xkmag = kptsmag[xpath]\\n\\n plt.figure()\\n\\n for i, ki in enumerate(linds):\\n energies = enkonly[enkinds == ki, 0]\\n thiskmag = lkmag[i]\\n if len(energies) > 1:\\n veck = np.ones((len(energies), 1)) * thiskmag\\n plt.plot(veck, energies, '.', color='C0')\\n else:\\n plt.plot(thiskmag, energies, '.', color='C0')\\n\\n for i, ki in enumerate(xinds):\\n energies = enkonly[enkinds == ki, 0]\\n thiskmag = lkmag[i]\\n if len(energies) > 1:\\n veck = np.ones((len(energies), 1)) * thiskmag\\n plt.plot(-1 * veck, energies, '.', color='C1')\\n else:\\n plt.plot(-1 * thiskmag, energies, '.', color='C1')\\n\\n plt.xlabel('k magnitude')\\n plt.ylabel('Energy in Ry')\",\n \"def hcn_kn(Y,t,voltage_clamp_func,voltage_clamp_params):\\n\\n v = voltage_clamp_func(t,voltage_clamp_params)\\n n_s = Y[0]\\n n_f = Y[1]\\n\\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\\n ninf_f = ninf_s\\n\\n if v > -70.0:\\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\\n else:\\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\\n\\n dns = (ninf_s - n_s)/tau_ns\\n dnf = (ninf_f - n_f)/tau_nf\\n\\n return [dns, dnf]\",\n \"def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cyl is None:\\n r_cyl = np.zeros(r_cp.shape)\\n if len(r_cyl)==1:\\n r_cyl=np.array([R])\\n else:\\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\\n else:\\n r_cyl = np.asarray(r_cyl).ravel()\\n misc={}\\n # --- Checks\\n if np.amax(r_cyl) < np.amax(r_cp):\\n warnings.warn('Cylinders are assumed to enclose the control points')\\n import pdb; pdb.set_trace()\\n if r_cyl[0] == 0:\\n raise Exception('First cylinder at 0, impossible')\\n\\n ## Interpolating Circulation on the control points\\n Gamma_cp = Gamma_cp * nB # IMPORTANT\\n lambda_rcp = Omega*r_cp/U0\\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\\n ## Some init\\n\\n n = len(r_cyl)\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n # --- Case 1: Using k / ct to determine gamma\\n # Using a_prime to correct Ct\\n # Tangential convection velocity\\n if not bTanInd_k:\\n ap_cyl_conv = 0 * Gamma_cp\\n else:\\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\\n # See Equation (26) of [1]: a'_c,i = (\\\\Gamma_i+\\\\Gamma_i+1)/(4 pi Omega R_i^2)\\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\\n # --- Allocation\\n b = np.zeros(n) # Cummulative sum of gamma_bar\\n S = np.zeros(n) # Term under the square root\\n Sbis = np.zeros(n) # Term under the square root, account\\n Ctrot = np.zeros(n)\\n Ctrot_loc = np.zeros(n)\\n Cti = np.zeros(n)\\n Cteff = np.zeros(n)\\n gamma_t_bar = np.zeros(n)\\n # --- Init\\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\\n lambda_R = Omega * r_cyl / U0\\n # Looping through radii in reversed order\\n for i in np.arange(n-1,-1,-1):\\n if i==n-1:\\n b[i] = 1\\n S[i] = 1 - C[i]\\n Sbis[i] = 1 - C[i]\\n Ctrot[i] = 0\\n Ctrot_loc[i] = 0\\n else:\\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\\n if not bSwirl:\\n Ctrot[i] = 0\\n Cti[i] = k_r[i]\\n else:\\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\\n Sbis[i] = 1 - Cteff[i]\\n if bSwirl :\\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\\n else:\\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \\n# print('b',b,'S',S)\\n if bHighThrustCorr:\\n if (Cteff[i] > Ct_c):\\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\\n #if np.abs(imag(gamma_t_bar(i))) > 0:\\n # gamma_t_bar[i] = - b[i] + 0\\n Vc = U0 * (b + gamma_t_bar / 2)\\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\\n\\n\\n # Analytical 1\\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\\n a_1=a_1[-1::-1]\\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\\n a=a_1;\\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\\n # # Analytical 2\\n # a_2=-(gamma_t_hat/2)/U0;\\n # a=a_2;\\n #else\\n # a=a_1;\\n #end\\n if bSwirl:\\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\\n else:\\n a_prime=a*0\\n\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n misc['h'] = h\\n\\n # --- Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n #gamma_t = - Gamma_tilde/h\\n gamma_t = gamma_t_bar * U0\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = None\\n Gamma_r = None\\n\\n return gamma_t,gamma_l,Gamma_r, misc\",\n \"def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cyl is None:\\n r_cyl = np.zeros(r_cp.shape)\\n if len(r_cyl)==1:\\n r_cyl=np.array([R])\\n else:\\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\\n else:\\n r_cyl = np.asarray(r_cyl).ravel()\\n misc={}\\n # --- Checks\\n if np.amax(r_cyl) < np.amax(r_cp):\\n warnings.warn('Cylinders are assumed to enclose the control points')\\n import pdb; pdb.set_trace()\\n if r_cyl[0] == 0:\\n raise Exception('First cylinder at 0, impossible')\\n\\n ## Interpolating Circulation on the control points\\n Gamma_cp = Gamma_cp * nB # IMPORTANT\\n lambda_rcp = Omega*r_cp/U0\\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\\n ## Some init\\n\\n n = len(r_cyl)\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n # --- Case 1: Using k / ct to determine gamma\\n # Using a_prime to correct Ct\\n # Tangential convection velocity\\n if not bTanInd_k:\\n ap_cyl_conv = 0 * Gamma_cp\\n else:\\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\\n # See Equation (26) of [1]: a'_c,i = (\\\\Gamma_i+\\\\Gamma_i+1)/(4 pi Omega R_i^2)\\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\\n # --- Allocation\\n b = np.zeros(n) # Cummulative sum of gamma_bar\\n S = np.zeros(n) # Term under the square root\\n Sbis = np.zeros(n) # Term under the square root, account\\n Ctrot = np.zeros(n)\\n Ctrot_loc = np.zeros(n)\\n Cti = np.zeros(n)\\n Cteff = np.zeros(n)\\n gamma_t_bar = np.zeros(n)\\n # --- Init\\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\\n lambda_R = Omega * r_cyl / U0\\n # Looping through radii in reversed order\\n for i in np.arange(n-1,-1,-1):\\n if i==n-1:\\n b[i] = 1\\n S[i] = 1 - C[i]\\n Sbis[i] = 1 - C[i]\\n Ctrot[i] = 0\\n Ctrot_loc[i] = 0\\n else:\\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\\n if not bSwirl:\\n Ctrot[i] = 0\\n Cti[i] = k_r[i]\\n else:\\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\\n Sbis[i] = 1 - Cteff[i]\\n if bSwirl :\\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\\n else:\\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \\n# print('b',b,'S',S)\\n if bHighThrustCorr:\\n if (Cteff[i] > Ct_c):\\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\\n #if np.abs(imag(gamma_t_bar(i))) > 0:\\n # gamma_t_bar[i] = - b[i] + 0\\n Vc = U0 * (b + gamma_t_bar / 2)\\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\\n\\n\\n # Analytical 1\\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\\n a_1=a_1[-1::-1]\\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\\n a=a_1;\\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\\n # # Analytical 2\\n # a_2=-(gamma_t_hat/2)/U0;\\n # a=a_2;\\n #else\\n # a=a_1;\\n #end\\n if bSwirl:\\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\\n else:\\n a_prime=a*0\\n\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n misc['h'] = h\\n\\n # --- Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n #gamma_t = - Gamma_tilde/h\\n gamma_t = gamma_t_bar * U0\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = None\\n Gamma_r = None\\n\\n return gamma_t,gamma_l,Gamma_r, misc\",\n \"def WakeVorticityFromCt(r,Ct,R,U0,Omega):\\n if Omega==np.inf:\\n Omega=800 # TODO, implement infinite lambd formulae directly\\n Lambda=Omega*R/U0\\n bSwirl=Lambda<20\\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\\n Gamma = vk*np.pi*U0**2/Omega\\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)\",\n \"def WakeVorticityFromCt(r,Ct,R,U0,Omega):\\n if Omega==np.inf:\\n Omega=800 # TODO, implement infinite lambd formulae directly\\n Lambda=Omega*R/U0\\n bSwirl=Lambda<20\\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\\n Gamma = vk*np.pi*U0**2/Omega\\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)\",\n \"def attach_to_controller(self, controller):\\r\\n\\r\\n def cv_amp(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n return np.std(amps) / np.mean(amps) if len(amps) >= 1 else 0\\r\\n\\r\\n def cum_amp_drift(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n # return cum_feat(amps) if len(amps) >= 2 else 0\\r\\n return np.sum(np.abs(np.diff(amps))) / len(amps) if len(amps) >= 2 else 0\\r\\n\\r\\n def cum_depth_drift(cluster_id):\\r\\n depths = controller.model.spike_depths[controller.get_spike_ids(cluster_id)].data\\r\\n # return cum_feat(depths) if len(depths) >= 2 else 0\\r\\n return np.sum(np.abs(np.diff(depths))) / len(depths) if len(depths) >= 2 else 0\\r\\n\\r\\n def cv_fr(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n fr = bb.singlecell.firing_rate(ts, hist_win=0.01, fr_win=0.25)\\r\\n return np.std(fr) / np.mean(fr) if len(fr) >= 1 else 0\\r\\n\\r\\n def frac_isi_viol(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n frac_isi_viol, _, _ = isi_viol(ts, rp=0.002)\\r\\n return frac_isi_viol\\r\\n\\r\\n def frac_missing_spikes(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n try:\\r\\n frac_missing_spks, _, _ = feat_cutoff(\\r\\n amps, spks_per_bin=10, sigma=4, min_num_bins=50)\\r\\n except:\\r\\n frac_missing_spks = np.NAN\\r\\n return frac_missing_spks\\r\\n\\r\\n def fp_estimate(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n return fp_est(ts, rp=0.002)\\r\\n\\r\\n def presence_ratio(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n pr, _ = pres_ratio(ts, hist_win=10)\\r\\n return pr\\r\\n\\r\\n def presence_ratio_std(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n pr, pr_bins = pres_ratio(ts, hist_win=10)\\r\\n return pr / np.std(pr_bins)\\r\\n\\r\\n def refp_viol(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n return FP_RP(ts)\\r\\n\\r\\n def n_cutoff(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n return noise_cutoff(amps, quartile_length=.25)\\r\\n\\r\\n def mean_amp_true(cluster_id):\\r\\n # Three cases: raw data\\r\\n\\r\\n # THIS APPROACH WORKS FOR BOTH SAMPLE WAVEFORMS AND RAW DATA\\r\\n # Specify 100 waveforms to average over, but may be less in the case where in the subset\\r\\n # of sample waveforms it doesn't contain 100 samples for specific cluster\\r\\n\\r\\n # N.B. These waveforms are median subtracted and have a high pass applied\\r\\n waveforms = controller._get_waveforms_with_n_spikes(\\r\\n cluster_id, 100)['data'].data\\r\\n\\r\\n # This way finds (max-min) on each channel, and then for each waveform finds the\\r\\n # maximum (max-min) on any channel and averages these\\r\\n # For each sample waveform find value on channel that has largest (max-min)\\r\\n p2p = np.max((np.max(waveforms, axis=1) - np.min(waveforms, axis=1)), axis=1)\\r\\n # Find mean p2p across all available sample waveforms\\r\\n p2p_mean = np.mean(p2p)\\r\\n\\r\\n # Alternative way\\r\\n # This way finds (max-min) on each channel, on each channel averages across all sample\\r\\n # waveforms and then finds the channel with the maximum average value\\r\\n p2p_mean_alt = np.max(np.mean(np.max(waveforms, axis=1) - np.min(waveforms, axis=1),\\r\\n axis=0))\\r\\n\\r\\n # Approach 2\\r\\n # Only works for sample waveforms\\r\\n # For non median subtracted and no high pass can access sample waveforms like this\\r\\n # spike_ids = controller.get_spike_ids(cluster_id).data\\r\\n # # Find which of the spike ids are in the subset of sample waveforms\\r\\n # _, _, idx = np.intersect1d(spike_ids,\\r\\n # controller.model.spike_waveforms['spike_ids'].data,\\r\\n # return_indices=True)\\r\\n # # Sample waveforms that are available for this cluster\\r\\n # # Shape of waveforms (n_waveforms, n_samples, n_channels)\\r\\n # # where len(idx) == n_waveforms\\r\\n # waveforms = controller.model.spike_waveforms['waveforms'][idx].data\\r\\n\\r\\n # RAW DATA CASE\\r\\n\\r\\n return p2p_mean\\r\\n\\r\\n # no waveforms\\r\\n\\r\\n # def ptp_sigma(cluster_id):\\r\\n # this also requires checking 3 cases above.\\r\\n\\r\\n def m_label(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n metrics_label = int(FP_RP(ts) and noise_cutoff(amps, quartile_length=.25) < 20)\\r\\n return metrics_label\\r\\n # if amplitudes are correct (i.e. raw data or sample wfs exist):\\r\\n #metrics_label = (FP_RP(ts) and noise_cutoff(amps,quartile_length=.25)<20 and np.mean(amps)>50)\\r\\n\\r\\n # Use this dictionary to define custom cluster metrics.\\r\\n # We memcache the function so that cluster metrics are only computed once and saved\\r\\n # within the session, and also between sessions (the memcached values are also saved\\r\\n # on disk).\\r\\n controller.cluster_metrics['cv_amp'] = controller.context.memcache(cv_amp)\\r\\n controller.cluster_metrics['cum_amp_drift'] = controller.context.memcache(cum_amp_drift)\\r\\n\\r\\n # NOTE: the branch of phylib which defines model.spike_depths is not working yet\\r\\n # controller.cluster_metrics['cum_depth_drift'] = controller.context.memcache(\\r\\n # cum_depth_drift)\\r\\n\\r\\n controller.cluster_metrics['cv_fr'] = controller.context.memcache(cv_fr)\\r\\n controller.cluster_metrics['frac_isi_viol'] = controller.context.memcache(frac_isi_viol)\\r\\n controller.cluster_metrics['frac_missing_spikes'] = controller.context.memcache(\\r\\n frac_missing_spikes)\\r\\n controller.cluster_metrics['fp_estimate'] = controller.context.memcache(fp_estimate)\\r\\n controller.cluster_metrics['presence_ratio'] = controller.context.memcache(presence_ratio)\\r\\n controller.cluster_metrics['presence_ratio_std'] = controller.context.memcache(\\r\\n presence_ratio_std)\\r\\n controller.cluster_metrics['refp_viol'] = controller.context.memcache(refp_viol)\\r\\n controller.cluster_metrics['noise_cutoff'] = controller.context.memcache(n_cutoff)\\r\\n controller.cluster_metrics['mean_amp'] = controller.context.memcache(mean_amp_true)\\r\\n controller.cluster_metrics['metrics_label'] = controller.context.memcache(m_label)\",\n \"def ridge_joint(trn_fs,trn_data,alphas,val_fs=None,val_data=None,square_alphas=False,chunk_sz=5000,is_verbose=True):\\n\\n n_resp, n_voxels = trn_data.shape\\n n_channels = np.sum([tfs.shape[1] for tfs in trn_fs])\\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\\n\\n if square_alphas:\\n alphas = [a**2 for a in alphas]\\n\\n num_train_points = float(list(trn_data.shape)[0])\\n num_val_points = float(list(val_data.shape)[0])\\n\\n n_abc = [np.minimum(*t_fs.shape) for t_fs in trn_fs]\\n ######################################################################################\\n ### --- First up: compute modified covariance matrix & scaled/rotated stimulus --- ###\\n ######################################################################################\\n # Perform SVD on training sets for all three models \\n if is_verbose:\\n print(\\\"computing SVD\\\")\\n U_trn,W_trn,Vt_trn = [],[],[]\\n for t_fs in trn_fs:\\n uu,ww,vv = np.linalg.svd(trn_stim_A, full_matrices=False)\\n U_trn.append(uu)\\n W_trn.append(ww)\\n Vt_trn.append(vv)\\n\\n # The square of Ws (the singular values from the SVD) are the eigenvalues of the covariance matrix but have not been divided by n-1.\\n L = [ww**2/float(num_train_points-1) for ww in W_trn]\\n\\n ### --- IDK WTF. Ask Wendino. --- ###\\n ## to change: make sure that Ws are in the right units (divided by n-1) when bootstrapping, so that alphas are already in correct units\\n ## at that point you can change the lines below and not divide alpha by (n-1)\\n # TO DO: make this more than one line for clarity.\\n w_alpha_trn = [np.diag(np.sqrt(1./(LL + aa)/(num_train_points-1))) for LL,aa in zip(L,alphas)]\\n #w1_alpha_trn = sqrt(1./(L1+ alphas_A2[0]/(num_train_points-1))) \\n #w1_alpha_trn = diag(w1_alpha_trn) #%turn it from an array to a matrix\\n\\n # Create & combine rotated & scaled stimulus space \\n X_prime_trn_t = [ww.dot(vv).dot(t_fs) for ww,vv,t_fs in zip(W_trn,Vt_trn,trn_fs)]\\n #S1_prime_trn_t = np.dot(np.dot(w1_alpha_trn, Vt1_trn), trn_stim_A.T) #w1_alpha_trn = 1200x1200, Vt1_trn = 1200x1200, trn_stim_A.T = 1200x3737\\n Xcomb_prime_trn_t = np.vstack(X_prime_trn_t)\\n\\n # Create & modify covariance matrix\\n stim_cov_mat_r = X_prime_trn_t.dot(X_prime_trn_t.T) / float(num_train_points-1)\\n cov_diag = np.sqrt(np.diag(stim_cov_mat_r))\\n full_mat_cov_diag = np.tile(cov_diag, [cov_diag.shape[0], 1])\\n # re-do w/ simpler syntax?\\n all_divisor = np.multiply(full_mat_cov_diag.T, full_mat_cov_diag) \\n corr_mat_r = np.divide(stim_cov_mat_r, all_divisor)\\n\\n ### --- Clean up the correlation matrix to have zeros where we know they exist and use that data to set a threshold --- ###\\n idx_ct = np.cumsum([0]+n_abc)\\n idxs = [(a,b) for a,b in zip(idx_ct[:-1],idx_ct[1:])]\\n # Block diagonal components of covariance matrix\\n for n,(ii,jj) in zip(n_abc,idxs):\\n corr_mat_r[ii:jj] = np.eye(n)\\n # Off-diagonal elements: ignore for now? \\n #for i1,i2 in zip(idxs[:-1],idxs[1:]):\\n # (ii,jj),(kk,ll) = i1,i2\\n \\n\\n # ##### --- WORKING HERE - SEE IPYTHON NOTEBOOK --- #########\\n # upper_right_corr = np.ravel(corr_mat_r[0:nA, nA:])\\n # middle_right_corr = np.ravel(corr_mat_r[nA:(nA+nB),(nA+nB):])\\n # right_corr = np.hstack([upper_right_corr, middle_right_corr])\\n # s_right_corr = argsort(right_corr)\\n # # WTF is this?\\n # #corr_cutoff = 954 # WH magic number; something to do with the fact that it's needless to have \\n # # ALL the block-diagonal diagonals, since we have limited data\\n # #goodcorrs_idx = np.hstack([s_right_corr[0:corr_cutoff], s_right_corr[-1:-(corr_cutoff+1):-1]])\\n\\n # new_right_corrs = np.squeeze(np.zeros([s_right_corr.shape[0],1]))\\n # #new_right_corrs[goodcorrs_idx] = right_corr[goodcorrs_idx]\\n # new_upper_right_corrs = np.reshape(new_right_corrs[0:(nB+nC)*nA],[nA,nB+nC])\\n # new_lower_left_corrs = new_upper_right_corrs.T\\n # new_middle_right_corrs = np.reshape(new_right_corrs[(nB+nC)*nA:],[nB,nC])\\n # new_middle_left_corrs = new_middle_right_corrs.T\\n\\n # ##NEED TO CHANGE THIS: REMOVE HARDCODED MATRIX SIZES\\n # new_corr_mat_r = copy.copy(corr_mat_r)\\n # new_corr_mat_r[0:nA, nA:]= new_upper_right_corrs\\n # new_corr_mat_r[nA:(nA+nB), (nA+nB):] = new_middle_right_corrs\\n # new_corr_mat_r[(nA+nB):, nA:(nA+nB)]= new_middle_left_corrs # More like bottom middle\\n # new_corr_mat_r[nA:,0:nA] = new_lower_left_corrs # \\n # new_corr_mat_r[0:nA,0:nA]= np.identity(nA)\\n # new_corr_mat_r[nA:(nA+nB), nA:(nA+nB)] = np.identity(nB)\\n # new_corr_mat_r[(nA+nB):,(nA+nB):] = np.identity(nC)\\n\\n #perform eigenvalue decomposition (WHAT FOR? delete this?)\\n #w, v = np.linalg.eigh(new_corr_mat_r)\\n # Invert modified covariance matrix\\n #corr_r_inv = np.linalg.inv(new_corr_mat_r)\\n corr_r_inv = np.linalg.inv(corr_mat_r)\\n #for \\n ##create filter\\n dot1 = np.dot(X_prime_trn_t, trn_data) #precompute for speed\\n dot2 = np.dot(corr_r_inv, dot1) #precompute for speed\\n # Weights\\n h_123_prime = np.divide(dot2, (float(num_train_points-1)))\\n\\n\\n ##create estimated responses from training data\\n #r_hat = np.dot(X_prime_trn_t.T, h_123_prime) # not usually done...\\n #if do_pred:\\n #validation set results\\n val_stim_A_prime = np.dot(np.dot(w1_alpha_r, Vt1_r), val_stim_A.T)\\n val_stim_B_prime = np.dot(np.dot(w2_alpha_r, Vh2_r), val_stim_B.T)\\n val_stim_C_prime = np.dot(np.dot(w3_alpha_r, Vh3_r), val_stim_C.T)\\n #S1_prime = S1_prime[0:200,:]\\n #S2_prime = S2_prime[0:200,:]\\n\\n S123_val_prime_t = np.vstack([val_stim_A_prime, val_stim_B_prime, val_stim_C_prime])\\n\\n #create validation set correlations\\n r_hat_val = np.dot(S123_val_prime_t.T, h_123_prime)\\n\\n\\n #look at performance\\n valcorr = _sutils.column_corr(r_hat_val, val_data)\\n out = dict(\\n #weights=wt,\\n #alphas=alphas,\\n #n_sig_vox_byalpha=n_sig_vox_byalpha,\\n cc=valcorr\\n )\\n return out\",\n \"def init_kern_act(num_pitches):\\n\\n kern_act = []\\n\\n for i in range(num_pitches):\\n kern_act.append(Matern32(1, lengthscales=1.0, variance=3.5))\\n return kern_act\",\n \"def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\\n \\n # INPUTS FROM TTTW SYSTEM\\n self.b = b #buoyancy field: [Ly,N]\\n self.u = u # x-component of velocity [Ly,N]\\n self.v = v # y-component of velocity [Ly+1,N]\\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \\n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\\n self.grid_dict = grid_dict #gridded data\\n self.f = f #coriolis parameter\\n # KPP-SPECIFIC VARIABLES \\n self.hbls = np.zeros([self.b.shape[0]])\\n self.hbbl = np.zeros([self.b.shape[0]])\\n self.ustar = []\\n self.bvf = [] \\n self.kmo = []\\n self.C_h_MO = []\\n self.kbl = []\\n self.Cr = [] \\n self.Fc = []\\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\\n self.dt = dt\",\n \"def hcn_tf(Y,t,voltage_clamp_func,voltage_clamp_params):\\n \\n v = voltage_clamp_func(t,voltage_clamp_params)\\n n_s = Y[0]\\n n_f = Y[1]\\n \\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\\n ninf_f = ninf_s\\n\\n if v > -70.0:\\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\\n else:\\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\\n\\n dns = (ninf_s - n_s)/tau_ns\\n dnf = (ninf_f - n_f)/tau_nf\\n \\n return [dns, dnf]\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def __init__(self, num_heads: int, size: int, size_v: int, dropout: float = 0.1):\\n super(ContMultiHeadedAttention, self).__init__()\\n\\n assert size % num_heads == 0\\n\\n self.head_size = head_size = size // num_heads\\n self.model_size = size\\n self.num_heads = num_heads\\n\\n self.k_layer = nn.Linear(size, num_heads * head_size)\\n self.v_layer = nn.Linear(size_v, num_heads * head_size)\\n self.q_layer = nn.Linear(size, num_heads * head_size)\\n\\n self.output_layer = nn.Linear(size, size_v)\\n self.softmax = nn.Softmax(dim=-1)\\n self.dropout = nn.Dropout(dropout)\",\n \"def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \\n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \\n N_res=30):\\n x_eps = 0.3 # shift from Dirac point\\n x_res = 20\\n kx_int = 0 + x_eps # -np.pi\\n kx_fin = 4*np.pi/3 + x_eps\\n Dx = (kx_fin - kx_int)/x_res\\n\\n y_res = 20\\n ky_int = 0 # -np.pi\\n ky_fin = 2*np.pi/np.sqrt(3)\\n Dy = (ky_fin - ky_int)/y_res\\n\\n Nd = self.Nd # dimension of the Hamiltonian\\n Dk = np.array([Dx,Dy], float)\\n\\n LF = np.zeros((Nd), dtype=complex)\\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n sumN = np.zeros((Nd), dtype=complex)\\n E_k = np.zeros((Nd), dtype=complex)\\n chernN = np.zeros((Nd), dtype=complex)\\n\\n # Loop over kx\\n for ix in range(x_res):\\n kx = kx_int + ix*Dx\\n\\n # Loop over ky\\n for iy in range(y_res):\\n ky = ky_int + iy*Dy\\n\\n k_vec = np.array([kx,ky], float)\\n\\n LF, E_k = self.latF(k_vec, Dk, self.delta)\\n\\n sumN += LF\\n\\n # # save data for plotting\\n LF_arr[:,ix,iy] = LF.imag\\n\\n E_arr[:,ix,iy] = np.sort(E_k.real)\\n\\n # End of ky Loop\\n # End of kx Loop\\n\\n chernN = sumN.imag/(2*np.pi)\\n print(\\\"Chern number bands are (%.3f, %.3f) \\\" \\n %(chernN[0], chernN[1]))\\n print(\\\"Sum of all bands Chern Number is %.2f \\\" %(sum(chernN)))\\n return chernN, E_arr\\n #################### \",\n \"def component_func(B, C, F, list_funcs, len_kegg, threshold=0.05):\\n\\n size_label = 18\\n size_tick = 18\\n sns.set_style(\\\"darkgrid\\\")\\n\\n list_funcs = list_funcs[0:len_kegg]\\n B = B[0:len_kegg]\\n C = C[0:len_kegg]\\n\\n idx_p = [idx*2+0 for idx in range(B.shape[1]/2)]\\n idx_m = [idx*2+1 for idx in range(B.shape[1]/2)]\\n is_p = F[:,idx_p].mean(axis=1) - F[:,idx_m].mean(axis=1) > threshold\\n is_m = F[:,idx_m].mean(axis=1) - F[:,idx_p].mean(axis=1) > threshold\\n is_p = [idx for idx, val in enumerate(is_p) if val]\\n is_m = [idx for idx, val in enumerate(is_m) if val]\\n is_n = [idx for idx in range(C.shape[1]) if (idx not in is_p) and (idx not in is_m)]\\n\\n fig = plt.figure(figsize=(6, 6))\\n\\n for idx_c in range(C.shape[1]):\\n clone_num = idx_c +1\\n if idx_c in is_p:\\n color=\\\"green\\\"\\n label = \\\"C\\\"+str(clone_num)+\\\"|P\\\"\\n elif idx_c in is_m:\\n color=\\\"red\\\"\\n label = \\\"C\\\"+str(clone_num)+\\\"|M\\\"\\n else:\\n color = \\\"royalblue\\\"\\n label = \\\"C\\\"+str(clone_num)\\n\\n if clone_num in [1]:\\n marker = \\\"$1$\\\"\\n elif clone_num in [2]:\\n marker = \\\"$2$\\\"\\n elif clone_num in [3]:\\n marker = \\\"$3$\\\"\\n elif clone_num in [4]:\\n marker = \\\"$4$\\\"\\n elif clone_num in [5]:\\n marker = \\\"$5$\\\"\\n elif clone_num in [6]:\\n marker = \\\"$6$\\\"\\n else:\\n print(\\\"error\\\")\\n plt.plot(C[:,idx_c],range(len_kegg), color=color, marker=marker, markersize=10, linestyle=\\\"\\\",label=label, alpha=0.5)\\n\\n plt.yticks(range(len_kegg), list_funcs)\\n plt.xlabel(\\\"Pathway strength\\\", fontsize=size_label)\\n plt.legend()\\n plt.tick_params(labelsize=size_tick-4)\\n plt.show()\\n ##fig.savefig(\\\"figures/fig7compfunc.pdf\\\", bbox_inches=\\\"tight\\\")\",\n \"def config_hog_search(self, img):\\n img = img.astype(np.float32)/255 # scale image: (png: 0-1, jpg: 0-255)\\n img_crop = img[self.ys[0]:self.ys[1], :, :] # crop img to relative dimensions (ROI)\\n clr_trf = cvf.transform_colorspace(img_crop, self.color_space) # transform color space from RGB\\n clr_trf = cvu.scale_image(clr_trf, self.scale) # scale rather than selecting diffferent window sizes\\n ch1, ch2, ch3 = [clr_trf[:,:,ch] for ch in range(3)] # HOG operates on per channel basis\\n\\n # get hog features as multi-dimensional array per channel for the entire image\\n params={'orient':self.orient, 'pix_per_cell':self.pix_per_cell, 'cells_per_block':self.cells_per_block}\\n params.update({'vis':False, 'feature_vec':False})\\n hog1,hog2,hog3 = [cvf.get_hog_features(ch, **params) for ch in ([ch1,ch2,ch3])]\\n # block configurations\\n self.nfeat_per_block = self.orient*self.cells_per_block**2\\n self.nblocks_per_window = (self.window //self.pix_per_cell) -1\\n # number_blocks: define number of hog cells across an image according to channel dimensions\\n # number_steps: define number of steps to occur across hog array to extract features\\n rows, cols = ch1.shape[:2]\\n number_blocks = lambda max_dim, pix_per_cell: (max_dim // pix_per_cell) -1\\n number_steps = lambda nblocks, nblocks_window, cells_step: (nblocks - nblocks_window)//cells_step\\n self.nxblocks, self.nyblocks = number_blocks(cols, self.pix_per_cell), number_blocks(rows, self.pix_per_cell)\\n nxsteps, nysteps = \\\\\\n [number_steps(it, self.nblocks_per_window, self.cells_per_step) for it in (self.nxblocks, self.nyblocks) ]\\n return clr_trf, (nxsteps, nysteps), (hog1,hog2,hog3)\",\n \"def demo3(image_paths, arch, topk, stride, n_batches, output_dir, cuda):\\n\\n device = get_device(cuda)\\n\\n # Synset words\\n classes = get_classtable()\\n\\n # Model from torchvision\\n model = models.__dict__[arch](pretrained=True)\\n model = torch.nn.DataParallel(model)\\n model.to(device)\\n model.eval()\\n\\n # Images\\n images, _ = load_images(image_paths)\\n images = torch.stack(images).to(device)\\n\\n print(\\\"Occlusion Sensitivity:\\\")\\n\\n patche_sizes = [10, 15, 25, 35, 45, 90]\\n\\n logits = model(images)\\n probs = F.softmax(logits, dim=1)\\n probs, ids = probs.sort(dim=1, descending=True)\\n\\n for i in range(topk):\\n for p in patche_sizes:\\n print(\\\"Patch:\\\", p)\\n sensitivity = occlusion_sensitivity(\\n model, images, ids[:, [i]], patch=p, stride=stride, n_batches=n_batches\\n )\\n\\n # Save results as image files\\n for j in range(len(images)):\\n print(\\\"\\\\t#{}: {} ({:.5f})\\\".format(j, classes[ids[j, i]], probs[j, i]))\\n\\n # save_sensitivity(\\n # filename=osp.join(\\n # output_dir,\\n # \\\"{}-{}-sensitivity-{}-{}.png\\\".format(\\n # j, arch, p, classes[ids[j, i]]\\n # ),\\n # ),\\n # maps=sensitivity[j],\\n # )\",\n \"def optical_kernels(K, J, Lxy, fmax, num):\\n\\n df = 1/Lxy\\n\\n # Compute TCC\\n TCC, f = trans_cross_coeff(K, J, df, fmax)\\n \\n # Convert to 2D matrix\\n N = f.size\\n TCCm = np.reshape(np.reshape(TCC, (N, N, -1)), (N**2, -1))\\n\\n # Compute largest eigenvalues and eigenvectors\\n w, v = scipy.linalg.eigh(TCCm, eigvals=(N**2 - num, N**2 - 1))\\n w = np.flip(w, 0)\\n v = np.flip(v, 1)\\n\\n # Get real-space optical kernels\\n phi = []\\n for i in range(num):\\n Phi = np.fft.ifftshift(np.reshape(v[:,i], [N, N]))\\n #phi.append(np.fft.fftshift(np.fft.ifft2(Phi)))\\n phi.append(np.fft.ifft2(Phi))\\n \\n return w, phi\",\n \"def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n pad=np.random.rand(nspad)/100\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_norm_padded=np.hstack((pad,trc_norm))\\n trc_entropy=self.entropy(trc_norm_padded,50)\\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\\n for i,j in enumerate(trc):\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def build_param_grid(self, C_list:list=[0.1, 1, 10, 100], gamma_list:list=[1, 0.1, 0.01, 0.001], kernel_list:list=['rbf']):\\n ans = {}\\n ans['C'] = C_list\\n ans['gamma'] = gamma_list\\n ans['kernel'] = kernel_list\\n self.param_grid = ans\\n return ans\",\n \"def dispersion_1(ztop, vp, vs, rh,\\n Waves, Types, Modes, Freqs,\\n h = 0.005, dcl = 0.005, dcr = 0.005, keepnans = False):\\n waves, types, modes, freqs = igroupbywtm(Waves, Types, Modes, Freqs)\\n values = dispersion(ztop, vp, vs, rh, \\\\\\n waves, types, modes, freqs,\\n h = h, dcl = dcl, dcr = dcr)\\n\\n for w, t, m, F, V in groupbywtm(waves, types, modes, freqs, values, keepnans = keepnans):\\n yield w, t, m, F, V\",\n \"def default_grid_feature_hp_kernel_config(defn):\\n defn = _validate_definition(defn)\\n config = {}\\n\\n grid = enumerate(zip(defn.models(), defn.hyperpriors()))\\n\\n for fi, (model, priors) in grid:\\n partials = copy.deepcopy(model.default_partial_hypergrid())\\n if not partials:\\n continue\\n\\n evals = []\\n for update_descs, fn in priors.iteritems():\\n if not hasattr(update_descs, '__iter__'):\\n update_descs = [update_descs]\\n keyidxs = []\\n for update_desc in update_descs:\\n key, idx = _parse_descriptor(update_desc, default=None)\\n keyidxs.append((key, idx))\\n\\n def func(raw, keyidxs):\\n s = 0.\\n for key, idx in keyidxs:\\n if idx is None:\\n s += raw[key]\\n else:\\n s += raw[key][idx]\\n return s\\n evals.append(lambda raw, keyidxs=keyidxs: func(raw, keyidxs))\\n\\n def jointprior(raw, evals):\\n return np.array([f(raw) for f in evals]).sum()\\n\\n config[fi] = {\\n 'hpdf': lambda raw, evals=evals: jointprior(raw, evals),\\n 'hgrid': partials,\\n }\\n\\n if not config:\\n return []\\n else:\\n return [('grid_feature_hp', config)]\",\n \"def one_iteration_step(self, tsm, tank, chp, kessel, cvalve, heizkurve, t_a, el_heat_status, actual_time, heatc_conf):\\n #print('\\\\n chp = {}; kessel = {}; t2 = {}; t3 = {}'.format(chp.get_status(), kessel.get_status(), self.t2, self.t3))\\n # combined heat and power unit - link outputs\\n wyn = chp.get_chp()\\n #self.t27 = wyn[1] # tin in °C = self.t1 = wyn[t1]\\n self.t26 = wyn[2] # tout in °C = chp.get_out_temp = wyn[2]\\n m3 = wyn[3] # mstr in kg/s \\n self.V_3 = m3 / utils.rho_fluid_water(self.t26, self.p_atm, 1) # volume flow incoming to chp from tank\\n V_chp = chp.get_volume_flow_at_output() # volume flow outoming from chp into tank\\n # combined heat and power unit - link inputs\\n chp.set_inp_temp(self.t27) # temperature incoming from tank to chp\\n\\n # ..............................................................\\n\\n # gas boiler - link outputs\\n wyn = kessel.get_kessel()\\n #self.t29 = wyn[1] # tin in °C - incoming into gas heater\\n self.t28 = wyn[2] # tout in °C - outcoming from gas heater\\n m4 = wyn[3] # mstr in kg/s - incoming into gas heater\\n self.V_4 = kessel.get_volume_flow_at_input()\\n V_kessel = kessel.get_volume_flow_at_output()\\n # gas boiler - link inputs\\n kessel.set_inp_temp(self.t29)\\n #kessel.calc_mass_flow()\\n\\n # ..............................................................\\n # at first no delay - just linking chp and heater\\n # delay due to the seuence of commands ie equal to the Timestep length\\n self.t27 = self.t1\\n self.t29 = self.t1\\n # ..............................................................\\n\\n # heating circuit\\n self.t23 = self.t20 # no delay assumed\\n #print('t20 = {}; t23 = {}'.format(self.t20, self.t23))\\n self.t25 = heizkurve.get_supply_temperature(t_a)\\n self.t24 = heizkurve.get_return_temperature(t_a)\\n heizkurve.calc_volume_flow()\\n\\n # comprehensive control algorithm - it stays\\n (m23, m25, m4) = self.control_internal_1(heizkurve, kessel, chp, cvalve, t_a, actual_time, m4, heatc_conf)\\n\\n m_bypass = m25 - m23\\n rho23 = utils.rho_fluid_water(self.t23, self.p_atm, 1)\\n V_23 = m23 / rho23 # in m3/s = kg/s / kg/m3\\n #print('V_23 = {}; m23 = {}; rho23 = {}; t23 = {}'.format(V_23,m23, rho23, self.t23))\\n m24 = m23\\n rho24 = utils.rho_fluid_water(self.t24, self.p_atm, 1)\\n V_24 = m24 / rho24\\n \\n # demand for domestic hot water\\n m22 = self.V_1 * utils.rho_fluid_water(self.t22, self.p_atm, 1) # in kg/s = m3/s * kg/m3\\n #m22 = 0.01 # kg/s\\n # ..............................................................\\n\\n t_ambient = 15.0\\n # storage tank - calculation\\n tank.calculate_storage_tank_obj(tsm, # time step manager\\n self.t23, # hk_inp_temp\\n V_23, # hk_inp_volfl_m3s\\n self.t24, # hk_out_temp\\n self.t27, # chp_inp_temp\\n self.t26, # chp_out_temp\\n self.V_3, # chp_inp_volfl_m3s\\n self.t29, # gb_inp_temp\\n self.t28, # gp_out_temp\\n self.V_4, # gb_inp_volfl_m3s\\n self.t22, # dhw_inp_temp\\n self.t21, # dhw_out_temp\\n self.V_1, # dhw_inp_volfl_m3s\\n el_heat_status, # el_heat_status\\n actual_time, # time in the timestamp format\\n t_ambient) # ambient temperature of the tank - defines heat losses to the outside\\n \\n self.t21 = tank.get_temp_dhw()\\n #self.t27 = \\n #self.t29 = \\n #self.t23 = \\n \\n # storage tank - linking\\n [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, \\n self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20] = tank.output_temperatures()\\n\\n # ..............................................................\\n # get rid of this part\\n #self.control_internal_2(chp, kessel, actual_time, m4)\\n # ..............................................................\\n heizwert_in_MJ_per_kg = 50.0 # kg/m3 N ~CH4\\n gas_density = 0.79 # kg/m3 N ~Erdgas\\n Z_boiler = kessel.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\\n self.Z_2 = chp.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\\n self.Z_1 = self.Z_2 + Z_boiler\\n \\n self.Wh1 = -1.0 * chp.get_el_prod()\\n self.Wh2 = tank.get_el_heater_consumption()\\n self.Wh3 = self.Wh1 + self.Wh2 + self.electricity_consumption_kWh\\n #print('END chp = {}; kessel = {}; heating = {}; t2 = {}; t3 = {};V1 = {}; V2 = {}; V3 = {}; V4 = {}; t_a = {}'.format(chp.get_status(), kessel.get_status(), heizkurve.get_status(), self.t2, self.t3, self.V_1, self.V_2, self.V_3, self.V_4, t_a))\",\n \"def model(**params):\\n N_frb = 0\\n vs = []\\n hs = []\\n cs = []\\n ncands = []\\n\\n for cand in candlist:\\n c_res = calculate_metric_terms(\\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\\n )\\n t, frb_found, h, c, v = c_res\\n vs.append(v)\\n hs.append(h)\\n cs.append(c)\\n ncands.append(t)\\n\\n if frb_found:\\n N_frb += 1\\n\\n vs = np.array(vs)\\n hs = np.array(hs)\\n cs = np.array(cs)\\n c_avg = np.average(cs, axis=0, weights=ncands)\\n h_avg = np.average(hs, axis=0, weights=ncands)\\n v_avg = np.average(vs, axis=0, weights=ncands)\\n recall = N_frb / len(vs)\\n score = v_avg * recall\\n\\n return score\",\n \"def main():\\n # Directory where the DICOM files are being stored (in this\\n input_path = './Inputs/valve'\\n\\n # Original image from the filepath\\n img_original = read_image(input_path)\\n\\n # Image with smoothing applied to reduce noise\\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\\n\\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\\n\\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \\\"blood\\\" without cardiac tissue,\\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\\n # valve tissue from the rest - all we need is the overlap of the two labels\\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\\n\\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\\n\\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\\n x_mid = df['x'].mean()\\n y_mid = df['y'].mean()\\n df = get_df_from_img(labels_valve_filtered)\\n distance_df = df.drop('z', axis=1)\\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\\n labels = fit.labels_\\n df['label'] = pd.Series(labels)\\n counts = df['label'].value_counts().to_dict()\\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Use a segmentation-based clustering algorithm to attempt to find each valve\\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\\n\\n left, right = (label_segments[0], label_segments[1])\\n if x_max[0] > x_max[1]:\\n left, right = right, left\\n\\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\\n # this can be done by every z value\\n left_points = {'x': [], 'y': [], 'z': []}\\n right_points = {'x': [], 'y': [], 'z': []}\\n zlen = len(sitk.GetArrayFromImage(left))\\n for z in xrange(zlen):\\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\\n if len(left_df['y']) > 0:\\n index = left_df['y'].idxmin()\\n row = left_df.iloc[index]\\n left_points['x'].append(int(row['x']))\\n left_points['y'].append(int(row['y']))\\n left_points['z'].append(z)\\n\\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\\n if len(right_df['x']) > 0:\\n index = right_df['x'].idxmax()\\n row = right_df.iloc[index]\\n right_points['x'].append(int(row['x']))\\n right_points['y'].append(int(row['y']))\\n right_points['z'].append(z)\\n\\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\\n # points\\n final_left = pd.DataFrame.from_dict(left_points)\\n final_right = pd.DataFrame.from_dict(right_points)\\n print('Coordinates for one side of the ring')\\n print(final_left)\\n print('\\\\n\\\\nCoordinates for the other side of the ring')\\n print(final_right)\\n\\n final_image = make_empty_img_from_img(left)\\n x = left_points['x'] + right_points['x']\\n y = left_points['y'] + right_points['y']\\n z = left_points['z'] + right_points['z']\\n for x, y, z in zip(x, y, z):\\n final_image.SetPixel(x, y, z, 1)\\n\\n show_all(img_smooth, final_image)\",\n \"def predit_vehicles(img, windows,\\n scaler = None,\\n classifier = None,\\n decision = DECISION_THRESHOLD,\\n view=True,\\n save_path=None,\\n prefix=None,\\n debug=True):\\n car_features_list = []\\n for window in windows:\\n sub_img = cv2.resize(\\n get_sub_image(img, window), CLASSIFIER_IMG_SIZE)\\n one_features = extract_one_features(\\n sub_img,\\n cspace=CSPACE, spatial_size=(32, 32),\\n hist_bins=32, hist_range=(0, 256),\\n orient=ORIENTS_HOG, pix_per_cell=PIX_PER_CELL,\\n cell_per_block=CELLS_PER_BLOCK,\\n hog_channel=HOG_CHANNEL)\\n car_features_list.append(\\n # scaler.transform(np.asarray(one_features, dtype=np.float64)))\\n one_features)\\n scaled_list = scaler.fit_transform(car_features_list)\\n #if view:\\n # show_features(scaled_list)\\n decs = classifier.decision_function(scaled_list)\\n #predicts = classifier.predict(scaled_list)\\n #predicts_bool = predicts.astype(np.bool)\\n\\n car_windows = []\\n #for p, w in zip(predicts_bool, windows):\\n # if p:\\n for d, w in zip(decs, windows):\\n if (d > decision): ## positive decision threshold\\n # print (\\\"dec\\\", d)\\n car_windows.append(w)\\n #if view:\\n # show_grid_view(img, car_windows)\\n if save_path is not None:\\n save_sub_images(img, car_windows,\\n path=save_path,\\n prefix=prefix,\\n size=CLASSIFIER_IMG_SIZE)\\n return car_windows\",\n \"def init_stitch(N):\\n\\tif N is None:\\n\\t\\tN = np.int32(HII_DIM) #prepare for stitching\\n\\tMETA_GRID_SIZE = DIM/N\\n\\tM = np.int32(HII_DIM/META_GRID_SIZE)\\n\\t#HII_DIM = np.int32(HII_DIM)\\n\\tf_pixel_factor = DIM/HII_DIM;\\n\\tscale = np.float32(BOX_LEN/DIM)\\n\\tprint 'scale', scale\\n\\tHII_scale = np.float32(BOX_LEN/HII_DIM)\\n\\tshape = (DIM,DIM,N)\\n\\tstitch_grid_size = (DIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tDIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tN/(block_size[0]))\\n\\tHII_stitch_grid_size = (HII_DIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tHII_DIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tM/(block_size[0]))\\n\\t#ratio of large box to small size\\n\\tkernel_source = open(cmd_folder+\\\"/initialize_stitch.cu\\\").read()\\n\\tkernel_code = kernel_source % {\\n\\n\\t\\t'DELTAK': DELTA_K,\\n\\t\\t'DIM': DIM, \\n\\t\\t'VOLUME': VOLUME,\\n\\t\\t'META_BLOCKDIM': N\\n\\t}\\n\\tmain_module = nvcc.SourceModule(kernel_code)\\n\\tinit_stitch = main_module.get_function(\\\"init_kernel\\\")\\n\\tHII_filter = main_module.get_function(\\\"HII_filter\\\")\\n\\tsubsample_kernel = main_module.get_function(\\\"subsample\\\")\\n\\tvelocity_kernel = main_module.get_function(\\\"set_velocity\\\")\\n\\tpspec_texture = main_module.get_texref(\\\"pspec\\\")\\n\\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\\n\\tplan2d = Plan((np.int64(DIM), np.int64(DIM)), dtype=np.complex64)\\n\\tplan1d = Plan((np.int64(DIM)), dtype=np.complex64)\\n\\tprint \\\"init pspec\\\"\\n\\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\\n\\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\\n\\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\\n\\t#hbox_large = pyfftw.empty_aligned((DIM, DIM, DIM), dtype='complex64')\\n\\thbox_large = np.zeros((DIM, DIM, DIM), dtype=np.complex64)\\n\\t#hbox_small = np.zeros(HII_shape, dtype=np.float32)\\n\\t#hbox_large = n\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\n\\t# Set up pinned memory for transfer\\n\\t#largebox_hs = cuda.aligned_empty(shape=shape, dtype=np.float32, alignment=resource.getpagesize())\\n\\tlargebox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.float32)\\n\\tlargecbox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.complex64)\\n\\n\\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\\n\\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\\n\\tprint \\\"init boxes\\\"\\n\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\t# MRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=meta_x*N**3)\\n\\t\\tinit_stitch(largebox_d, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\\n\\t\\tinit_stitch(largebox_d_imag, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\\n\\t\\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\t\\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\t\\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\\n\\t\\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\\n\\t\\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largecbox_pin.copy()\\n\\t#if want to get velocity need to use this\\n\\tif True:\\n\\t\\tprint \\\"saving kbox\\\"\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN), hbox_large)\\n\\n\\tprint \\\"Executing FFT on device\\\"\\n\\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\\n\\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\\n\\tprint hbox_large.dtype\\n\\tprint \\\"Finished FFT on device\\\"\\n\\tnp.save(parent_folder+\\\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN), hbox_large)\\n\\t\\n\\tif True:\\n\\t\\tprint \\\"loading kbox\\\"\\n\\t\\thbox_large = np.load(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN))\\n\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\\n\\t\\t#cuda.memcpy_htod_async(largebox_d, largebox_pin)\\n\\t\\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\tHII_filter(largebox_d, DIM, np.int32(meta_z), ZERO, smoothR, block=block_size, grid=stitch_grid_size);\\n\\t\\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largebox_d.get_async()\\n\\t#import IPython; IPython.embed()\\n\\tprint \\\"Executing FFT on host\\\"\\n\\t#hbox_large = hifft(hbox_large).astype(np.complex64).real\\n\\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\\n\\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\\n\\tprint \\\"Finished FFT on host\\\"\\n\\t#import IPython; IPython.embed()\\n\\n\\t# for meta_x in xrange(META_GRID_SIZE):\\n\\t# \\tfor meta_y in xrange(META_GRID_SIZE):\\n\\t# \\t\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t# \\t\\t\\tlargebox_d = gpuarray.to_gpu(hbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N])\\n\\t# \\t\\t\\tHII_filter(largebox_d, N, np.int32(meta_x), np.int32(meta_y), np.int32(meta_z), ZERO, smoothR, block=block_size, grid=grid_size);\\n\\t# \\t\\t\\thbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N] = largebox_d.get()\\n\\t#plan = Plan(shape, dtype=np.complex64)\\n\\t#plan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\n\\n\\t# This saves a large resolution deltax\\n\\n\\t\\n\\tprint \\\"downsampling\\\"\\n\\tsmallbox_d = gpuarray.zeros((HII_DIM,HII_DIM,M), dtype=np.float32)\\n\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\\n\\t\\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\\n\\t\\t#largebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\tlargebox_d /= scale**3 #\\n\\t\\tsubsample_kernel(largebox_d, smallbox_d, DIM, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size) #subsample in real space\\n\\t\\thbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallbox_d.get_async()\\n\\tnp.save(parent_folder+\\\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(HII_DIM, BOX_LEN), hbox_small)\\n\\t#import IPython; IPython.embed()\\n\\n\\n\\t# To get velocities: reload the k-space box\\n\\thbox_large = np.load(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN))\\n\\thvbox_large = np.zeros((DIM, DIM, DIM), dtype=np.float32)\\n\\thvbox_small = np.zeros(HII_shape, dtype=np.float32)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tlargevbox_d = gpuarray.zeros((DIM,DIM,N), dtype=np.complex64)\\n\\tsmallvbox_d = gpuarray.zeros((HII_DIM, HII_DIM, M), dtype=np.float32)\\n\\tfor num, mode in enumerate(['x', 'y', 'z']):\\n\\t\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\t\\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\t\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\t\\t\\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(meta_z), np.int32(num), block=block_size, grid=stitch_grid_size)\\n\\t\\t\\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=stitch_grid_size)\\n\\t\\t\\tprint hvbox_large.shape, largevbox_d.shape\\n\\t\\t\\thvbox_large[:, :, meta_z*N:(meta_z+1)*N] = largevbox_d.get_async()\\n\\t\\thvbox_large = fft_stitch(N, plan2d, plan1d, hvbox_large, largevbox_d).real\\n\\t\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\t\\tlargevbox_d = gpuarray.to_gpu_async(hvbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\t\\tsubsample_kernel(largevbox_d.real, smallvbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size)\\n\\t\\t\\thvbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallvbox_d.get_async()\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\\\".format(mode, HII_DIM, BOX_LEN), smallvbox_d.get())\\n\\n\\treturn\",\n \"def weight_list_rsexecute_workflow(vis_list, model_imagelist, gcfcf=None, weighting='uniform', robustness=0.0,\\n **kwargs):\\n if gcfcf is None:\\n gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(m, oversampling=1) for m in model_imagelist]\\n \\n def grid_wt(vis, model, g):\\n if vis is not None:\\n if model is not None:\\n griddata = create_griddata_from_image(model, vis)\\n if isinstance(vis, BlockVisibility):\\n griddata = grid_blockvisibility_weight_to_griddata(vis, griddata, g[0][1])\\n else:\\n griddata = grid_visibility_weight_to_griddata(vis, griddata, g[0][1])\\n \\n return griddata\\n else:\\n return None\\n else:\\n return None\\n \\n weight_list = [rsexecute.execute(grid_wt, pure=True, nout=1)(vis_list[i], model_imagelist[i],\\n gcfcf)\\n for i in range(len(vis_list))]\\n \\n merged_weight_grid = rsexecute.execute(griddata_merge_weights, nout=1)(weight_list)\\n merged_weight_grid = rsexecute.persist(merged_weight_grid, broadcast=True)\\n \\n def re_weight(vis, model, gd, g):\\n if gd is not None:\\n if vis is not None:\\n # Ensure that the griddata has the right axes so that the convolution\\n # function mapping works\\n agd = create_griddata_from_image(model, vis)\\n agd.data = gd[0].data\\n if isinstance(vis, BlockVisibility):\\n vis = griddata_blockvisibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\\n else:\\n vis = griddata_visibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\\n return vis\\n else:\\n return None\\n else:\\n return vis\\n \\n result = [rsexecute.execute(re_weight, nout=1)\\n (v, model_imagelist[i], merged_weight_grid, gcfcf)\\n for i, v in enumerate(vis_list)]\\n \\n return rsexecute.optimize(result)\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\\n\\t\\t# Active K-rotor\\n\\t\\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\\n\\t\\tif len(rotors) == 0:\\n\\t\\t\\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\\n\\t\\t\\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\t# Other modes\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tQ0 = mode.getPartitionFunction(Tlist)\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\treturn Q\",\n \"def init():\\n\\tN = np.int32(DIM) #prepare for stitching\\n\\t#HII_DIM = np.int32(HII_DIM)\\n\\tf_pixel_factor = DIM/HII_DIM;\\n\\tscale = np.float32(BOX_LEN)/DIM\\n\\tHII_scale = np.float32(BOX_LEN)/HII_DIM\\n\\tshape = (N,N,N)\\n\\t\\n\\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\\n\\n\\tkernel_source = open(cmd_folder+\\\"/initialize.cu\\\").read()\\n\\tkernel_code = kernel_source % {\\n\\n\\t\\t'DELTAK': DELTA_K,\\n\\t\\t'VOLUME': VOLUME,\\n\\t\\t'DIM': DIM\\n\\t}\\n\\tmain_module = nvcc.SourceModule(kernel_code)\\n\\tinit_kernel = main_module.get_function(\\\"init_kernel\\\")\\n\\tHII_filter = main_module.get_function(\\\"HII_filter\\\")\\n\\tadj_complex_conj = main_module.get_function(\\\"adj_complex_conj\\\")\\n\\tsubsample_kernel = main_module.get_function(\\\"subsample\\\")\\n\\tvelocity_kernel = main_module.get_function(\\\"set_velocity\\\")\\n\\tpspec_texture = main_module.get_texref(\\\"pspec\\\")\\n\\n\\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\\n\\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\\n\\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\\n\\n\\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\\n\\tinit_kernel(largebox_d, np.int32(DIM), block=block_size, grid=grid_size)\\n\\n\\t#import IPython; IPython.embed()\\n\\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\\n\\tinit_kernel(largebox_d_imag, np.int32(DIM), block=block_size, grid=grid_size)\\n\\n\\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\\n\\n\\t#adj_complex_conj(largebox_d, DIM, block=block_size, grid=grid_size)\\n\\tlargebox = largebox_d.get()\\n\\t#np.save(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc\\\".format(DIM, BOX_LEN), largebox)\\n\\n\\t#save real space box before smoothing\\n\\tplan = Plan(shape, dtype=np.complex64)\\n\\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\tlargebox_d /= scale**3\\n\\tnp.save(parent_folder+\\\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(DIM, BOX_LEN), largebox_d.real.get_async())\\n\\n\\t#save real space box after smoothing and subsampling\\n\\t# host largebox is still in k space, no need to reload from disk\\n\\tlargebox_d = gpuarray.to_gpu(largebox)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tHII_filter(largebox_d, N, ZERO, smoothR, block=block_size, grid=grid_size);\\n\\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\tlargebox_d /= scale**3\\n\\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\\n\\tsubsample_kernel(largebox_d.real, smallbox_d, N, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_grid_size) #subsample in real space\\n\\tnp.save(parent_folder+\\\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(HII_DIM, BOX_LEN), smallbox_d.get_async())\\n\\n\\t# reload the k-space box for velocity boxes\\n\\tlargebox_d = gpuarray.to_gpu(largebox)\\n\\t\\n\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tlargevbox_d = gpuarray.zeros((DIM,DIM,DIM), dtype=np.complex64)\\n\\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\\n\\tfor num, mode in enumerate(['x', 'y', 'z']):\\n\\t\\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(num), block=block_size, grid=grid_size)\\n\\t\\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=grid_size)\\n\\t\\tplan.execute(largevbox_d, inverse=True)\\n\\t\\tlargevbox_d /= scale**3\\n\\t\\t#import IPython; IPython.embed()\\n\\t\\tsubsample_kernel(largevbox_d.real, smallbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_grid_size)\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\\\".format(mode, HII_DIM, BOX_LEN), smallbox_d.get())\\n\\n\\treturn\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def ridge_cv(trn_fs, trn_data, val_fs=None, val_data=None, alphas=DEFAULT_ALPHAS, \\n n_resamps=10, n_splits=10, chunk_sz=5000, dtype=np.single,pthr=0.005,\\n square_alpha=False,is_verbose=False):\\n #def ridge_cv(model,data,n_splits=10,n_resamps=10,alpha=DEFAULT_ALPHAS,efficient=np.nan,):\\n # (trn_fs, trn_data, val_fs, val_data, alphas, nboots, chunklen, n_chunks, dtype=np.single, corrmin=0.2):\\n n_resp, n_voxels = trn_data.shape\\n _,n_channels = trn_fs.shape\\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\\n bestalphas = np.zeros((n_resamps, n_voxels)) ## Will hold the best alphas for each voxel\\n trn_idx,val_idx = _utils.contig_partition(trn_fs.shape[0],n_splits)\\n\\n Rcmats = np.zeros((n_voxels,len(alphas),n_resamps))\\n for iRpt,cvi in enumerate(np.random.permutation(n_splits)[:n_resamps]):\\n if is_verbose:\\n print('Running split %d/%d'%(iRpt+1,n_resamps))\\n ti,vi = trn_idx[cvi],val_idx[cvi]\\n trn_fs_split = trn_fs[ti,:]\\n val_fs_split = trn_fs[vi,:]\\n trn_data_split = trn_data[ti,:]\\n val_data_split = trn_data[vi,:]\\n \\n # Run ridge regression to estimate predictions (within training set) for different alphas\\n Rcmats[:,:,iRpt] = _fit_ridge_alpha(trn_fs_split, trn_data_split, val_fs_split, val_data_split, alphas,\\n dtype=dtype, chunk_sz=chunk_sz,pthr=pthr,square_alpha=square_alpha)\\n if is_verbose:\\n print(\\\"Finding best alpha...\\\")\\n ## Find best alpha for each voxel\\n #trncc_byvox = np.nansum(Rcmats,axis=2)/np.sum(np.logical_not(np.isnan(Rcmats)),axis=2)\\n trncc_byvox = np.nanmean(Rcmats,axis=2)\\n # Taking mean is BS: too many voxels poorly predicted, floor effect. \\n #mean_cv_corr = np.nanmean(mean_cv_corr_byvox,axis=0)\\n #bestalphaind = np.argmax(mean_cv_corr)\\n # Thus just count voxels over significance threshold (with a lenient threshold)\\n #print(len(vi))\\n sig_thresh = _sutils.pval2r(pthr,len(vi),is_two_sided=False)\\n n_sig_vox_byalpha = sum(trncc_byvox>sig_thresh)-sum(trncc_byvox<-sig_thresh)\\n bestalphaind = np.argmax(n_sig_vox_byalpha)\\n alpha = alphas[bestalphaind]\\n if is_verbose:\\n print(\\\"Best alpha = %0.3f\\\"%alpha)\\n \\n ## Find weights for each voxel\\n U,S,Vt = np.linalg.svd(trn_fs, full_matrices=False)\\n # Loop over groups of voxels\\n wt = np.zeros((n_channels,n_voxels),dtype=dtype)\\n\\n ###\\n if (not val_fs is None) and (not val_data is None):\\n # Validation data / model supplied implies we want predictions\\n do_pred = True\\n if np.sum(val_fs[:,0]) != val_fs.shape[0]:\\n warnings.warn('First column of val_fs is NOT all ones! Consider including a DC term!')\\n # Pre-allocate for predictions, with or without separate validation sequences to predict\\n is_rpts = np.ndim(val_data)==3\\n if is_rpts:\\n n_rpts,n_tps_val,n_voxels_val = val_data.shape\\n cc = np.zeros((n_rpts,n_voxels),dtype);\\n else:\\n n_rpts,(n_tps_val,n_voxels_val) = 0,val_data.shape\\n cc = np.zeros((n_voxels),dtype);\\n pred = np.zeros((n_tps_val,n_voxels_val),dtype)\\n else:\\n # No Validation data / model supplied\\n do_pred = False;\\n\\n if is_verbose:\\n predstr = ' and model predictions...' if do_pred else \\\"...\\\"\\n print('Computing weights'+predstr)\\n for iChunk in range(n_chunks):\\n if is_verbose:\\n print('Running chunk %d of %d...\\\\n'%(iChunk+1,n_chunks))\\n ChIdx = np.arange(chunk_sz) + chunk_sz*iChunk\\n ChIdx = ChIdx[ChIdx<n_voxels] # clip extra voxels in last run.\\n Ychunk = trn_data[:,ChIdx]\\n\\n UtYchunk = np.dot(U.T, np.nan_to_num(Ychunk))\\n if square_alpha:\\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha**2)), UtYchunk])\\n else:\\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha)), UtYchunk])\\n\\n ## Find test correlations if validation data is present\\n if do_pred:\\n # Compute correlations btw validation data and model prediction\\n pred[:,ChIdx] = val_fs.dot(wt[:,ChIdx]).astype(dtype) \\n nnpred = np.nan_to_num(pred[:,ChIdx])\\n if is_rpts:\\n # The transpose here is related to deep mysteries in python. See \\n cc[:,ChIdx] = np.vstack([_sutils.column_corr(nnpred,val_data[rpt,:,ChIdx].T) for rpt in range(n_rpts)])\\n else:\\n cc[ChIdx] = _sutils.column_corr(nnpred,val_data[:,ChIdx])\\n\\n # Output\\n out = dict(\\n weights=wt,\\n alpha=alpha,\\n n_sig_vox_byalpha=n_sig_vox_byalpha,\\n #trncc_byvox=trncc_byvox,f\\n #trncc_byvox_byalpha=Rcmats\\n )\\n if not val_data is None: \\n out['cc'] = cc\\n return out\",\n \"def compute_gain( hv, cv, thot, tcold):\\n\\n nData = len(cv) \\n epsilons = np.full( nData, EPSILON)\\n\\n # For full Temp calibration, a spectrum taken at high elevation, away from \\n # The galactic plan is used.\\n dv = hv - cv \\n dv = np.maximum( dv, epsilons)\\n hv = np.maximum( hv, epsilons)\\n\\n # use the comparison of hot and cold to get gain without trx contribution\\n gain = (thot - tcold)/dv\\n\\n trx = gain*cv \\n trx = trx - tcold # correct for cold load input in counts\\n\\n n6 = int(nData/6)\\n n56 = 5*n6\\n\\n trxmedian = np.median( trx[n6:n56])\\n gain = (thot + trxmedian)/hv\\n \\n return trxmedian, gain # channel by channel gain in K/counts\",\n \"def model(cp_list,cp_now):\\r\\n global record\\r\\n distance_threshold = 0.5\\r\\n model_path = \\\"trained_knn_model.clf\\\"\\r\\n \\r\\n # Load a trained KNN model (if one was passed in)\\r\\n with open(model_path, 'rb') as f:\\r\\n knn_clf = pickle.load(f)\\r\\n\\r\\n for X_img in cp_list:\\r\\n # Load image file and find face locations\\r\\n X_face_locations = face_recognition.face_locations(X_img)\\r\\n\\r\\n # If no faces are found in the image, return an empty result.\\r\\n if len(X_face_locations) == 0:\\r\\n return []\\r\\n\\r\\n # Find encodings for faces in the test iamge\\r\\n faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)\\r\\n\\r\\n # Use the KNN model to find the best matches for the test face\\r\\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\\r\\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]\\r\\n # Predict classes and remove classifications that aren't within the threshold\\r\\n for pred, rec in zip(knn_clf.predict(faces_encodings), are_matches):\\r\\n if rec:\\r\\n name = pred\\r\\n else:\\r\\n name = \\\"unknown\\\"\\r\\n if name not in record:\\r\\n end = datetime.now()\\r\\n record.append(name)\\r\\n record_time.append(end-cp_now)\",\n \"def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\\n pi, ids = induced_distribution(hmsm, 0, level)\\n\\n discrete_free_energy = np.ndarray(pi.shape)\\n for i, id in enumerate(ids):\\n discrete_free_energy[i] = \\\\\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\\n boltzmann = np.exp(-discrete_free_energy/kT)\\n boltzmann *= (1/np.sum(boltzmann))\\n return D_KL(boltzmann, pi)\",\n \"def kick_from_eccentric_tides(self):\\n\\n inv_r_7 = self.inv_r**7\\n r0_5 = self.pair[0].radius ** 5\\n r1_5 = self.pair[1].radius ** 5\\n m0_2 = self.pair[0].mass * self.pair[0].mass\\n m1_2 = self.pair[1].mass * self.pair[1].mass\\n\\n ftr = -3.0 * inv_r_7 * constants.G * ((m1_2 * r0_5 * self.pair[0].kaps + m0_2 * r1_5 * self.pair[1].kaps) + # Non-dissipative\\n 3 * self.inv_r * self.rdot_mag *\\n (m1_2 * r0_5 * self.pair[0].kaps * self.pair[0].taulag\\n + m0_2 * r1_5 * self.pair[1].kaps * self.pair[1].taulag)) # Dissipative\\n\\n hutforce = ftr * self.inv_r * self.pos\\n kick0 = (1.0 / self.pair[0].mass) * hutforce * self.dt\\n kick1 = (-1.0 / self.pair[1].mass) * hutforce * self.dt\\n\\n self.pair[0].velocity += kick0\\n self.pair[1].velocity += kick1\",\n \"def kViterbi(crf_obj, emissions, topK, mask):\\n assert topK >=1\\n if topK == 1:\\n seq_length = emissions.size(1)\\n best_path = crf_obj.decode(emissions, mask)\\n observation = pad_seq(best_path, seq_length, crf_obj.batch_first, 0)\\n best_probs = calculate_prob_byObser(crf_obj, emissions, observation, mask)\\n return best_path, best_probs.squeeze()\\n\\n crf_obj._validate(emissions, mask=mask)\\n if mask is None:\\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\\n if crf_obj.batch_first:\\n emissions = emissions.transpose(0, 1)\\n mask = mask.transpose(0, 1)\\n normalizer = crf_obj._compute_normalizer(emissions, mask)\\n # ===============start main part========================\\n # emissions: (seq_length, batch_size, num_tags)\\n # mask: (seq_length, batch_size)\\n assert emissions.dim() == 3 and mask.dim() == 2\\n assert emissions.shape[:2] == mask.shape\\n assert emissions.size(2) == crf_obj.num_tags\\n assert mask[0].all()\\n\\n seq_length, batch_size = mask.shape\\n\\n # Start transition and first emission\\n # score is a tensor of size(batch_size, num_tags, topK) where for each\\n # batch, value at tags i and top j stores the scores of the j-th best tag\\n # sequence so far that ends with tag i\\n #\\n # pre_states saves the previous tag where the j-th best path that ends with tag i currently\\n score = emissions.new_zeros((seq_length, batch_size, crf_obj.num_tags, topK))\\n score[0,:,:,0] = crf_obj.start_transitions + emissions[0] # batch x num_tags\\n\\n pre_states = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\\n for i in range(crf_obj.num_tags):\\n for b in range(batch_size):\\n for k in range(topK):\\n pre_states[0,b,i,k] = i # should be start transition\\n\\n # The ranking of multiple paths through same state\\n rank = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\\n for t in range(1, seq_length):\\n next_score_list = []\\n for k in range(topK):\\n broadcast_score = score[t-1,:,:,k].unsqueeze(2) #(batch_size, num_tags, 1)\\n broadcast_emissions = emissions[t].unsqueeze(1) #(batch_size, 1, num_tags)\\n\\n # Compute the score tensor of size (batch_size, num_tags, num_tags)\\n # where for each sample, entry at row i and column j stores\\n # the sum of scores of all possible tag sequences so far that end\\n # with transitioning from tag i to tag j and emitting\\n # shape: (batch_size, num_tags, num_tags)\\n next_score = broadcast_score + crf_obj.transitions + broadcast_emissions\\n next_score_list.append(next_score)\\n\\n for b in range(batch_size):\\n if mask[t,b]:\\n for cur_state in range(crf_obj.num_tags):\\n h = []\\n for pre_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n heapq.heappush(h, (-1*next_score_list[k][b, pre_state, cur_state], pre_state))\\n\\n # Get the sorted list\\n h_sorted = [heapq.heappop(h) for _ in range(topK)] #get topK path into cur_state\\n # We need to keep a ranking if a path crosses a state more than once\\n rankDict = dict()\\n # Retain the topK scoring paths\\n for k in range(topK):\\n score[t, b, cur_state, k] = score[t, b, cur_state, k] + (h_sorted[k][0].data * -1)\\n pre_states[t, b, cur_state, k] = h_sorted[k][1]\\n state = h_sorted[k][1]\\n if state in rankDict:\\n rankDict[state] = rankDict[state]+1\\n else:\\n rankDict[state] = 0\\n rank[t, b, cur_state, k] = rankDict[state]\\n else:\\n for cur_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n score[t, b, cur_state, k]=score[t-1, b, cur_state, k]\\n\\n\\n batch_path = []\\n batch_path_prob = []\\n seq_ends = mask.long().sum(dim=0) - 1 # seq_len x batch # assume seq_ends=8, seq_len=9\\n for b in range(batch_size):\\n h = []\\n for cur_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n heapq.heappush(h, ( -1 * (score[seq_ends[b], b, cur_state, k]+crf_obj.end_transitions[cur_state]),\\n cur_state, k))\\n h_sorted = [heapq.heappop(h) for _ in range(topK)]\\n k_list = np.zeros((topK, seq_ends[b]+1), int) # k x 9\\n k_list_probs = list()\\n for k in range(topK):\\n prob = h_sorted[k][0]\\n state = h_sorted[k][1]\\n rankK = h_sorted[k][2]\\n\\n k_list_probs.append((prob*-1)-(normalizer[b]))\\n k_list[k][seq_ends[b]] = state # assign index 8 == last one\\n for t in range(seq_ends[b]-1, -1, -1): # t = 7,6,5,4,3,2,1,0\\n nextState = k_list[k][t+1]\\n preState = pre_states[t+1, b, nextState, rankK]\\n k_list[k][t] = preState\\n rankK = rank[t+1,b,nextState,rankK]\\n batch_path.append(k_list.tolist())\\n batch_path_prob.append(k_list_probs)\\n if crf_obj.batch_first:\\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions.transpose(0,1), mask.transpose(0,1), topK)\\n else:\\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions, mask, topK)\\n return batch_path, batch_probs\",\n \"def metro_ising(L, T, h):\\n\\n lattice = transform_lattice(np.random.rand(N + 2, N + 2)) # +2 because of periodic bounds\\n ising_chain = [lattice]\\n m = 0\\n\\n for i in range(L):\\n rand_row = np.random.choice(index)\\n rand_col = np.random.choice(index)\\n\\n if H(ising_chain[i], rand_row, rand_col, h, T):\\n new_lattice = ising_chain[i].copy()\\n new_lattice[rand_row][rand_col] *= -1\\n ising_chain.append(transform_lattice(new_lattice))\\n else:\\n ising_chain.append(ising_chain[i])\\n\\n m += np.sum(ising_chain[i][1:N + 1, 1:N + 1]) # magnetization\\n\\n return m\",\n \"def cifarnet(images, candidate, N, F, num_classes=10, is_training=False,\\n dropout_keep_prob=0.5,\\n prediction_fn=slim.softmax,\\n scope='CifarNet'):\\n end_points = {}\\n assert len(candidate) == 20\\n\\n with tf.variable_scope(scope, 'CifarNet', [images]):\\n net = images\\n cell_id = -2\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n for i in xrange(N):\\n net = build_cell(end_points, cell_id, candidate, F, stride = 1, scope = 'Normal_cell_{}'.format(cell_id),is_training=is_training)\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n net = build_cell(end_points, cell_id, candidate, F, stride = 2, scope = 'Reduction_cell_{}'.format(cell_id),is_training=is_training)\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n F = F * 2\\n\\n for i in xrange(N):\\n net = build_cell(end_points, cell_id, candidate, F, stride = 1, scope = 'Normal_cell_{}'.format(cell_id),is_training=is_training)\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n net = build_cell(end_points, cell_id, candidate, F, stride = 2, scope = 'Reduction_cell_{}'.format(cell_id),is_training=is_training)\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n F = F * 2\\n\\n for i in xrange(N):\\n net = build_cell(end_points, cell_id, candidate, F, stride = 1, scope = 'Normal_cell_{}'.format(cell_id),is_training=is_training)\\n end_points['cell_{}'.format(cell_id)] = net\\n cell_id += 1\\n\\n net = tf.reduce_mean(net, [1, 2], name='global_pool', keep_dims=False)\\n\\n if not num_classes:\\n return net, end_points\\n logits = slim.fully_connected(net, num_classes,\\n biases_initializer=tf.zeros_initializer(),\\n weights_initializer=trunc_normal(1/192.0),\\n weights_regularizer=None,\\n activation_fn=None,\\n scope='logits',\\n trainable = is_training)\\n\\n end_points['Logits'] = logits\\n end_points['Predictions'] = prediction_fn(logits, scope='Predictions')\\n\\n return logits, end_points\",\n \"def set_voltages(): \\n #0) set parameters\\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\\n import pickle\\n with open(trapFile,'rb') as f:\\n trap = pickle.load(f)\\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\\n tc=trap.configuration\\n C = tc.multipoleControl\\n el = []\\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\\n if tc.trap_knobs != True:\\n return 'WARNING: You must run trap_knobs first!'\\n #2a) determine electrode voltages directly\\n elif multipoleControls: # note plurality to contrast from attribute\\n el = np.dot(C,coefs.T) # these are the electrode voltages\\n #2b) determine electrode volages indirectly\\n else:\\n charge = tc.charge\\n mass = tc.mass\\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\\n U2 = az*V0/8\\n U1 = U2+ax*V0/4\\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\\n U1p= np.sqrt(U1**2+U3**2/2)\\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\\n mCf = tc.multipoleCoefficients[1:9,:]\\n el = np.dot(mCf.T,inp) # these are the electrode voltages\\n el = np.real(el)\\n #3) regularize if set to do so\\n reg = 0\\n if reg: \\n C = el\\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\\n Lambda=Lambda[0]\\n el = el-(np.dot(tc.multipoleKernel,Lambda))\\n return el\",\n \"def compute_autocorrelation_rlzn_ensemble(fopen_list, te):\\n print 'Compute the autocorrelation'\\n\\n # initialize components of rho\\n sumuu = 0.0\\n sumvv = 0.0\\n\\n psiuu = 0.0\\n psivv = 0.0\\n\\n sumup2 = 0.0\\n sumvp2 = 0.0\\n\\n # get characteristics of mean velocity field\\n fbs = netCDF4.Dataset('buoyancySurface.nc','r')\\n lonCell = fbs.variables['lonCell']\\n latCell = fbs.variables['latCell']\\n lon = np.degrees(np.mod(lonCell[:]+np.pi,2*np.pi)-np.pi)\\n lat = np.degrees(latCell[:])\\n hull = spatial.ConvexHull(np.vstack((lon,lat)).T) \\n triang = Triangulation(lon,lat)\\n buoy_surf_zonal = fbs.variables['buoyancySurfaceVelocityZonal']\\n buoy_surf_merid = fbs.variables['buoyancySurfaceVelocityMeridional']\\n\\n \\n # build up layers for interpolation of particle layers\\n interp_zonal = []\\n interp_merid = []\\n nlayers = len(fbs.dimensions['nBuoyancySurfaces'])\\n for alayer in np.arange(nlayers):\\n interp_zonal.append(LinearTriInterpolator(triang, buoy_surf_zonal[0,:,alayer]))\\n interp_merid.append(LinearTriInterpolator(triang, buoy_surf_merid[0,:,alayer]))\\n\\n for num, afile in enumerate(fopen_list):\\n print 'working on %d' % num\\n # interpolate mean velocities onto points for the computation\\n x = afile.variables['xParticle'][:te,:]\\n y = afile.variables['yParticle'][:te,:]\\n z = afile.variables['zParticle'][:te,:]\\n latr, lonr = proj_lat_long(x,y,z)\\n latr = np.degrees(latr)\\n lonr = np.degrees(lonr)\\n\\n ubar = np.zeros(x.shape)\\n vbar = np.zeros(x.shape)\\n nparticle_layer = x.shape[1]/nlayers\\n for alayer in np.arange(nlayers):\\n ps = np.arange(alayer*nparticle_layer,(alayer+1)*nparticle_layer)\\n ubar[:,ps] = interp_zonal[alayer](lonr[:,ps],latr[:,ps])\\n vbar[:,ps] = interp_merid[alayer](lonr[:,ps],latr[:,ps])\\n\\n # compute portions of autocorrelation\\n u = afile.variables['lonVel'][:te,:]\\n up = u - ubar\\n up0 = up[0,:]\\n\\n v = afile.variables['latVel'][:te,:]\\n vp = v - vbar\\n vp0 = vp[0,:]\\n\\n sumuu += up0*up\\n sumvv += vp0*vp\\n\\n psiuu += up0*up0\\n psivv += vp0*vp0\\n \\n sumup2 += np.nanmean(up**2.0, axis=0)\\n sumvp2 += np.nanmean(vp**2.0, axis=0)\\n \\n\\n fbs.close()\\n\\n # note division by psi removes need to divide the sums by the number of realizations\\n sumuu /= psiuu \\n sumvv /= psivv\\n\\n sumup2 /= len(fopen_list)\\n sumvp2 /= len(fopen_list)\\n\\n print 'done'\\n\\n return sumuu, sumvv, sumup2, sumvp2, lonr[0,:], latr[0,:], lon, lat, hull\",\n \"def ALIGNF(km_list, ky):\\n n_feat = len(km_list)\\n\\n #km_list_copy = []\\n # center the kernel first\\n #for i in range(n_feat):\\n # km_list_copy.append(center(km_list[i].copy()))\\n #ky_copy = center(ky.copy())\\n\\n\\n a = np.zeros(n_feat)\\n for i in range(n_feat):\\n a[i] = f_dot(km_list[i], ky)\\n\\n M = np.zeros((n_feat, n_feat))\\n for i in range(n_feat):\\n for j in range(i,n_feat):\\n M[i,j] = f_dot(km_list[i],km_list[j])\\n M[j,i] = M[i,j]\\n\\n Q = 2*M\\n C = -2*a\\n\\n Q = Q + np.diag(np.ones(n_feat)*1e-8)\\n\\n ################################################\\n # Using mosek to solve the quadratice programming\\n\\n # Set upper diagonal element to zeros, mosek only accept lower triangle\\n iu = np.triu_indices(n_feat,1)\\n Q[iu] = 0\\n\\n # start solving with mosek\\n inf = 0.0\\n env = mosek.Env()\\n env.set_Stream(mosek.streamtype.log, streamprinter)\\n\\n # Create a task \\n task = env.Task()\\n task.set_Stream(mosek.streamtype.log, streamprinter)\\n\\n # Set up bound for variables \\n bkx = [mosek.boundkey.lo]* n_feat\\n blx = [0.0] * n_feat\\n #bkx = [mosek.boundkey.fr]* n_feat\\n #blx = [-inf] * n_feat\\n bux = [+inf] * n_feat\\n\\n numvar = len(bkx)\\n\\n task.appendvars(numvar)\\n\\n for j in range(numvar):\\n task.putcj(j,C[j])\\n task.putvarbound(j,bkx[j],blx[j],bux[j])\\n\\n # Set up quadratic objective \\n inds = np.nonzero(Q)\\n qsubi = inds[0].tolist()\\n qsubj = inds[1].tolist()\\n qval = Q[inds].tolist()\\n\\n # Input quadratic objective \\n task.putqobj(qsubi,qsubj,qval)\\n\\n # Input objective sense (minimize/mximize) \\n task.putobjsense(mosek.objsense.minimize)\\n\\n task.optimize()\\n\\n # Print a summary containing information \\n # about the solution for debugging purposes \\n task.solutionsummary(mosek.streamtype.msg)\\n\\n solsta = task.getsolsta(mosek.soltype.itr)\\n if (solsta == mosek.solsta.optimal or\\n solsta == mosek.solsta.near_optimal):\\n # Output a solution \\n xx = np.zeros(numvar, float)\\n task.getxx(mosek.soltype.itr, xx)\\n #xx = xx/np.linalg.norm(xx)\\n return xx\\n else:\\n print solsta\\n xx = np.zeros(numvar, float)\\n task.getxx(mosek.soltype.itr, xx)\\n #xx = xx/np.linalg.norm(xx)\\n return xx\",\n \"def getContSpec(par):\\n # read input\\n if par['verbose']:\\n print('\\\\n(*) Start\\\\n(*) Loading Data File: {}...'.format(par['GexpFile']))\\n\\n # t, Gexp = GetExpData(par['GexpFile'])\\n t, Gexp, wexp = GetExpData(par['GexpFile'])\\n\\n if par['verbose']:\\n print('(*) Initial Set up...', end=\\\"\\\")\\n \\n # Set up some internal variables\\n n = len(t)\\n ns = par['ns'] # discretization of 'tau'\\n\\n tmin = t[0];\\n tmax = t[n-1];\\n \\n # determine frequency window\\n if par['FreqEnd'] == 1:\\n smin = np.exp(-np.pi/2) * tmin; smax = np.exp(np.pi/2) * tmax\\t\\t\\n elif par['FreqEnd'] == 2:\\n smin = tmin; smax = tmax\\t\\t\\t\\t\\n elif par['FreqEnd'] == 3:\\n smin = np.exp(+np.pi/2) * tmin; smax = np.exp(-np.pi/2) * tmax\\t\\t\\n\\n hs = (smax/smin)**(1./(ns-1))\\n s = smin * hs**np.arange(ns)\\n \\n kernMat = getKernMat(s, t)\\n tic = time.time()\\n \\n # get an initial guess for Hgs, G0\\n if par['plateau']:\\n Hgs, G0 = InitializeH(Gexp, wexp, s, kernMat, np.min(Gexp))\\t\\t\\n else:\\n Hgs = InitializeH(Gexp, wexp, s, kernMat)\\n \\n if par['verbose']:\\n te = time.time() - tic\\n print('\\\\t({0:.1f} seconds)\\\\n(*) Building the L-curve ...'.format(te), end=\\\"\\\")\\t\\n tic = time.time()\\n\\n # Find Optimum Lambda with 'lcurve'\\n if par['lamC'] == 0:\\n if par['plateau']:\\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par, G0)\\n else:\\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par)\\n else:\\n lamC = par['lamC']\\n\\n if par['verbose']:\\n te = time.time() - tic\\n print('({1:.1f} seconds)\\\\n(*) Extracting CRS, ...\\\\n\\\\t... lamC = {0:0.3e}; '.\\n format(lamC, te), end=\\\"\\\")\\n \\n tic = time.time()\\n\\n # Get the best spectrum\\t\\n if par['plateau']:\\n H, G0 = getH(lamC, Gexp, wexp, Hgs, kernMat, G0);\\n print('G0 = {0:0.3e} ...'.format(G0), end=\\\"\\\")\\n else:\\n H = getH(lamC, Gexp, wexp, Hgs, kernMat);\\n\\n #----------------------\\n # Print some datafiles\\n #----------------------\\n\\n if par['verbose']:\\n te = time.time() - tic\\n print('done ({0:.1f} seconds)\\\\n(*) Writing and Printing, ...'.format(te), end=\\\"\\\")\\n\\n # Save inferred G(t)\\n if par['plateau']:\\n K = kernel_prestore(H, kernMat, G0);\\t\\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e', header='G0 = {0:0.3e}'.format(G0))\\n else:\\n K = kernel_prestore(H, kernMat);\\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e')\\n \\n np.savetxt('output/Gfit.dat', np.c_[t, K], fmt='%e')\\n\\n # print Hlam, rho-eta, and logP if lcurve has been visited\\n if par['lamC'] == 0:\\n if os.path.exists(\\\"output/Hlam.dat\\\"):\\n os.remove(\\\"output/Hlam.dat\\\")\\n \\n fHlam = open('output/Hlam.dat','ab')\\n for i, lamb in enumerate(lam):\\n np.savetxt(fHlam, Hlam[:,i])\\t\\n fHlam.close()\\t\\n\\n # print logP\\n np.savetxt('output/logPlam.dat', np.c_[lam, logP])\\n \\n # print rho-eta\\n np.savetxt('output/rho-eta.dat', np.c_[lam, rho, eta], fmt='%e')\\n\\n #------------\\n # Graphing\\n #------------\\n\\n if par['plotting']:\\n\\n # plot spectrum \\\"H.pdf\\\" with errorbars\\n plt.clf()\\n\\n plt.semilogx(s,H,'o-')\\n plt.xlabel(r'$s$')\\n plt.ylabel(r'$H(s)$')\\n\\n # error bounds are only available if lcurve has been implemented\\n if par['lamC'] == 0:\\n plam = np.exp(logP); plam = plam/np.sum(plam)\\t\\t\\t\\n Hm = np.zeros(len(s))\\n Hm2 = np.zeros(len(s))\\n cnt = 0\\n for i in range(len(lam)):\\t\\n #~ Hm += plam[i]*Hlam[:,i]\\n #~ Hm2 += plam[i]*Hlam[:,i]**2\\n # count all spectra within a threshold\\n if plam[i] > 0.1:\\n Hm += Hlam[:,i]\\n Hm2 += Hlam[:,i]**2\\n cnt += 1\\n\\n Hm = Hm/cnt\\n dH = np.sqrt(Hm2/cnt - Hm**2)\\n\\n plt.semilogx(s,Hm+2.5*dH, c='gray', alpha=0.5)\\n plt.semilogx(s,Hm-2.5*dH, c='gray', alpha=0.5)\\n\\n plt.tight_layout()\\n plt.savefig('output/H.pdf')\\n\\n\\n #\\n # plot comparison with input spectrum\\n #\\n\\n plt.clf()\\n\\n if par['plateau']:\\n K = kernel_prestore(H, kernMat, G0);\\t\\n else:\\n K = kernel_prestore(H, kernMat);\\n\\n plt.loglog(t, Gexp,'o',t, K, 'k-')\\n plt.xlabel(r'$t$')\\n plt.ylabel(r'$G(t)$')\\n plt.tight_layout()\\n plt.savefig('output/Gfit.pdf')\\n\\n\\n #\\n # if lam not explicitly specified then print rho-eta.pdf\\n #\\n\\n try:\\n lam\\n except NameError:\\n print(\\\"lamC prespecified, so not printing rho-eta.pdf/dat\\\")\\n else:\\n plt.clf()\\n plt.scatter(rho, eta, marker='x')\\n plt.plot(rho, eta)\\n\\n\\n rhost = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(rho)))\\n etast = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(eta)))\\n\\n plt.plot(rhost, etast, 'o', color='k')\\n plt.xscale('log')\\n plt.yscale('log')\\n \\n #~ print(rhost, etast)\\n \\n plt.xlabel(r'$\\\\rho$')\\n plt.ylabel(r'$\\\\eta$')\\n plt.tight_layout()\\n plt.savefig('output/rho-eta.pdf')\\n\\n if par['verbose']:\\n print('done\\\\n(*) End\\\\n')\\n \\n return H, lamC\",\n \"def solve(list_k, examples, out_path, centers_=None,\\n conf_num=None, out_minus=True, out_iterations=False):\\n\\n # start_centers = utils.get_centers()\\n dimension = len(examples[0][0])\\n # print (dimension)\\n N = len(examples) # print(N)\\n for k in list_k:\\n # sys.stderr.write(str(k) + \\\"\\\\n\\\")\\n h = np.zeros((N, k), dtype=np.float64)\\n # responsibilities.fill(1/float(k))\\n pi_k = np.zeros(k, dtype=np.float64)\\n pi_k.fill(1/float(k))\\n # print\\n configuration = False\\n if centers_ == None:\\n centers = utils.get_centers(k, examples)\\n else:\\n centers = centers_\\n configuration = True\\n\\n matrix = np.identity(dimension, dtype=np.float64)\\n matrices = np.array([matrix] * k)\\n # print (matrices)\\n log = calc_log(examples, centers, matrices, pi_k)\\n # print (log)\\n\\n # output stuff\\n num_iter = 0\\n # if k == 4:\\n # groups = [list([])] * k\\n groups = []\\n for i in range(k):\\n groups.append([])\\n probabilities = dict()\\n\\n # if k == 4:\\n # print (h)\\n # print (pi_k)\\n # print (matrices)\\n # print (centers)\\n\\n if out_iterations:\\n iter_out = open(out_path + \\\"em-kmeans.dat\\\", \\\"w\\\")\\n iter_out.write(\\\"#iteracije: log-izglednost\\\\n\\\")\\n iter_out.write(\\\"--\\\\n\\\")\\n iter_out.write(\\\"#0: %.2lf\\\\n\\\" % log)\\n # buffer_all = \\\"K = %d\\\\n\\\" % k\\n # number of members in a certain group\\n\\n while True:\\n num_iter += 1\\n group_count = [0] * k\\n # init = dict()\\n group_dicts = []\\n for i in range(k):\\n group_dicts.append({})\\n # group_dicts = [] * k\\n # E step\\n # print (num_iter)\\n # changed = 0\\n for i in range(N):\\n x = examples[i][0]\\n mi_j = centers[0][0]\\n sigma_j = matrices[0]\\n p = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[0]\\n h[i][0] = p\\n sum_h = h[i][0]\\n probabilities[i] = p\\n group = examples[i][1]\\n if group not in group_dicts[0]:\\n group_dicts[0][group] = 1\\n else:\\n group_dicts[0][group] += 1\\n\\n # if p > \\n group_count[0] += 1\\n examples[i][2] = 0\\n\\n for j in range(1,k):\\n mi_j = centers[j][0]\\n sigma_j = matrices[j]\\n # print (sigma_j)\\n p2 = utils.multivariate_probability(x, mi_j, sigma_j, dimension) * pi_k[j]\\n if p2 > p:\\n group_count[examples[i][2]] -= 1\\n group_dicts[examples[i][2]][group] -= 1\\n if group not in group_dicts[j]:\\n group_dicts[j][group] = 1\\n else:\\n group_dicts[j][group] += 1\\n examples[i][2] = j\\n group_count[j] += 1\\n p = p2\\n probabilities[i] = p\\n\\n h[i][j] = p2\\n sum_h += h[i][j]\\n\\n h[i] /= sum_h\\n probabilities[i] /= sum_h\\n # print (\\\"$$$$$$$\\\")\\n # M step\\n # if num_iter == 1:\\n # print (h)\\n # sys.exit(1)\\n for i in range(k):\\n new_mi = np.zeros(dimension, dtype=np.float64)\\n sum_h = 0.\\n new_sigma = np.zeros((dimension, dimension), dtype=np.float64)\\n\\n for j in range(N):\\n x = examples[j][0]\\n sum_h += h[j][i]\\n new_mi += h[j][i] * x\\n\\n new_mi /= sum_h\\n # if utils.euclid(new_mi, centers[i][0]) > EPS:\\n # changed = 1\\n centers[i] = (new_mi, centers[i][1], centers[i][2])\\n\\n # mi = np.matrix(new_mi)\\n mi = new_mi\\n for j in range(N):\\n x = examples[j][0]\\n # print ((x-mi).T * (x - mi))\\n diff = np.matrix(x - mi)\\n # print (diff.T * diff)\\n new_sigma += h[j][i] * (diff.T * diff)\\n # break\\n\\n new_sigma /= sum_h\\n matrices[i] = new_sigma\\n new_pi = sum_h / float(N)\\n pi_k[i] = new_pi\\n\\n # print (matrices)\\n # if num_iter == 1:\\n # sys.exit(1)\\n\\n new_log = calc_log(examples, centers, matrices, pi_k)\\n\\n # print (new_log)\\n if abs(new_log - log) < EPS:\\n break\\n log = new_log\\n # if k == 4:\\n # print (log)\\n if out_iterations:\\n iter_out.write(\\\"#%d: %.2lf\\\\n\\\" % (num_iter, log))\\n # if changed == 0:\\n # break\\n\\n # set the groups for K = 4\\n # print (groups)\\n if not configuration and not out_iterations:\\n if k == 4:\\n for i in range(N):\\n # print (examples[i][2])\\n # print (groups)\\n groups[examples[i][2]].append((examples[i][1], probabilities[i]))\\n\\n with open(out_path + \\\"/em-k4.dat\\\", \\\"a\\\") as f:\\n for i in range(k):\\n # print (len(groups[i]))\\n groups[i] = sorted(groups[i], key=lambda tup: tup[1], reverse=True)\\n f.write(\\\"Grupa %d:\\\\n\\\" % (i+1))\\n for j in range(len(groups[i])):\\n f.write(groups[i][j][0] + \\\" %.2lf\\\\n\\\" % groups[i][j][1])\\n if i < k-1:\\n f.write(\\\"--\\\\n\\\")\\n\\n with open(out_path + \\\"/em-all.dat\\\", \\\"a\\\") as f:\\n f.write(\\\"K = %d\\\\n\\\" % k)\\n for i in range(k):\\n f.write(\\\"c%d:\\\" % (i+1))\\n for j in range(dimension):\\n f.write(\\\" %.2lf\\\" % centers[i][0][j])\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"grupa %d: %d primjera\\\\n\\\" % ((i+1), group_count[i]))\\n f.write(\\\"#iter: %d\\\\n\\\" % num_iter)\\n f.write(\\\"log-izglednost: %.2lf\\\\n\\\" % log)\\n if k < 5:\\n f.write(\\\"--\\\\n\\\")\\n elif not out_iterations:\\n with open(out_path + \\\"/em-konf.dat\\\", \\\"a\\\") as f:\\n f.write(\\\"Konfiguracija %d:\\\\n\\\" % conf_num)\\n f.write(\\\"log-izglednost: %.2lf\\\\n\\\" % log)\\n f.write(\\\"#iteracija: %d\\\\n\\\" % num_iter)\\n if out_minus == True:\\n f.write(\\\"--\\\\n\\\")\\n # if i < k - 1:\\n else:\\n iter_out.write(\\\"--\\\\n\\\")\\n for i in range(len(group_dicts)):\\n iter_out.write(\\\"Grupa %d:\\\" % (i+1))\\n buff = \\\"\\\"\\n for key in group_dicts[i]:\\n buff += \\\" \\\" + key + \\\" %d\\\" % group_dicts[i][key] + \\\",\\\"\\n\\n buff = buff[:-1]\\n iter_out.write(buff + \\\"\\\\n\\\")\\n # pass\",\n \"def fit(self):\\n N = self.data.shape\\n prev_k = 1\\n k_lst = []\\n k_list = self.tt_ranks.copy()\\n if self.model=='tt': depth = len(N)-1\\n elif self.model=='tk': depth = len(N)\\n\\n for axis in range(depth):\\n if self.global_rank==0: print('Decomposing for stage=',axis+1)\\n if self.model=='tt':\\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([prev_k * N[axis], -1])\\n elif self.model=='tk':\\n k_lst.append(prev_k)\\n self.data = tn_data_operations(self.comm1,self.fpath,self.data).dist_reshape([N[axis], np.product(k_lst)*np.product(N[axis+1:])])\\n\\n if np.any(k_list) != False:\\n self.this_k = k_list[axis]\\n else:\\n if self.global_rank==0: print('Estimating rank now with SVD...')\\n self.this_k = self.determine_rank(self.data, self.err)\\n\\n if self.routine=='nmf':\\n self.params.k = self.this_k\\n if self.global_rank==0: print('Performing NMF for TN stage=',axis+1)\\n W, H, rel_error = PyNMF(self.data, factors=None, params=self.params).fit()\\n\\n elif self.routine=='svd':\\n if self.global_rank == 0: print('Performing SVD for TN stage=', axis + 1)\\n singularValues, U, V,rel_error = self.compute_svd(self.data,self.this_k)\\n S = np.diag(singularValues)\\n W = U\\n H = S @ V\\n\\n if self.model=='tt':\\n self.factors.append(np.reshape(W, (prev_k, N[axis], self.this_k)))\\n elif self.model=='tk':\\n self.factors.append(W)\\n if axis==depth-1:\\n H_final = np.hstack((self.comm.allgather(H)))\\n if self.model=='tk':\\n k_lst.append(self.this_k)\\n H_final = np.reshape(H_final,k_lst[1:])\\n # H_final = np.hstack((block_idx_rank_H_tran(H_final,1, self.size)))\\n self.factors.append(H_final)\\n self.rel_error.append(rel_error)\\n prev_k = self.this_k\\n fpath = 'data/H_factor.zarr'\\n self.data = tn_data_operations(self.comm1,fpath,H).lazy_store_file()\",\n \"def fit_FITC(self, Kmm, Kmn, Knn_diag):\\r\\n num_inducing = Kmm.shape[0]\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Prior approximation parameters:\\r\\n q(f|X) = int_{df}{N(f|KfuKuu_invu,diag(Kff-Qff)*N(u|0,Kuu)} = N(f|0,Sigma0)\\r\\n Sigma0 = diag(Knn-Qnn) + Qnn, Qnn = Knm*Kmmi*Kmn\\r\\n \\\"\\\"\\\"\\r\\n Lm = jitchol(Kmm)\\r\\n Lmi = chol_inv(Lm)\\r\\n Kmmi = np.dot(Lmi.T,Lmi)\\r\\n P0 = Kmn.T\\r\\n KmnKnm = np.dot(P0.T, P0)\\r\\n KmmiKmn = np.dot(Kmmi,P0.T)\\r\\n Qnn_diag = np.sum(P0.T*KmmiKmn,-2)\\r\\n Diag0 = Knn_diag - Qnn_diag\\r\\n R0 = jitchol(Kmmi).T\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Posterior approximation: q(f|y) = N(f| mu, Sigma)\\r\\n Sigma = Diag + P*R.T*R*P.T + K\\r\\n mu = w + P*Gamma\\r\\n \\\"\\\"\\\"\\r\\n self.w = np.zeros(self.N)\\r\\n self.Gamma = np.zeros(num_inducing)\\r\\n mu = np.zeros(self.N)\\r\\n P = P0.copy()\\r\\n R = R0.copy()\\r\\n Diag = Diag0.copy()\\r\\n Sigma_diag = Knn_diag\\r\\n RPT0 = np.dot(R0,P0.T)\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(g|mu_,sigma2_) = Product{q_i(g|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.N,dtype=float)\\r\\n self.v_ = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.N,dtype=float)\\r\\n self.Z_hat = np.empty(self.N,dtype=float)\\r\\n phi = np.empty(self.N,dtype=float)\\r\\n mu_hat = np.empty(self.N,dtype=float)\\r\\n sigma2_hat = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = 1\\r\\n epsilon_np2 = 1\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.N)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma_diag[i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma_diag[i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma_diag[i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma_diag[i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n dtd1 = Delta_tau*Diag[i] + 1.\\r\\n dii = Diag[i]\\r\\n Diag[i] = dii - (Delta_tau * dii**2.)/dtd1\\r\\n pi_ = P[i,:].reshape(1,num_inducing)\\r\\n P[i,:] = pi_ - (Delta_tau*dii)/dtd1 * pi_\\r\\n Rp_i = np.dot(R,pi_.T)\\r\\n RTR = np.dot(R.T,np.dot(np.eye(num_inducing) - Delta_tau/(1.+Delta_tau*Sigma_diag[i]) * np.dot(Rp_i,Rp_i.T),R))\\r\\n R = jitchol(RTR).T\\r\\n self.w[i] += (Delta_v - Delta_tau*self.w[i])*dii/dtd1\\r\\n self.Gamma += (Delta_v - Delta_tau*mu[i])*np.dot(RTR,P[i,:].T)\\r\\n RPT = np.dot(R,P.T)\\r\\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\\r\\n mu = self.w + np.dot(P,self.Gamma)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Iplus_Dprod_i = 1./(1.+ Diag0 * self.tau_tilde)\\r\\n Diag = Diag0 * Iplus_Dprod_i\\r\\n P = Iplus_Dprod_i[:,None] * P0\\r\\n safe_diag = np.where(Diag0 < self.tau_tilde, self.tau_tilde/(1.+Diag0*self.tau_tilde), (1. - Iplus_Dprod_i)/Diag0)\\r\\n L = jitchol(np.eye(num_inducing) + np.dot(RPT0,safe_diag[:,None]*RPT0.T))\\r\\n R,info = dtrtrs(L,R0,lower=1)\\r\\n RPT = np.dot(R,P.T)\\r\\n Sigma_diag = Diag + np.sum(RPT.T*RPT.T,-1)\\r\\n self.w = Diag * self.v_tilde\\r\\n self.Gamma = np.dot(R.T, np.dot(RPT,self.v_tilde))\\r\\n mu = self.w + np.dot(P,self.Gamma)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def setCtrls(self, fks, ik, upv):\\n # type: (list[str], str, str) -> None\\n\\n self.fkCtrls = [self._getNode(x) for x in fks]\\n self.fkTargets = [self._getMth(x) for x in fks]\\n\\n self.ikCtrl = self._getNode(ik)\\n self.ikTarget = self._getMth(ik)\\n\\n self.upvCtrl = self._getNode(upv)\\n self.upvTarget = self._getMth(upv)\\n\\n self.ikRotCtrl = self._getNode(ik.replace(\\\"_ik_\\\", \\\"_rot_\\\"))\\n self.ikRotTarget = self.ikTarget\",\n \"def mtvsolverbis(Hurstaest_init, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0, wtype=1, lipschitz_constant=0):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurstaest_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = H_size * lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(estimation):\\n return fbis(estimation, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(estimation[:H_size / 2],\\n mask))\\n\\n def unmaskvec(estimation):\\n return _unmask(estimation, mask)\\n\\n def maskvec(estimation):\\n return estimation[flat_mask]\\n\\n def f1_grad(estimation):\\n return gradfbis(estimation, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(estimation, stepsize, dgap_tol, init):\\n lenw = len(estimation)\\n Hurst = estimation[lenw / 2:]\\n init = unmaskvec(init[:lenw / 2]) if not init is None else init\\n\\n out, info = _prox_tvl1(unmaskvec(Hurst),\\n weight=(l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=init,\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return np.concatenate((maskvec(out.ravel()),estimation[lenw / 2:])), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def rk5(accel,m,r,h,v):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n \\n return new_v5, new_r5\",\n \"def HPI_update(task, subject, block, data, precision='0.5cm', opt='start', reject_head_mvt=True):\\r\\n \\r\\n #==============================================================================\\r\\n hc_path = op.join(Analysis_path, task, 'meg', 'Coregistration', subject)\\r\\n #==============================================================================\\r\\n \\r\\n # Find the .hc file corresponding to this block\\r\\n hc_files = glob.glob(op.join(hc_path, '*{}*_{}*.hc'.format(precision,block)))\\r\\n hc_file = ''\\r\\n if len(hc_files) > 1:\\r\\n for hc in hc_files:\\r\\n if not opt and not '+' in hc:\\r\\n hc_file = hc\\r\\n continue\\r\\n if opt and opt in hc:\\r\\n hc_file = hc\\r\\n continue\\r\\n if not hc_file:\\r\\n hc_file = hc_files[0]\\r\\n warnings.warn(\\\"Multiple .hc files found, none matching the desired option. Using {}.\\\".format(hc_file))\\r\\n else:\\r\\n hc_file = hc_files[0]\\r\\n \\r\\n bs_fname = hc_file[:-3] + '-bad.segments' + block\\r\\n bads = False\\r\\n if os.stat(bs_fname).st_size > 0:\\r\\n bad_segments = pd.read_table(bs_fname, header=None)\\r\\n bads = True\\r\\n \\r\\n # Read and load the content of the .hc file \\r\\n#==============================================================================\\r\\n with open(hc_file) as f:\\r\\n content = f.readlines()\\r\\n\\r\\n content = [x.strip() for x in content] \\r\\n \\r\\n Nasion_ctf = [0,0,0,1]\\r\\n Left_ctf = [0,0,0,1]\\r\\n Right_ctf = [0,0,0,1]\\r\\n \\r\\n Nasion_ctf[0] = float(content[25].strip('x = '))\\r\\n Nasion_ctf[1] = float(content[26].strip('y = '))\\r\\n Nasion_ctf[2] = float(content[27].strip('z = '))\\r\\n \\r\\n Left_ctf[0] = float(content[29].strip('x = '))\\r\\n Left_ctf[1] = float(content[30].strip('y = '))\\r\\n Left_ctf[2] = float(content[31].strip('z = '))\\r\\n \\r\\n Right_ctf[0] = float(content[33].strip('x = '))\\r\\n Right_ctf[1] = float(content[34].strip('y = '))\\r\\n Right_ctf[2] = float(content[35].strip('z = '))\\r\\n#==============================================================================\\r\\n \\r\\n \\r\\n # CTF -> Neuromag Coordinate transformation matrix\\r\\n#==============================================================================\\r\\n ctf_head_trans = data.info['ctf_head_t']['trans']\\r\\n \\r\\n # New Neuromag coordinates\\r\\n \\r\\n Nasion_head = np.dot(ctf_head_trans, Nasion_ctf)*0.01\\r\\n \\r\\n Left_head = np.dot(ctf_head_trans, Left_ctf)*0.01\\r\\n \\r\\n Right_head = np.dot(ctf_head_trans, Right_ctf)*0.01\\r\\n#==============================================================================\\r\\n \\r\\n \\r\\n \\r\\n # DEV <-> CTF Coordinate transformation matrix\\r\\n#==============================================================================\\r\\n dev_ctf_trans = data.info['dev_ctf_t']['trans']\\r\\n ctf_dev_trans = inv(dev_ctf_trans)\\r\\n \\r\\n # New Dev coordinates \\r\\n \\r\\n Nasion_dev = np.dot(ctf_dev_trans, Nasion_ctf)*0.01\\r\\n \\r\\n Left_dev = np.dot(ctf_dev_trans, Left_ctf)*0.01\\r\\n \\r\\n Right_dev = np.dot(ctf_dev_trans, Right_ctf)*0.01\\r\\n#==============================================================================\\r\\n \\r\\n \\r\\n \\r\\n # UPDATE THE INFO 'hpi_results' DATA WITH NEW DEV COORDINATES\\r\\n#==============================================================================\\r\\n for i in range(len(data.info['hpi_results'][0]['dig_points'])):\\r\\n \\r\\n #Just checking it's the right kind of digitizer ...\\r\\n if data.info['hpi_results'][0]['dig_points'][i]['kind'] == 1:\\r\\n \\r\\n #Left, Nasion, Right\\r\\n if data.info['hpi_results'][0]['dig_points'][i]['ident'] == 1:\\r\\n \\r\\n data.info['hpi_results'][0]['dig_points'][i]['r'] = Left_dev[:3]\\r\\n #data.info['hpi_results'][0]['dig_points'][i]['coord_frame'] = 1\\r\\n \\r\\n if data.info['hpi_results'][0]['dig_points'][i]['ident'] == 2:\\r\\n \\r\\n data.info['hpi_results'][0]['dig_points'][i]['r'] = Nasion_dev[:3]\\r\\n #data.info['hpi_results'][0]['dig_points'][i]['coord_frame'] = 1\\r\\n \\r\\n if data.info['hpi_results'][0]['dig_points'][i]['ident'] == 3:\\r\\n \\r\\n data.info['hpi_results'][0]['dig_points'][i]['r'] = Right_dev[:3]\\r\\n #data.info['hpi_results'][0]['dig_points'][i]['coord_frame'] = 1\\r\\n#==============================================================================\\r\\n \\r\\n \\r\\n \\r\\n # UPDATE THE INFO 'dig' DATA WITH NEUROMAG HEAD COORDINATES\\r\\n#==============================================================================\\r\\n for i in range(len(data.info['dig'])):\\r\\n \\r\\n #Just checking it's the right kind of digitizer ...\\r\\n if data.info['dig'][i]['kind'] == 1:\\r\\n \\r\\n #Left, Nasion, Right\\r\\n if data.info['dig'][i]['ident'] == 1:\\r\\n \\r\\n data.info['dig'][i]['r'] = Left_head[:3]\\r\\n data.info['dig'][i]['coord_frame'] = 4\\r\\n \\r\\n if data.info['dig'][i]['ident'] == 2:\\r\\n \\r\\n data.info['dig'][i]['r'] = Nasion_head[:3]\\r\\n data.info['dig'][i]['coord_frame'] = 4\\r\\n \\r\\n if data.info['dig'][i]['ident'] == 3:\\r\\n \\r\\n data.info['dig'][i]['r'] = Right_head[:3]\\r\\n data.info['dig'][i]['coord_frame'] = 4\\r\\n#==============================================================================\\r\\n \\r\\n if bads and reject_head_mvt:\\r\\n# for i in range(len(bad_segments)):\\r\\n new_annot = mne.Annotations(bad_segments.get_values()[:,0], np.diff(bad_segments.get_values()).ravel(), ['bad head mvt'] * bad_segments.get_values().shape[0])\\r\\n if data.annotations:\\r\\n for onset, duration, description in zip(new_annot.onset, new_annot.duration, new_annot.description):\\r\\n data.annotations.append(onset, duration, description)\\r\\n else:\\r\\n data.annotations = new_annot\\r\\n# events = data.events[:,0]/data.info['sfreq'] #extract event timing\\r\\n# data.drop(np.logical_and(bad_segments.iloc[i][0] < events + data.times[-1], events + data.times[0] < bad_segments.iloc[i][1]), reason = 'head_movement')\\r\\n# #reject the epoch if it ends after the beginning of the bad segment, and starts before the end of the bad segment\\r\\n \\r\\n return data\",\n \"def set_kbest_features_list(data_dict, features_list):\\n \\n print \\\" --- \\\"\\n\\n k_best = get_k_best(data_dict,features_list,len(features_list)-1)\\n \\n ### Sort the k_best features in descending order\\n arr_features = []\\n print \\\"sorted k_best:\\\"\\n for key, value in sorted(k_best.iteritems(), key=lambda (k,v): (v,k), reverse=True):\\n print \\\"%s: %s\\\" % (key, value)\\n arr_features.append(key)\\n\\n print \\\"---\\\"\\n poi = [\\\"poi\\\"]\\n features_list = poi\\n features_list += arr_features\\n\\n print \\\"---\\\"\\n print \\\"features List: \\\"\\n print features_list\\n print(\\\"Number of features in k_best: \\\",len(features_list))\\n print \\\" \\\"\\n\\n return features_list\",\n \"def camb_XPk(self,\\n z = 0.,\\n k = np.logspace(-4., 2., 1001),\\n nonlinear = False,\\n halofit = 'mead2020',\\n var_1 = ['tot'],\\n var_2 = ['tot'],\\n share_delta_neff = True,\\n **kwargs\\n ):\\n\\n # Neutrino part\\n nu_mass_eigen = len(np.unique([mm for mm in self.M_nu])) if np.any(self.M_nu!=0.) else 0\\n nu_mass_numbers = [list(self.M_nu).count(x) for x in set(list(self.M_nu))]\\n nu_mass_numbers = sorted(nu_mass_numbers,reverse=True) if np.any(self.M_nu!=0.) else [0]\\n # Set parameters\\n cambparams = {\\n 'num_nu_massive': self.massive_nu,\\n 'num_nu_massless': self.massless_nu,\\n 'nu_mass_eigenstates': nu_mass_eigen, \\n 'nu_mass_numbers': nu_mass_numbers,\\n 'nnu': self.N_eff,\\n 'omnuh2': self.omega_nu_tot,\\n 'ombh2': self.omega_b,\\n 'omch2': self.omega_cdm+self.omega_wdm_tot,\\n 'omk': self.Omega_K,\\n 'H0': 100.*self.h,\\n 'As': self.As,\\n 'ns': self.ns,\\n 'w': self.w0,\\n 'wa': self.wa,\\n 'TCMB': self.T_cmb,\\n 'tau': self.tau,\\n 'share_delta_neff':True,\\n 'dark_energy_model':'DarkEnergyPPF'}\\n # kwargs\\n for key, value in kwargs.items():\\n if not key in cambparams: cambparams[key] = value\\n params = camb.set_params(**cambparams)\\n\\n # Redshifts and scales\\n k = np.atleast_1d(k)\\n nk = len(k)\\n z = np.atleast_1d(z)\\n nz = len(z)\\n if nz > 3: spline = 'cubic'\\n else: spline = 'linear'\\n\\n # Possible components to use\\n components = {'tot' : 'delta_tot',\\n 'cdm' : 'delta_cdm',\\n 'b' : 'delta_baryon',\\n 'nu' : 'delta_nu',\\n 'cb' : 'delta_nonu',\\n 'gamma': 'delta_photon',\\n 'v_cdm': 'v_newtonian_cdm',\\n 'v_b' : 'v_newtonian_baryon',\\n 'Phi' : 'Weyl'}\\n\\n # Number of points (according to logint)\\n npoints = int(100*np.log10(k.max()/k.min()))\\n dlogk = 2.*np.log10(k.max()/k.min())/npoints\\n\\n # Halofit version\\n if nonlinear == True:\\n #camb.nonlinear.Halofit(halofit_version = halofit)\\n params.NonLinearModel.set_params(halofit_version=halofit)\\n params.NonLinear = camb.model.NonLinear_both\\n\\n # Initialize power spectrum as a dictionary and compute it\\n pk = {}\\n params.set_matter_power(redshifts = z, kmax = k.max()*10**dlogk, silent = True,accurate_massive_neutrino_transfers=True)\\n results = camb.get_results(params)\\n\\n # Fill the power spectrum array\\n for c1 in var_1:\\n for c2 in var_2:\\n string = c1+'-'+c2\\n kh, zz, ppkk = results.get_matter_power_spectrum(minkh = k.min()*10.**-dlogk,\\n maxkh = k.max()*10**dlogk,\\n npoints = npoints,\\n var1 = components[c1],\\n var2 = components[c2])\\n\\n pk[string] = np.zeros((nz,nk))\\n for iz in range(nz):\\n lnpower = si.InterpolatedUnivariateSpline(kh,np.log(ppkk[iz]),k=3,ext=0, check_finite=False)\\n pk[string][iz] = np.exp(lnpower(k))\\n \\n #if nz != 1:\\n # power = si.interp2d(kh, zz, ppkk, kind = spline)\\n # pk[string] = power(k, z)\\n # pk[string] = np.nan_to_num(pk[string])\\n #else:\\n # power = si.interp1d(kh, ppkk, kind = spline)\\n # pk[string] = power(k)\\n # pk[string] = np.nan_to_num(pk[string])\\n\\n return k, pk\",\n \"def evolve(self, k_vec, Nt,**kwargs):\\n \\n M_eff = np.eye((self.Nd), dtype=complex) # aux matrix\\n T = 1.\\n for it in range(Nt):\\n \\n # update the Hamiltonian for time-inteval\\n self.updateH(k_vec, it)\\n\\n # return eigenenergies and vectors\\n E_k, U = lg.eig(self.H_kc) \\n\\n # U^-1 * exp(H_d) U\\n U_inv = lg.inv(U)\\n\\n # construct a digonal matrix out of a vector\\n M1 = (np.exp(-1.j*E_k*T) * U_inv.T).T\\n\\n #MM = np.dot(U_inv,np.dot(H_M, U))\\n MM = np.dot(U,M1)\\n M_eff = np.dot(M_eff,MM)\\n # end of loop\\n Ek, Uk = lg.eig( M_eff )\\n idx = (np.log(Ek).imag).argsort()\\n Efl_k = np.log(Ek).imag[idx]\\n Ufl_k = Uk[idx]\\n return Efl_k, Ufl_k\",\n \"def non_interacting_conductivity(self,\\n sigma=0.04,\\n freq_range=(0.0, 6.0, 1000),\\n imag_dielectric=False,\\n broadening='lorentz'):\\n cell_area = np.abs(float(np.cross(self.a1, self.a2)))*len(self.k_grid)\\n broad_fnc = get_broadening_function(broadening, sigma)\\n\\n frequency_grid = np.linspace(*freq_range)\\n energy_increment = np.abs(frequency_grid[1] - frequency_grid[0])\\n num_freqs, min_freq = len(frequency_grid), min(frequency_grid)\\n output_grid = np.zeros(num_freqs)\\n\\n energy_power = 1 + int(imag_dielectric)\\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\\n prefactor = prefactor/cell_area\\n\\n # Assuming x polarisation for now\\n position_dipole_matrix = self.construct_position_dipole_matrix()\\n\\n n_shift = self.n_spins*self.n_orbs\\n for idx1, kpt in enumerate(self.k_grid):\\n for s0 in range(self.n_spins):\\n velocity_matrix = self.load_velocity_matrix(idx1)\\n bands = self.exciton_obj.get_number_conduction_valence_bands(\\n idx1, s0\\n )\\n v_num, c_num = bands\\n eigvals = np.array(\\n self.file_storage['eigensystem']['eigenvalues'][idx1]\\n )\\n\\n j1 = n_shift*idx1 + (self.n_spins - 1)*s0*self.n_orbs\\n j2 = j1 + self.n_orbs\\n eigvecs = np.array(\\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\\n )\\n for v, c in product(range(v_num), range(c_num)):\\n cb_vector = eigvecs[:, v_num + c]\\n vb_vector = eigvecs[:, v]\\n cb_energy, vb_energy = eigvals[v_num + c], eigvals[v]\\n energy_diff = (cb_energy - vb_energy)\\n\\n energy_diff_pow = energy_diff**energy_power\\n matrix_elem = velocity_matrix_element(vb_vector,\\n cb_vector,\\n velocity_matrix)\\n if self.use_dipole_term:\\n position_dipole_term = get_position_dipole_element(\\n vb_vector,\\n cb_vector,\\n vb_energy,\\n cb_energy,\\n position_dipole_matrix\\n )\\n matrix_elem = matrix_elem + position_dipole_term\\n\\n main_term = np.abs(matrix_elem)**2/energy_diff_pow\\n closest_idx = (energy_diff - min_freq)//energy_increment\\n idx_reach = self.reach_multiplier*(sigma//energy_increment)\\n\\n lower_idx = max([closest_idx - idx_reach, 0])\\n upper_idx = min([closest_idx + idx_reach, num_freqs - 1])\\n\\n for idx2 in range(int(lower_idx), int(upper_idx)):\\n smearing = broad_fnc(energy_diff, frequency_grid[idx2])\\n output = prefactor*main_term*smearing\\n output_grid[idx2] += output\\n\\n return frequency_grid, output_grid\",\n \"def multi_head_attention(queries, keys, values, attn_bias, d_key, d_value, d_model, pos_enc,\\n n_head=1, dropout_rate=0., cache=None, static_kv=False):\\n keys = queries if keys is None else keys\\n values = keys if values is None else values\\n if not (len(queries.shape) == len(keys.shape) == len(values.shape) == 3):\\n raise ValueError(\\n \\\"Inputs: quries, keys and values should all be 3-D tensors.\\\"\\n )\\n\\n def __compute_qkv(queries, keys, values, n_head, d_key, d_value):\\n \\\"\\\"\\\"\\n Add linear projection to queries, keys, and values.\\n \\\"\\\"\\\"\\n q = layers.fc(input=queries, size=d_key * n_head,\\n bias_attr=False, num_flatten_dims=2)\\n fc_layer = wrap_layer_with_block(\\n layers.fc, fluid.default_main_program().current_block().parent_idx\\n ) if cache is not None and static_kv else layers.fc\\n k = fc_layer(input=keys, size=d_key * n_head,\\n bias_attr=False, num_flatten_dims=2)\\n v = fc_layer(input=values, size=d_value * n_head,\\n bias_attr=False, num_flatten_dims=2)\\n return q, k, v\\n\\n def __split_heads_qkv(queries, keys, values, n_head, d_key, d_value)\\n \\\"\\\"\\\"\\n Reshape input tensors at the last dimension to split multi-heads\\n and then transpose. Specifically, transform the input tensor with shape\\n [bs, max_sequence_length, n_head * hidden_dim] to the output tensor\\n with shape [bs, n_head, max_sequence_length, hidden_dim].\\n \\\"\\\"\\\"\\n # The value 0 in shape attr means copying the corresponding dimension\\n # size of the input as the output dimension size.\\n reshaped_q = layers.reshape(\\n x=queries, shape=[0, 0, n_head, d_key], inplace=True)\\n # permute the dimensions into:\\n # [batch_size, n_head, max_sequence_len, hidden_size_per_head]\\n q = layers.transpose(x=reshaped_q, perm=[0, 2, 1, 3])\\n # For encoder-decoder attention in inference, insert the ops and vars\\n # into global block to use as cache among beam search.\\n reshape_layer = wrap_layer_with_block(\\n layers.reshape,\\n fluid.default_main_program().current_block(\\n ).parent_idx) if cache is not None and static_kv else layers.reshape\\n transpose_layer = wrap_layer_with_block(\\n layers.transpose,\\n fluid.default_main_program().current_block().\\n parent_idx) if cache is not None and static_kv else layers.transpose\\n reshaped_k = reshape_layer(\\n x=keys, shape=[0, 0, n_head, d_key], inplace=True)\\n k = transpose_layer(x=reshaped_k, perm=[0, 2, 1, 3])\\n reshaped_v = reshape_layer(\\n x=values, shape=[0, 0, n_head, d_value], inplace=True)\\n v = transpose_layer(x=reshaped_v, perm=[0, 2, 1, 3])\\n\\n if cache is not None: # only for faster inference\\n cache_, i = cache\\n if static_kv: # For encoder-decoder attention in inference\\n cache_k, cache_v = cache_[\\\"static_k\\\"], cache_[\\\"static_v\\\"]\\n # To init the static_k and static_v in global block.\\n static_cache_init = wrap_layer_with_block(\\n layers.assign,\\n fluid.default_main_program().current_block().parent_idx)\\n static_cache_init(\\n k,\\n fluid.default_main_program().global_block().var(\\n \\\"static_k_%d\\\" % i))\\n static_cache_init(\\n v,\\n fluid.default_main_program().global_block().var(\\n \\\"static_v_%d\\\" % i))\\n k, v = cache_k, cache_v\\n else: # For decoder self-attention in inference\\n # use cache and concat time steps.\\n cache_k, cache_v = cache_[\\\"k\\\"], cache_[\\\"v\\\"]\\n k = layers.concat([cache_k, k], axis=2)\\n v = layers.concat([cache_v, v], axis=2)\\n cache_[\\\"k\\\"], cache_[\\\"v\\\"] = (k, v)\\n return q, k, v\\n\\n def __combine_heads(x):\\n \\\"\\\"\\\"\\n Transpose and then reshape the last two dimensions of inpunt tensor x\\n so that it becomes one dimension, which is reverse to __split_heads.\\n \\\"\\\"\\\"\\n if len(x.shape) != 4:\\n raise ValueError(\\\"Input(x) should be a 4-D Tensor.\\\")\\n\\n trans_x = layers.transpose(x, perm=[0, 2, 1, 3])\\n # The value 0 in shape attr means copying the corresponding dimension\\n # size of the input as the output dimension size.\\n return layers.reshape(\\n x=trans_x,\\n shape=[0, 0, trans_x.shape[2] * trans_x.shape[3]],\\n inplace=True)\\n \\n def _shift(BD):\\n \\\"\\\"\\\"\\n -3 -2 -1 0 1 2\\n -3 -2 -1 0 1 2\\n -3 -2 -1 0 1 2\\n\\n to\\n 0 1 2\\n -1 0 1\\n -2 -1 0\\n\\n :param BD: batch_size x n_head x max_len x 2max_len\\n :return: batch_size x n_head x max_len x max_len\\n \\\"\\\"\\\"\\n bsz, n_head, max_len, _ = BD.size()\\n zero_pad = layers.zeros(shape=(bsz, n_head, max_len, 1))\\n BD = layers.reshape(x=layers.concat([BD, zero_pad], axis=-1),\\n shape=(bsz, n_head, -1, max_len))\\n BD = layers.reshape(x=BD[:, :, :-1], shape=(bsz, n_head, max_len, -1))\\n BD = BD[:, :, :, max_len:]\\n return BD\\n\\n def _transpose_shift(E):\\n \\\"\\\"\\\"\\n -3 -2 -1 0 1 2\\n -30 -20 -10 00 10 20\\n -300 -200 -100 000 100 200\\n\\n to\\n 0 -10 -200\\n 1 00 -100\\n 2 10 000\\n\\n\\n :param E: batch_size x n_head x max_len x 2max_len\\n :return: batch_size x n_head x max_len x max_len\\n \\\"\\\"\\\"\\n bsz, n_head, max_len, _ = E.size()\\n zero_pad = layers.zeros(shape=(bsz, n_head, max_len, 1))\\n E = layers.reshape(x=layers.concat([E, zero_pad], axis=-1),\\n shape=(bsz, n_head, -1, max_len))\\n indice = layers.arange(start=0, end=max_len, dtype=int)\\n E = layers.index_select(input=E, index=indice, dim=-2)\\n E = layers.transpose(E, perm=[0, 1, 3, 2])\\n return E\\n\\n def scaled_dot_product_attention(q, k, v, pos_enc, attn_bias, d_key, dropout_rate):\\n \\\"\\\"\\\"\\n Scaled Dot-Product Attention\\n\\n Change:\\n - Different from the original one.\\n We will remove the scale factor math: \\\\sqrt{d_k} according to the paper.\\n - Bias for attention and position encoding are added.\\n \\n \\\"\\\"\\\"\\n # product = layers.matmul(x=q, y=k, transpose_y=True, alpha=d_key**-0.5)\\n\\n # now q, k should be shaped like\\n # [batch_size, n_head, max_sequence_len, hidden_size_per_head]\\n # pos_enc should be shaped like [2 X l, head_dim], and head_dim = d_key\\n max_sequence_len = q.shape[2]\\n \\n r_r_bias = layers.create_parameter(shape=(n_head, d_key)) # [n_head, head_dim]\\n r_w_bias = layers.create_parameter(shape=(n_head, d_key)) # [n_head, head_dim]\\n rw_head_q = q + r_r_bias[:, None] # [batch, n_head, max_sequence_len, head_dim]\\n AC = layers.matmul(x=rw_head_q, y=k, transpose_y=True) # [batch, n_head, max_sequence_len, max_seqence_len]\\n \\n # position bias for each head, shaped like [n_head, 2 X max_sequence_len].\\n # Then add two dimensions at `batch` and `maxlen`.\\n D_ = layers.matmul(x=r_w_bias, y=pos_enc, transpose_y=True)[None, :, None]\\n # position bias for each query, shaped like [batch, n_head, max_len, 2 X max_len]\\n B_ = layers.matmul(x=q, y=pos_enc, transpose_y=True)\\n # bias for each key, shaped like [batch, n_head, max_len, 2 X max_len]\\n E_ = layers.matmul(x=k, y=pos_enc, transpose_y=True)\\n \\n # shaped like [batch, n_head, max_len, 2 X max_len]\\n # change it to [batch, n_head, max_len, max_len]\\n BD = B_ + D_\\n BDE = _shift(BD) + _transpose_shift(E_)\\n product = AC + BDE\\n\\n # product = layers.matmul(x=q, y=k, transposed_y=True, alpha=1.0) + \\\\\\n # layers.matmul(x=q, y=pos_enc, transposed_y=True) +\\\\\\n # layers.transpose(x=last_two, perm=[0, 1, 3, 2])\\n if attn_bias:\\n product += attn_bias\\n weights = layers.softmax(product)\\n if dropout_rate:\\n weights = layers.dropout(\\n weights,\\n dropout_prob=dropout_rate,\\n seed=dropout_seed,\\n is_test=False)\\n out = layers.matmul(weights, v)\\n return out\\n\\n q, k, v = __compute_qkv(queries, keys, values, n_head, d_key, d_value)\\n q, k, v = __split_heads_qkv(q, k, v, n_head, d_key, d_value)\\n\\n ctx_multiheads = scaled_dot_product_attention(q, k, v, pos_enc, attn_bias, d_key,\\n dropout_rate)\\n\\n out = __combine_heads(ctx_multiheads)\\n\\n # Project back to the model size.\\n proj_out = layers.fc(input=out,\\n size=d_model,\\n bias_attr=False,\\n num_flatten_dims=2)\\n return proj_out\",\n \"def pfit(Vrf,Vdc,X,Y,Z,Irf,Jrf,Krf):\\n #1) find dc potential\\n #from all_functions import plot_potential,p2d,trap_depth,find_saddle,exact_saddle\\n from project_parameters import charge,mass,driveAmplitude,Omega,debug,scale\\n #2) find pseudopotential\\n \\\"\\\"\\\"Gebhard, Oct 2010:\\n changed back to calculating field numerically in ppt2 instead directly\\n with bemsolver. this is because the slow bemsolver (new version) does not output EX, EY, EZ.\\\"\\\"\\\"\\n [Ey,Ex,Ez] = np.gradient(Vrf,abs(X[1]-X[0])/scale,abs(Y[1]-Y[0])/scale,abs(Z[1]-Z[0])/scale) # fortran indexing\\n Esq = Ex**2 + Ey**2 + Ez**2\\n #3) plotting pseudopotential, etc; outdated?\\n PseudoPhi = Esq*(charge**2)/(4*mass*Omega**2) \\n U = PseudoPhi+charge*Vdc # total trap potential\\n if debug.pfit:\\n# plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Ex,X,Y,Z,'1D plots','Ex','U_{ps} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Ey,X,Y,Z,'1D plots','Ey','U_{ps} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Ez,X,Y,Z,'1D plots','Ez','U_{ps} (eV)',[Irf,Jrf,Krf]) \\n# plot_potential(Esq,X,Y,Z,'1D plots','E**2','U_{ps} (eV)',[Irf,Jrf,Krf])\\n plot_potential(Vrf,X,Y,Z,'1D plots','Vrf','U_{rf} (eV)',[Irf,Jrf,Krf])\\n plot_potential(PseudoPhi/charge,X,Y,Z,'1D plots','Pseudopotential','U_{ps} (eV)',[Irf,Jrf,Krf])\\n# plot_potential(Vdc,X,Y,Z,'1D plots','DC Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\\n plot_potential(U/charge,X,Y,Z,'1D plots','Trap Potential','U_{sec} (eV)',[Irf,Jrf,Krf])\\n #4) determine trap frequencies and tilt in radial directions\\n Uxy = U[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]\\n MU = np.max(Uxy) # normalization factor, will be undone when calculating frequencies\\n Uxy = Uxy/MU \\n nx,ny,nz=X.shape[0],Y.shape[0],Z.shape[0]\\n x,y,z = np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz)),np.zeros((nx,ny,nz))\\n for i in range(nx):\\n for j in range(ny):\\n for k in range(nz):\\n x[i,j,k] = X[i]\\n y[i,j,k] = Y[j]\\n z[i,j,k] = Z[k]\\n dL = x[Irf+3,Jrf,Krf]-x[Irf,Jrf,Krf] # is this X? Originally x. Temporarily y so that dL not 0. Probably related to meshgrid or indexing.\\n xr = (x[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-x[Irf,Jrf,Krf])/dL \\n yr = (y[Irf-3:Irf+4,Jrf-3:Jrf+4,Krf]-y[Irf,Jrf,Krf])/dL\\n [C1,C2,theta] = p2d(Uxy,xr,yr) \\n C1,C2,theta = C1[0],C2[0],theta[0] \\n fx = (1e3/dL)*np.sqrt(abs(2*C1*MU/(mass)))/(2*np.pi)\\n fy = (1e3/dL)*np.sqrt(abs(2*C2*MU/(mass)))/(2*np.pi)\\n #5) trap frequency in axial direction\\n Uz=U[Irf,Jrf,:] # old projection\\n l1 = np.max([Krf-6,1])\\n l2 = np.min([Krf+6,np.max(Z.shape)])\\n p = np.polyfit((Z[l1:l2+1]-Z[Krf])/dL,Uz[l1:l2+1],6)\\n fz = (1e3/dL)*np.sqrt(2*p[4]/mass)/(2*np.pi)\\n [Depth,Xe,Ye,Ze] = trap_depth(U/charge,X,Y,Z,Irf,Jrf,Krf) \\n return [fx,fy,fz,theta,Depth,Xe,Ye,Ze]\",\n \"def Heston_fft(self,alpha,n,B,K):\\r\\n bt = time.time()\\r\\n r = self.r\\r\\n T = self.T\\r\\n S0 = self.S0\\r\\n N = 2**n\\r\\n Eta = B / N\\r\\n Lambda_Eta = 2 * math.pi / N\\r\\n Lambda = Lambda_Eta / Eta\\r\\n \\r\\n J = np.arange(1,N+1,dtype = complex)\\r\\n vj = (J-1) * Eta\\r\\n m = np.arange(1,N+1,dtype = complex)\\r\\n Beta = np.log(S0) - Lambda * N / 2\\r\\n km = Beta + (m-1) * Lambda\\r\\n \\r\\n ii = complex(0,1)\\r\\n \\r\\n Psi_vj = np.zeros(len(J),dtype = complex)\\r\\n \\r\\n for zz in range(0,N):\\r\\n u = vj[zz] - (alpha + 1) * ii\\r\\n numer = self.Heston_cf(u)\\r\\n denom = (alpha + vj[zz] * ii) * (alpha + 1 + vj[zz] * ii)\\r\\n \\r\\n Psi_vj [zz] = numer / denom\\r\\n \\r\\n # Compute FTT\\r\\n xx = (Eta/2) * Psi_vj * np.exp(-ii * Beta * vj) * (2 - self.dirac(J-1))\\r\\n zz = np.fft.fft(xx)\\r\\n \\r\\n # Option price\\r\\n Mul = np.exp(-alpha * np.array(km)) / np.pi\\r\\n zz2 = Mul * np.array(zz).real\\r\\n k_List = list(Beta + (np.cumsum(np.ones((N, 1))) - 1) * Lambda)\\r\\n Kt = np.exp(np.array(k_List))\\r\\n \\r\\n Kz = []\\r\\n Z = []\\r\\n for i in range(len(Kt)):\\r\\n if( Kt[i]>1e-16 )&(Kt[i] < 1e16)& ( Kt[i] != float(\\\"inf\\\"))&( Kt[i] != float(\\\"-inf\\\")) &( zz2[i] != float(\\\"inf\\\"))&(zz2[i] != float(\\\"-inf\\\")) & (zz2[i] is not float(\\\"nan\\\")):\\r\\n Kz += [Kt[i]]\\r\\n Z += [zz2[i]]\\r\\n tck = interpolate.splrep(Kz , np.real(Z))\\r\\n price = np.exp(-r*T)*interpolate.splev(K, tck).real\\r\\n et = time.time()\\r\\n \\r\\n runt = et-bt\\r\\n\\r\\n return(price,runt)\",\n \"def cvstem(self):\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Cfun).parameters) == 1):\\n fun1 = self.Cfun\\n self.Cfun = lambda x,p: fun1(x)\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Gw).parameters) == 1):\\n fun2 = self.Gw\\n self.Gw = lambda x,p: fun2(x)\\n if self.iEC == \\\"est\\\":\\n self.c_over = self.matrix_2bound(self.Cfun)\\n self.g_over = self.matrix_2bound(self.Gw)\\n if (len(sig(self.Bw).parameters) == 1):\\n fun3 = self.Bw\\n self.Bw = lambda x,p: fun3(x)\\n self.b_over = self.matrix_2bound(self.Bw)\\n self.linesearch()\\n alp = self.alp_opt\\n Nx = self.Nx\\n Nsplit = 1\\n Np = int(Nx/Nsplit)\\n Nr = np.remainder(Nx,Nsplit)\\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\\n Nxp = self.n+self.n_p\\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\\n Ws_opt = []\\n chi_opt = 0\\n nu_opt = 0\\n print(\\\"========================================================\\\")\\n print(\\\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\\\")\\n print(\\\"========================================================\\\")\\n for p in range(Np):\\n if np.remainder(p,int(Np/10)) == 0:\\n print(\\\"# sampled metrics: \\\",p*Nsplit,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n if Nr != 0:\\n print(\\\"# samples metrics: \\\",Nx,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n self.xs_opt = xs_opt\\n self.ps_opt = ps_opt\\n self.Ws_opt = Ws_opt\\n self.chi_opt = chi_opt\\n self.nu_opt = nu_opt\\n if self.iEC == \\\"est\\\":\\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\\n print(\\\"Optimal steady-state estimation error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n elif self.iEC == \\\"con\\\":\\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\\n print(\\\"Optimal steady-state tracking error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n else:\\n raise ValueError('Invalid iEC: iEC = \\\"est\\\" or \\\"con\\\"')\\n self.M2cholM()\\n path = \\\"models/optvals/\\\"+self.fname\\n if os.path.exists(path) == False:\\n try:\\n os.makedirs(path)\\n except: \\n raise OSError(\\\"Creation of directory %s failed\\\" %path)\\n else:\\n print (\\\"Successfully created directory %s \\\" %path)\\n else:\\n print (\\\"Directory %s already exists\\\" %path)\\n np.save(path+\\\"/alp_opt.npy\\\",alp)\\n np.save(path+\\\"/chi_opt.npy\\\",self.chi_opt)\\n np.save(path+\\\"/nu_opt.npy\\\",self.nu_opt)\\n np.save(path+\\\"/Jcv_opt.npy\\\",self.Jcv_opt)\\n print(\\\"========================================================\\\")\\n print(\\\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\\\")\\n print(\\\"========================================================\\\\n\\\\n\\\")\\n pass\",\n \"def g0_hz(sp,cal_Veff = 5e-3, V_pi = None, askFit = True,T = 293,PM_calib_file = \\\"M:\\\\\\\\phaseModulationCalibrations\\\\\\\\V_pi1550.spe\\\"):#V_pi = 7.1\\n \\n cal_Veff = addDefaultUnit(cal_Veff,V)\\n T = addDefaultUnit(T,K)\\n f = sp.fitter\\n if not isinstance(sp.fitter,fit.FitterLorentzAndGauss):\\n if askFit:\\n yn = \\\"dummy\\\"\\n while yn is not \\\"y\\\":\\n yn = raw_input(\\\"spectrum %s was fitted with model %s. refit it with model \\\\\\\"LorentzGauss\\\\\\\"(y/n)?\\\"%(sp.name,f.ID_STR))\\n if yn ==\\\"n\\\":\\n raise ValueError(\\\"spectrum should be fitted with LorentzGauss for determining effective mass\\\")\\n sp.fit(model = \\\"LorentzGauss\\\")\\n\\n\\n if V_pi == None:\\n f = load(PM_calib_file)\\n V_pi = utils.misc.interpFromPlottable(f,sp[\\\"x0_2_hz\\\"])\\n else:\\n V_pi = 7.1\\n V_pi = addDefaultUnit(V_pi,V)\\n print \\\"value of V_pi used is \\\" + str(V_pi)\\n\\n ratio = sp[\\\"area_2\\\"]/sp[\\\"area\\\"]\\n \\n phi0 = np.pi*cal_Veff*sqrt(2)/V_pi\\n \\n# omega = 2.0*np.pi*cst.c/(lambda_nm*1e-9)\\n\\n Omega = 2.0*np.pi*sp[\\\"x0_2_hz\\\"]*Hz\\n\\n nbar = k*T/(hbar*Omega)\\n g0 = ((Omega**2*phi0**2)/(4*nbar*ratio))**.5/(2*pi)\\n yn = raw_input(\\\"would you like results to be pasted in Origin to be copied in clipboard? [y]/n\\\")\\n if yn is not \\\"n\\\":\\n #import utils\\n utils.misc.copyToClipboard(str(sp[\\\"x0_hz\\\"]*1e-6) +\\\"\\\\t\\\"+str(sp[\\\"gamma_hz\\\"]) + \\\"\\\\t\\\"+\\\"0\\\" +\\\"\\\\t\\\"+ str(g0.asNumber()))\\n return g0\",\n \"def dispersion_2(ztop, vp, vs, rh, Curves,\\n h=0.005, dcl=0.005, dcr=0.005, keepnans=False):\\n Waves, Types, Modes, Freqs = zip(*Curves)\\n for w, t, m, F, V in dispersion_1(\\\\\\n ztop, vp, vs, rh,\\n Waves, Types, Modes, Freqs,\\n h=h, dcl=dcl, dcr=dcr, keepnans=keepnans):\\n yield w, t, m, F, V\",\n \"def non_max_suppression(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\\n # print('conf_thres',conf_thres)\\n if prediction.dtype is torch.float16:\\n prediction = prediction.float() # to FP32\\n\\n nc = prediction[0].shape[1] - 5 # number of classes\\n xc = prediction[..., 4] > conf_thres # candidates\\n\\n # Settings\\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\\n max_det = 300 # maximum number of detections per image\\n time_limit = 10.0 # seconds to quit after\\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\\n\\n t = time.time()\\n output = [None] * prediction.shape[0]\\n for xi, x in enumerate(prediction): # image index, image inference\\n # Apply constraints\\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\\n x = x[xc[xi]] # confidence\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\\n box = xywh2xyxy(x[:, :4])\\n\\n # Detections matrix nx6 (xyxy, conf, cls)\\n if multi_label:\\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\\n else: # best class only\\n conf, j = x[:, 5:].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\\n\\n\\n\\n # If none remain process next image\\n n = x.shape[0] # number of boxes\\n if not n:\\n continue\\n\\n # Sort by confidence\\n # x = x[x[:, 4].argsort(descending=True)]\\n\\n # Batched NMS\\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\\n # # Sort by confidence\\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\\n x = x[ind_Sort_by_confidence][:top_k_num] #\\n # cross classes nms\\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n # if merge and (1 < n < 3E3): # Merge NMS (boxes merged using weighted mean)\\n # update boxes as boxes(i,4) = weights(i,n) * boxes(n,4)\\n # iou = box_iou(boxes[i], boxes) > iou_thres # iou matrix\\n # weights = iou * scores[None] # box weights\\n # x[i, :4] = torch.mm(weights, x[:, :4]).float() / weights.sum(1, keepdim=True) # merged boxes\\n # if redundant:\\n # i = i[iou.sum(1) > 1] # require redundancy\\n\\n output[xi] = x[i]\\n if (time.time() - t) > time_limit:\\n break # time limit exceeded\\n\\n return output\",\n \"def compute_mixing_coefficients_surf(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n\\n # SET UP NEW MIXING COEFFICIENT ARRAYS\\n self.Kv_surf = np.zeros([Ly,N+1])\\n self.Kt_surf = np.zeros([Ly,N+1])\\n \\n self.ghat = np.zeros([Ly,N+1])\\n \\n\\n #################################\\n # \\tSURFACE KPP\\n ################################\\n #---> j-loop\\n \\n self.wm2 = []\\n self.ws2 = []\\n self.sigma_y = []\\n for j in range(Ly):\\n #--> k-loop (top to kbl[j])\\n # in fortran k=N-1,kbl(j),-1\\n for k in range(N-1,self.kbl[j]-1,-1):\\n k_w = k\\n k_r = k-1\\n\\n Bfsfc = self.Bfsfc_bl[j]\\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\\n \\n # CALCULATE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm2.append(wm)\\n self.ws2.append(ws)\\n # COMPUTE VERTICAL MIXING COEFFICIENTS\\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\\n self.sigma1 = sigma #for debugging\\n if j == 25: \\n self.sigma_y.append(sigma)\\n a1 = sigma - 2.\\n a2 = 3.-2.*sigma\\n a3 = sigma - 1.\\n\\n if sigma < 0.07:\\n cff = 0.5 * (sigma-0.07)**2/0.07\\n else:\\n cff = 0\\n \\n \\n if k == N-1: \\n self.wm_debug = wm\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n\\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\\n\\n if k == N-1:\\n self.ws_debug = ws\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n \\n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\\n #---> end k-loop \\n if self.LMD_NONLOCAL:\\n if Bfsfc < 0:\\n self.ghat[j,k_w] = 0\\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\\n else:\\n self.ghat[j,k_w] = 0.\\n\\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \\n if self.LMD_CONVEC and self.MLCONVEC: \\n for k in range(N-1,int(self.kbl[j]-1),-1):\\n k_w = k\\n k_r = k -1\\n\\n if self.bvf[j,k_w] < 0:\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\\n\\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\\n # IF BKPP IS SWITCHED OFF!!\\n for k in range(int(self.kbl[j]-1),-1,-1):\\n k_w = k\\n k_r = k -1\\n if self.LMD_NONLOCAL:\\n self.ghat[j,k_w] = 0\\n if self.LMD_CONVEC and self.LMD_BKPP == False:\\n if self.bvf[j,k_w] < 0:\\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\\n \\n\\n #---> end j-loop\",\n \"def solve_system_for_vv_harmonic_weak_Maass_waveforms_new(H, W, N=None, gr=False, cn=False, verbose=0):\\n V = W['V']\\n Ms = W['Ms']\\n Mf = W['Mf']\\n # WR=W['WR']\\n X = H.multiplier()\\n WM = H.multiplier().weil_module()\\n nc = W['nc']\\n Ml = Mf - Ms + 1\\n get_reduced_matrix = gr\\n verbose = H._verbose\\n comp_norm = cn\\n r = W['r'] # WM.rank()\\n if verbose > 0:\\n print(\\\"Ml={0}\\\".format(Ml))\\n print(\\\"nv={0}\\\".format(nc))\\n # if W['sym_type']==1:\\n # setD=range(WM.rank()/2+1) # 0,1,...,N\\n # #setD=range(WR.N+1) # 0,1,...,N\\n # elif W['sym_type']==-1:\\n # setD=range(1,WM.rank()/2) # 1,2,...,N-1 (since -0=0 and -N=N)\\n setD = X.D()\\n Ds = setD[0]\\n num_comp = nc * r\\n if num_comp != len(setD):\\n raise Exception(\\\" Wrong dimension of input matrix! r={0},nc={1},setD={2}\\\".format(r, nc, setD))\\n if V.ncols() != Ml * num_comp or V.nrows() != Ml * num_comp:\\n raise Exception(\\\" Wrong dimension of input matrix!\\\")\\n if N is None:\\n SetCs = [[]]\\n Vals = [{}]\\n for b in WM.basis():\\n if WM.Q(b) == 0:\\n SetCs[0].append((b, 0))\\n Vals[0][(b, 0)] = 0\\n comp_dim = 1\\n else:\\n SetCs = N['SetCs']\\n Vals = N['Vals']\\n comp_dim = N['comp_dim']\\n\\n # for a in Vals.keys():\\n # Vals[a]=mpmath.mp.mpc(Vals[a])\\n if Ms < 0:\\n use_sym = 0\\n else:\\n use_sym = 1\\n if verbose > 0:\\n print(\\\"Before SetCs={0}\\\".format(SetCs))\\n if use_sym == 1:\\n if len(SetCs[0]) > 0:\\n num_set = 0\\n for (r, m) in SetCs[0]:\\n if r in X.D(): # )_as_int:\\n num_set = num_set + 1\\n else:\\n num_set = len(SetCs[0])\\n t = V[0, 0]\\n CF = MPComplexField(H._prec)\\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(comp_dim))\\n RHS = Matrix_complex_dense(MS, 0, True, True)\\n # if W.has_key('RHS'):\\n # if(W['RHS'].ncols()!=comp_dim):\\n # raise ValueError,\\\"Inum_comporrect number of right hand sides!\\\"\\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(Ml * num_comp - num_set))\\n LHS = Matrix_complex_dense(MS, 0, True, True)\\n if verbose > 0:\\n print(\\\"Ml={0}\\\".format(Ml))\\n print(\\\"num_set={0}\\\".format(num_set))\\n print(\\\"num_comp={0}\\\".format(num_comp))\\n print(\\\"SetCs={0}\\\".format(SetCs))\\n print(\\\"setD={0}\\\".format(setD))\\n print(\\\"Vals={0}\\\".format(Vals))\\n print(\\\"V.rows={0}\\\".format(V.nrows()))\\n print(\\\"V.cols={0}\\\".format(V.ncols()))\\n print(\\\"LHS.rows={0}\\\".format(LHS.nrows()))\\n print(\\\"LHS.cols={0}\\\".format(LHS.ncols()))\\n print(\\\"RHS.rows={0}\\\".format(RHS.nrows()))\\n print(\\\"RHS.cols={0}\\\".format(RHS.ncols()))\\n print(\\\"use_sym={0}\\\".format(use_sym))\\n print(\\\"N={0}\\\".format(N))\\n\\n num_rhs = 0\\n if 'RHS' in W:\\n num_rhs = W['RHS'].ncols()\\n else:\\n num_rhs = 1\\n if num_rhs != 1 and num_rhs != comp_dim:\\n raise ValueError(\\\"Need same number of right hand sides (or just one) as the number of set coefficients!\\\")\\n\\n if V.nrows() != num_comp * Ml:\\n raise ArithmeticError(\\\" Matrix does not have correct size!\\\")\\n roffs = 0\\n for a in range(num_comp):\\n for n in range(Ms, Mf + 1):\\n r = a * Ml + n - Ms\\n if SetCs[0].count((a + Ds, n)) > 0 and a + Ds in setD:\\n # print \\\" set row a,n=\\\",a,n\\n roffs = roffs + 1\\n continue\\n for fn_j in range(comp_dim):\\n # ztmp=CF(ztmp.real(),ztmp.imag())\\n if verbose > 3:\\n print(\\\"fn_j={0}\\\".format(fn_j))\\n print(\\\"r,roffs={0},{1},{2}\\\".format(r, roffs, r - roffs))\\n if num_rhs == comp_dim:\\n rhs_j = fn_j\\n else:\\n rhs_j = 0\\n if 'RHS' in W:\\n RHS[r - roffs, fn_j] = -W['RHS'][r, rhs_j]\\n else:\\n RHS[r - roffs, fn_j] = 0\\n for (i, cset) in SetCs[fn_j]:\\n if i in setD:\\n v = Vals[fn_j][(i, cset)]\\n # k = i*Ml+cset-Ms\\n k = (i - Ds) * Ml + cset - Ms\\n if verbose > 3:\\n print(\\\"fi,cset={0},{1}\\\".format(i, cset))\\n print(\\\"r,k={0},{1}\\\".format(r, k))\\n tmp = CF(v) * V[r, k]\\n RHS[r - roffs, fn_j] = RHS[r - roffs, fn_j] - tmp\\n coffs = 0\\n for b in range(num_comp):\\n for l in range(Ms, Mf + 1):\\n k = b * Ml + l - Ms\\n if SetCs[0].count((b + Ds, l)) > 0 and b + Ds in setD:\\n coffs = coffs + 1\\n continue\\n if verbose > 3:\\n print(\\\"r,k={0},{1}\\\".format(r, k))\\n print(\\\"r-roffs,k-coffs={0},{1}\\\".format(r - roffs, k - coffs))\\n LHS[r - roffs, k - coffs] = V[r, k]\\n # print \\\"LHS[\\\",r,k,\\\"]=\\\",LHS[r-roffs,k-coffs]\\n # else:\\n # LHS = V\\n # RHS = -W['RHS']\\n if get_reduced_matrix:\\n return [LHS, RHS]\\n maxit = 100\\n i = 0\\n done = False\\n dps0 = CF.prec()\\n while (not done and i <= maxit):\\n try:\\n Q, R = LHS.qr_decomposition()\\n done = True\\n except ZeroDivisionError:\\n t = int(ceil(-log(smallest_inf_norm(LHS), 10)))\\n dps = t + 5 * i\\n i = i + 1\\n print(\\\"raising number of digits to:{0}\\\".format(dps))\\n LHS.set_prec(dps)\\n # raise ZeroDivisionError,\\\"Need higher precision! Use > %s digits!\\\" % t\\n if i >= maxit:\\n raise ZeroDivisionError(\\\"Can not raise precision enough to solve system! Should need > {0} digits! and {1} digits was not enough!\\\".format(t, dps))\\n if comp_norm:\\n max_norm = LHS.norm()\\n for j in range(LHS.rows):\\n # y=mpmath_ctx.matrix(LHS.rows,int(1)); y[j,0]=1\\n y = Vector_complex_dense(vector(CF, LHS.rows).parent(), 0)\\n y[j] = 1\\n TMP = RHS.solve(b) # pmath_ctx.U_solve(A, b)\\n tmpnorm = max(list(map(abs, TMP)))\\n if(tmpnorm > max_norm):\\n max_norm = tmpnorm\\n print(\\\"max norm of V^-1={0}\\\".format(max_norm))\\n X = dict()\\n for fn_j in range(comp_dim):\\n X[fn_j] = dict() # mpmath.matrix(int(Ml),int(1))\\n # b = mpmath_ctx.L_solve(A, RHS.column(fn_j), p)\\n v = RHS.column(fn_j)\\n print(\\\"len(B)={0}\\\".format(len(v)))\\n TMP = LHS.solve(v)\\n # TMP = mpmath_ctx.U_solve(A, b)\\n roffs = 0\\n # res = mpmath_ctx.norm(mpmath_ctx.residual(LHS, TMP, RHS.column(fn_j)))\\n res = (LHS * TMP - v).norm()\\n print(\\\"res(\\\", fn_j, \\\")={0}\\\".format(res))\\n for ai in range(num_comp):\\n X[fn_j][ai] = dict()\\n for n in range(Ms, Mf + 1):\\n ni = Ml * ai + n - Ms\\n if SetCs[fn_j].count((ai + Ds, n)) > 0 and ai + Ds in setD:\\n roffs = roffs + 1\\n X[fn_j][ai][n] = CF(Vals[fn_j][(ai + Ds, n)])\\n continue\\n # if verbose>0:\\n # print \\\"ni-roffs=\\\",ni-roffs\\n X[fn_j][ai][n] = TMP[ni - roffs]\\n return X\",\n \"def _fit_multiple(self, X, y, configurations, bracket_num):\\n device_used = self.device\\n if device_used == 'cuda':\\n device_used += f':{self.gpu_ids[bracket_num % self.n_device]}'\\n list_toTrain_model = []\\n best_config_by_round = []\\n\\n for i in tqdm(range(bracket_num + 1), desc=f'Bracket {bracket_num}', position=(self.max_rounds-bracket_num), leave=True):\\n for contender in range(self.brackets[bracket_num][i]['ni']):\\n self.brackets[bracket_num][i]['contenders'][contender] = dict.fromkeys([\\n 'hparams', 'score'])\\n self.brackets[bracket_num][i]['contenders'][contender]['hparams'] = configurations[contender]['hparams']\\n model = self.create_model(\\n self.estimator,\\n random_state=self.random_state,\\n epoch=self.brackets[bracket_num][i]['ri'],\\n device=device_used,\\n log_path=self.log_path,\\n **configurations[contender]['hparams']\\n )\\n verbose = 0\\n list_toTrain_model.append(\\n (model, X, y, self.scoring, self.cv, self.n_jobs_cv, verbose))\\n\\n torch.multiprocessing.set_start_method('spawn', force=True)\\n with MyPool(self.n_jobs_model) as p:\\n list_toTrain_score = p.starmap(\\n self.get_mean_cv_score, list_toTrain_model)\\n\\n for contender in range(self.brackets[bracket_num][i]['ni']):\\n self.brackets[bracket_num][i]['contenders'][contender]['score'] = list_toTrain_score[contender]\\n\\n configurations = self.get_top_k(\\n self.brackets[bracket_num][i]['contenders'],\\n k=max(math.floor(\\n self.brackets[bracket_num][i]['ni']/self.factor), 1)\\n )\\n\\n best_config = configurations[0].copy()\\n best_config_by_round.append({\\n 'bracket': bracket_num,\\n 'round': i,\\n 'epoch': int(self.brackets[bracket_num][i]['ri']),\\n **best_config\\n })\\n\\n return best_config_by_round\",\n \"def convert2EbnerParam(joblib,list_prefix,directory):\\n \\n key=[p[0] for p in joblib]\\n element=[p[1] for p in joblib]\\n\\n \\n listSlice=element[key.index('listSlice')] #list of slice\\n parameters=element[key.index('EvolutionParameters')][-1,:,:] #estimated paramters of the registration\\n rejectedSlice=element[key.index('RejectedSlices')] #rejected slices\\n\\n \\n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\\n \\n for i_slice in range(len(listSlice)): \\n slicei=listSlice[i_slice]\\n slicei.set_parameters(parameters[i_slice,:]) #set parameters to the last estimated parameters\\n \\n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\\n\\n for n in range(len(images)): #for each stack\\n \\n imagen = images[n]\\n \\n for i_slice in range(len(images[n])): #for each slices (in each stacks)\\n \\n slicei=imagen[i_slice]\\n s = (slicei.get_orientation(),slicei.get_index_slice())\\n \\n if s not in rejectedSlice:\\n dimension=3\\n X,Y,Z= slicei.get_slice().get_fdata().shape\\n center= -slicei.get_center()\\n centerMat = np.eye(4)\\n centerMat[0:3,3] = center[0:3]\\n invcenterMat = np.eye(4)\\n invcenterMat[0:3,3] = -center[0:3] \\n p = slicei.get_parameters()\\n matrix = mat @ centerMat @ rigidMatrix([p[0],p[1],p[2],p[3],p[4],p[5]]) @ invcenterMat @ mat\\n test = sitk.AffineTransform(dimension)\\n test.SetMatrix(matrix[0:3,0:3].flatten())\\n test.SetTranslation(matrix[0:3,3])\\n images_index = slicei.get_index_image()\\n sitk.WriteTransform(test,\\\"%s/%s_slice%d.tfm\\\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\\n #else:\\n #print(s)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7044471","0.6196605","0.60360116","0.50493073","0.50484276","0.5042975","0.48713553","0.47226658","0.46531764","0.4640844","0.46398926","0.45862988","0.45844907","0.45613056","0.4558295","0.45362642","0.4533591","0.45092642","0.4467235","0.44669557","0.4452809","0.44360697","0.4435155","0.4427887","0.44111398","0.43857205","0.43812606","0.43759474","0.43654087","0.43633294","0.43566397","0.4355602","0.43546537","0.4345576","0.4333257","0.43305728","0.42977512","0.42977512","0.42951402","0.42951402","0.4290339","0.42891848","0.42840427","0.42793128","0.4277554","0.42750075","0.42726076","0.42493597","0.42467546","0.42466953","0.4235587","0.42317286","0.42308465","0.42235035","0.42210695","0.42191964","0.42185396","0.4218203","0.42112675","0.42110956","0.4208951","0.42086047","0.42060477","0.41972712","0.41942963","0.41831413","0.41819745","0.41779587","0.41778168","0.41736156","0.41736114","0.41687012","0.41674107","0.41659346","0.41609257","0.41564834","0.4156434","0.41505077","0.4148201","0.41463363","0.4144439","0.41420525","0.41397375","0.41363057","0.41347405","0.41276276","0.41275465","0.41271502","0.41250062","0.41108862","0.41099378","0.40992537","0.40978608","0.4097015","0.40966487","0.40952104","0.4091277","0.40885136","0.4084689","0.40818387"],"string":"[\n \"0.7044471\",\n \"0.6196605\",\n \"0.60360116\",\n \"0.50493073\",\n \"0.50484276\",\n \"0.5042975\",\n \"0.48713553\",\n \"0.47226658\",\n \"0.46531764\",\n \"0.4640844\",\n \"0.46398926\",\n \"0.45862988\",\n \"0.45844907\",\n \"0.45613056\",\n \"0.4558295\",\n \"0.45362642\",\n \"0.4533591\",\n \"0.45092642\",\n \"0.4467235\",\n \"0.44669557\",\n \"0.4452809\",\n \"0.44360697\",\n \"0.4435155\",\n \"0.4427887\",\n \"0.44111398\",\n \"0.43857205\",\n \"0.43812606\",\n \"0.43759474\",\n \"0.43654087\",\n \"0.43633294\",\n \"0.43566397\",\n \"0.4355602\",\n \"0.43546537\",\n \"0.4345576\",\n \"0.4333257\",\n \"0.43305728\",\n \"0.42977512\",\n \"0.42977512\",\n \"0.42951402\",\n \"0.42951402\",\n \"0.4290339\",\n \"0.42891848\",\n \"0.42840427\",\n \"0.42793128\",\n \"0.4277554\",\n \"0.42750075\",\n \"0.42726076\",\n \"0.42493597\",\n \"0.42467546\",\n \"0.42466953\",\n \"0.4235587\",\n \"0.42317286\",\n \"0.42308465\",\n \"0.42235035\",\n \"0.42210695\",\n \"0.42191964\",\n \"0.42185396\",\n \"0.4218203\",\n \"0.42112675\",\n \"0.42110956\",\n \"0.4208951\",\n \"0.42086047\",\n \"0.42060477\",\n \"0.41972712\",\n \"0.41942963\",\n \"0.41831413\",\n \"0.41819745\",\n \"0.41779587\",\n \"0.41778168\",\n \"0.41736156\",\n \"0.41736114\",\n \"0.41687012\",\n \"0.41674107\",\n \"0.41659346\",\n \"0.41609257\",\n \"0.41564834\",\n \"0.4156434\",\n \"0.41505077\",\n \"0.4148201\",\n \"0.41463363\",\n \"0.4144439\",\n \"0.41420525\",\n \"0.41397375\",\n \"0.41363057\",\n \"0.41347405\",\n \"0.41276276\",\n \"0.41275465\",\n \"0.41271502\",\n \"0.41250062\",\n \"0.41108862\",\n \"0.41099378\",\n \"0.40992537\",\n \"0.40978608\",\n \"0.4097015\",\n \"0.40966487\",\n \"0.40952104\",\n \"0.4091277\",\n \"0.40885136\",\n \"0.4084689\",\n \"0.40818387\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6537572"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88351,"cells":{"query":{"kind":"string","value":"Fit `Nvib` harmonic oscillator and `Nrot` hindered internal rotor modes to the provided dimensionless heat capacities `Cvlist` at temperatures `Tlist` in K. This method assumes that there are relatively few heat capacity points provided, so the vibrations must be combined into one real vibration and two \"pseudovibrations\" and the hindered rotors must be combined into a single \"pseudorotor\"."},"document":{"kind":"string","value":"def fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # x[0] corresponds to the first harmonic oscillator (real) frequency\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # x[1] corresponds to the degeneracy of the second harmonic oscillator\n bounds.append((1.0, float(Nvib - 2)))\n # x[2] corresponds to the second harmonic oscillator pseudo-frequency\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # x[3] corresponds to the third harmonic oscillator pseudo-frequency\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # x[4] corresponds to the hindered rotor pseudo-frequency\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n # x[5] corresponds to the hindered rotor pseudo-barrier\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n x0 = numpy.zeros(6, numpy.float64) # Initial guess\n x0[0] = 300.0\n x0[1] = float(math.floor((Nvib - 1) / 2.0))\n x0[2] = 800.0\n x0[3] = 1600.0\n x0[4] = 100.0\n x0[5] = 300.0\n\n # Execute the optimization\n fit = PseudoFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n Nvib2 = int(round(x[1]))\n Nvib3 = Nvib - Nvib2 - 1\n if Nvib2 < 0 or Nvib2 > Nvib-1 or Nvib3 < 0 or Nvib3 > Nvib-1:\n raise StatmechFitError('Invalid degeneracies {0} and {1} fitted for pseudo-frequencies.'.format(Nvib2, Nvib3))\n\n vib = [x[0]]\n for i in range(Nvib2): vib.append(x[2])\n for i in range(Nvib3): vib.append(x[3])\n hind = []\n for i in range(Nrot):\n hind.append((x[4], x[5]))\n\n return vib, hind"},"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 fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # Bounds for harmonic oscillator frequencies\n for i in range(Nvib):\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # Bounds for pseudo-hindered rotor frequency and barrier height\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n # Initial guesses within each mode type must be distinct or else the\n # optimization will fail\n x0 = numpy.zeros(Nvib + 2, numpy.float64)\n # Initial guess for harmonic oscillator frequencies\n if Nvib > 0:\n x0[0] = 200.0\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\n # Initial guess for hindered rotor frequencies and barrier heights\n x0[Nvib] = 100.0\n x0[Nvib+1] = 300.0\n\n # Execute the optimization\n fit = PseudoRotorFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n vib = list(x[0:Nvib])\n hind = []\n for i in range(Nrot):\n hind.append((x[Nvib], x[Nvib+1]))\n\n return vib, hind","def fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # Bounds for harmonic oscillator frequencies\n for i in range(Nvib):\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # Bounds for hindered rotor frequencies and barrier heights\n for i in range(Nrot):\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n # Initial guesses within each mode type must be distinct or else the\n # optimization will fail\n x0 = numpy.zeros(Nvib + 2*Nrot, numpy.float64)\n # Initial guess for harmonic oscillator frequencies\n if Nvib > 0:\n x0[0] = 200.0\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\n # Initial guess for hindered rotor frequencies and barrier heights\n if Nrot > 0:\n x0[Nvib] = 100.0\n x0[Nvib+1] = 100.0\n for i in range(1, Nrot):\n x0[Nvib+2*i] = x0[Nvib+2*i-2] + 20.0\n x0[Nvib+2*i+1] = x0[Nvib+2*i-1] + 100.0\n\n # Execute the optimization\n fit = DirectFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n vib = list(x[0:Nvib])\n hind = []\n for i in range(Nrot):\n hind.append((x[Nvib+2*i], x[Nvib+2*i+1]))\n\n return vib, hind","def weak_repulsion(Cents,a,k, CV_matrix,n_c,L):\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\n displacement = np.mod(Cents - CCW + L/2,L) - L/2\n rij = np.sqrt(displacement[:,:,0]**2 + displacement[:,:,1]**2)\n norm_disp = (displacement.T/rij.T).T\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\n V_soft = V_soft_CW + V_soft_CCW\n F_soft = np.zeros((n_c, 2))\n for i in range(3):\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\n return F_soft","def specific_heat(Ekinv,n0,N,t0):\n Cv = np.zeros(10)\n for i in range(10):\n avg_K_squared = (1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]))**2\n FluctK = 1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]**2) - avg_K_squared\n Cv[i] = -1 / (FluctK/ avg_K_squared * 3 * N / 2 - 1) * 3 * N / 2\n return Cv","def define_potts_helper_functions(k):\n\n @njit\n def calc_observables(X, k=k):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n\n Returns\n -------\n ndarray\n Dimensions (n_samples, n_observables).\n \"\"\"\n\n n = X.shape[1]\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\n \n # average orientation (magnetization)\n # note that fields for the third state are often set to 0\n counter = 0\n for i in range(k):\n for j in range(n):\n Y[:,counter] = X[:,j]==i\n counter += 1\n \n # pairwise correlations\n for i in range(n-1):\n for j in range(i+1, n):\n Y[:,counter] = X[:,i]==X[:,j]\n counter += 1\n \n return Y\n\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\n \"\"\"\n Parameters\n ----------\n X : ndarray of dtype np.int64\n Dimensions (n_samples, n_spins).\n multipliers : ndarray of dtype np.float64\n\n Returns\n -------\n ndarray\n Energies of each observable.\n \"\"\"\n\n return -calc_observables(X, k).dot(multipliers)\n\n def mch_approximation(sample, dlamda, calc_e=calc_e):\n \"\"\"Function for making MCH approximation step for Potts model.\n \n Parameters\n ----------\n sample : ndarray\n Of dimensions (n_sample, n_spins).\n dlamda : ndarray\n Change in parameters.\n \n Returns\n -------\n ndarray\n Predicted correlations.\n \"\"\"\n\n dE = calc_e(sample, dlamda)\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \n assert not ((predsisj<0).any() or\n (predsisj>(1+1e-10)).any()),\"Predicted values are beyond limits, (%E,%E)\"%(predsisj.min(),\n predsisj.max())\n return predsisj\n\n return calc_e, calc_observables, mch_approximation","def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\n # We move from an array to a list of 2d-array for the competition over each template:\n\n cp=cps[0]\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\n new_cp = 1\n\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\n # update for fixed point:\n new_cp += w_inpIdx*x_eq\n # saving values\n layerEq[inpIdx] = x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n layerEq[inpIdx] = x_eq\n\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\n\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n new_cp += Inhib2/(E0*cp)*x_eq\n\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\n diff_cps = np.zeros(cps.shape)\n if new_cp>=1:\n diff_cps[0] = cp - new_cp\n else:\n diff_cps[0] = 10**3\n for l,m in enumerate(masks):\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\n return diff_cps","def weak_repulsion_boundary(Cents,a,k, CV_matrix,n_c,n_C):\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\n CCW_displacement = Cents - CCW\n rij = np.sqrt(CCW_displacement[:,:,0]**2 + CCW_displacement[:,:,1]**2)\n norm_disp = (CCW_displacement.T/rij.T).T\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\n V_soft = V_soft_CW + V_soft_CCW\n F_soft = np.zeros((n_c, 2))\n for i in range(3):\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\n F_soft[n_C:] = 0\n return F_soft","def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\n # get activation for each seperated vc\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\n max_ch_index = max_ch_index.view(-1, L) # n, L\n\n all_activation_vcs = []\n\n for i in range(len(integrate_activation_vc)):\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\n all_activation_vcs.append(integrate_activation_vc_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n print(f\"unique_vc_i {unique_vc_i.shape}\")\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\n activate_vc_i[index_vc_i, :] = 0.\n all_activation_vcs.append(activate_vc_i)\n \n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\n \n # decompose each mask \n all_masks = []\n for i in range(len(sim_map_max)):\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\n all_masks.append(sim_map_max_i) \n max_ch_index_i = max_ch_index[i] # L,\n unique_vc_i = torch.unique(max_ch_index_i) # k,\n for vc_i in unique_vc_i:\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\n vc_sim_map_max_i[index_vc_i] = 0.\n all_masks.append(vc_sim_map_max_i)\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\n\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\"\n\n return all_activation_vcs, all_masks","def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\n mask, max_iter=100, init=None,\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\n\n # shape of image box\n \n alpha = 1\n\n flat_mask = mask.ravel()\n volume_shape = mask.shape\n H_size = len(Hurst_init)\n\n if lipschitz_constant == 0:\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\n\n #init[\"z\"] = Hurst_init.copy()\n #init[\"t\"] = 1\n #ini[\"stepsize\"] = 1 / lipschitz_constant\n\n def total_energy(x):\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\n\n def unmaskvec(w):\n return _unmask(w, mask)\n\n def maskvec(w):\n return w[flat_mask]\n\n def f1_grad(x):\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\n\n def f2_prox(w, stepsize, dgap_tol, init):\n out, info = _prox_tvl1(unmaskvec(w),\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\n dgap_tol=dgap_tol, init=unmaskvec(init),\n max_iter=prox_max_iter, fista = False,\n verbose=verbose)\n #pdb.set_trace()\n return maskvec(out.ravel()), info\n\n w, obj, init = mfista(\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\n max_iter=max_iter, callback=None)\n \n return w, obj, init","def WakeVorticityFromCirculation_Cont(r_cp,Gamma_cp,R,U0,Omega,bSwirl,method='analytical',bHighThrustCorr=True):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cp[0]==0:\n r_cp[0]=r_cp[1]*0.5;\n # Non dimensional parameters\n k = Omega*Gamma_cp/(np.pi*U0**2)\n vr_bar = r_cp/R \n lambda_r = Omega*r_cp/U0\n # Finding inductions\n a,a_prime,misc= InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method=method,bHighThrustCorr=bHighThrustCorr)\n # Computing convection\n misc['Vz'] = U0*(1-2*a)\n misc['h'] = misc['Vz']*2*np.pi/(Omega*(1+2*a_prime))\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n # Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n gamma_t = - Gamma_tilde/misc['h']\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = 0\n Gamma_r = 0\n return gamma_t,gamma_l,Gamma_r,misc","def Boltzchoice(LFnum, energylist, RNs):\n # transform list to energy values in kT according to experimental\n # affinities and the energy window allowed by the threshold\n energylist = cf.y0 + np.array(energylist) * cf.m\n # calculate norm of initial list\n Norm = sum([math.exp(-ener) for ener in energylist])\n # calculate initial probability vector\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\n # list to catch indices of selected cells\n selected = []\n # cells to be picked: determined by the lesser of #waiters and #LFs\n cellpick = min(len(energylist), LFnum)\n while len(selected) < cellpick:\n bins = np.cumsum(probs)\n ind = np.digitize(RNs.getR(), bins)\n selected.append(ind)\n # now, set the probability of the selected cell to 0 and renormalise\n # the remaining probability vector\n newNorm = Norm - math.exp(-energylist[ind])\n probs[ind] = 0\n probs = probs * Norm / newNorm\n Norm = newNorm\n\n return selected","def non_max_suppression_kneron(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\n if prediction.dtype is torch.float16:\n prediction = prediction.float() # to FP32\n\n nc = prediction[0].shape[1] - 5 # number of classes\n xc = prediction[..., 4] > conf_thres # candidates\n\n # Settings\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\n max_det = 300 # maximum number of detections per image\n time_limit = 10.0 # seconds to quit after\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\n\n t = time.time()\n output = [None] * prediction.shape[0]\n for xi, x in enumerate(prediction): # image index, image inference\n # Apply constraints\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\n x = x[xc[xi]] # confidence\n\n # If none remain process next image\n if not x.shape[0]:\n continue\n\n # Compute conf\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\n\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\n box = xywh2xyxy(x[:, :4])\n\n # Detections matrix nx6 (xyxy, conf, cls)\n if multi_label:\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\n else: # best class only\n conf, j = x[:, 5:].max(1, keepdim=True)\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\n\n\n\n # If none remain process next image\n n = x.shape[0] # number of boxes\n if not n:\n continue\n\n # Sort by confidence\n # x = x[x[:, 4].argsort(descending=True)]\n\n # Batched NMS\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\n # Sort by confidence\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\n x = x[ind_Sort_by_confidence][:top_k_num] #\n # cross classes nms\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\n if i.shape[0] > max_det: # limit detections\n i = i[:max_det]\n\n\n output[xi] = x[i]\n if (time.time() - t) > time_limit:\n break # time limit exceeded\n\n return output","def grid_visibilities(self, visibilities, N = 120):\n logger.info(\"Gridding the visibilities\")\n\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\n\n centres = (ugrid[1:] + ugrid[:-1]) / 2\n\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\n\n if(os.path.exists(self.datafile[0][:-4]+\".kernel_weights.npy\")):\n kernel_weights = np.load(self.datafile[0][:-4]+\".kernel_weights.npy\")\n else:\n kernel_weights=None\n\n if kernel_weights is None:\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\n\n for jj, freq in enumerate(self.frequencies):\n u_bl = (self.baselines[:,0] * freq / const.c).value\n v_bl = (self.baselines[:,1] * freq / const.c).value\n\n beam, indx_u, indx_v = self.fourierBeam(centres, u_bl, v_bl, freq, N=N)\n for kk in range(len(indx_u)):\n visgrid[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk]) * visibilities[kk,jj]\n\n if kernel_weights is None:\n weights[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk])\n\n if kernel_weights is None:\n kernel_weights = weights\n\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\n\n return visgrid,kernel_weights","def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\n max_cp = 1\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n for inpIdx in range(layer.shape[1]):\n #compute of Kactivs,Kinhibs;\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #compute of \"weights\": sum of kactivs and kinhibs\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\n max_cp += w_inpIdx*X0[inpIdx]\n # saving values\n layerEq[inpIdx] = X0[inpIdx]\n olderX[layeridx] = layerEq\n else:\n for inpIdx in range(layer.shape[1]):\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n layerEq[inpIdx] = x_eq\n #compute of Kactivs,Kinhibs, for the current layer:\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\n max_cp += firstComplex + Inhib2/E0*x_eq\n olderX[layeridx] = layerEq\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\n for outputsIdx in range(masks[-1].shape[0]):\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\n max_cp += Inhib2/E0*x_eq\n return max_cp","def error_specific_heat(Cv):\n ncv = 10\n tcv = np.linspace(0,50,ncv) \n \n chi = auto_correlation(tcv,Cv,ncv)\n tau_fit = curve_fit(exp,tcv,chi)\n tau = tau_fit[0]\n\n error_Cv = error(tau,ncv,Cv,tcv) \n\n return error_Cv","def mtvsolverbis(Hurstaest_init, yij, varyj, nj, j1, j2,\n mask, max_iter=100, init=None,\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\n l=1, l1_ratio=0, wtype=1, lipschitz_constant=0):\n\n # shape of image box\n \n alpha = 1\n\n flat_mask = mask.ravel()\n volume_shape = mask.shape\n H_size = len(Hurstaest_init)\n\n if lipschitz_constant == 0:\n lipschitz_constant = H_size * lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\n\n #init[\"z\"] = Hurst_init.copy()\n #init[\"t\"] = 1\n #ini[\"stepsize\"] = 1 / lipschitz_constant\n\n def total_energy(estimation):\n return fbis(estimation, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(estimation[:H_size / 2],\n mask))\n\n def unmaskvec(estimation):\n return _unmask(estimation, mask)\n\n def maskvec(estimation):\n return estimation[flat_mask]\n\n def f1_grad(estimation):\n return gradfbis(estimation, yij, varyj, nj, j1, j2, wtype)\n\n def f2_prox(estimation, stepsize, dgap_tol, init):\n lenw = len(estimation)\n Hurst = estimation[lenw / 2:]\n init = unmaskvec(init[:lenw / 2]) if not init is None else init\n\n out, info = _prox_tvl1(unmaskvec(Hurst),\n weight=(l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\n dgap_tol=dgap_tol, init=init,\n max_iter=prox_max_iter, fista = False,\n verbose=verbose)\n #pdb.set_trace()\n return np.concatenate((maskvec(out.ravel()),estimation[lenw / 2:])), info\n\n w, obj, init = mfista(\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\n max_iter=max_iter, callback=None)\n \n return w, obj, init","def grid_visibilities_parallel(self, visibilities,min_attenuation = 1e-10, N = 120):\n\n #Find out the number of frequencies to process per thread\n nfreq = len(self.frequencies)\n numperthread = int(np.ceil(nfreq/self.n_obs))\n offset = 0\n nfreqstart = np.zeros(self.n_obs,dtype=int)\n nfreqend = np.zeros(self.n_obs,dtype=int)\n infreq = np.zeros(self.n_obs,dtype=int)\n for i in range(self.n_obs):\n nfreqstart[i] = offset\n nfreqend[i] = offset + numperthread\n\n if(i==self.n_obs-1):\n infreq[i] = nfreq - offset\n else:\n infreq[i] = numperthread\n\n offset+=numperthread\n\n # Set the last process to the number of frequencies\n nfreqend[-1] = nfreq\n\n processes = []\n\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\n \n centres = (ugrid[1:] + ugrid[:-1]) / 2\n \n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\n\n\n if(os.path.exists(self.datafile[0][:-4]+\".kernel_weights.npy\")):\n kernel_weights = np.load(self.datafile[0][:-4]+\".kernel_weights.npy\")\n else:\n kernel_weights=None\n \n if kernel_weights is None:\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\n\n visgrid_buff_real = []\n visgrid_buff_imag = []\n weights_buff = []\n\n #Lets split this array up into chunks\n for i in range(self.n_obs):\n\n visgrid_buff_real.append(multiprocessing.RawArray(np.sctype2char(visgrid.real),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\n visgrid_buff_imag.append(multiprocessing.RawArray(np.sctype2char(visgrid.imag),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\n visgrid_tmp_real = np.frombuffer(visgrid_buff_real[i])\n visgrid_tmp_imag = np.frombuffer(visgrid_buff_imag[i])\n visgrid_tmp_real = visgrid[:,:,nfreqstart[i]:nfreqend[i]].real.flatten()\n visgrid_tmp_imag = visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag.flatten()\n\n\n if(kernel_weights is None):\n weights_buff.append(multiprocessing.RawArray(np.sctype2char(weights),weights[:,:,nfreqstart[i]:nfreqend[i]].size))\n weights_tmp = np.frombuffer(weights_buff[i])\n weights_tmp = weights[:,:,nfreqstart[i]:nfreqend[i]]\n else:\n weights_buff.append(None)\n\n processes.append(multiprocessing.Process(target=self._grid_visibilities_buff,args=(self.n_uv,visgrid_buff_real[i],visgrid_buff_imag[i],weights_buff[i], visibilities[:,nfreqstart[i]:nfreqend[i]],self.frequencies[nfreqstart[i]:nfreqend[i]],self.baselines,centres,self._instr_core.sigma(self.frequencies[nfreqstart[i]:nfreqend[i]]),min_attenuation, N) ))\n\n for p in processes:\n p.start()\n\n for p in processes:\n p.join()\n\n for i in range(self.n_obs):\n\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].real = np.frombuffer(visgrid_buff_real[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag = np.frombuffer(visgrid_buff_imag[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n\n if(kernel_weights is None):\n weights[:,:,nfreqstart[i]:nfreqend[i]] = np.frombuffer(weights_buff[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\n\n if kernel_weights is None:\n kernel_weights = weights\n \n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\n\n return visgrid,kernel_weights","def showCortexImg(pV,nV):\n # object arrays of the positive and negative images\n pos_cort_img = np.empty(8, dtype=object)\n neg_cort_img = np.empty(8, dtype=object)\n for t in range(8):\n # cortical mapping functions\n lpos, rpos = cortex.cort_img(pV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\n lneg, rneg = cortex.cort_img(nV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\n pos_cort_img[t] = np.concatenate((np.rot90(lpos),np.rot90(rpos,k=3)),axis=1)\n neg_cort_img[t] = np.concatenate((np.rot90(lneg),np.rot90(rneg,k=3)),axis=1)\n # stack all images into a grid\n posRGcort = np.vstack((pos_cort_img[:4]))\n negRGcort = np.vstack((neg_cort_img[:4]))\n posYBcort = np.vstack((pos_cort_img[4:]))\n negYBcort = np.vstack((neg_cort_img[4:]))\n mergecort = np.concatenate((posRGcort,negRGcort,posYBcort,negYBcort),axis=1)\n return mergecort","def define_pseudo_potts_helper_functions(n, k):\n\n assert n>1\n assert k>1\n\n @njit\n def get_multipliers_r(r, multipliers, n=n, k=k):\n \"\"\"Return r's field and all couplings to spin r.\n\n Parameters\n ----------\n r : int\n multipliers : ndarray\n All fields and couplings concatenated together.\n\n Returns\n -------\n ndarray\n Relevant multipliers.\n list\n Index of where multipliers appear in full multipliers array.\n \"\"\"\n \n ix = [r+n*i for i in range(k)]\n multipliersr = np.zeros(k-1+n)\n for i in range(k):\n multipliersr[i] = multipliers[r+n*i]\n\n # fill in the couplings\n ixcounter = k\n for i in range(n):\n if i!=r:\n if i<r:\n ix.append( sub_to_ind(n, i, r) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n else:\n ix.append( sub_to_ind(n, r, i) + k*n )\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\n ixcounter += 1\n return multipliersr, ix\n\n @njit\n def calc_observables_r(r, X, n=n, k=k):\n \"\"\"Return the observables relevant for calculating the conditional probability of\n spin r.\n\n Parameters\n ----------\n r : int\n Spin index.\n X : ndarray\n Data samples of dimensions (n_samples, n_dim).\n\n Returns\n -------\n ndarray\n observables\n list of ndarray\n observables if spin r were to occupy all other possible states\n ndarray\n Each col details the occupied by spin r in each array of the previous return\n value, i.e., the first col of this array tells me what r has been changed to\n in the first array in the above list.\n \"\"\"\n\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n # keep another copy of observables where the spin iterates thru all other possible states\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\n for i in range(k-1)]\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\n \n # for each data sample in X\n for rowix in range(X.shape[0]):\n counter = 0\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\n for i in range(k):\n if X[rowix,r]==i:\n obs[rowix,i] = 1\n else:\n otherobs[counter][rowix,i] = 1\n otherstates[rowix,counter] = i\n counter += 1\n ixcounter = k\n \n for i in range(n-1):\n for j in range(i+1,n):\n if i==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\n kcounter += 1\n ixcounter += 1\n elif j==r:\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\n kcounter = 0\n for state in range(k):\n if state!=X[rowix,r]:\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\n kcounter += 1\n ixcounter += 1\n return obs, otherobs, otherstates\n\n return get_multipliers_r, calc_observables_r","def optimize_force_field_parameters_Cv_FWHM(cgmodel, file_list, temperature_list, param_bounds_dict,\n frame_begin=0, frame_end=-1, sample_spacing=1, sparsify_stride=1, output_data='output.nc',\n verbose=False, n_cpu=12, min_eff_samples=50,\n n_trial_boot=200, num_intermediate_states=0, plotfile='optimize_FWHM_iterations.pdf',\n min_method='TNC'):\n\n # Parse the force field parameter change dict:\n x0 = []\n param_names = []\n bounds = []\n units = []\n \n for key,value in param_bounds_dict.items():\n # value should be [(bound_lo, bound_hi)]\n # key should be a valid force field parameter name\n param_names.append(key)\n # Every parameter except periodicity should have units\n # For now, changing periodicity is not supported.\n \n # TODO: add support for sums of periodic torsion terms\n units.append(value[0].unit)\n bounds.append((value[0].value_in_unit(units[-1]),value[1].value_in_unit(units[-1])))\n # Use mean value as starting guess:\n x0.append((value[1].value_in_unit(units[-1])+value[0].value_in_unit(units[-1]))/2)\n\n if verbose:\n print(f'param_names: {param_names}')\n print(f'unit: {units}')\n print(f'bounds: {bounds}')\n print(f'x0: {x0}')\n\n def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n \"\"\"\n Objective function to be minimized\n \"\"\"\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)\n\n # Run optimization:\n\n # if len(param_names) == 1:\n # # Do scalar optimization:\n # opt_results = minimize_scalar(get_reeval_FWHM, x0,\n # args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\n # frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\n # method='bounded',\n # bounds=[bounds[0][0],bounds[0][1]],\n # options={'maxiter': 25},\n # )\n\n # else:\n # Do multivariate optimization:\n opt_results = minimize(get_reeval_FWHM, x0, jac='2-point',\n args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\n frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\n method=min_method,\n bounds=bounds,\n options={'maxfun': 25, 'finite_diff_rel_step': 0.005, 'eta': 0.5}, # This should be user input\n ) \n \n # TODO: plot the heat capacity curves at each iteration, and make a plot of all FWHM_values \n\n # Construct dictionary of optimal parameters:\n opt_param_dict = {} \n \n k = 0\n for key,value in param_bounds_dict.items():\n opt_param_dict[key] = opt_results.x[k] * units[k]\n k += 1\n \n return opt_param_dict, opt_results","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 set_voltages(): \n #0) set parameters\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\n import pickle\n with open(trapFile,'rb') as f:\n trap = pickle.load(f)\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\n tc=trap.configuration\n C = tc.multipoleControl\n el = []\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\n if tc.trap_knobs != True:\n return 'WARNING: You must run trap_knobs first!'\n #2a) determine electrode voltages directly\n elif multipoleControls: # note plurality to contrast from attribute\n el = np.dot(C,coefs.T) # these are the electrode voltages\n #2b) determine electrode volages indirectly\n else:\n charge = tc.charge\n mass = tc.mass\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\n U2 = az*V0/8\n U1 = U2+ax*V0/4\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\n U1p= np.sqrt(U1**2+U3**2/2)\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\n mCf = tc.multipoleCoefficients[1:9,:]\n el = np.dot(mCf.T,inp) # these are the electrode voltages\n el = np.real(el)\n #3) regularize if set to do so\n reg = 0\n if reg: \n C = el\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\n Lambda=Lambda[0]\n el = el-(np.dot(tc.multipoleKernel,Lambda))\n return el","def spec_helm_decomp(k,Cu,Cv,GM=False):\n dk = k[1]-k[0]\n s = np.log(k)\n\n Fphi = np.zeros_like(Cu)\n Fpsi = np.zeros_like(Cu)\n Cphi = np.zeros_like(Cu)\n Cpsi = np.zeros_like(Cu)\n\n # assume GM for decomposing into wave and vortex\n if GM:\n gm = np.load(\"/Users/crocha/Projects/dp_spectra/GM/gm_omega_star.npz\")\n f2omg2 = gm['rgm']\n ks = gm['k']*1.e3\n\n for i in range(s.size-1):\n\n ds = np.diff(s[i:])\n\n sh = sinh(s[i]-s[i:])\n ch = cosh(s[i]-s[i:])\n\n # the function to integrate\n Fp = Cu[i:]*sh + Cv[i:]*ch\n Fs = Cv[i:]*sh + Cu[i:]*ch\n\n # integrate using Simpson's rule\n Fpsi[i] = integrate.simps(Fs,s[i:])\n Fphi[i] = integrate.simps(Fp,s[i:])\n\n # zero out unphysical values\n Fpsi[Fpsi < 0.] = 0.\n Fphi[Fphi < 0.] = 0.\n\n # compute rotational and divergent components\n Cpsi = Fpsi - Fphi + Cu\n Cphi = Fphi - Fpsi + Cv\n\n if GM:\n\n f2omg2i = np.interp(k,ks,f2omg2)\n\n Cv_w = f2omg2i*Fphi - Fpsi + Cv\n Cv_v = Cv - Cv_w\n \n kdkromg = diff_central(ks, f2omg2)\n kdkromg = np.interp(k,ks[1:-1],kdkromg)\n\n dFphi = diff_central(k, Fphi)\n #dFphi = np.gradient(Fphi,k)\n dFphi = np.interp(k,k[1:-1],dFphi.real)\n E_w = Fphi - k*dFphi\n\n Cu_w = -k*kdkromg*Fphi + f2omg2i*(-Fpsi+Cv) + Fphi\n Cu_v = Cu - Cu_w\n\n Cb_w = E_w - (Cu_w + Cv_w)/2.\n\n return Cpsi,Cphi, Cu_w,Cv_w, Cu_v,Cv_v, E_w, Cb_w\n\n else:\n return Cpsi,Cphi","def estimate_opt_eff(self, iv_fn_hot, iv_fn_cold,t_hot=293.,t_cold=77.,\n channels = None, dPdT_lim=(0.,0.5)):\n ivs_hot = np.load(iv_fn_hot).item()\n ivs_cold = np.load(iv_fn_cold).item()\n \n iv_fn_raw_hot = iv_fn_hot.split('.')[0] + '_raw_data.npy'\n iv_fn_raw_cold = iv_fn_cold.split('.')[0] + '_raw_data.npy'\n\n ivs_raw_hot = np.load(iv_fn_raw_hot).item()\n ivs_raw_cold = np.load(iv_fn_raw_cold).item()\n \n basename_hot = ivs_raw_hot['basename']\n basename_cold = ivs_raw_cold['basename']\n\n #band = ivs_raw_hot['band']\n #assert ivs_raw_cold['band'] == band, \\\n # 'Files must contain IVs from the same band'\n group = ivs_raw_hot['bias group']\n assert ivs_raw_cold['bias group'], \\\n 'Files must contain IVs from the same bias group'\n \n import matplotlib.pyplot as plt\n plot_dir = self.plot_dir\n\n dT = t_hot - t_cold\n dPdT_list = []\n n_outliers = 0\n for ch in ivs_hot:\n if channels is not None:\n if ch not in channels:\n continue\n elif not isinstance(ch,np.int64):\n continue\n \n if ch not in ivs_cold:\n continue\n \n P_hot = ivs_hot[ch]['P']\n P_cold = ivs_cold[ch]['P']\n R_hot = ivs_hot[ch]['R']\n R_cold = ivs_cold[ch]['R']\n Ptrans_hot = ivs_hot[ch]['Ptrans']\n Ptrans_cold = ivs_cold[ch]['Ptrans']\n if Ptrans_hot is None or Ptrans_cold is None:\n print('Missing in-transition electrical powers for Ch. %i' % (ch))\n continue\n dPdT = (Ptrans_cold - Ptrans_hot)/dT\n self.log('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\n if dPdT_lim is not None:\n if dPdT >= dPdT_lim[0] and dPdT <= dPdT_lim[1]:\n dPdT_list.append(dPdT)\n else:\n n_outliers += 1\n else:\n dPdT_list.append(dPdT)\n\n fig_pr,ax_pr = plt.subplots(1,sharex=True)\n ax_pr.set_xlabel(r'$R_\\mathrm{TES}$ [$\\Omega$]')\n ax_pr.set_ylabel(r'$P_\\mathrm{TES}$ [pW]')\n label_hot = '%s: %.0f K' % (basename_hot,t_hot)\n label_cold = '%s: %.0f K' % (basename_cold,t_cold)\n ax_pr.axhline(y=Ptrans_hot,linestyle = '--',color = 'b')\n ax_pr.axhline(y=Ptrans_cold,linestyle = '--',color = 'r')\n ax_pr.plot(R_hot,P_hot,label=label_hot,color='b')\n ax_pr.plot(R_cold,P_cold,label=label_cold,color='r')\n ax_pr.legend(loc='best')\n fig_pr.suptitle('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\n ax_pr.grid()\n \n plot_name = basename_hot + '_' + basename_cold + '_optEff_g{}_ch{:03}.png'.format(group, ch)\n plot_filename = os.path.join(plot_dir, plot_name)\n self.log('Saving optical-efficiency plot to {}'.format(plot_filename))\n plt.savefig(plot_filename,bbox_inches='tight', dpi=300)\n plt.close()\n\n plt.figure()\n plt.hist(dPdT_list,edgecolor='k')\n plt.xlabel('dP/dT [pW/K]')\n plt.grid()\n dPdT_median = np.median(dPdT_list)\n plt.title('Group {}, median = {:.3f} pW/K ({} outliers not plotted)'.format(group,dPdT_median,n_outliers))\n plot_name = basename_hot + '_' + basename_cold + '_dPdT_hist_g{}.png'.format(group)\n hist_filename = os.path.join(plot_dir,plot_name)\n self.log('Saving optical-efficiency histogram to {}'.format(hist_filename))\n plt.savefig(hist_filename,bbox_inches='tight',dpi=300)\n plt.close()","def main():\n # Directory where the DICOM files are being stored (in this\n input_path = './Inputs/valve'\n\n # Original image from the filepath\n img_original = read_image(input_path)\n\n # Image with smoothing applied to reduce noise\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\n\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\n\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \"blood\" without cardiac tissue,\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\n # valve tissue from the rest - all we need is the overlap of the two labels\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\n\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\n\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\n x_mid = df['x'].mean()\n y_mid = df['y'].mean()\n df = get_df_from_img(labels_valve_filtered)\n distance_df = df.drop('z', axis=1)\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\n labels = fit.labels_\n df['label'] = pd.Series(labels)\n counts = df['label'].value_counts().to_dict()\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\n\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\n start, end = filter_by_label_count(labels_valve_filtered, 10)\n img_smooth = img_smooth[:, :, start:end]\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\n\n # Use a segmentation-based clustering algorithm to attempt to find each valve\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\n\n left, right = (label_segments[0], label_segments[1])\n if x_max[0] > x_max[1]:\n left, right = right, left\n\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\n # this can be done by every z value\n left_points = {'x': [], 'y': [], 'z': []}\n right_points = {'x': [], 'y': [], 'z': []}\n zlen = len(sitk.GetArrayFromImage(left))\n for z in xrange(zlen):\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\n if len(left_df['y']) > 0:\n index = left_df['y'].idxmin()\n row = left_df.iloc[index]\n left_points['x'].append(int(row['x']))\n left_points['y'].append(int(row['y']))\n left_points['z'].append(z)\n\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\n if len(right_df['x']) > 0:\n index = right_df['x'].idxmax()\n row = right_df.iloc[index]\n right_points['x'].append(int(row['x']))\n right_points['y'].append(int(row['y']))\n right_points['z'].append(z)\n\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\n # points\n final_left = pd.DataFrame.from_dict(left_points)\n final_right = pd.DataFrame.from_dict(right_points)\n print('Coordinates for one side of the ring')\n print(final_left)\n print('\\n\\nCoordinates for the other side of the ring')\n print(final_right)\n\n final_image = make_empty_img_from_img(left)\n x = left_points['x'] + right_points['x']\n y = left_points['y'] + right_points['y']\n z = left_points['z'] + right_points['z']\n for x, y, z in zip(x, y, z):\n final_image.SetPixel(x, y, z, 1)\n\n show_all(img_smooth, final_image)","def compute_autocorrelation_rlzn_ensemble(fopen_list, te):\n print 'Compute the autocorrelation'\n\n # initialize components of rho\n sumuu = 0.0\n sumvv = 0.0\n\n psiuu = 0.0\n psivv = 0.0\n\n sumup2 = 0.0\n sumvp2 = 0.0\n\n # get characteristics of mean velocity field\n fbs = netCDF4.Dataset('buoyancySurface.nc','r')\n lonCell = fbs.variables['lonCell']\n latCell = fbs.variables['latCell']\n lon = np.degrees(np.mod(lonCell[:]+np.pi,2*np.pi)-np.pi)\n lat = np.degrees(latCell[:])\n hull = spatial.ConvexHull(np.vstack((lon,lat)).T) \n triang = Triangulation(lon,lat)\n buoy_surf_zonal = fbs.variables['buoyancySurfaceVelocityZonal']\n buoy_surf_merid = fbs.variables['buoyancySurfaceVelocityMeridional']\n\n \n # build up layers for interpolation of particle layers\n interp_zonal = []\n interp_merid = []\n nlayers = len(fbs.dimensions['nBuoyancySurfaces'])\n for alayer in np.arange(nlayers):\n interp_zonal.append(LinearTriInterpolator(triang, buoy_surf_zonal[0,:,alayer]))\n interp_merid.append(LinearTriInterpolator(triang, buoy_surf_merid[0,:,alayer]))\n\n for num, afile in enumerate(fopen_list):\n print 'working on %d' % num\n # interpolate mean velocities onto points for the computation\n x = afile.variables['xParticle'][:te,:]\n y = afile.variables['yParticle'][:te,:]\n z = afile.variables['zParticle'][:te,:]\n latr, lonr = proj_lat_long(x,y,z)\n latr = np.degrees(latr)\n lonr = np.degrees(lonr)\n\n ubar = np.zeros(x.shape)\n vbar = np.zeros(x.shape)\n nparticle_layer = x.shape[1]/nlayers\n for alayer in np.arange(nlayers):\n ps = np.arange(alayer*nparticle_layer,(alayer+1)*nparticle_layer)\n ubar[:,ps] = interp_zonal[alayer](lonr[:,ps],latr[:,ps])\n vbar[:,ps] = interp_merid[alayer](lonr[:,ps],latr[:,ps])\n\n # compute portions of autocorrelation\n u = afile.variables['lonVel'][:te,:]\n up = u - ubar\n up0 = up[0,:]\n\n v = afile.variables['latVel'][:te,:]\n vp = v - vbar\n vp0 = vp[0,:]\n\n sumuu += up0*up\n sumvv += vp0*vp\n\n psiuu += up0*up0\n psivv += vp0*vp0\n \n sumup2 += np.nanmean(up**2.0, axis=0)\n sumvp2 += np.nanmean(vp**2.0, axis=0)\n \n\n fbs.close()\n\n # note division by psi removes need to divide the sums by the number of realizations\n sumuu /= psiuu \n sumvv /= psivv\n\n sumup2 /= len(fopen_list)\n sumvp2 /= len(fopen_list)\n\n print 'done'\n\n return sumuu, sumvv, sumup2, sumvp2, lonr[0,:], latr[0,:], lon, lat, hull","def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\n \n # INPUTS FROM TTTW SYSTEM\n self.b = b #buoyancy field: [Ly,N]\n self.u = u # x-component of velocity [Ly,N]\n self.v = v # y-component of velocity [Ly+1,N]\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\n self.grid_dict = grid_dict #gridded data\n self.f = f #coriolis parameter\n # KPP-SPECIFIC VARIABLES \n self.hbls = np.zeros([self.b.shape[0]])\n self.hbbl = np.zeros([self.b.shape[0]])\n self.ustar = []\n self.bvf = [] \n self.kmo = []\n self.C_h_MO = []\n self.kbl = []\n self.Cr = [] \n self.Fc = []\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\n self.dt = dt","def attach_to_controller(self, controller):\r\n\r\n def cv_amp(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n return np.std(amps) / np.mean(amps) if len(amps) >= 1 else 0\r\n\r\n def cum_amp_drift(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n # return cum_feat(amps) if len(amps) >= 2 else 0\r\n return np.sum(np.abs(np.diff(amps))) / len(amps) if len(amps) >= 2 else 0\r\n\r\n def cum_depth_drift(cluster_id):\r\n depths = controller.model.spike_depths[controller.get_spike_ids(cluster_id)].data\r\n # return cum_feat(depths) if len(depths) >= 2 else 0\r\n return np.sum(np.abs(np.diff(depths))) / len(depths) if len(depths) >= 2 else 0\r\n\r\n def cv_fr(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n fr = bb.singlecell.firing_rate(ts, hist_win=0.01, fr_win=0.25)\r\n return np.std(fr) / np.mean(fr) if len(fr) >= 1 else 0\r\n\r\n def frac_isi_viol(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n frac_isi_viol, _, _ = isi_viol(ts, rp=0.002)\r\n return frac_isi_viol\r\n\r\n def frac_missing_spikes(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n try:\r\n frac_missing_spks, _, _ = feat_cutoff(\r\n amps, spks_per_bin=10, sigma=4, min_num_bins=50)\r\n except:\r\n frac_missing_spks = np.NAN\r\n return frac_missing_spks\r\n\r\n def fp_estimate(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n return fp_est(ts, rp=0.002)\r\n\r\n def presence_ratio(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n pr, _ = pres_ratio(ts, hist_win=10)\r\n return pr\r\n\r\n def presence_ratio_std(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n pr, pr_bins = pres_ratio(ts, hist_win=10)\r\n return pr / np.std(pr_bins)\r\n\r\n def refp_viol(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n return FP_RP(ts)\r\n\r\n def n_cutoff(cluster_id):\r\n amps = controller.get_amplitudes(cluster_id).data\r\n return noise_cutoff(amps, quartile_length=.25)\r\n\r\n def mean_amp_true(cluster_id):\r\n # Three cases: raw data\r\n\r\n # THIS APPROACH WORKS FOR BOTH SAMPLE WAVEFORMS AND RAW DATA\r\n # Specify 100 waveforms to average over, but may be less in the case where in the subset\r\n # of sample waveforms it doesn't contain 100 samples for specific cluster\r\n\r\n # N.B. These waveforms are median subtracted and have a high pass applied\r\n waveforms = controller._get_waveforms_with_n_spikes(\r\n cluster_id, 100)['data'].data\r\n\r\n # This way finds (max-min) on each channel, and then for each waveform finds the\r\n # maximum (max-min) on any channel and averages these\r\n # For each sample waveform find value on channel that has largest (max-min)\r\n p2p = np.max((np.max(waveforms, axis=1) - np.min(waveforms, axis=1)), axis=1)\r\n # Find mean p2p across all available sample waveforms\r\n p2p_mean = np.mean(p2p)\r\n\r\n # Alternative way\r\n # This way finds (max-min) on each channel, on each channel averages across all sample\r\n # waveforms and then finds the channel with the maximum average value\r\n p2p_mean_alt = np.max(np.mean(np.max(waveforms, axis=1) - np.min(waveforms, axis=1),\r\n axis=0))\r\n\r\n # Approach 2\r\n # Only works for sample waveforms\r\n # For non median subtracted and no high pass can access sample waveforms like this\r\n # spike_ids = controller.get_spike_ids(cluster_id).data\r\n # # Find which of the spike ids are in the subset of sample waveforms\r\n # _, _, idx = np.intersect1d(spike_ids,\r\n # controller.model.spike_waveforms['spike_ids'].data,\r\n # return_indices=True)\r\n # # Sample waveforms that are available for this cluster\r\n # # Shape of waveforms (n_waveforms, n_samples, n_channels)\r\n # # where len(idx) == n_waveforms\r\n # waveforms = controller.model.spike_waveforms['waveforms'][idx].data\r\n\r\n # RAW DATA CASE\r\n\r\n return p2p_mean\r\n\r\n # no waveforms\r\n\r\n # def ptp_sigma(cluster_id):\r\n # this also requires checking 3 cases above.\r\n\r\n def m_label(cluster_id):\r\n ts = controller.get_spike_times(cluster_id).data\r\n amps = controller.get_amplitudes(cluster_id).data\r\n metrics_label = int(FP_RP(ts) and noise_cutoff(amps, quartile_length=.25) < 20)\r\n return metrics_label\r\n # if amplitudes are correct (i.e. raw data or sample wfs exist):\r\n #metrics_label = (FP_RP(ts) and noise_cutoff(amps,quartile_length=.25)<20 and np.mean(amps)>50)\r\n\r\n # Use this dictionary to define custom cluster metrics.\r\n # We memcache the function so that cluster metrics are only computed once and saved\r\n # within the session, and also between sessions (the memcached values are also saved\r\n # on disk).\r\n controller.cluster_metrics['cv_amp'] = controller.context.memcache(cv_amp)\r\n controller.cluster_metrics['cum_amp_drift'] = controller.context.memcache(cum_amp_drift)\r\n\r\n # NOTE: the branch of phylib which defines model.spike_depths is not working yet\r\n # controller.cluster_metrics['cum_depth_drift'] = controller.context.memcache(\r\n # cum_depth_drift)\r\n\r\n controller.cluster_metrics['cv_fr'] = controller.context.memcache(cv_fr)\r\n controller.cluster_metrics['frac_isi_viol'] = controller.context.memcache(frac_isi_viol)\r\n controller.cluster_metrics['frac_missing_spikes'] = controller.context.memcache(\r\n frac_missing_spikes)\r\n controller.cluster_metrics['fp_estimate'] = controller.context.memcache(fp_estimate)\r\n controller.cluster_metrics['presence_ratio'] = controller.context.memcache(presence_ratio)\r\n controller.cluster_metrics['presence_ratio_std'] = controller.context.memcache(\r\n presence_ratio_std)\r\n controller.cluster_metrics['refp_viol'] = controller.context.memcache(refp_viol)\r\n controller.cluster_metrics['noise_cutoff'] = controller.context.memcache(n_cutoff)\r\n controller.cluster_metrics['mean_amp'] = controller.context.memcache(mean_amp_true)\r\n controller.cluster_metrics['metrics_label'] = controller.context.memcache(m_label)","def WakeVorticityFromCt(r,Ct,R,U0,Omega):\n if Omega==np.inf:\n Omega=800 # TODO, implement infinite lambd formulae directly\n Lambda=Omega*R/U0\n bSwirl=Lambda<20\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\n Gamma = vk*np.pi*U0**2/Omega\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)","def WakeVorticityFromCt(r,Ct,R,U0,Omega):\n if Omega==np.inf:\n Omega=800 # TODO, implement infinite lambd formulae directly\n Lambda=Omega*R/U0\n bSwirl=Lambda<20\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\n Gamma = vk*np.pi*U0**2/Omega\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)","def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cyl is None:\n r_cyl = np.zeros(r_cp.shape)\n if len(r_cyl)==1:\n r_cyl=np.array([R])\n else:\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\n else:\n r_cyl = np.asarray(r_cyl).ravel()\n misc={}\n # --- Checks\n if np.amax(r_cyl) < np.amax(r_cp):\n warnings.warn('Cylinders are assumed to enclose the control points')\n import pdb; pdb.set_trace()\n if r_cyl[0] == 0:\n raise Exception('First cylinder at 0, impossible')\n\n ## Interpolating Circulation on the control points\n Gamma_cp = Gamma_cp * nB # IMPORTANT\n lambda_rcp = Omega*r_cp/U0\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\n ## Some init\n\n n = len(r_cyl)\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n # --- Case 1: Using k / ct to determine gamma\n # Using a_prime to correct Ct\n # Tangential convection velocity\n if not bTanInd_k:\n ap_cyl_conv = 0 * Gamma_cp\n else:\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\n # See Equation (26) of [1]: a'_c,i = (\\Gamma_i+\\Gamma_i+1)/(4 pi Omega R_i^2)\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\n # --- Allocation\n b = np.zeros(n) # Cummulative sum of gamma_bar\n S = np.zeros(n) # Term under the square root\n Sbis = np.zeros(n) # Term under the square root, account\n Ctrot = np.zeros(n)\n Ctrot_loc = np.zeros(n)\n Cti = np.zeros(n)\n Cteff = np.zeros(n)\n gamma_t_bar = np.zeros(n)\n # --- Init\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\n lambda_R = Omega * r_cyl / U0\n # Looping through radii in reversed order\n for i in np.arange(n-1,-1,-1):\n if i==n-1:\n b[i] = 1\n S[i] = 1 - C[i]\n Sbis[i] = 1 - C[i]\n Ctrot[i] = 0\n Ctrot_loc[i] = 0\n else:\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\n if not bSwirl:\n Ctrot[i] = 0\n Cti[i] = k_r[i]\n else:\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\n Sbis[i] = 1 - Cteff[i]\n if bSwirl :\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\n else:\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \n# print('b',b,'S',S)\n if bHighThrustCorr:\n if (Cteff[i] > Ct_c):\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\n #if np.abs(imag(gamma_t_bar(i))) > 0:\n # gamma_t_bar[i] = - b[i] + 0\n Vc = U0 * (b + gamma_t_bar / 2)\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\n\n\n # Analytical 1\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\n a_1=a_1[-1::-1]\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\n a=a_1;\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\n # # Analytical 2\n # a_2=-(gamma_t_hat/2)/U0;\n # a=a_2;\n #else\n # a=a_1;\n #end\n if bSwirl:\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\n else:\n a_prime=a*0\n\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n misc['h'] = h\n\n # --- Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n #gamma_t = - Gamma_tilde/h\n gamma_t = gamma_t_bar * U0\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = None\n Gamma_r = None\n\n return gamma_t,gamma_l,Gamma_r, misc","def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\n r_cp = np.asarray(r_cp).ravel()\n Gamma_cp = np.asarray(Gamma_cp).ravel()\n if r_cyl is None:\n r_cyl = np.zeros(r_cp.shape)\n if len(r_cyl)==1:\n r_cyl=np.array([R])\n else:\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\n else:\n r_cyl = np.asarray(r_cyl).ravel()\n misc={}\n # --- Checks\n if np.amax(r_cyl) < np.amax(r_cp):\n warnings.warn('Cylinders are assumed to enclose the control points')\n import pdb; pdb.set_trace()\n if r_cyl[0] == 0:\n raise Exception('First cylinder at 0, impossible')\n\n ## Interpolating Circulation on the control points\n Gamma_cp = Gamma_cp * nB # IMPORTANT\n lambda_rcp = Omega*r_cp/U0\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\n ## Some init\n\n n = len(r_cyl)\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n # --- Case 1: Using k / ct to determine gamma\n # Using a_prime to correct Ct\n # Tangential convection velocity\n if not bTanInd_k:\n ap_cyl_conv = 0 * Gamma_cp\n else:\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\n # See Equation (26) of [1]: a'_c,i = (\\Gamma_i+\\Gamma_i+1)/(4 pi Omega R_i^2)\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\n # --- Allocation\n b = np.zeros(n) # Cummulative sum of gamma_bar\n S = np.zeros(n) # Term under the square root\n Sbis = np.zeros(n) # Term under the square root, account\n Ctrot = np.zeros(n)\n Ctrot_loc = np.zeros(n)\n Cti = np.zeros(n)\n Cteff = np.zeros(n)\n gamma_t_bar = np.zeros(n)\n # --- Init\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\n lambda_R = Omega * r_cyl / U0\n # Looping through radii in reversed order\n for i in np.arange(n-1,-1,-1):\n if i==n-1:\n b[i] = 1\n S[i] = 1 - C[i]\n Sbis[i] = 1 - C[i]\n Ctrot[i] = 0\n Ctrot_loc[i] = 0\n else:\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\n if not bSwirl:\n Ctrot[i] = 0\n Cti[i] = k_r[i]\n else:\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\n Sbis[i] = 1 - Cteff[i]\n if bSwirl :\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\n else:\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \n# print('b',b,'S',S)\n if bHighThrustCorr:\n if (Cteff[i] > Ct_c):\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\n #if np.abs(imag(gamma_t_bar(i))) > 0:\n # gamma_t_bar[i] = - b[i] + 0\n Vc = U0 * (b + gamma_t_bar / 2)\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\n\n\n # Analytical 1\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\n a_1=a_1[-1::-1]\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\n a=a_1;\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\n # # Analytical 2\n # a_2=-(gamma_t_hat/2)/U0;\n # a=a_2;\n #else\n # a=a_1;\n #end\n if bSwirl:\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\n else:\n a_prime=a*0\n\n misc['a'] = a\n misc['a_prime'] = a_prime\n misc['Gamma_cp'] = Gamma_cp\n misc['r_cp'] = r_cp\n misc['h'] = h\n\n # --- Vortex intensities\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\n #gamma_t = - Gamma_tilde/h\n gamma_t = gamma_t_bar * U0\n if bSwirl:\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\n Gamma_r = - Gamma_cp[0]\n else:\n gamma_l = None\n Gamma_r = None\n\n return gamma_t,gamma_l,Gamma_r, misc","def compute_mixing_coefficients_bot(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n\n v_upts = TTTW_func.v2u(self.v)\n\n self.sigma_bot = []\n self.Kv0 = np.zeros([Ly,N+1])\n self.Kt0 = np.zeros([Ly,N+1])\n for j in range(Ly):\n # turbulent velocity sclaes with buoyancy effects neglected\n ustar2 = self.r_D[j] * np.sqrt(self.u[j,0]**2 + v_upts[j,0]**2)\n wm = self.vonKar * np.sqrt(ustar2)\n ws = wm\n \n for k in range(1,N):\n k_w = k\n k_r = k - 1\n\n if k_w < self.kbl[j]: # NEED Zob\n sigma = np.min( [ ((z_u_w[j,k_w] - z_u_w[j,0] + self.Zob) / (self.hbbl[j] + self.Zob)),1.])\n if j ==1:\n self.sigma_bot.append(sigma)\n a1 = sigma - 2.\n a2 = 3. - 2.*sigma\n a3 = sigma - 1.\n\n self.Kv0[j,k_w] = wm * self.hbbl[j] * ( sigma * (1. + sigma * ( a1 + a2*self.Gm1_bot[j]+a3*self.dGm1_dS_bot[j]))) \n self.Kt0[j,k_w] = ws * self.hbbl[j] * ( sigma * (1. + sigma * ( a1 + a2*self.Gt1_bot[j]+a3*self.dGt1_dS_bot[j])))","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def compute_mixing_coefficients_surf(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n\n # SET UP NEW MIXING COEFFICIENT ARRAYS\n self.Kv_surf = np.zeros([Ly,N+1])\n self.Kt_surf = np.zeros([Ly,N+1])\n \n self.ghat = np.zeros([Ly,N+1])\n \n\n #################################\n # \tSURFACE KPP\n ################################\n #---> j-loop\n \n self.wm2 = []\n self.ws2 = []\n self.sigma_y = []\n for j in range(Ly):\n #--> k-loop (top to kbl[j])\n # in fortran k=N-1,kbl(j),-1\n for k in range(N-1,self.kbl[j]-1,-1):\n k_w = k\n k_r = k-1\n\n Bfsfc = self.Bfsfc_bl[j]\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\n \n # CALCULATE TURBULENT VELOCITY SCALES\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\n self.wm2.append(wm)\n self.ws2.append(ws)\n # COMPUTE VERTICAL MIXING COEFFICIENTS\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\n self.sigma1 = sigma #for debugging\n if j == 25: \n self.sigma_y.append(sigma)\n a1 = sigma - 2.\n a2 = 3.-2.*sigma\n a3 = sigma - 1.\n\n if sigma < 0.07:\n cff = 0.5 * (sigma-0.07)**2/0.07\n else:\n cff = 0\n \n \n if k == N-1: \n self.wm_debug = wm\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\n\n if k == N-1:\n self.ws_debug = ws\n self.hbls_debug = self.hbls[j]\n self.cff_debug = cff\n self.sigma_debug = sigma\n self.a1_debug = a1\n self.a2_debug = a2\n self.a3_debug = a3\n \n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\n #---> end k-loop \n if self.LMD_NONLOCAL:\n if Bfsfc < 0:\n self.ghat[j,k_w] = 0\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\n else:\n self.ghat[j,k_w] = 0.\n\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \n if self.LMD_CONVEC and self.MLCONVEC: \n for k in range(N-1,int(self.kbl[j]-1),-1):\n k_w = k\n k_r = k -1\n\n if self.bvf[j,k_w] < 0:\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\n\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\n # IF BKPP IS SWITCHED OFF!!\n for k in range(int(self.kbl[j]-1),-1,-1):\n k_w = k\n k_r = k -1\n if self.LMD_NONLOCAL:\n self.ghat[j,k_w] = 0\n if self.LMD_CONVEC and self.LMD_BKPP == False:\n if self.bvf[j,k_w] < 0:\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\n \n\n #---> end j-loop","def weight_list_rsexecute_workflow(vis_list, model_imagelist, gcfcf=None, weighting='uniform', robustness=0.0,\n **kwargs):\n if gcfcf is None:\n gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(m, oversampling=1) for m in model_imagelist]\n \n def grid_wt(vis, model, g):\n if vis is not None:\n if model is not None:\n griddata = create_griddata_from_image(model, vis)\n if isinstance(vis, BlockVisibility):\n griddata = grid_blockvisibility_weight_to_griddata(vis, griddata, g[0][1])\n else:\n griddata = grid_visibility_weight_to_griddata(vis, griddata, g[0][1])\n \n return griddata\n else:\n return None\n else:\n return None\n \n weight_list = [rsexecute.execute(grid_wt, pure=True, nout=1)(vis_list[i], model_imagelist[i],\n gcfcf)\n for i in range(len(vis_list))]\n \n merged_weight_grid = rsexecute.execute(griddata_merge_weights, nout=1)(weight_list)\n merged_weight_grid = rsexecute.persist(merged_weight_grid, broadcast=True)\n \n def re_weight(vis, model, gd, g):\n if gd is not None:\n if vis is not None:\n # Ensure that the griddata has the right axes so that the convolution\n # function mapping works\n agd = create_griddata_from_image(model, vis)\n agd.data = gd[0].data\n if isinstance(vis, BlockVisibility):\n vis = griddata_blockvisibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\n else:\n vis = griddata_visibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\n return vis\n else:\n return None\n else:\n return vis\n \n result = [rsexecute.execute(re_weight, nout=1)\n (v, model_imagelist[i], merged_weight_grid, gcfcf)\n for i, v in enumerate(vis_list)]\n \n return rsexecute.optimize(result)","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def compute_gain( hv, cv, thot, tcold):\n\n nData = len(cv) \n epsilons = np.full( nData, EPSILON)\n\n # For full Temp calibration, a spectrum taken at high elevation, away from \n # The galactic plan is used.\n dv = hv - cv \n dv = np.maximum( dv, epsilons)\n hv = np.maximum( hv, epsilons)\n\n # use the comparison of hot and cold to get gain without trx contribution\n gain = (thot - tcold)/dv\n\n trx = gain*cv \n trx = trx - tcold # correct for cold load input in counts\n\n n6 = int(nData/6)\n n56 = 5*n6\n\n trxmedian = np.median( trx[n6:n56])\n gain = (thot + trxmedian)/hv\n \n return trxmedian, gain # channel by channel gain in K/counts","def non_interacting_conductivity(self,\n sigma=0.04,\n freq_range=(0.0, 6.0, 1000),\n imag_dielectric=False,\n broadening='lorentz'):\n cell_area = np.abs(float(np.cross(self.a1, self.a2)))*len(self.k_grid)\n broad_fnc = get_broadening_function(broadening, sigma)\n\n frequency_grid = np.linspace(*freq_range)\n energy_increment = np.abs(frequency_grid[1] - frequency_grid[0])\n num_freqs, min_freq = len(frequency_grid), min(frequency_grid)\n output_grid = np.zeros(num_freqs)\n\n energy_power = 1 + int(imag_dielectric)\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\n prefactor = prefactor/cell_area\n\n # Assuming x polarisation for now\n position_dipole_matrix = self.construct_position_dipole_matrix()\n\n n_shift = self.n_spins*self.n_orbs\n for idx1, kpt in enumerate(self.k_grid):\n for s0 in range(self.n_spins):\n velocity_matrix = self.load_velocity_matrix(idx1)\n bands = self.exciton_obj.get_number_conduction_valence_bands(\n idx1, s0\n )\n v_num, c_num = bands\n eigvals = np.array(\n self.file_storage['eigensystem']['eigenvalues'][idx1]\n )\n\n j1 = n_shift*idx1 + (self.n_spins - 1)*s0*self.n_orbs\n j2 = j1 + self.n_orbs\n eigvecs = np.array(\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\n )\n for v, c in product(range(v_num), range(c_num)):\n cb_vector = eigvecs[:, v_num + c]\n vb_vector = eigvecs[:, v]\n cb_energy, vb_energy = eigvals[v_num + c], eigvals[v]\n energy_diff = (cb_energy - vb_energy)\n\n energy_diff_pow = energy_diff**energy_power\n matrix_elem = velocity_matrix_element(vb_vector,\n cb_vector,\n velocity_matrix)\n if self.use_dipole_term:\n position_dipole_term = get_position_dipole_element(\n vb_vector,\n cb_vector,\n vb_energy,\n cb_energy,\n position_dipole_matrix\n )\n matrix_elem = matrix_elem + position_dipole_term\n\n main_term = np.abs(matrix_elem)**2/energy_diff_pow\n closest_idx = (energy_diff - min_freq)//energy_increment\n idx_reach = self.reach_multiplier*(sigma//energy_increment)\n\n lower_idx = max([closest_idx - idx_reach, 0])\n upper_idx = min([closest_idx + idx_reach, num_freqs - 1])\n\n for idx2 in range(int(lower_idx), int(upper_idx)):\n smearing = broad_fnc(energy_diff, frequency_grid[idx2])\n output = prefactor*main_term*smearing\n output_grid[idx2] += output\n\n return frequency_grid, output_grid","def one_iteration_step(self, tsm, tank, chp, kessel, cvalve, heizkurve, t_a, el_heat_status, actual_time, heatc_conf):\n #print('\\n chp = {}; kessel = {}; t2 = {}; t3 = {}'.format(chp.get_status(), kessel.get_status(), self.t2, self.t3))\n # combined heat and power unit - link outputs\n wyn = chp.get_chp()\n #self.t27 = wyn[1] # tin in °C = self.t1 = wyn[t1]\n self.t26 = wyn[2] # tout in °C = chp.get_out_temp = wyn[2]\n m3 = wyn[3] # mstr in kg/s \n self.V_3 = m3 / utils.rho_fluid_water(self.t26, self.p_atm, 1) # volume flow incoming to chp from tank\n V_chp = chp.get_volume_flow_at_output() # volume flow outoming from chp into tank\n # combined heat and power unit - link inputs\n chp.set_inp_temp(self.t27) # temperature incoming from tank to chp\n\n # ..............................................................\n\n # gas boiler - link outputs\n wyn = kessel.get_kessel()\n #self.t29 = wyn[1] # tin in °C - incoming into gas heater\n self.t28 = wyn[2] # tout in °C - outcoming from gas heater\n m4 = wyn[3] # mstr in kg/s - incoming into gas heater\n self.V_4 = kessel.get_volume_flow_at_input()\n V_kessel = kessel.get_volume_flow_at_output()\n # gas boiler - link inputs\n kessel.set_inp_temp(self.t29)\n #kessel.calc_mass_flow()\n\n # ..............................................................\n # at first no delay - just linking chp and heater\n # delay due to the seuence of commands ie equal to the Timestep length\n self.t27 = self.t1\n self.t29 = self.t1\n # ..............................................................\n\n # heating circuit\n self.t23 = self.t20 # no delay assumed\n #print('t20 = {}; t23 = {}'.format(self.t20, self.t23))\n self.t25 = heizkurve.get_supply_temperature(t_a)\n self.t24 = heizkurve.get_return_temperature(t_a)\n heizkurve.calc_volume_flow()\n\n # comprehensive control algorithm - it stays\n (m23, m25, m4) = self.control_internal_1(heizkurve, kessel, chp, cvalve, t_a, actual_time, m4, heatc_conf)\n\n m_bypass = m25 - m23\n rho23 = utils.rho_fluid_water(self.t23, self.p_atm, 1)\n V_23 = m23 / rho23 # in m3/s = kg/s / kg/m3\n #print('V_23 = {}; m23 = {}; rho23 = {}; t23 = {}'.format(V_23,m23, rho23, self.t23))\n m24 = m23\n rho24 = utils.rho_fluid_water(self.t24, self.p_atm, 1)\n V_24 = m24 / rho24\n \n # demand for domestic hot water\n m22 = self.V_1 * utils.rho_fluid_water(self.t22, self.p_atm, 1) # in kg/s = m3/s * kg/m3\n #m22 = 0.01 # kg/s\n # ..............................................................\n\n t_ambient = 15.0\n # storage tank - calculation\n tank.calculate_storage_tank_obj(tsm, # time step manager\n self.t23, # hk_inp_temp\n V_23, # hk_inp_volfl_m3s\n self.t24, # hk_out_temp\n self.t27, # chp_inp_temp\n self.t26, # chp_out_temp\n self.V_3, # chp_inp_volfl_m3s\n self.t29, # gb_inp_temp\n self.t28, # gp_out_temp\n self.V_4, # gb_inp_volfl_m3s\n self.t22, # dhw_inp_temp\n self.t21, # dhw_out_temp\n self.V_1, # dhw_inp_volfl_m3s\n el_heat_status, # el_heat_status\n actual_time, # time in the timestamp format\n t_ambient) # ambient temperature of the tank - defines heat losses to the outside\n \n self.t21 = tank.get_temp_dhw()\n #self.t27 = \n #self.t29 = \n #self.t23 = \n \n # storage tank - linking\n [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, \n self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20] = tank.output_temperatures()\n\n # ..............................................................\n # get rid of this part\n #self.control_internal_2(chp, kessel, actual_time, m4)\n # ..............................................................\n heizwert_in_MJ_per_kg = 50.0 # kg/m3 N ~CH4\n gas_density = 0.79 # kg/m3 N ~Erdgas\n Z_boiler = kessel.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\n self.Z_2 = chp.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\n self.Z_1 = self.Z_2 + Z_boiler\n \n self.Wh1 = -1.0 * chp.get_el_prod()\n self.Wh2 = tank.get_el_heater_consumption()\n self.Wh3 = self.Wh1 + self.Wh2 + self.electricity_consumption_kWh\n #print('END chp = {}; kessel = {}; heating = {}; t2 = {}; t3 = {};V1 = {}; V2 = {}; V3 = {}; V4 = {}; t_a = {}'.format(chp.get_status(), kessel.get_status(), heizkurve.get_status(), self.t2, self.t3, self.V_1, self.V_2, self.V_3, self.V_4, t_a))","def vote_for_k(utilities, k):\n utilities = np.asarray(utilities)\n n_cands = utilities.shape[1]\n if k == 'half':\n # \"It is interesting to observe that the vote-for-k and vote-for-(n-k)\n # voting systems are equally effective.\"\n # So for 7 candidates, we could use either k=4 or k=3 (= 7//2)\n # TODO: Though this seems only true with infinite voters?\n k = n_cands // 2\n elif -n_cands < k < 0:\n k = n_cands + k\n elif not 0 < k < n_cands:\n raise ValueError(f'k of {k} not possible with {n_cands} candidates')\n\n # Efficiently get indices of top k candidates for each voter\n # https://stackoverflow.com/a/23734295/125507\n # TODO: How are tied utilities handled, such as top 2 with 3 tied? Random?\n top_k = np.argpartition(utilities, -k, axis=1)[:, -k:]\n\n # Create blank ballots\n approvals = np.zeros(utilities.shape, np.uint8)\n\n # Fill in approvals\n # TODO: Not sure if this is the most efficient way\n approvals[np.arange(len(approvals))[:, np.newaxis], top_k] = 1\n return approvals","def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\n\n # def Q_gen(I, R):\n # w = I * I * R\n # return w\n\n # def Q_rad_in(I_sun, A_s, a_s):\n # w = I_sun * D * a_s\n # return w\n\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\n # w = htcoeff * A_s * (T_line - T_amb)\n # return w\n\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\n # return w\n\n def reynolds(V, D, v, Mair=1.103):\n r = V * D / v\n return r\n\n def nusselt(Re, Pr):\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\n c = (Re / 282000) ** (5.0/8.0)\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\n return n\n\n def air_prop(T_amb):\n # temp v k Pr\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\n [250, 11.44e-6, 22.3e-3, 0.720],\n [300, 15.89e-6, 26.3e-3, 0.707],\n [350, 20.92e-6, 30.0e-3, 0.700],\n [400, 26.41e-6, 33.8e-3, 0.690],\n [450, 32.39e-6, 37.3e-3, 0.686],\n [500, 38.79e-6, 40.7e-3, 0.684],\n [550, 45.57e-6, 43.9e-3, 0.683],\n [600, 52.69e-6, 46.9e-3, 0.685]])\n\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\n 0, air_prop[:,1:])\n return v, k, Pr\n\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\n if 273 <= T_line <= 323:\n R = ((R_lo + \n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\n *(T_line - T_range[0]))/N_cond)\n elif T_line > 323:\n R = ((R_mid + \n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\n *(T_line - T_range[1]))/N_cond)\n else:\n R = R_lo\n print('Out of bounds')\n return R\n\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\n temp_factor = 1\n wind_factor = 1\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\n\n T_amb = T_amb*temp_factor\n V = V*wind_factor\n\n v, k, Pr = air_prop(T_amb)\n Re = reynolds(V, D, v)\n htcoeff = nusselt(Re, Pr) * k / D\n\n def T_line(T_init):\n \n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\n print R\n\n C4 = e_s * sigma * D * math.pi\n C3 = 0.0\n C2 = 0.0\n C1 = htcoeff * D * math.pi\n C0 = - ( I ** 2 * R\n + I_sun * a_s * D\n + htcoeff * D * math.pi * T_amb\n + e_s * D * math.pi * sigma * (T_amb ** 4))\n\n return np.roots([C4, C3, C2, C1, C0])\n\n T_c = T_amb\n \n for i in range(n_iter):\n T_arr = T_line(T_c)\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\n print T_c\n\n return T_c","def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n pad=np.random.rand(nspad)/100\n trc_norm=trc/np.amax(np.abs(trc))\n trc_norm_padded=np.hstack((pad,trc_norm))\n trc_entropy=self.entropy(trc_norm_padded,50)\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\n for i,j in enumerate(trc):\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def hcn_tf(Y,t,voltage_clamp_func,voltage_clamp_params):\n \n v = voltage_clamp_func(t,voltage_clamp_params)\n n_s = Y[0]\n n_f = Y[1]\n \n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\n ninf_f = ninf_s\n\n if v > -70.0:\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\n else:\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\n\n dns = (ninf_s - n_s)/tau_ns\n dnf = (ninf_f - n_f)/tau_nf\n \n return [dns, dnf]","def init_kern_act(num_pitches):\n\n kern_act = []\n\n for i in range(num_pitches):\n kern_act.append(Matern32(1, lengthscales=1.0, variance=3.5))\n return kern_act","def ridge_joint(trn_fs,trn_data,alphas,val_fs=None,val_data=None,square_alphas=False,chunk_sz=5000,is_verbose=True):\n\n n_resp, n_voxels = trn_data.shape\n n_channels = np.sum([tfs.shape[1] for tfs in trn_fs])\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\n\n if square_alphas:\n alphas = [a**2 for a in alphas]\n\n num_train_points = float(list(trn_data.shape)[0])\n num_val_points = float(list(val_data.shape)[0])\n\n n_abc = [np.minimum(*t_fs.shape) for t_fs in trn_fs]\n ######################################################################################\n ### --- First up: compute modified covariance matrix & scaled/rotated stimulus --- ###\n ######################################################################################\n # Perform SVD on training sets for all three models \n if is_verbose:\n print(\"computing SVD\")\n U_trn,W_trn,Vt_trn = [],[],[]\n for t_fs in trn_fs:\n uu,ww,vv = np.linalg.svd(trn_stim_A, full_matrices=False)\n U_trn.append(uu)\n W_trn.append(ww)\n Vt_trn.append(vv)\n\n # The square of Ws (the singular values from the SVD) are the eigenvalues of the covariance matrix but have not been divided by n-1.\n L = [ww**2/float(num_train_points-1) for ww in W_trn]\n\n ### --- IDK WTF. Ask Wendino. --- ###\n ## to change: make sure that Ws are in the right units (divided by n-1) when bootstrapping, so that alphas are already in correct units\n ## at that point you can change the lines below and not divide alpha by (n-1)\n # TO DO: make this more than one line for clarity.\n w_alpha_trn = [np.diag(np.sqrt(1./(LL + aa)/(num_train_points-1))) for LL,aa in zip(L,alphas)]\n #w1_alpha_trn = sqrt(1./(L1+ alphas_A2[0]/(num_train_points-1))) \n #w1_alpha_trn = diag(w1_alpha_trn) #%turn it from an array to a matrix\n\n # Create & combine rotated & scaled stimulus space \n X_prime_trn_t = [ww.dot(vv).dot(t_fs) for ww,vv,t_fs in zip(W_trn,Vt_trn,trn_fs)]\n #S1_prime_trn_t = np.dot(np.dot(w1_alpha_trn, Vt1_trn), trn_stim_A.T) #w1_alpha_trn = 1200x1200, Vt1_trn = 1200x1200, trn_stim_A.T = 1200x3737\n Xcomb_prime_trn_t = np.vstack(X_prime_trn_t)\n\n # Create & modify covariance matrix\n stim_cov_mat_r = X_prime_trn_t.dot(X_prime_trn_t.T) / float(num_train_points-1)\n cov_diag = np.sqrt(np.diag(stim_cov_mat_r))\n full_mat_cov_diag = np.tile(cov_diag, [cov_diag.shape[0], 1])\n # re-do w/ simpler syntax?\n all_divisor = np.multiply(full_mat_cov_diag.T, full_mat_cov_diag) \n corr_mat_r = np.divide(stim_cov_mat_r, all_divisor)\n\n ### --- Clean up the correlation matrix to have zeros where we know they exist and use that data to set a threshold --- ###\n idx_ct = np.cumsum([0]+n_abc)\n idxs = [(a,b) for a,b in zip(idx_ct[:-1],idx_ct[1:])]\n # Block diagonal components of covariance matrix\n for n,(ii,jj) in zip(n_abc,idxs):\n corr_mat_r[ii:jj] = np.eye(n)\n # Off-diagonal elements: ignore for now? \n #for i1,i2 in zip(idxs[:-1],idxs[1:]):\n # (ii,jj),(kk,ll) = i1,i2\n \n\n # ##### --- WORKING HERE - SEE IPYTHON NOTEBOOK --- #########\n # upper_right_corr = np.ravel(corr_mat_r[0:nA, nA:])\n # middle_right_corr = np.ravel(corr_mat_r[nA:(nA+nB),(nA+nB):])\n # right_corr = np.hstack([upper_right_corr, middle_right_corr])\n # s_right_corr = argsort(right_corr)\n # # WTF is this?\n # #corr_cutoff = 954 # WH magic number; something to do with the fact that it's needless to have \n # # ALL the block-diagonal diagonals, since we have limited data\n # #goodcorrs_idx = np.hstack([s_right_corr[0:corr_cutoff], s_right_corr[-1:-(corr_cutoff+1):-1]])\n\n # new_right_corrs = np.squeeze(np.zeros([s_right_corr.shape[0],1]))\n # #new_right_corrs[goodcorrs_idx] = right_corr[goodcorrs_idx]\n # new_upper_right_corrs = np.reshape(new_right_corrs[0:(nB+nC)*nA],[nA,nB+nC])\n # new_lower_left_corrs = new_upper_right_corrs.T\n # new_middle_right_corrs = np.reshape(new_right_corrs[(nB+nC)*nA:],[nB,nC])\n # new_middle_left_corrs = new_middle_right_corrs.T\n\n # ##NEED TO CHANGE THIS: REMOVE HARDCODED MATRIX SIZES\n # new_corr_mat_r = copy.copy(corr_mat_r)\n # new_corr_mat_r[0:nA, nA:]= new_upper_right_corrs\n # new_corr_mat_r[nA:(nA+nB), (nA+nB):] = new_middle_right_corrs\n # new_corr_mat_r[(nA+nB):, nA:(nA+nB)]= new_middle_left_corrs # More like bottom middle\n # new_corr_mat_r[nA:,0:nA] = new_lower_left_corrs # \n # new_corr_mat_r[0:nA,0:nA]= np.identity(nA)\n # new_corr_mat_r[nA:(nA+nB), nA:(nA+nB)] = np.identity(nB)\n # new_corr_mat_r[(nA+nB):,(nA+nB):] = np.identity(nC)\n\n #perform eigenvalue decomposition (WHAT FOR? delete this?)\n #w, v = np.linalg.eigh(new_corr_mat_r)\n # Invert modified covariance matrix\n #corr_r_inv = np.linalg.inv(new_corr_mat_r)\n corr_r_inv = np.linalg.inv(corr_mat_r)\n #for \n ##create filter\n dot1 = np.dot(X_prime_trn_t, trn_data) #precompute for speed\n dot2 = np.dot(corr_r_inv, dot1) #precompute for speed\n # Weights\n h_123_prime = np.divide(dot2, (float(num_train_points-1)))\n\n\n ##create estimated responses from training data\n #r_hat = np.dot(X_prime_trn_t.T, h_123_prime) # not usually done...\n #if do_pred:\n #validation set results\n val_stim_A_prime = np.dot(np.dot(w1_alpha_r, Vt1_r), val_stim_A.T)\n val_stim_B_prime = np.dot(np.dot(w2_alpha_r, Vh2_r), val_stim_B.T)\n val_stim_C_prime = np.dot(np.dot(w3_alpha_r, Vh3_r), val_stim_C.T)\n #S1_prime = S1_prime[0:200,:]\n #S2_prime = S2_prime[0:200,:]\n\n S123_val_prime_t = np.vstack([val_stim_A_prime, val_stim_B_prime, val_stim_C_prime])\n\n #create validation set correlations\n r_hat_val = np.dot(S123_val_prime_t.T, h_123_prime)\n\n\n #look at performance\n valcorr = _sutils.column_corr(r_hat_val, val_data)\n out = dict(\n #weights=wt,\n #alphas=alphas,\n #n_sig_vox_byalpha=n_sig_vox_byalpha,\n cc=valcorr\n )\n return out","def hcn_kn(Y,t,voltage_clamp_func,voltage_clamp_params):\n\n v = voltage_clamp_func(t,voltage_clamp_params)\n n_s = Y[0]\n n_f = Y[1]\n\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\n ninf_f = ninf_s\n\n if v > -70.0:\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\n else:\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\n\n dns = (ninf_s - n_s)/tau_ns\n dnf = (ninf_f - n_f)/tau_nf\n\n return [dns, dnf]","def fit_full(self,K):\r\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\r\n mu = np.zeros(self.N)\r\n Sigma = K.copy()\r\n\r\n \"\"\"\r\n Initial values - Cavity distribution parameters:\r\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\r\n sigma_ = 1./tau_\r\n mu_ = v_/tau_\r\n \"\"\"\r\n self.tau_ = np.empty(self.N,dtype=float)\r\n self.v_ = np.empty(self.N,dtype=float)\r\n\r\n #Initial values - Marginal moments\r\n z = np.empty(self.N,dtype=float)\r\n self.Z_hat = np.empty(self.N,dtype=float)\r\n phi = np.empty(self.N,dtype=float)\r\n mu_hat = np.empty(self.N,dtype=float)\r\n sigma2_hat = np.empty(self.N,dtype=float)\r\n\r\n #Approximation\r\n epsilon_np1 = self.epsilon + 1.\r\n epsilon_np2 = self.epsilon + 1.\r\n \tself.iterations = 0\r\n self.np1 = [self.tau_tilde.copy()]\r\n self.np2 = [self.v_tilde.copy()]\r\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\r\n update_order = np.random.permutation(self.N)\r\n for i in update_order:\r\n #Cavity distribution parameters\r\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\r\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\r\n #Marginal moments\r\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\r\n #Site parameters update\r\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\r\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\r\n self.tau_tilde[i] += Delta_tau\r\n self.v_tilde[i] += Delta_v\r\n #Posterior distribution parameters update\r\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\r\n mu = np.dot(Sigma,self.v_tilde)\r\n self.iterations += 1\r\n #Sigma recomptutation with Cholesky decompositon\r\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\r\n B = np.eye(self.N) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\r\n L = jitchol(B)\r\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\r\n Sigma = K - np.dot(V.T,V)\r\n mu = np.dot(Sigma,self.v_tilde)\r\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\r\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\r\n self.np1.append(self.tau_tilde.copy())\r\n self.np2.append(self.v_tilde.copy())\r\n\r\n return self._compute_GP_variables()","def demo3(image_paths, arch, topk, stride, n_batches, output_dir, cuda):\n\n device = get_device(cuda)\n\n # Synset words\n classes = get_classtable()\n\n # Model from torchvision\n model = models.__dict__[arch](pretrained=True)\n model = torch.nn.DataParallel(model)\n model.to(device)\n model.eval()\n\n # Images\n images, _ = load_images(image_paths)\n images = torch.stack(images).to(device)\n\n print(\"Occlusion Sensitivity:\")\n\n patche_sizes = [10, 15, 25, 35, 45, 90]\n\n logits = model(images)\n probs = F.softmax(logits, dim=1)\n probs, ids = probs.sort(dim=1, descending=True)\n\n for i in range(topk):\n for p in patche_sizes:\n print(\"Patch:\", p)\n sensitivity = occlusion_sensitivity(\n model, images, ids[:, [i]], patch=p, stride=stride, n_batches=n_batches\n )\n\n # Save results as image files\n for j in range(len(images)):\n print(\"\\t#{}: {} ({:.5f})\".format(j, classes[ids[j, i]], probs[j, i]))\n\n # save_sensitivity(\n # filename=osp.join(\n # output_dir,\n # \"{}-{}-sensitivity-{}-{}.png\".format(\n # j, arch, p, classes[ids[j, i]]\n # ),\n # ),\n # maps=sensitivity[j],\n # )","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","def model(**params):\n N_frb = 0\n vs = []\n hs = []\n cs = []\n ncands = []\n\n for cand in candlist:\n c_res = calculate_metric_terms(\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\n )\n t, frb_found, h, c, v = c_res\n vs.append(v)\n hs.append(h)\n cs.append(c)\n ncands.append(t)\n\n if frb_found:\n N_frb += 1\n\n vs = np.array(vs)\n hs = np.array(hs)\n cs = np.array(cs)\n c_avg = np.average(cs, axis=0, weights=ncands)\n h_avg = np.average(hs, axis=0, weights=ncands)\n v_avg = np.average(vs, axis=0, weights=ncands)\n recall = N_frb / len(vs)\n score = v_avg * recall\n\n return score","def ghosal_edge(img,Ks,thr=1,thrmax=0.995,lmin = 0.5,phimin=1.4,thresholding=True, debug=False):\n\ttotaltime = time.time()\n\tkerneltime = time.time()\n\t# Ks must be odd\n\tif Ks%2 != 1:\n\t\tprint(\"Ks must be odd! Continuing with Ks = Ks-1\")\n\t\tKs = Ks-1\n\t# define the rectangular kernels\n\t#Vc00 = np.zeros((Ks,Ks),dtype=complex)\n\tVc11 = np.zeros((Ks,Ks),dtype=complex)\n\tVc20 = np.zeros((Ks,Ks),dtype=complex)\n\tofs = 1 *(1-1/Ks) # offset for centering kernel around 0,0\n\tfor i in range(Ks):\n\t\tfor j in range(Ks):\n\t\t\tKx = 2*j/Ks-ofs # limits of integration between -1 and 1\n\t\t\tKy = 2*i/Ks-ofs\n\t\t\tif Kx**2+Ky**2 <= 1: # only a circle\n\t\t\t\t#Vc00[i,j] = 1 # the conjugate of V00\n\t\t\t\tVc11[i,j] = Kx-Ky*1j # ...\n\t\t\t\tVc20[i,j] = 2*Kx**2+2*Ky**2-1\n\tkerneltime = time.time() - kerneltime\n\t\n\t# Kernel Plots\n\t#\tVCplot = Vc00\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Vc11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Vc20\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real w K Vc20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag w K Vc20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\t# do the convolution with the images to get the zernike moments\n\tAnorm = lambda n : (n+1)/np.pi\t# a normalization value\n\tconvolvetime = time.time()\n\t#A00 = scig.convolve2d(img,Vc00,mode='same')\n\t#\tA11 = Anorm(1)*scig.convolve2d(img,Vc11,mode='same')\n\t#\tA20 = Anorm(2)*scig.convolve2d(img,Vc20,mode='same')\n\tA11 = Anorm(1)*scig.oaconvolve(img,Vc11,mode='same')\n\tA20 = Anorm(2)*scig.oaconvolve(img,Vc20,mode='same')\n\tconvolvetime = time.time() - convolvetime\n\t# Plot Zernike moments\n\t#\tVCplot = A00\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A00\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = A11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = A20\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A20\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\tparamstime = time.time()\n\t# calculate the edge paramters\n\t#\ttanphi = np.imag(A11)/np.real(A11)\n\t#\tphi = np.arctan(tanphi)\n\t#\tcosphi = np.cos(phi)\n\t#\tsinphi = cosphi*tanphi\n\t#\tAl11 = np.real(A11)*cosphi+np.imag(A11)*sinphi\n\t\n\tphi = np.arctan(np.imag(A11)/np.real(A11))\n\tAl11 = np.real(A11)*np.cos(phi)+np.imag(A11)*np.sin(phi)\n\t\n\t#\tAl11 = A11*np.exp(-phi*1j)\n\tl = A20/Al11 # A20 has no imaginary component so A20 = A'20\n\n\tk = 3*Al11/(2*(1-l**2)**(3/2))\n\tparamstime = time.time() - paramstime\n\t\n\t# Plot edge paramters\n\t#\tVCplot = phi\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real phi\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag phi\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = Al11\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real A\\'11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag A\\'11\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = l\n\t#\tplt.pcolormesh(np.real(VCplot))#,vmin=-5,vmax=5\n\t#\tplt.title(\"real l\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot)) # ,vmin=-5,vmax=5\n\t#\tplt.title(\"imag l\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tVCplot = k\n\t#\tplt.pcolormesh(np.real(VCplot))\n\t#\tplt.title(\"real k\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t#\tplt.pcolormesh(np.imag(VCplot))\n\t#\tplt.title(\"imag k\")\n\t#\tplt.colorbar()\n\t#\tplt.show()\n\t\n\t\n\ttreattime = time.time()\n\tif thresholding==True:\n\t\t# do the thresholding\n\t\tif (thrmax<0)&(thr>0):\n\t\t\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])\n\t\telif thrmax>0:\n\t\t\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])&(abs(k)<knorm[1])\n\t\telif thr<0:\n\t\t\tidx = (abs(l)<lmin)&(abs(phi)>phimin)\n\t\t\tknorm = np.sort(k[idx].flatten())[int(thr)]\n\t\t\tidx = idx&(abs(k)>abs(knorm))\n\t\tne = np.sum(idx)\n\telif thresholding==False:\n\t\traise ValueError(\"this option is not still uncer development\")\n\t\t# no thresholding\n\t\tidx = np.ones(np.shape(l),dtype=bool)\n\t\tne =np.sum(idx)\n\telse:\n\t\traise ValueError(\"thresholding should be boolean\")\n\t\n\t# put all detected points in a vector of (x,y) values\n\tedg = np.zeros((ne,2))\n\torg = np.zeros((ne,2))\n\tnx,ny = np.shape(img)\n\te = 0\n\tfor i in range(nx):\n\t\tfor j in range(ny):\n\t\t\tif idx[i,j]:\n\t\t\t\tedg[e]=np.array([i,j]) + l[i,j]*Ks/2*np.array(\n\t\t\t\t\t[np.sin(phi[i,j]),-np.cos(phi[i,j])])\n\t\t\t\torg[e]=np.array([i,j])\n\t\t\t\te +=1\n\ttreattime = time.time() - treattime\n\ttotaltime = time.time() - totaltime\n\tprint(\"total %0.5f\tconvolution %0.5f\tthresholding %0.5f\tparamters %0.5f\tkernel %0.5f\"%(totaltime,convolvetime,treattime,paramstime,kerneltime))\n\t\n\tif debug==True:\n\t\treturn edg, org, k, l, phi\n\telse:\n\t\treturn edg, org","def init():\n\tN = np.int32(DIM) #prepare for stitching\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN)/DIM\n\tHII_scale = np.float32(BOX_LEN)/HII_DIM\n\tshape = (N,N,N)\n\t\n\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\n\n\tkernel_source = open(cmd_folder+\"/initialize.cu\").read()\n\tkernel_code = kernel_source % {\n\n\t\t'DELTAK': DELTA_K,\n\t\t'VOLUME': VOLUME,\n\t\t'DIM': DIM\n\t}\n\tmain_module = nvcc.SourceModule(kernel_code)\n\tinit_kernel = main_module.get_function(\"init_kernel\")\n\tHII_filter = main_module.get_function(\"HII_filter\")\n\tadj_complex_conj = main_module.get_function(\"adj_complex_conj\")\n\tsubsample_kernel = main_module.get_function(\"subsample\")\n\tvelocity_kernel = main_module.get_function(\"set_velocity\")\n\tpspec_texture = main_module.get_texref(\"pspec\")\n\n\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\n\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\n\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\n\n\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\n\tinit_kernel(largebox_d, np.int32(DIM), block=block_size, grid=grid_size)\n\n\t#import IPython; IPython.embed()\n\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\n\tinit_kernel(largebox_d_imag, np.int32(DIM), block=block_size, grid=grid_size)\n\n\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\n\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\n\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\n\n\t#adj_complex_conj(largebox_d, DIM, block=block_size, grid=grid_size)\n\tlargebox = largebox_d.get()\n\t#np.save(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc\".format(DIM, BOX_LEN), largebox)\n\n\t#save real space box before smoothing\n\tplan = Plan(shape, dtype=np.complex64)\n\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\tlargebox_d /= scale**3\n\tnp.save(parent_folder+\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(DIM, BOX_LEN), largebox_d.real.get_async())\n\n\t#save real space box after smoothing and subsampling\n\t# host largebox is still in k space, no need to reload from disk\n\tlargebox_d = gpuarray.to_gpu(largebox)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tHII_filter(largebox_d, N, ZERO, smoothR, block=block_size, grid=grid_size);\n\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\tlargebox_d /= scale**3\n\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\n\tsubsample_kernel(largebox_d.real, smallbox_d, N, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_grid_size) #subsample in real space\n\tnp.save(parent_folder+\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(HII_DIM, BOX_LEN), smallbox_d.get_async())\n\n\t# reload the k-space box for velocity boxes\n\tlargebox_d = gpuarray.to_gpu(largebox)\n\t\n\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tlargevbox_d = gpuarray.zeros((DIM,DIM,DIM), dtype=np.complex64)\n\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\n\tfor num, mode in enumerate(['x', 'y', 'z']):\n\t\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(num), block=block_size, grid=grid_size)\n\t\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=grid_size)\n\t\tplan.execute(largevbox_d, inverse=True)\n\t\tlargevbox_d /= scale**3\n\t\t#import IPython; IPython.embed()\n\t\tsubsample_kernel(largevbox_d.real, smallbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_grid_size)\n\t\tnp.save(parent_folder+\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\".format(mode, HII_DIM, BOX_LEN), smallbox_d.get())\n\n\treturn","def normal_modes_gHST(R, NL, KL, params, dispersion=[], spin_dir=[], sublattice_labels=[], b='hang', spring='auto',\n pin='auto'):\n try:\n NP, NN = np.shape(NL)\n except:\n '''There is only one particle.'''\n NP = 1\n NN = 0\n\n M1 = np.zeros((2 * NP, 2 * NP))\n M2 = np.zeros((2 * NP, 2 * NP))\n if spring == 'auto':\n spring = params['k'] * params['l'] ** 2 / (params['I3'] * np.abs(params['w3']))\n # If there is more than one particle, and if the speeds vary from particle to particle,\n # then make spring the same length as a dynamical matrix column\n if len(spring) > 0:\n if (abs(spring - spring[0]) > 1e-9).any():\n # The rotation rates vary from particle to particle, so reshape\n spring_new = np.zeros_like(spring)\n dmyi = 0 # a new index ('dummy i')\n for ii in range(NP):\n # Since 2 dof for position of pivot of gHST, double the size\n spring_new[dmyi] = spring[ii]\n spring_new[dmyi + 1] = spring[ii]\n dmyi += 2\n else:\n # the elements are all identical, so just keep the first one\n spring = spring[0]\n\n if pin == 'auto':\n gn = params['Mm'] * params['g']\n pin = params['l'] * gn / (params['I3'] * np.abs(params['w3']))\n # If there is more than one particle, and if the speeds vary from particle to particle,\n # then make pin the same length as a dynamical matrix column\n if len(pin) > 0:\n if (abs(pin - pin[0]) > 1e-9).any():\n # The rotation rates vary from particle to particle, so reshape\n pin_new = np.zeros_like(pin)\n dmyi = 0 # a new index ('dummy i')\n for ii in range(NP):\n # Since 2 dof for position of pivot of gHST, double the size\n pin_new[dmyi] = pin[ii]\n pin_new[dmyi + 1] = pin[ii]\n dmyi += 2\n else:\n # the elements are all identical, so just keep the first one\n pin = pin[0]\n\n m2_shape = np.shape(M2)\n\n if b == 'hang':\n b = np.zeros(NP)\n elif b == 'stand':\n b = np.ones(NP)\n\n if spin_dir == []:\n '''Assume antialigned with a, aligned with body axis 3'''\n spin_dir = np.ones(NP)\n\n print 'Constructing dynamical matrix...'\n for i in range(NP):\n for nn in range(NN):\n\n ni = NL[i, nn] # the number of the gyroscope i is connected to (particle j)\n k = KL[i, nn] # true connection?\n\n if len(dispersion) > 1:\n disp = 1. / (1. + dispersion[i])\n else:\n disp = 1.\n\n diffx = R[ni, 0] - R[i, 0]\n diffy = R[ni, 1] - R[i, 1]\n alphaij = 0.\n\n rij_mag = np.sqrt(diffx ** 2 + diffy ** 2)\n\n if k != 0:\n alphaij = np.arctan2(diffy, diffx)\n\n # for periodic systems, KL is -1 for particles on opposing boundaries\n if KL[i, nn] == -1:\n alphaij = (np.pi + alphaij) % (2 * pi)\n\n # What is this for?\n if KL[i, nn] == -2: # will only happen on first or last gyro in a line\n if i == 0 or i == (NP - 1):\n print i, '--> NL=-2 for this particle'\n yy = np.where(KL[i] == 1)\n dx = R[NL[i, yy], 0] - R[NL[i, yy], 0]\n dy = R[NL[i, yy], 1] - R[NL[i, yy], 1]\n al = (np.arctan2(dy, dx)) % (2 * pi)\n alphaij = np.pi - al\n if i == 1:\n alphaij = np.pi - ((90 / 2) * np.pi / 180.)\n else:\n alphaij = - ((90 / 2) * np.pi / 180.)\n\n Cos = np.cos(alphaij)\n Sin = np.sin(alphaij)\n\n if abs(Cos) < 10E-8:\n Cos = 0.0\n\n if abs(Sin) < 10E-8:\n Sin = 0\n\n Cos2 = Cos ** 2\n Sin2 = Sin ** 2\n CosSin = Cos * Sin\n\n # -1 for aligned with a, 1 for aligned with 3.\n # dir factor :== 1/(-1)^c = (-1)^c\n dir_factor = spin_dir[i]\n\n if len(sublattice_labels) > 0:\n if sublattice_labels[i] == 1:\n extra_factor = 1. * del_A_B\n # print self.del_A_B\n elif sublattice_labels[i] == 0:\n extra_factor = 1.\n else:\n extra_factor = 1.\n else:\n extra_factor = 1.\n\n M1[2 * i, 2 * i] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxi\n M1[2 * i, 2 * i + 1] += -disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyi\n M1[2 * i, 2 * ni] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxj\n M1[2 * i, 2 * ni + 1] += disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyj\n\n # (y components)\n M1[2 * i + 1, 2 * i] += disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxi\n M1[2 * i + 1, 2 * i + 1] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyi\n M1[2 * i + 1, 2 * ni] += -disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxj\n M1[2 * i + 1, 2 * ni + 1] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyj\n\n # if i==0:\n # print '\\n --- \\n added M1[2*i+1, 2*i] = ',disp*k*Cos2 *((-1)**b[i]) *dir_factor\n # print 'dir_factor = ', dir_factor\n # print 'k = ', k\n # print 'else =', ((-1)**b[i]) *dir_factor\n\n # pinning/gravitational matrix\n M2[2 * i, 2 * i + 1] = (1.) * disp * dir_factor * extra_factor\n M2[2 * i + 1, 2 * i] = -(1.) * disp * dir_factor * extra_factor\n\n # self.pin_array.append(2*pi*1*extra_factor)\n # Assumes:\n # (-1)**c adot = - spring* (-1)**b SUM{ z x nij*(nij.(dri-drj)) } + pin\n matrix = - (-spring * M1 + pin * M2)\n\n return matrix","def HKS(evals,evects, time_list,scaled=False):\n evals_s = np.asarray(evals).flatten()\n t_list = np.asarray(time_list).flatten()\n\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\n\n if scaled:\n inv_scaling = coefs.sum(1) # (num_T)\n return (1/inv_scaling)[None,:] * natural_HKS\n\n else:\n return natural_HKS","def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\n\n # Compute constants.\n kT = kB * temperature\n gamma = collision_rate\n\n # Create a new custom integrator.\n super(VVVRIntegrator, self).__init__(timestep)\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addGlobalVariable(\"b\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\n self.addPerDofVariable(\"sigma\", 0)\n self.addPerDofVariable(\"x1\", 0) # position before application of constraints\n\n #\n # Allow context updating here.\n #\n self.addUpdateContextState()\n\n #\n # Pre-computation.\n # This only needs to be done once, but it needs to be done for each degree of freedom.\n # Could move this to initialization?\n #\n self.addComputePerDof(\"sigma\", \"sqrt(kT/m)\")\n\n #\n # Velocity perturbation.\n #\n self.addComputePerDof(\"v\", \"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Metropolized symplectic step.\n #\n self.addComputePerDof(\"v\", \"v + 0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x + v*dt\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v + 0.5*dt*f/m + (x-x1)/dt\")\n self.addConstrainVelocities()\n\n #\n # Velocity randomization\n #\n self.addComputePerDof(\"v\", \"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\")\n self.addConstrainVelocities()","def InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method='analytical',bHighThrustCorr=True,Cq=None):\n # Critical values for high-thrust Spera correction\n ac = 0.34\n Ct_c = 4*ac*(1-ac)\n misc={}\n # Safety\n if lambda_r[0]==0:\n lambda_r[0]=lambda_r[1]*0.01;\n # --- Finding Cylinders intensities\n if method.lower()=='analytical':\n if bSwirl:\n a_prime = k/(4*lambda_r**2) # NOTE: entirely determined from Gamma! Eq.(38)\n Ir=np.arange(len(k)-1,-1,-1)\n Ct_rot = -8*sciint.cumtrapz(lambda_r[Ir]**2*a_prime[Ir]**2/vr_bar[Ir], vr_bar[Ir])# Eq.(6)\n Ct_rot = np.concatenate(([0],Ct_rot))\n Ct_rot=Ct_rot[Ir];\n else:\n a_prime = k*0\n Ct_rot = k*0\n Ct_KJ = k*(1+a_prime)\n Ct_eff = Ct_KJ-Ct_rot \n a=np.zeros(vr_bar.shape)\n if bHighThrustCorr:\n Icorr=Ct_eff> Ct_c\n Inorm=Ct_eff<=Ct_c\n # Spera correction\n a[Icorr]=(Ct_eff[Icorr]-4*ac**2)/(4*(1-2*ac));\n a[Inorm]=1/2*(1-np.sqrt(1-Ct_eff[Inorm]))\n else:\n a=1/2*(1-np.sqrt(1-Ct_eff));\n\n # Using Cq\n if Cq is not None:\n a_2 = 1 - lambda_r*Cq/k\n k2 = Cq*lambda_r/(1-a)\n a_prime = k2/(4*lambda_r**2)\n misc['k_Cq'] = k2\n else:\n raise NotImplementedError('')\n misc['Ct_KJ'] = Ct_KJ\n misc['Ct_eff'] = Ct_eff\n misc['Ct_rot'] = Ct_rot\n return a,a_prime,misc","def _psicomputations(self, kern, Z, variational_posterior, return_psi2_n=False):\n variance, lengthscale = kern.variance, kern.lengthscale\n N,M,Q = self.get_dimensions(Z, variational_posterior)\n self._initGPUCache(N,M,Q)\n self.sync_params(lengthscale, Z, variational_posterior.mean, variational_posterior.variance)\n \n psi1_gpu = self.gpuCache['psi1_gpu']\n psi2_gpu = self.gpuCache['psi2_gpu']\n psi2n_gpu = self.gpuCache['psi2n_gpu']\n l_gpu = self.gpuCache['l_gpu']\n Z_gpu = self.gpuCache['Z_gpu']\n mu_gpu = self.gpuCache['mu_gpu']\n S_gpu = self.gpuCache['S_gpu']\n log_denom1_gpu = self.gpuCache['log_denom1_gpu']\n log_denom2_gpu = self.gpuCache['log_denom2_gpu']\n\n psi0 = np.empty((N,))\n psi0[:] = variance\n self.g_psi1computations.prepared_call((self.blocknum,1),(self.threadnum,1,1),psi1_gpu.gpudata, log_denom1_gpu.gpudata, np.float64(variance),l_gpu.gpudata,Z_gpu.gpudata,mu_gpu.gpudata,S_gpu.gpudata, np.int32(N), np.int32(M), np.int32(Q))\n self.g_psi2computations.prepared_call((self.blocknum,1),(self.threadnum,1,1),psi2_gpu.gpudata, psi2n_gpu.gpudata, log_denom2_gpu.gpudata, np.float64(variance),l_gpu.gpudata,Z_gpu.gpudata,mu_gpu.gpudata,S_gpu.gpudata, np.int32(N), np.int32(M), np.int32(Q))\n # t = self.g_psi1computations(psi1_gpu, log_denom1_gpu, np.float64(variance),l_gpu,Z_gpu,mu_gpu,S_gpu, np.int32(N), np.int32(M), np.int32(Q), block=(self.threadnum,1,1), grid=(self.blocknum,1),time_kernel=True)\n # print 'g_psi1computations '+str(t)\n # t = self.g_psi2computations(psi2_gpu, psi2n_gpu, log_denom2_gpu, np.float64(variance),l_gpu,Z_gpu,mu_gpu,S_gpu, np.int32(N), np.int32(M), np.int32(Q), block=(self.threadnum,1,1), grid=(self.blocknum,1),time_kernel=True)\n # print 'g_psi2computations '+str(t)\n \n if self.GPU_direct:\n return psi0, psi1_gpu, psi2_gpu\n else:\n if return_psi2_n:\n return psi0, psi1_gpu.get(), psi2n_gpu.get()\n else:\n return psi0, psi1_gpu.get(), psi2_gpu.get()","def CLOMPR(task,sketch,featureMap,K,bounds,dimensions_to_consider=None, nb_cat_per_dim=None,nIterations=None, nRepetitions=1, ftol=1e-6, verbose=0 ):\n\n ## 0) Defining all the tools we need\n ####################################\n ## 0.1) Handle input\n\n ## 0.1.1) task name\n if task.lower() in [\"km\",\"ckm\",\"kmeans\",\"k-means\"]:\n task = \"kmeans\"\n task_finetuning = \"kmeans\"\n elif task.lower() in [\"gmm\",\"gaussian mixture model\"]:\n task = \"gmm\"\n task_finetuning = \"gmm\"\n elif task.lower() in [\"gmm-nondiag\"]:\n task = \"gmm\"\n task_finetuning = \"gmm-nondiag\"\n else:\n raise ValueError('The task argument does not match one of the available options.')\n\n ## 0.1.2) sketch feature function\n if isinstance(featureMap,SimpleFeatureMap):\n d_all = featureMap.d\n m = featureMap.m\n else:\n raise ValueError('The featureMap argument does not match one of the supported formats.')\n\n # Restrict the dimension\n if dimensions_to_consider is None:\n dimensions_to_consider = np.arange(d_all)\n dimensions_to_ignore = np.delete(np.arange(d_all), dimensions_to_consider)\n d = dimensions_to_consider.size\n \n # Pre-compute sketch of unused dimensions\n z_to_ignore = fourierSketchOfBox(bounds.T,featureMap,nb_cat_per_dim, dimensions_to_consider = dimensions_to_ignore)\n # Compensate the normalization constant and the dithering which will be taken into account in the centroid sketch\n z_to_ignore = z_to_ignore/(featureMap(np.zeros(d_all))) # giving zeros yields the dithering and the c_norm\n \n # Restrict the featureMap for the centroids\n Phi = copy(featureMap) # Don't touch to the inital map, Phi is featureMap restricted to relevant dims\n Phi.d = d\n Phi.Omega = featureMap.Omega[dimensions_to_consider]\n \n ## 0.1.3) nb of iterations\n if nIterations is None:\n nIterations = 2*K # By default: CLOMP-*R* (repeat twice)\n \n ## 0.1.4) Bounds of the optimization problems\n if bounds is None:\n lowb = -np.ones(d) # by default data is assumed normalized\n uppb = +np.ones(d)\n if verbose > 0: print(\"WARNING: data is assumed to be normalized in [-1,+1]^d\")\n else:\n lowb = bounds[0][dimensions_to_consider]\n uppb = bounds[1][dimensions_to_consider] # Bounds for one centroid\n\n # Format the bounds for the optimization solver\n if task_finetuning == \"kmeans\":\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the centroids\n elif task_finetuning == \"gmm\":\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\n elif task_finetuning == \"gmm-nondiag\":\n # Usual bounds of GMM\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\n \n # Bounds for the nondiagonal problem\n boundstheta_finetuning = np.array([lowb,uppb]).T.tolist() # bounds for the means\n varianceLowerBound = 1e-8\n varianceUpperBound = ((uppb-lowb).max()/2)**2\n\n _lowb_var = -varianceUpperBound*np.ones((d,d))\n np.fill_diagonal(_lowb_var, varianceLowerBound)\n _uppb_var = +varianceUpperBound*np.ones((d,d))\n\n _boundsvar = np.append(_lowb_var.reshape(-1),_uppb_var.reshape(-1)).reshape(2,d**2).T.tolist()\n for _i in _boundsvar: boundstheta_finetuning.append(_i) # bounds for the variance\n \n\n ## 0.1.5) Misc. initializations\n # Chosen method for the optimization solver\n opt_method = 'L-BFGS-B' # could also consider 'TNC'\n # Separated real and imaginary part of the sketch\n sketch_ri = np.r_[sketch.real, sketch.imag]\n if task == \"kmeans\":\n thetadim = d\n elif task == \"gmm\":\n thetadim = 2*d\n elif task == \"gmm-nondiag\":\n thetadim = d*(d+1)\n\n\n ## THE ACTUAL ALGORITHM\n #######################\n bestResidualNorm = np.inf \n bestTheta = None\n bestalpha = None\n for iRun in range(nRepetitions):\n \n ## 1) Initialization\n r = sketch # residual\n Theta = np.empty([0,thetadim]) # Theta is a nbAtoms-by-atomDimension array\n A = np.empty([m,0]) # Contains the sketches of the atoms\n\n ## 2) Main optimization\n for i in range(nIterations):\n ## 2.1] Step 1 : find new atom theta most correlated with residual\n # Initialize the new atom\n if task == \"kmeans\":\n th_0 = np.random.uniform(lowb,uppb)\n elif task == \"gmm\":\n mu0 = np.random.uniform(lowb,uppb) # initial mean\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\n th_0 = _stackAtom(\"gmm\",mu0,sig0)\n \n elif task == \"gmm-nondiag\":\n # Solve once for diagonal\n mu0 = np.random.uniform(lowb,uppb) # initial mean\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\n th_0 = _stackAtom(\"gmm\",mu0,sig0)\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(\"gmm\",Phi,th,r,z_to_ignore,verbose),\n x0 = th_0, method=opt_method, jac=True,\n bounds=boundstheta_gmm)\n\n (mu0,sig0) = _destackAtom(\"gmm\",sol.x,d)\n\n th_0 = _stackAtom(\"gmm-nondiag\",mu0,np.diag(sig0))\n\n # And solve with LBFGS \n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(task,Phi,th,r,z_to_ignore,verbose),\n x0 = th_0, method=opt_method, jac=True,\n bounds=boundstheta)\n new_theta = sol.x\n \n if task == \"gmm-nondiag\":\n new_theta = _makeGMMfeasible(new_theta,d)\n\n ## 2.2] Step 2 : add it to the support\n Theta = np.append(Theta,[new_theta],axis=0)\n A = np.c_[A,_sketchAtom(task,Phi,new_theta,z_to_ignore)] # Add a column to the A matrix\n\n ## 2.3] Step 3 : if necessary, hard-threshold to nforce sparsity\n if Theta.shape[0] > K:\n norms = np.linalg.norm(A,axis=0)\n norms[np.where(norms < 1e-15)[0]] = 1e-15 # Avoid /0\n A_norm = A/norms # normalize, unlike step 4\n A_normri = np.r_[A_norm.real, A_norm.imag] \n (beta,_) = nnls(A_normri,sketch_ri) # non-negative least squares\n index_to_delete = np.argmin(beta)\n Theta = np.delete(Theta, index_to_delete, axis=0)\n A = np.delete(A, index_to_delete, axis=1)\n if index_to_delete == K:\n continue # No gain to be expected wrt previous iteration\n\n ## 2.4] Step 4 : project to find weights\n Ari = np.r_[A.real, A.imag]\n (alpha,_) = nnls(Ari,sketch_ri) # non-negative least squares\n\n\n\n ## 2.5] Step 5\n p0 = _stackTheta(task,Theta,alpha) # Initialize at current solution \n # Compute the bounds for step 5 : boundsOfOneAtom * numberAtoms then boundsOneWeight * numberAtoms\n boundsThetaAlpha = boundstheta * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\n # Solve\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task,Phi,p,sketch,z_to_ignore),\n x0 = p0, method=opt_method, jac=True,\n bounds=boundsThetaAlpha, options={'ftol': ftol}) \n (Theta,alpha) = _destackTheta(task,sol.x,Phi.d)\n \n # Make covariances feasible\n if task == \"gmm-nondiag\":\n for k in range(Theta.shape[0]):\n Theta[k] = _makeGMMfeasible(Theta[k],d)\n\n # The atoms have changed: we must re-compute A\n A = np.empty([m,0])\n for theta_i in Theta:\n Apthi = _sketchAtom(task,Phi,theta_i,z_to_ignore)\n A = np.c_[A,Apthi]\n # Update residual\n r = sketch - A@alpha\n\n ## 3) Finalization boundstheta_finetuning\n # Last optimization with the default (fine-grained) tolerance\n if task_finetuning == \"gmm-nondiag\":\n if verbose > 0: print('finetuning')\n Theta_new = np.zeros((K,d*(d+1))) # Expand to have full cov matrix\n for k in range(K):\n (mu,sig2) = _destackAtom(\"gmm\",Theta[k],d)\n # put current sol on the diagonal of full covariance matrix\n Theta_new[k] = _stackAtom(\"gmm-nondiag\",mu,np.diag(sig2))\n Theta = Theta_new # overwrite\n \n boundsThetaAlpha = boundstheta_finetuning * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\n \n if task_finetuning == \"gmm-nondiag\" or ftol >= 1e-8:\n p0 = _stackTheta(task_finetuning,Theta,alpha)\n \n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task_finetuning,Phi,p,sketch,z_to_ignore),\n x0 = p0, method=opt_method, jac=True,\n bounds=boundsThetaAlpha) # Here ftol is much smaller\n (Theta,alpha) = _destackTheta(task_finetuning,sol.x,Phi.d) \n \n \n # Normalize alpha\n alpha /= np.sum(alpha)\n \n \n runResidualNorm = np.linalg.norm(sketch - A@alpha)\n if verbose>1: print('Run {}, residual norm is {} (best: {})'.format(iRun,runResidualNorm,bestResidualNorm))\n if runResidualNorm <= bestResidualNorm:\n bestResidualNorm = runResidualNorm\n bestTheta = Theta\n bestalpha = alpha\n \n ## FORMAT OUTPUT\n if task == \"kmeans\":\n return (bestalpha,bestTheta)\n elif task == \"gmm\" or task == \"gmm-nondiag\":\n return _ThetasToGMM(task_finetuning,bestTheta,bestalpha)\n\n return None","def face_template_matching(visible_image, thermal_image, bboxlist):\n x1, y1, x2, y2, confidence = bboxlist\n template = np.mean(\n visible_image[int(bboxlist[1]):int(bboxlist[3]), int(bboxlist[0]):int(bboxlist[2]), :], axis=-1)\n image = thermal_image[int(bboxlist[1]):int(bboxlist[3]), :]\n corr_coeff = cv2.matchTemplate(image.astype(np.float32), template.astype(np.float32), cv2.TM_CCOEFF_NORMED)\n corr_coeff = np.squeeze(corr_coeff)\n delta_x = np.argmax(corr_coeff) - x1\n visible_crops = np.array(bboxlist[:4], dtype=\"int\")\n thermal_crops = np.array([x1 + delta_x, y1, x2 + delta_x, y2], dtype=\"int\")\n visible_face = crop_face(visible_image, visible_crops, mode=\"visible\")\n thermal_face = crop_face(thermal_image, thermal_crops, mode=\"thermal\")\n return visible_face, thermal_face","def integrate_verlet(X, V, iparams, blist, sp):\n T, E = np.zeros(sp.Nt), np.zeros(sp.Nt)\n N = len(X)\n Vtemp = np.zeros(X.shape)\n Fnew = np.zeros(X.shape)\n ti = time.time()\n\n F = force_list(X, V, iparams, blist, \\\n sp.L, sp.gamma, sp.kT, sp.dt, sp.rc)\n T[0] = temperature(V)\n E[0] = tot_KE(V) + tot_PE(X, iparams, blist, sp.rc)\n save_xyzmatrix(\"Dump/dump_%i.xyz\" % 0, blist, X)\n\n for i in range(1, sp.Nt):\n # 1. GW formulation DIVERGES TWICE AS MUCH AS 3rd!\n# X = X + V * sp.dt + F * sp.dt**2 / 2.0\n# Vtemp = V + F * sp.dt / 2.0\n# Fnew = force_list(X, Vtemp, iparams, blist, \\\n# sp.L, sp.gamma, sp.kT, sp.dt, sp.rc)\n# V = Vtemp + (F + Fnew) * sp.dt / 2\n# F = Fnew\n\n # 2. Wiki formulation without half-step velocity\n X = X + V * sp.dt + F * sp.dt**2 / 2.0\n Fnew = force_list(X, V, iparams, blist, \\\n sp.L, sp.gamma, sp.kT, sp.dt, sp.rc)\n V = V + (F + Fnew) * sp.dt / 2.0\n F = Fnew\n\n X = X % sp.L\n\n KE = tot_KE(V)\n E[i] = KE + tot_PE(X, iparams, blist, sp.rc)\n T[i] = KE / (3.0 / 2.0 * N)\n tf = time.time()\n if (i+1) % sp.thermo == 0:\n save_xyzmatrix(\"Dump/dump_%i.xyz\" % (i+1), blist, X)\n print(\"Step: %i | t: %.3f | T: %.5f | E: %.3e | Time: %.2f\" % \\\n (i+1, i * sp.dt, T[i], E[i], tf - ti))\n return T, E","def solve_system_for_vv_harmonic_weak_Maass_waveforms_new(H, W, N=None, gr=False, cn=False, verbose=0):\n V = W['V']\n Ms = W['Ms']\n Mf = W['Mf']\n # WR=W['WR']\n X = H.multiplier()\n WM = H.multiplier().weil_module()\n nc = W['nc']\n Ml = Mf - Ms + 1\n get_reduced_matrix = gr\n verbose = H._verbose\n comp_norm = cn\n r = W['r'] # WM.rank()\n if verbose > 0:\n print(\"Ml={0}\".format(Ml))\n print(\"nv={0}\".format(nc))\n # if W['sym_type']==1:\n # setD=range(WM.rank()/2+1) # 0,1,...,N\n # #setD=range(WR.N+1) # 0,1,...,N\n # elif W['sym_type']==-1:\n # setD=range(1,WM.rank()/2) # 1,2,...,N-1 (since -0=0 and -N=N)\n setD = X.D()\n Ds = setD[0]\n num_comp = nc * r\n if num_comp != len(setD):\n raise Exception(\" Wrong dimension of input matrix! r={0},nc={1},setD={2}\".format(r, nc, setD))\n if V.ncols() != Ml * num_comp or V.nrows() != Ml * num_comp:\n raise Exception(\" Wrong dimension of input matrix!\")\n if N is None:\n SetCs = [[]]\n Vals = [{}]\n for b in WM.basis():\n if WM.Q(b) == 0:\n SetCs[0].append((b, 0))\n Vals[0][(b, 0)] = 0\n comp_dim = 1\n else:\n SetCs = N['SetCs']\n Vals = N['Vals']\n comp_dim = N['comp_dim']\n\n # for a in Vals.keys():\n # Vals[a]=mpmath.mp.mpc(Vals[a])\n if Ms < 0:\n use_sym = 0\n else:\n use_sym = 1\n if verbose > 0:\n print(\"Before SetCs={0}\".format(SetCs))\n if use_sym == 1:\n if len(SetCs[0]) > 0:\n num_set = 0\n for (r, m) in SetCs[0]:\n if r in X.D(): # )_as_int:\n num_set = num_set + 1\n else:\n num_set = len(SetCs[0])\n t = V[0, 0]\n CF = MPComplexField(H._prec)\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(comp_dim))\n RHS = Matrix_complex_dense(MS, 0, True, True)\n # if W.has_key('RHS'):\n # if(W['RHS'].ncols()!=comp_dim):\n # raise ValueError,\"Inum_comporrect number of right hand sides!\"\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(Ml * num_comp - num_set))\n LHS = Matrix_complex_dense(MS, 0, True, True)\n if verbose > 0:\n print(\"Ml={0}\".format(Ml))\n print(\"num_set={0}\".format(num_set))\n print(\"num_comp={0}\".format(num_comp))\n print(\"SetCs={0}\".format(SetCs))\n print(\"setD={0}\".format(setD))\n print(\"Vals={0}\".format(Vals))\n print(\"V.rows={0}\".format(V.nrows()))\n print(\"V.cols={0}\".format(V.ncols()))\n print(\"LHS.rows={0}\".format(LHS.nrows()))\n print(\"LHS.cols={0}\".format(LHS.ncols()))\n print(\"RHS.rows={0}\".format(RHS.nrows()))\n print(\"RHS.cols={0}\".format(RHS.ncols()))\n print(\"use_sym={0}\".format(use_sym))\n print(\"N={0}\".format(N))\n\n num_rhs = 0\n if 'RHS' in W:\n num_rhs = W['RHS'].ncols()\n else:\n num_rhs = 1\n if num_rhs != 1 and num_rhs != comp_dim:\n raise ValueError(\"Need same number of right hand sides (or just one) as the number of set coefficients!\")\n\n if V.nrows() != num_comp * Ml:\n raise ArithmeticError(\" Matrix does not have correct size!\")\n roffs = 0\n for a in range(num_comp):\n for n in range(Ms, Mf + 1):\n r = a * Ml + n - Ms\n if SetCs[0].count((a + Ds, n)) > 0 and a + Ds in setD:\n # print \" set row a,n=\",a,n\n roffs = roffs + 1\n continue\n for fn_j in range(comp_dim):\n # ztmp=CF(ztmp.real(),ztmp.imag())\n if verbose > 3:\n print(\"fn_j={0}\".format(fn_j))\n print(\"r,roffs={0},{1},{2}\".format(r, roffs, r - roffs))\n if num_rhs == comp_dim:\n rhs_j = fn_j\n else:\n rhs_j = 0\n if 'RHS' in W:\n RHS[r - roffs, fn_j] = -W['RHS'][r, rhs_j]\n else:\n RHS[r - roffs, fn_j] = 0\n for (i, cset) in SetCs[fn_j]:\n if i in setD:\n v = Vals[fn_j][(i, cset)]\n # k = i*Ml+cset-Ms\n k = (i - Ds) * Ml + cset - Ms\n if verbose > 3:\n print(\"fi,cset={0},{1}\".format(i, cset))\n print(\"r,k={0},{1}\".format(r, k))\n tmp = CF(v) * V[r, k]\n RHS[r - roffs, fn_j] = RHS[r - roffs, fn_j] - tmp\n coffs = 0\n for b in range(num_comp):\n for l in range(Ms, Mf + 1):\n k = b * Ml + l - Ms\n if SetCs[0].count((b + Ds, l)) > 0 and b + Ds in setD:\n coffs = coffs + 1\n continue\n if verbose > 3:\n print(\"r,k={0},{1}\".format(r, k))\n print(\"r-roffs,k-coffs={0},{1}\".format(r - roffs, k - coffs))\n LHS[r - roffs, k - coffs] = V[r, k]\n # print \"LHS[\",r,k,\"]=\",LHS[r-roffs,k-coffs]\n # else:\n # LHS = V\n # RHS = -W['RHS']\n if get_reduced_matrix:\n return [LHS, RHS]\n maxit = 100\n i = 0\n done = False\n dps0 = CF.prec()\n while (not done and i <= maxit):\n try:\n Q, R = LHS.qr_decomposition()\n done = True\n except ZeroDivisionError:\n t = int(ceil(-log(smallest_inf_norm(LHS), 10)))\n dps = t + 5 * i\n i = i + 1\n print(\"raising number of digits to:{0}\".format(dps))\n LHS.set_prec(dps)\n # raise ZeroDivisionError,\"Need higher precision! Use > %s digits!\" % t\n if i >= maxit:\n raise ZeroDivisionError(\"Can not raise precision enough to solve system! Should need > {0} digits! and {1} digits was not enough!\".format(t, dps))\n if comp_norm:\n max_norm = LHS.norm()\n for j in range(LHS.rows):\n # y=mpmath_ctx.matrix(LHS.rows,int(1)); y[j,0]=1\n y = Vector_complex_dense(vector(CF, LHS.rows).parent(), 0)\n y[j] = 1\n TMP = RHS.solve(b) # pmath_ctx.U_solve(A, b)\n tmpnorm = max(list(map(abs, TMP)))\n if(tmpnorm > max_norm):\n max_norm = tmpnorm\n print(\"max norm of V^-1={0}\".format(max_norm))\n X = dict()\n for fn_j in range(comp_dim):\n X[fn_j] = dict() # mpmath.matrix(int(Ml),int(1))\n # b = mpmath_ctx.L_solve(A, RHS.column(fn_j), p)\n v = RHS.column(fn_j)\n print(\"len(B)={0}\".format(len(v)))\n TMP = LHS.solve(v)\n # TMP = mpmath_ctx.U_solve(A, b)\n roffs = 0\n # res = mpmath_ctx.norm(mpmath_ctx.residual(LHS, TMP, RHS.column(fn_j)))\n res = (LHS * TMP - v).norm()\n print(\"res(\", fn_j, \")={0}\".format(res))\n for ai in range(num_comp):\n X[fn_j][ai] = dict()\n for n in range(Ms, Mf + 1):\n ni = Ml * ai + n - Ms\n if SetCs[fn_j].count((ai + Ds, n)) > 0 and ai + Ds in setD:\n roffs = roffs + 1\n X[fn_j][ai][n] = CF(Vals[fn_j][(ai + Ds, n)])\n continue\n # if verbose>0:\n # print \"ni-roffs=\",ni-roffs\n X[fn_j][ai][n] = TMP[ni - roffs]\n return X","def __init__(self, num_heads: int, size: int, size_v: int, dropout: float = 0.1):\n super(ContMultiHeadedAttention, self).__init__()\n\n assert size % num_heads == 0\n\n self.head_size = head_size = size // num_heads\n self.model_size = size\n self.num_heads = num_heads\n\n self.k_layer = nn.Linear(size, num_heads * head_size)\n self.v_layer = nn.Linear(size_v, num_heads * head_size)\n self.q_layer = nn.Linear(size, num_heads * head_size)\n\n self.output_layer = nn.Linear(size, size_v)\n self.softmax = nn.Softmax(dim=-1)\n self.dropout = nn.Dropout(dropout)","def init_stitch(N):\n\tif N is None:\n\t\tN = np.int32(HII_DIM) #prepare for stitching\n\tMETA_GRID_SIZE = DIM/N\n\tM = np.int32(HII_DIM/META_GRID_SIZE)\n\t#HII_DIM = np.int32(HII_DIM)\n\tf_pixel_factor = DIM/HII_DIM;\n\tscale = np.float32(BOX_LEN/DIM)\n\tprint 'scale', scale\n\tHII_scale = np.float32(BOX_LEN/HII_DIM)\n\tshape = (DIM,DIM,N)\n\tstitch_grid_size = (DIM/(block_size[0]),\n\t\t\t\t\t\tDIM/(block_size[0]),\n\t\t\t\t\t\tN/(block_size[0]))\n\tHII_stitch_grid_size = (HII_DIM/(block_size[0]),\n\t\t\t\t\t\tHII_DIM/(block_size[0]),\n\t\t\t\t\t\tM/(block_size[0]))\n\t#ratio of large box to small size\n\tkernel_source = open(cmd_folder+\"/initialize_stitch.cu\").read()\n\tkernel_code = kernel_source % {\n\n\t\t'DELTAK': DELTA_K,\n\t\t'DIM': DIM, \n\t\t'VOLUME': VOLUME,\n\t\t'META_BLOCKDIM': N\n\t}\n\tmain_module = nvcc.SourceModule(kernel_code)\n\tinit_stitch = main_module.get_function(\"init_kernel\")\n\tHII_filter = main_module.get_function(\"HII_filter\")\n\tsubsample_kernel = main_module.get_function(\"subsample\")\n\tvelocity_kernel = main_module.get_function(\"set_velocity\")\n\tpspec_texture = main_module.get_texref(\"pspec\")\n\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\n\tplan2d = Plan((np.int64(DIM), np.int64(DIM)), dtype=np.complex64)\n\tplan1d = Plan((np.int64(DIM)), dtype=np.complex64)\n\tprint \"init pspec\"\n\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\n\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\n\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\n\t#hbox_large = pyfftw.empty_aligned((DIM, DIM, DIM), dtype='complex64')\n\thbox_large = np.zeros((DIM, DIM, DIM), dtype=np.complex64)\n\t#hbox_small = np.zeros(HII_shape, dtype=np.float32)\n\t#hbox_large = n\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\n\t# Set up pinned memory for transfer\n\t#largebox_hs = cuda.aligned_empty(shape=shape, dtype=np.float32, alignment=resource.getpagesize())\n\tlargebox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.float32)\n\tlargecbox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.complex64)\n\n\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\n\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\n\tprint \"init boxes\"\n\tfor meta_z in xrange(META_GRID_SIZE):\n\t\t# MRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=meta_x*N**3)\n\t\tinit_stitch(largebox_d, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\n\t\tinit_stitch(largebox_d_imag, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\n\t\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\n\t\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\n\t\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\n\t\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\n\t\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largecbox_pin.copy()\n\t#if want to get velocity need to use this\n\tif True:\n\t\tprint \"saving kbox\"\n\t\tnp.save(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN), hbox_large)\n\n\tprint \"Executing FFT on device\"\n\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\n\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\n\tprint hbox_large.dtype\n\tprint \"Finished FFT on device\"\n\tnp.save(parent_folder+\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN), hbox_large)\n\t\n\tif True:\n\t\tprint \"loading kbox\"\n\t\thbox_large = np.load(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN))\n\tfor meta_z in xrange(META_GRID_SIZE):\n\t\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\n\t\t#cuda.memcpy_htod_async(largebox_d, largebox_pin)\n\t\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\tHII_filter(largebox_d, DIM, np.int32(meta_z), ZERO, smoothR, block=block_size, grid=stitch_grid_size);\n\t\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largebox_d.get_async()\n\t#import IPython; IPython.embed()\n\tprint \"Executing FFT on host\"\n\t#hbox_large = hifft(hbox_large).astype(np.complex64).real\n\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\n\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\n\tprint \"Finished FFT on host\"\n\t#import IPython; IPython.embed()\n\n\t# for meta_x in xrange(META_GRID_SIZE):\n\t# \tfor meta_y in xrange(META_GRID_SIZE):\n\t# \t\tfor meta_z in xrange(META_GRID_SIZE):\n\t# \t\t\tlargebox_d = gpuarray.to_gpu(hbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N])\n\t# \t\t\tHII_filter(largebox_d, N, np.int32(meta_x), np.int32(meta_y), np.int32(meta_z), ZERO, smoothR, block=block_size, grid=grid_size);\n\t# \t\t\thbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N] = largebox_d.get()\n\t#plan = Plan(shape, dtype=np.complex64)\n\t#plan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\n\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\n\n\t# This saves a large resolution deltax\n\n\t\n\tprint \"downsampling\"\n\tsmallbox_d = gpuarray.zeros((HII_DIM,HII_DIM,M), dtype=np.float32)\n\tfor meta_z in xrange(META_GRID_SIZE):\n\t\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\n\t\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\n\t\t#largebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\tlargebox_d /= scale**3 #\n\t\tsubsample_kernel(largebox_d, smallbox_d, DIM, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size) #subsample in real space\n\t\thbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallbox_d.get_async()\n\tnp.save(parent_folder+\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\".format(HII_DIM, BOX_LEN), hbox_small)\n\t#import IPython; IPython.embed()\n\n\n\t# To get velocities: reload the k-space box\n\thbox_large = np.load(parent_folder+\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\".format(DIM, BOX_LEN))\n\thvbox_large = np.zeros((DIM, DIM, DIM), dtype=np.float32)\n\thvbox_small = np.zeros(HII_shape, dtype=np.float32)\n\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\n\tlargevbox_d = gpuarray.zeros((DIM,DIM,N), dtype=np.complex64)\n\tsmallvbox_d = gpuarray.zeros((HII_DIM, HII_DIM, M), dtype=np.float32)\n\tfor num, mode in enumerate(['x', 'y', 'z']):\n\t\tfor meta_z in xrange(META_GRID_SIZE):\n\t\t\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\t\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\n\t\t\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(meta_z), np.int32(num), block=block_size, grid=stitch_grid_size)\n\t\t\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=stitch_grid_size)\n\t\t\tprint hvbox_large.shape, largevbox_d.shape\n\t\t\thvbox_large[:, :, meta_z*N:(meta_z+1)*N] = largevbox_d.get_async()\n\t\thvbox_large = fft_stitch(N, plan2d, plan1d, hvbox_large, largevbox_d).real\n\t\tfor meta_z in xrange(META_GRID_SIZE):\n\t\t\tlargevbox_d = gpuarray.to_gpu_async(hvbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\n\t\t\tsubsample_kernel(largevbox_d.real, smallvbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size)\n\t\t\thvbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallvbox_d.get_async()\n\t\tnp.save(parent_folder+\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\".format(mode, HII_DIM, BOX_LEN), smallvbox_d.get())\n\n\treturn","def cvstem0(self,xs,ps,alp):\n epsilon = self.epsilon\n Ncv = np.size(xs,0)\n n = self.n\n I = np.identity(n)\n Ws = []\n for k in range(Ncv):\n Ws.append(cp.Variable((n,n),PSD=True))\n nu = cp.Variable(nonneg=True)\n chi = cp.Variable(nonneg=True)\n errtxt = \"https://github.com/AstroHiro/ncm#troubleshooting\"\n if len(sig(self.Afun).parameters) == 1:\n fun1 = self.Afun\n self.Afun = lambda x,p: fun1(x)\n if (self.iEC == \"est\") and (len(sig(self.Cfun).parameters) == 1):\n fun2 = self.Cfun\n self.Cfun = lambda x,p: fun2(x)\n if self.iEC == \"est\":\n Af = self.Afun\n Cf = self.Cfun\n J = (self.d1_over*self.b_over*chi\\\n +self.d2_over*self.c_over*self.g_over*nu)/alp\n elif self.iEC == \"con\":\n Af = lambda x,p: self.Afun(x,p).T\n Cf = lambda x,p: self.h_or_g(x,p).T\n J = self.d1_over*self.b_over*chi/alp+self.d2_over*nu\n else:\n raise ValueError('Invalid iEC: iEC = \"est\" or \"con\"')\n constraints = []\n for k in range(Ncv):\n x = xs[k,:]\n p = ps[k,:]\n Ax = Af(x,p)\n Cx = Cf(x,p)\n W = Ws[k]\n constraints += [chi*I-W >> 0,W-I >> 0]\n constraints += [-2*alp*W-((W-I)/self.dt+W@Ax+Ax.T@W-2*nu*Cx.T@Cx)\\\n >> epsilon*I]\n prob = cp.Problem(cp.Minimize(J),constraints)\n prob.solve(solver=cp.MOSEK)\n cvx_status = prob.status\n if cvx_status in [\"infeasible\",\"infeasible_inaccurate\"]:\n raise ValueError(\"Problem infeasible: see \"+errtxt)\n elif cvx_status in [\"unbounded\",\"unbounded_inaccurate\"]:\n raise ValueError(\"Problem unbounded: \"+errtxt)\n Wsout = []\n for k in range(Ncv):\n Wk = Ws[k].value/nu.value\n Wsout.append(Wk)\n self.Ws = Wsout\n self.nu = nu.value\n self.chi = chi.value\n self.Jcv = prob.value\n self.cvx_status = cvx_status\n pass","def dispersion_2(ztop, vp, vs, rh, Curves,\n h=0.005, dcl=0.005, dcr=0.005, keepnans=False):\n Waves, Types, Modes, Freqs = zip(*Curves)\n for w, t, m, F, V in dispersion_1(\\\n ztop, vp, vs, rh,\n Waves, Types, Modes, Freqs,\n h=h, dcl=dcl, dcr=dcr, keepnans=keepnans):\n yield w, t, m, F, V","def interacting_conductivity(self,\n sigma=0.04,\n freq_range=(0.0, 6.0, 1000),\n imag_dielectric=False,\n broadening='lorentz'):\n cell_area = np.abs(np.cross(self.a1, self.a2))*len(self.k_grid)\n broad_fnc = get_broadening_function(broadening, sigma)\n\n frequency_grid = np.linspace(*freq_range)\n output_grid = np.zeros(len(frequency_grid))\n\n energy_power = 1 + int(imag_dielectric)\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\n prefactor = prefactor/cell_area\n\n # Assuming x polarisation for now\n position_dipole_matrix = self.construct_position_dipole_matrix()\n\n n_shift = self.n_spins*self.n_orbs\n cutoff_band_min_maxes = self.exciton_obj.get_cutoff_band_min_maxes()\n # Construct vector of velocity matrix elements to dot with the\n # bse eigenvector.\n velocity_element_lists = []\n for s0 in range(self.n_spins):\n velocity_elements = []\n for idx_1, kpt in enumerate(self.k_grid):\n velocity_matrix = self.load_velocity_matrix(idx_1)\n bands = self.exciton_obj.get_number_conduction_valence_bands(\n idx_1, s0\n )\n v_num, c_num = bands\n v_min = 0\n if self.exciton_obj.energy_cutoff is not None:\n v_min = int(cutoff_band_min_maxes[s0][idx_1][0])\n c_num = int(cutoff_band_min_maxes[s0][idx_1][1]) + 1\n v_num = v_num - v_min\n j1 = n_shift*idx_1 + s0*self.n_orbs\n j2 = j1 + n_shift - (1 - s0)*self.n_orbs*(self.n_spins - 1)\n eigvecs = np.array(\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\n )\n if self.use_dipole_term:\n eigvals = np.array(\n self.file_storage['eigensystem']['eigenvalues'][idx_1]\n )\n else:\n eigvals = None\n for c, v in product(range(c_num), range(v_num)):\n cb_vector = eigvecs[:, v_min + v_num + c]\n vb_vector = eigvecs[:, v_min + v]\n\n matrix_elem = velocity_matrix_element(cb_vector,\n vb_vector,\n velocity_matrix)\n if self.use_dipole_term:\n cb_energy = eigvals[v_min + v_num + c]\n vb_energy = eigvals[v_min + v]\n position_dipole_term = get_position_dipole_element(\n vb_vector,\n cb_vector,\n vb_energy,\n cb_energy,\n position_dipole_matrix\n )\n matrix_elem = matrix_elem + position_dipole_term\n velocity_elements.append(matrix_elem)\n velocity_elements = np.array(velocity_elements, dtype=complex)\n velocity_element_lists.append(velocity_elements)\n\n bse_eigsys = self.exciton_obj.get_bse_eigensystem_direct(solve=True)\n for s0 in range(self.n_spins):\n for idx_1 in range(len(bse_eigsys[s0][0])):\n bse_vector = bse_eigsys[s0][1][:, idx_1]\n bse_value = bse_eigsys[s0][0][idx_1]\n energy_denominator = bse_value**energy_power\n interact_elem = np.dot(bse_vector, velocity_element_lists[s0])\n for idx_2, omega in enumerate(frequency_grid):\n smearing = broad_fnc(bse_value, omega)\n main_term = np.abs(interact_elem)**2/energy_denominator\n output = prefactor*main_term*smearing\n output_grid[idx_2] += output\n\n return frequency_grid, output_grid","def _computeEquilibriumValue(self,cp,kdT,kdI,Cactiv0,Cinhib0,E0,X0,masks,observed=None,verbose=False):\n # We move from an array to a list of 2d-array for the competition over each template:\n olderX = [np.zeros(m.shape[1]) for m in masks]\n for layeridx,layer in enumerate(masks):\n layerEq = np.zeros(layer.shape[1])\n if(layeridx==0):\n if verbose:\n print(\" input to python:\",X0,\" with cp: \",cp)\n for inpIdx in range(layer.shape[1]):\n # The first layer is a one to one non-linearity leading to an equation of the second order:\n if self.k1M[layeridx][inpIdx,inpIdx]*E0*self.TA0[layeridx][inpIdx,inpIdx]/cp == 0:\n x_eq = X0[inpIdx]\n else:\n bOnA = X0[inpIdx]-self.TA0[layeridx][inpIdx,inpIdx]- cp/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0)\n if verbose:\n print(\"bOnA python\",bOnA)\n print(\"second part\",4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))\n x_eq = 1/2*(bOnA + (bOnA**2+4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))**0.5)\n # saving values\n layerEq[inpIdx] = x_eq\n olderX[layeridx] = layerEq\n\n else:\n for inpIdx in range(layer.shape[1]):\n\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\n #Terms for the previous layers\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx]/(1+self.k1M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx]/(1+self.k3M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n if verbose:\n print(\"numerateur: \",np.sum(CactivsOld*olderX[layeridx-1]), \" denominateur: \",np.sum(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\n layerEq[inpIdx] = x_eq\n #compute of Kactivs,Kinhibs, for the current layer:\n olderX[layeridx] = layerEq\n if verbose and layeridx==1:\n print(\"python second layer:\",layerEq)\n if verbose and layeridx==2:\n print(\"python third layer: \",layerEq)\n #Compute equilibrium for last layers:\n layerEq = np.zeros(masks[-1].shape[0])\n for outputIdx in range(masks[-1].shape[0]):\n\n CactivsOld = np.where(masks[-1][outputIdx,:]>0,Cactiv0[-1][outputIdx]/(1+self.k1M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\n CinhibsOld = np.where(masks[-1][outputIdx,:]<0,Cinhib0[-1][outputIdx]/(1+self.k3M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\n Inhib = np.sum(CinhibsOld*olderX[-1]/kdT[-1][outputIdx])\n #computing of new equilibrium\n x_eq = np.sum(CactivsOld*olderX[-1]/(kdI[-1][outputIdx]*cp+Inhib/cp))\n layerEq[outputIdx]=x_eq\n olderX = olderX + [layerEq]\n\n if observed is not None:\n try:\n assert len(observed)==2\n except:\n raise Exception(\"please provide a tuple of size two for observed indicating the value to use.\")\n return olderX[observed[0]][observed[1]]\n return olderX","def config_hog_search(self, img):\n img = img.astype(np.float32)/255 # scale image: (png: 0-1, jpg: 0-255)\n img_crop = img[self.ys[0]:self.ys[1], :, :] # crop img to relative dimensions (ROI)\n clr_trf = cvf.transform_colorspace(img_crop, self.color_space) # transform color space from RGB\n clr_trf = cvu.scale_image(clr_trf, self.scale) # scale rather than selecting diffferent window sizes\n ch1, ch2, ch3 = [clr_trf[:,:,ch] for ch in range(3)] # HOG operates on per channel basis\n\n # get hog features as multi-dimensional array per channel for the entire image\n params={'orient':self.orient, 'pix_per_cell':self.pix_per_cell, 'cells_per_block':self.cells_per_block}\n params.update({'vis':False, 'feature_vec':False})\n hog1,hog2,hog3 = [cvf.get_hog_features(ch, **params) for ch in ([ch1,ch2,ch3])]\n # block configurations\n self.nfeat_per_block = self.orient*self.cells_per_block**2\n self.nblocks_per_window = (self.window //self.pix_per_cell) -1\n # number_blocks: define number of hog cells across an image according to channel dimensions\n # number_steps: define number of steps to occur across hog array to extract features\n rows, cols = ch1.shape[:2]\n number_blocks = lambda max_dim, pix_per_cell: (max_dim // pix_per_cell) -1\n number_steps = lambda nblocks, nblocks_window, cells_step: (nblocks - nblocks_window)//cells_step\n self.nxblocks, self.nyblocks = number_blocks(cols, self.pix_per_cell), number_blocks(rows, self.pix_per_cell)\n nxsteps, nysteps = \\\n [number_steps(it, self.nblocks_per_window, self.cells_per_step) for it in (self.nxblocks, self.nyblocks) ]\n return clr_trf, (nxsteps, nysteps), (hog1,hog2,hog3)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def predit_vehicles(img, windows,\n scaler = None,\n classifier = None,\n decision = DECISION_THRESHOLD,\n view=True,\n save_path=None,\n prefix=None,\n debug=True):\n car_features_list = []\n for window in windows:\n sub_img = cv2.resize(\n get_sub_image(img, window), CLASSIFIER_IMG_SIZE)\n one_features = extract_one_features(\n sub_img,\n cspace=CSPACE, spatial_size=(32, 32),\n hist_bins=32, hist_range=(0, 256),\n orient=ORIENTS_HOG, pix_per_cell=PIX_PER_CELL,\n cell_per_block=CELLS_PER_BLOCK,\n hog_channel=HOG_CHANNEL)\n car_features_list.append(\n # scaler.transform(np.asarray(one_features, dtype=np.float64)))\n one_features)\n scaled_list = scaler.fit_transform(car_features_list)\n #if view:\n # show_features(scaled_list)\n decs = classifier.decision_function(scaled_list)\n #predicts = classifier.predict(scaled_list)\n #predicts_bool = predicts.astype(np.bool)\n\n car_windows = []\n #for p, w in zip(predicts_bool, windows):\n # if p:\n for d, w in zip(decs, windows):\n if (d > decision): ## positive decision threshold\n # print (\"dec\", d)\n car_windows.append(w)\n #if view:\n # show_grid_view(img, car_windows)\n if save_path is not None:\n save_sub_images(img, car_windows,\n path=save_path,\n prefix=prefix,\n size=CLASSIFIER_IMG_SIZE)\n return car_windows","def setCtrls(self, fks, ik, upv):\n # type: (list[str], str, str) -> None\n\n self.fkCtrls = [self._getNode(x) for x in fks]\n self.fkTargets = [self._getMth(x) for x in fks]\n\n self.ikCtrl = self._getNode(ik)\n self.ikTarget = self._getMth(ik)\n\n self.upvCtrl = self._getNode(upv)\n self.upvTarget = self._getMth(upv)\n\n self.ikRotCtrl = self._getNode(ik.replace(\"_ik_\", \"_rot_\"))\n self.ikRotTarget = self.ikTarget","def plot_dispersion(kpts, enk):\n\n # Lattice constant and reciprocal lattice vectors\n # b1 = 2 pi/a (kx - ky + kz)\n # b2 = 2 pi/a (kx + ky - kz)\n # b3 = 2 pi/a (-kx + ky + kz)\n a = 5.556 # [A]\n b1 = (2 * np.pi / a) * np.array([1, -1, 1])\n b2 = (2 * np.pi / a) * np.array([1, 1, -1])\n b3 = (2 * np.pi / a) * np.array([-1, 1, 1])\n\n # L point in BZ is given by 0.5*b1 + 0.5*b2 + 0.5*b3\n # X point in BZ is given by 0.5*b2 + 0.5*b3\n lpoint = 0.5 * (b1 + b2 + b3)\n xpoint = 0.5 * (b2 + b3)\n\n # We can find kpoints along a path just by considering a dot product with lpoint and xpoint vectors.\n # Any kpoints with angle smaller than some tolerance are considered on the path and we can plot their frequencies\n deg2rad = 2 * np.pi / 360\n ang_tol = 1 * deg2rad # 1 degree in radians\n\n print(list(kpts))\n\n enkonly = np.array(enk['energy [Ryd]'])[:, np.newaxis]\n enkinds = np.array(enk['q_inds'])\n kptsonly = np.array(kpts[['kx [1/A]', 'ky [1/A]', 'kz [1/A]']]) / (2 * np.pi / a)\n kptsinds = np.array(kpts['q_inds'])\n kptsmag = np.linalg.norm(kptsonly, axis=1)[:, np.newaxis]\n\n dot_l = np.zeros(len(kpts))\n dot_x = np.zeros(len(kpts))\n\n # Separate assignment for gamma point to avoid divide by zero error\n nongamma = kptsmag != 0\n dot_l[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, lpoint[:, np.newaxis])[nongamma],\n kptsmag[nongamma]) / np.linalg.norm(lpoint)\n dot_x[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, xpoint[:, np.newaxis])[nongamma],\n kptsmag[nongamma]) / np.linalg.norm(xpoint)\n dot_l[np.squeeze(kptsmag == 0)] = 0\n dot_x[np.squeeze(kptsmag == 0)] = 0\n\n lpath = np.logical_or(np.arccos(dot_l) < ang_tol, np.squeeze(kptsmag == 0))\n xpath = np.logical_or(np.arccos(dot_x) < ang_tol, np.squeeze(kptsmag == 0))\n\n linds = kptsinds[lpath]\n xinds = kptsinds[xpath]\n lkmag = kptsmag[lpath]\n xkmag = kptsmag[xpath]\n\n plt.figure()\n\n for i, ki in enumerate(linds):\n energies = enkonly[enkinds == ki, 0]\n thiskmag = lkmag[i]\n if len(energies) > 1:\n veck = np.ones((len(energies), 1)) * thiskmag\n plt.plot(veck, energies, '.', color='C0')\n else:\n plt.plot(thiskmag, energies, '.', color='C0')\n\n for i, ki in enumerate(xinds):\n energies = enkonly[enkinds == ki, 0]\n thiskmag = lkmag[i]\n if len(energies) > 1:\n veck = np.ones((len(energies), 1)) * thiskmag\n plt.plot(-1 * veck, energies, '.', color='C1')\n else:\n plt.plot(-1 * thiskmag, energies, '.', color='C1')\n\n plt.xlabel('k magnitude')\n plt.ylabel('Energy in Ry')","def kViterbi(crf_obj, emissions, topK, mask):\n assert topK >=1\n if topK == 1:\n seq_length = emissions.size(1)\n best_path = crf_obj.decode(emissions, mask)\n observation = pad_seq(best_path, seq_length, crf_obj.batch_first, 0)\n best_probs = calculate_prob_byObser(crf_obj, emissions, observation, mask)\n return best_path, best_probs.squeeze()\n\n crf_obj._validate(emissions, mask=mask)\n if mask is None:\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\n if crf_obj.batch_first:\n emissions = emissions.transpose(0, 1)\n mask = mask.transpose(0, 1)\n normalizer = crf_obj._compute_normalizer(emissions, mask)\n # ===============start main part========================\n # emissions: (seq_length, batch_size, num_tags)\n # mask: (seq_length, batch_size)\n assert emissions.dim() == 3 and mask.dim() == 2\n assert emissions.shape[:2] == mask.shape\n assert emissions.size(2) == crf_obj.num_tags\n assert mask[0].all()\n\n seq_length, batch_size = mask.shape\n\n # Start transition and first emission\n # score is a tensor of size(batch_size, num_tags, topK) where for each\n # batch, value at tags i and top j stores the scores of the j-th best tag\n # sequence so far that ends with tag i\n #\n # pre_states saves the previous tag where the j-th best path that ends with tag i currently\n score = emissions.new_zeros((seq_length, batch_size, crf_obj.num_tags, topK))\n score[0,:,:,0] = crf_obj.start_transitions + emissions[0] # batch x num_tags\n\n pre_states = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\n for i in range(crf_obj.num_tags):\n for b in range(batch_size):\n for k in range(topK):\n pre_states[0,b,i,k] = i # should be start transition\n\n # The ranking of multiple paths through same state\n rank = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\n for t in range(1, seq_length):\n next_score_list = []\n for k in range(topK):\n broadcast_score = score[t-1,:,:,k].unsqueeze(2) #(batch_size, num_tags, 1)\n broadcast_emissions = emissions[t].unsqueeze(1) #(batch_size, 1, num_tags)\n\n # Compute the score tensor of size (batch_size, num_tags, num_tags)\n # where for each sample, entry at row i and column j stores\n # the sum of scores of all possible tag sequences so far that end\n # with transitioning from tag i to tag j and emitting\n # shape: (batch_size, num_tags, num_tags)\n next_score = broadcast_score + crf_obj.transitions + broadcast_emissions\n next_score_list.append(next_score)\n\n for b in range(batch_size):\n if mask[t,b]:\n for cur_state in range(crf_obj.num_tags):\n h = []\n for pre_state in range(crf_obj.num_tags):\n for k in range(topK):\n heapq.heappush(h, (-1*next_score_list[k][b, pre_state, cur_state], pre_state))\n\n # Get the sorted list\n h_sorted = [heapq.heappop(h) for _ in range(topK)] #get topK path into cur_state\n # We need to keep a ranking if a path crosses a state more than once\n rankDict = dict()\n # Retain the topK scoring paths\n for k in range(topK):\n score[t, b, cur_state, k] = score[t, b, cur_state, k] + (h_sorted[k][0].data * -1)\n pre_states[t, b, cur_state, k] = h_sorted[k][1]\n state = h_sorted[k][1]\n if state in rankDict:\n rankDict[state] = rankDict[state]+1\n else:\n rankDict[state] = 0\n rank[t, b, cur_state, k] = rankDict[state]\n else:\n for cur_state in range(crf_obj.num_tags):\n for k in range(topK):\n score[t, b, cur_state, k]=score[t-1, b, cur_state, k]\n\n\n batch_path = []\n batch_path_prob = []\n seq_ends = mask.long().sum(dim=0) - 1 # seq_len x batch # assume seq_ends=8, seq_len=9\n for b in range(batch_size):\n h = []\n for cur_state in range(crf_obj.num_tags):\n for k in range(topK):\n heapq.heappush(h, ( -1 * (score[seq_ends[b], b, cur_state, k]+crf_obj.end_transitions[cur_state]),\n cur_state, k))\n h_sorted = [heapq.heappop(h) for _ in range(topK)]\n k_list = np.zeros((topK, seq_ends[b]+1), int) # k x 9\n k_list_probs = list()\n for k in range(topK):\n prob = h_sorted[k][0]\n state = h_sorted[k][1]\n rankK = h_sorted[k][2]\n\n k_list_probs.append((prob*-1)-(normalizer[b]))\n k_list[k][seq_ends[b]] = state # assign index 8 == last one\n for t in range(seq_ends[b]-1, -1, -1): # t = 7,6,5,4,3,2,1,0\n nextState = k_list[k][t+1]\n preState = pre_states[t+1, b, nextState, rankK]\n k_list[k][t] = preState\n rankK = rank[t+1,b,nextState,rankK]\n batch_path.append(k_list.tolist())\n batch_path_prob.append(k_list_probs)\n if crf_obj.batch_first:\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions.transpose(0,1), mask.transpose(0,1), topK)\n else:\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions, mask, topK)\n return batch_path, batch_probs","def kick_from_eccentric_tides(self):\n\n inv_r_7 = self.inv_r**7\n r0_5 = self.pair[0].radius ** 5\n r1_5 = self.pair[1].radius ** 5\n m0_2 = self.pair[0].mass * self.pair[0].mass\n m1_2 = self.pair[1].mass * self.pair[1].mass\n\n ftr = -3.0 * inv_r_7 * constants.G * ((m1_2 * r0_5 * self.pair[0].kaps + m0_2 * r1_5 * self.pair[1].kaps) + # Non-dissipative\n 3 * self.inv_r * self.rdot_mag *\n (m1_2 * r0_5 * self.pair[0].kaps * self.pair[0].taulag\n + m0_2 * r1_5 * self.pair[1].kaps * self.pair[1].taulag)) # Dissipative\n\n hutforce = ftr * self.inv_r * self.pos\n kick0 = (1.0 / self.pair[0].mass) * hutforce * self.dt\n kick1 = (-1.0 / self.pair[1].mass) * hutforce * self.dt\n\n self.pair[0].velocity += kick0\n self.pair[1].velocity += kick1","def cvstem(self):\n if (self.iEC == \"est\") and (len(sig(self.Cfun).parameters) == 1):\n fun1 = self.Cfun\n self.Cfun = lambda x,p: fun1(x)\n if (self.iEC == \"est\") and (len(sig(self.Gw).parameters) == 1):\n fun2 = self.Gw\n self.Gw = lambda x,p: fun2(x)\n if self.iEC == \"est\":\n self.c_over = self.matrix_2bound(self.Cfun)\n self.g_over = self.matrix_2bound(self.Gw)\n if (len(sig(self.Bw).parameters) == 1):\n fun3 = self.Bw\n self.Bw = lambda x,p: fun3(x)\n self.b_over = self.matrix_2bound(self.Bw)\n self.linesearch()\n alp = self.alp_opt\n Nx = self.Nx\n Nsplit = 1\n Np = int(Nx/Nsplit)\n Nr = np.remainder(Nx,Nsplit)\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\n Nxp = self.n+self.n_p\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\n Ws_opt = []\n chi_opt = 0\n nu_opt = 0\n print(\"========================================================\")\n print(\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\")\n print(\"========================================================\")\n for p in range(Np):\n if np.remainder(p,int(Np/10)) == 0:\n print(\"# sampled metrics: \",p*Nsplit,\"...\")\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n if Nr != 0:\n print(\"# samples metrics: \",Nx,\"...\")\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\n self.cvstem0(xs_p,ps_p,alp)\n Ws_opt += self.Ws\n if self.nu >= nu_opt:\n nu_opt = self.nu\n if self.chi >= chi_opt:\n chi_opt = self.chi\n self.xs_opt = xs_opt\n self.ps_opt = ps_opt\n self.Ws_opt = Ws_opt\n self.chi_opt = chi_opt\n self.nu_opt = nu_opt\n if self.iEC == \"est\":\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\n print(\"Optimal steady-state estimation error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n elif self.iEC == \"con\":\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\n print(\"Optimal steady-state tracking error =\",\\\n \"{:.2f}\".format(self.Jcv_opt))\n else:\n raise ValueError('Invalid iEC: iEC = \"est\" or \"con\"')\n self.M2cholM()\n path = \"models/optvals/\"+self.fname\n if os.path.exists(path) == False:\n try:\n os.makedirs(path)\n except: \n raise OSError(\"Creation of directory %s failed\" %path)\n else:\n print (\"Successfully created directory %s \" %path)\n else:\n print (\"Directory %s already exists\" %path)\n np.save(path+\"/alp_opt.npy\",alp)\n np.save(path+\"/chi_opt.npy\",self.chi_opt)\n np.save(path+\"/nu_opt.npy\",self.nu_opt)\n np.save(path+\"/Jcv_opt.npy\",self.Jcv_opt)\n print(\"========================================================\")\n print(\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\")\n print(\"========================================================\\n\\n\")\n pass","def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 4th order calculation\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\n \n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n\n # Calculate truncation error between 5th and 4th order\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\n \n # Compare eps to emin and emax and update h accordingly\n if np.max(eps) < emin:\n if h*2.0 < hmax:\n h *= 2.0\n new_v = new_v5\n new_r = new_r5 \n \n if np.max(eps) > emax:\n if h/2.0 > hmin:\n h /= 2.0\n print h\n # Error too large, call rk_adaptive again with smaller h\n if recur < recurmax:\n recur += 1\n rk_adaptive(accel,m,r,h,v,recur)\n new_v = new_v5\n new_r = new_r5\n \n else:\n new_v = new_v5\n new_r = new_r5\n \n return new_v, new_r, h","def prepare_CvD16_for_M2L_calc(templates_lam_range, verbose=False):\n import glob\n import os\n template_glob=os.path.expanduser('~/z/Data/stellarpops/CvD2/vcj_models/VCJ_*.s100')\n\n vcj_models=sorted(glob.glob(template_glob))\n temp_lamdas, x35, x3, x23, kroupa, flat=np.genfromtxt(vcj_models[-1], unpack=True)\n\n n_ages=7\n n_zs=5\n n_imfs=5\n\n \n\n\n Zs=['m1.5', 'm1.0', 'm0.5', 'p0.0', 'p0.2']\n ages=[1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.5]\n model_imfs_order=['x35', 'x3', 'x23', 'kroupa', 'flat']\n\n t_mask = ((temp_lamdas > templates_lam_range[0]) & (temp_lamdas <templates_lam_range[1]))\n\n\n\n y=x35[t_mask]\n x=temp_lamdas[t_mask]\n\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\n new_x=temp_lamdas[t_mask][0]+0.9*(np.arange(np.ceil((temp_lamdas[t_mask][-1]-temp_lamdas[t_mask][0])/0.9))+1)\n interp=si.interp1d(x, y, fill_value='extrapolate')\n out=interp(new_x)\n\n templates=np.empty((len(out), n_ages, n_zs, n_imfs))\n\n\n\n for a, Z in enumerate(Zs): \n for b, age in enumerate(ages):\n model=glob.glob(os.path.expanduser('~/z/Data/stellarpops/CvD2/vcj_models/VCJ_*{}*{}.ssp.s100'.format(Z, age)))[0]\n if verbose:\n print 'Loading {}'.format(model)\n data=np.genfromtxt(model)\n\n for c, counter in enumerate(reversed(range(1, data.shape[-1]))):\n \n #Interpolate templates onto a uniform wavelength grid and then log-rebin\n y=data[:, counter][t_mask] \n x=temp_lamdas[t_mask]\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\n new_x=temp_lamdas[t_mask][0]+0.9*(np.arange(np.ceil((temp_lamdas[t_mask][-1]-temp_lamdas[t_mask][0])/0.9))+1)\n\n interp=si.interp1d(x, y, fill_value='extrapolate')\n out=interp(new_x) \n\n templates[:, b, a, c]=out\n\n return templates, new_x","def evolve(self, k_vec, Nt,**kwargs):\n \n M_eff = np.eye((self.Nd), dtype=complex) # aux matrix\n T = 1.\n for it in range(Nt):\n \n # update the Hamiltonian for time-inteval\n self.updateH(k_vec, it)\n\n # return eigenenergies and vectors\n E_k, U = lg.eig(self.H_kc) \n\n # U^-1 * exp(H_d) U\n U_inv = lg.inv(U)\n\n # construct a digonal matrix out of a vector\n M1 = (np.exp(-1.j*E_k*T) * U_inv.T).T\n\n #MM = np.dot(U_inv,np.dot(H_M, U))\n MM = np.dot(U,M1)\n M_eff = np.dot(M_eff,MM)\n # end of loop\n Ek, Uk = lg.eig( M_eff )\n idx = (np.log(Ek).imag).argsort()\n Efl_k = np.log(Ek).imag[idx]\n Ufl_k = Uk[idx]\n return Efl_k, Ufl_k","def jackknifed_coh_variance(tx, ty, eigvals, adaptive=True):\r\n\r\n K = tx.shape[0]\r\n\r\n # calculate leave-one-out estimates of MSC (magnitude squared coherence)\r\n jk_coh = []\r\n # coherence is symmetric (right??)\r\n sides = 'onesided'\r\n all_orders = set(range(K))\r\n\r\n import nitime.algorithms as alg\r\n\r\n # get the leave-one-out estimates\r\n for i in range(K):\r\n items = list(all_orders.difference([i]))\r\n tx_i = np.take(tx, items, axis=0)\r\n ty_i = np.take(ty, items, axis=0)\r\n eigs_i = np.take(eigvals, items)\r\n if adaptive:\r\n wx, _ = adaptive_weights(tx_i, eigs_i, sides=sides)\r\n wy, _ = adaptive_weights(ty_i, eigs_i, sides=sides)\r\n else:\r\n wx = wy = eigs_i[:, None]\r\n # The CSD\r\n sxy_i = alg.mtm_cross_spectrum(tx_i, ty_i, (wx, wy), sides=sides)\r\n # The PSDs\r\n sxx_i = alg.mtm_cross_spectrum(tx_i, tx_i, wx, sides=sides)\r\n syy_i = alg.mtm_cross_spectrum(ty_i, ty_i, wy, sides=sides)\r\n # these are the | c_i | samples\r\n msc = np.abs(sxy_i)\r\n msc /= np.sqrt(sxx_i * syy_i)\r\n jk_coh.append(msc)\r\n\r\n jk_coh = np.array(jk_coh)\r\n # now normalize the coherence estimates and take the mean\r\n normalize_coherence(jk_coh, 2 * K - 2, copy=False) # inplace\r\n jk_avg = np.mean(jk_coh, axis=0)\r\n\r\n jk_var = (jk_coh - jk_avg)\r\n np.power(jk_var, 2, jk_var)\r\n jk_var = jk_var.sum(axis=0)\r\n\r\n # Do/Don't use the alternative scaling here??\r\n f = float(K - 1) / K\r\n\r\n jk_var *= f\r\n\r\n return jk_var","def tuto_kernel_overview(optimize=True, plot=True):\r\n ker1 = GPy.kern.rbf(1) # Equivalent to ker1 = GPy.kern.rbf(input_dim=1, variance=1., lengthscale=1.)\r\n ker2 = GPy.kern.rbf(input_dim=1, variance = .75, lengthscale=2.)\r\n ker3 = GPy.kern.rbf(1, .5, .5)\r\n\r\n print ker2\r\n\r\n if plot:\r\n ker1.plot()\r\n ker2.plot()\r\n ker3.plot()\r\n\r\n k1 = GPy.kern.rbf(1,1.,2.)\r\n k2 = GPy.kern.Matern32(1, 0.5, 0.2)\r\n\r\n # Product of kernels\r\n k_prod = k1.prod(k2) # By default, tensor=False\r\n k_prodtens = k1.prod(k2,tensor=True)\r\n\r\n # Sum of kernels\r\n k_add = k1.add(k2) # By default, tensor=False\r\n k_addtens = k1.add(k2,tensor=True)\r\n\r\n k1 = GPy.kern.rbf(1,1.,2)\r\n k2 = GPy.kern.periodic_Matern52(1,variance=1e3, lengthscale=1, period = 1.5, lower=-5., upper = 5)\r\n\r\n k = k1 * k2 # equivalent to k = k1.prod(k2)\r\n print k\r\n\r\n # Simulate sample paths\r\n X = np.linspace(-5,5,501)[:,None]\r\n Y = np.random.multivariate_normal(np.zeros(501),k.K(X),1)\r\n\r\n k1 = GPy.kern.rbf(1)\r\n k2 = GPy.kern.Matern32(1)\r\n k3 = GPy.kern.white(1)\r\n\r\n k = k1 + k2 + k3\r\n print k\r\n\r\n k.constrain_positive('.*var')\r\n k.constrain_fixed(np.array([1]),1.75)\r\n k.tie_params('.*len')\r\n k.unconstrain('white')\r\n k.constrain_bounded('white',lower=1e-5,upper=.5)\r\n print k\r\n\r\n k_cst = GPy.kern.bias(1,variance=1.)\r\n k_mat = GPy.kern.Matern52(1,variance=1., lengthscale=3)\r\n Kanova = (k_cst + k_mat).prod(k_cst + k_mat,tensor=True)\r\n print Kanova\r\n\r\n # sample inputs and outputs\r\n X = np.random.uniform(-3.,3.,(40,2))\r\n Y = 0.5*X[:,:1] + 0.5*X[:,1:] + 2*np.sin(X[:,:1]) * np.sin(X[:,1:])\r\n\r\n # Create GP regression model\r\n m = GPy.models.GPRegression(X, Y, Kanova)\r\n\r\n if plot:\r\n fig = pb.figure(figsize=(5,5))\r\n ax = fig.add_subplot(111)\r\n m.plot(ax=ax)\r\n\r\n pb.figure(figsize=(20,3))\r\n pb.subplots_adjust(wspace=0.5)\r\n axs = pb.subplot(1,5,1)\r\n m.plot(ax=axs)\r\n pb.subplot(1,5,2)\r\n pb.ylabel(\"= \",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,3)\r\n m.plot(ax=axs, which_parts=[False,True,False,False])\r\n pb.ylabel(\"cst +\",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,4)\r\n m.plot(ax=axs, which_parts=[False,False,True,False])\r\n pb.ylabel(\"+ \",rotation='horizontal',fontsize='30')\r\n axs = pb.subplot(1,5,5)\r\n pb.ylabel(\"+ \",rotation='horizontal',fontsize='30')\r\n m.plot(ax=axs, which_parts=[False,False,False,True])\r\n\r\n return(m)","def rk5(accel,m,r,h,v):\n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\n\n # 5th order calculation\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \n \n return new_v5, new_r5","def model(cp_list,cp_now):\r\n global record\r\n distance_threshold = 0.5\r\n model_path = \"trained_knn_model.clf\"\r\n \r\n # Load a trained KNN model (if one was passed in)\r\n with open(model_path, 'rb') as f:\r\n knn_clf = pickle.load(f)\r\n\r\n for X_img in cp_list:\r\n # Load image file and find face locations\r\n X_face_locations = face_recognition.face_locations(X_img)\r\n\r\n # If no faces are found in the image, return an empty result.\r\n if len(X_face_locations) == 0:\r\n return []\r\n\r\n # Find encodings for faces in the test iamge\r\n faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)\r\n\r\n # Use the KNN model to find the best matches for the test face\r\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\r\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]\r\n # Predict classes and remove classifications that aren't within the threshold\r\n for pred, rec in zip(knn_clf.predict(faces_encodings), are_matches):\r\n if rec:\r\n name = pred\r\n else:\r\n name = \"unknown\"\r\n if name not in record:\r\n end = datetime.now()\r\n record.append(name)\r\n record_time.append(end-cp_now)","def component_func(B, C, F, list_funcs, len_kegg, threshold=0.05):\n\n size_label = 18\n size_tick = 18\n sns.set_style(\"darkgrid\")\n\n list_funcs = list_funcs[0:len_kegg]\n B = B[0:len_kegg]\n C = C[0:len_kegg]\n\n idx_p = [idx*2+0 for idx in range(B.shape[1]/2)]\n idx_m = [idx*2+1 for idx in range(B.shape[1]/2)]\n is_p = F[:,idx_p].mean(axis=1) - F[:,idx_m].mean(axis=1) > threshold\n is_m = F[:,idx_m].mean(axis=1) - F[:,idx_p].mean(axis=1) > threshold\n is_p = [idx for idx, val in enumerate(is_p) if val]\n is_m = [idx for idx, val in enumerate(is_m) if val]\n is_n = [idx for idx in range(C.shape[1]) if (idx not in is_p) and (idx not in is_m)]\n\n fig = plt.figure(figsize=(6, 6))\n\n for idx_c in range(C.shape[1]):\n clone_num = idx_c +1\n if idx_c in is_p:\n color=\"green\"\n label = \"C\"+str(clone_num)+\"|P\"\n elif idx_c in is_m:\n color=\"red\"\n label = \"C\"+str(clone_num)+\"|M\"\n else:\n color = \"royalblue\"\n label = \"C\"+str(clone_num)\n\n if clone_num in [1]:\n marker = \"$1$\"\n elif clone_num in [2]:\n marker = \"$2$\"\n elif clone_num in [3]:\n marker = \"$3$\"\n elif clone_num in [4]:\n marker = \"$4$\"\n elif clone_num in [5]:\n marker = \"$5$\"\n elif clone_num in [6]:\n marker = \"$6$\"\n else:\n print(\"error\")\n plt.plot(C[:,idx_c],range(len_kegg), color=color, marker=marker, markersize=10, linestyle=\"\",label=label, alpha=0.5)\n\n plt.yticks(range(len_kegg), list_funcs)\n plt.xlabel(\"Pathway strength\", fontsize=size_label)\n plt.legend()\n plt.tick_params(labelsize=size_tick-4)\n plt.show()\n ##fig.savefig(\"figures/fig7compfunc.pdf\", bbox_inches=\"tight\")","def solveverlet(self,T,dt):\r\n t = 0.\r\n self.dt = dt\r\n self.n = int(T/dt)\r\n L = self.param[2]\r\n N = self.particles.size\r\n\r\n self.U = np.zeros([self.n])\r\n\r\n progress = t/T*100\r\n\r\n #JV: Here we define the number of the GxG grid that we will need to calcule the entropy, change in order to change the precision of this grid\r\n self.G = 7\r\n\r\n #JV: We create a list that will be useful for the walls submenu, that will help us in the border conditions of the wall, see in vel_verlet()\r\n self.bouncing = np.zeros(self.particles.size)\r\n\r\n if(self.param[4] == \"Subsystems\"): #JV: If we are on \"Subsystems\", we will count different the types of particles\r\n self.grid = np.zeros([self.G,self.G,2])\r\n else:\r\n self.grid = np.zeros([self.G,self.G,2]) #JV: When we are not in \"Subsystems\", we will have the same type of variable, but will only use the [:,:,0] (this is because numba has problems otherwise)\r\n\r\n self.entropy_val = 0\r\n\r\n #JV: If we are simulating the brownian simulation, we initialize the array that will keep track if the brownian particle goes through a wall\r\n if(self.param[4] == \"Brownian\"):\r\n self.wallcount = np.zeros([2])\r\n else:\r\n self.wallcount = np.zeros([2]) #JV: We have to keep both in the same type of variables, otherwise numba will have problems. So now this conditional block is quite poinless. TO-ERASE\r\n\r\n np.vectorize(lambda i: i.reset())(self.particles) #This line resets the particles to their initial position\r\n\r\n self.vel_verlet_on = True #JV: If it's true, it will compute with the velocity verlet algorithm, if it's not, it will compute with normal verlet\r\n\r\n self.Nlist = int(1*(self.particles.size)**(1/2)) #JV:This variable defines the number of close particles that will be stored in the list (go to close_particles_list() for more info)\r\n #print(self.Nlist)\r\n\r\n #X,Y,VX,VY has the trajectories of the particles with two indexes that\r\n #access time and particles, respectively\r\n self.X = np.vectorize(lambda i: i.r[0])(self.particles)\r\n self.Y = np.vectorize(lambda i: i.r[1])(self.particles)\r\n self.VX = np.vectorize(lambda i: i.v[0])(self.particles)\r\n self.VY = np.vectorize(lambda i: i.v[1])(self.particles)\r\n\r\n MX, MXT = np.meshgrid(self.X[:],self.X[:])\r\n MY, MYT = np.meshgrid(self.Y[:],self.Y[:])\r\n\r\n #JV: So dx is a nxn simetric array with 0 in the diagonal, and each position is the corresponding distance between the particles,\r\n # so the position [1,2] is the distance between partcle 1 and 2 (x1-x2), and so on\r\n dx = MXT - MX\r\n dx = dx\r\n\r\n dy = MYT - MY\r\n dy = dy\r\n\r\n r2 = np.square(dx)+np.square(dy)\r\n\r\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: we first calculate the matrix that contains in every row the indexs of the m closest particles\r\n\r\n if(self.vel_verlet_on == True):\r\n #JV: We define the variables that we will need in the velocity verlet algorithm\r\n print(\"Computing with the Velocity-Verlet algorithm\")\r\n X0 = self.X\r\n Y0 = self.Y\r\n VX0 = self.VX\r\n VY0 = self.VY\r\n\r\n X1 = self.X\r\n Y1 = self.Y\r\n VX1 = self.VX\r\n VY1 = self.VY\r\n\r\n MX, MXT = np.meshgrid(X0[:],X0[:],copy=False)\r\n MY, MYT = np.meshgrid(Y0[:],Y0[:],copy=False)\r\n dx = MXT - MX\r\n dx = dx\r\n\r\n dy = MYT - MY\r\n dy = dy\r\n\r\n r2 = np.square(dx)+np.square(dy)\r\n\r\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\r\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\r\n\r\n a0 = (1/self.m)*np.transpose(fv(X0[:],Y0[:],dx,dy,r2,t/self.dt,False,self.param[2],self.particles.size,self.U,self.dt,self.close_list,self.Nlist,self.vel_verlet_on,self.R,self.param[3],self.param[4],self.param[5],self.grid,self.G,self.wallcount,self.X2))\r\n\r\n for i in range(0, self.n):\r\n r1 = np.array([X0,Y0]) + np.array([VX0,VY0])*dt + 0.5*a0*dt**2\r\n\r\n MX, MXT = np.meshgrid(r1[0,:],r1[0,:],copy=False)\r\n MY, MYT = np.meshgrid(r1[1,:],r1[1,:],copy=False)\r\n dx = MXT - MX\r\n dx = dx\r\n\r\n dy = MYT - MY\r\n dy = dy\r\n\r\n r2 = np.square(dx)+np.square(dy)\r\n\r\n if(self.param[3] == \"Free!\"):\r\n #JV: We do this to get the actual distance in the case of the \"Free!\" simulation, in which there is no elastic collision between the particles and the boundaries\r\n dx_v2 = (np.abs(dx.copy())-1*L)\r\n r2_v2 = dx_v2**2+dy**2\r\n dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\r\n r2 = np.where(r2 > r2_v2,r2_v2,r2)\r\n dy_v2 = (np.abs(dy.copy())-1*L)\r\n r2_v2 = dx**2+dy_v2**2\r\n dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\r\n r2 = np.where(r2 > r2_v2,r2_v2,r2)\r\n r2_v2 = dx_v2**2+dy_v2**2\r\n dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\r\n dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\r\n r2 = np.where(r2 > r2_v2,r2_v2,r2)\r\n\r\n #JV: call velocityverlet to compute the next position\r\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\r\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\r\n\r\n X1,Y1,VX1,VY1,a1 = vel_verlet(t,dt,np.array([X0,Y0]),np.array([VX0,VY0]),a0,dx,dy,r2,self.close_list,self.m,self.R,L,N,self.param[3],self.param[4],self.param[7],self.param[8],self.param[9],self.U,self.Nlist,self.vel_verlet_on,self.param[5],self.grid,self.G,self.wallcount,self.X2,self.bouncing)\r\n\r\n #JV: Now we check where this particle is in a RxR grid, that will help us to calcule the entropy. We do not do this for the Brownian mode because we don't compute the entropy in that case.\r\n if(self.param[4] != \"Brownian\"):\r\n for h in range(0, N):\r\n if(self.param[4] == \"Subsystems\"):\r\n if(h < self.param[5]**2): #JV: self.param[5] stores the number of n1xn1 type 1 particles\r\n self.grid[int((X1[h]+0.495*L) / (L/self.G)), int((Y1[h]+0.495*L) / (L/self.G)),0] += 1\r\n else:\r\n self.grid[int((X1[h]+0.495*L) / (L/self.G)), int((Y1[h]+0.495*L) / (L/self.G)),1] += 1\r\n else:\r\n self.grid[int((X1[h]+0.495*L) / (L/self.G)), int((Y1[h]+0.495*L) / (L/self.G))] += 1\r\n\r\n if(self.param[4] == \"Brownian\"):\r\n if(self.wallcount[0] == 0):\r\n self.X2 = np.append(self.X2,(abs(X1[N-1]))**2)\r\n else:\r\n self.X2 = np.append(self.X2,(L*self.wallcount[0]+(X1[N-1]))**2)\r\n self.entropy = np.append(self.entropy,self.entropy_val)\r\n\r\n t += dt\r\n\r\n self.X = np.vstack((self.X,X1))\r\n self.Y = np.vstack((self.Y,Y1))\r\n self.VX = np.vstack((self.VX, VX1))\r\n self.VY = np.vstack((self.VY, VY1))\r\n a0 = a1\r\n\r\n #Redefine and repeat\r\n X0,Y0 = X1,Y1\r\n VX0,VY0 = VX1,VY1\r\n\r\n #JV: Every amount of steps of time we calculate the entropy\r\n update_entropy = 2\r\n if(i % update_entropy == 0):\r\n\r\n self.entropy_val = 0\r\n sumagrid = np.sum(self.grid)\r\n\r\n if(self.param[4] == \"Subsystems\"):\r\n sumagrid_subs = np.zeros([2])\r\n sumagrid_subs[0] = np.sum(self.grid[:,:,0]) #JV: Number of type-0 particles\r\n sumagrid_subs[1] = sumagrid - sumagrid_subs[0] #JV: Number of type-1 particles\r\n\r\n for j in range(self.G):\r\n for k in range(self.G):\r\n for l in range(2):\r\n if ((self.grid[j,k,0]+self.grid[j,k,1]) != 0):\r\n # pji = float(self.grid[j,k,l])/(update_entropy*(self.grid[j,k,0]+self.grid[j,k,1]))\r\n pji = float((self.grid[j,k,l]/(sumagrid_subs[l]/(sumagrid_subs[0]+sumagrid_subs[1])))/(update_entropy*(self.grid[j,k,0]/(sumagrid_subs[0]/(sumagrid_subs[0]+sumagrid_subs[1])))+(self.grid[j,k,1]/(sumagrid_subs[1]/(sumagrid_subs[0]+sumagrid_subs[1])))))\r\n else:\r\n pji = 0\r\n if(pji != 0):\r\n self.entropy_val += -pji*np.log(pji) #JV: We will only calculate the value when pji != 0\r\n\r\n self.entropy_val = self.entropy_val /(self.G**2)\r\n\r\n else:\r\n for j in range(self.G):\r\n for k in range(self.G):\r\n pji = float(self.grid[j,k,0])/(update_entropy*sumagrid)\r\n if(pji != 0):\r\n self.entropy_val += -pji*np.log(pji)\r\n\r\n self.entropy_val = self.entropy_val /(self.G**2)\r\n\r\n if(self.param[4] == \"Subsystems\"):\r\n self.grid = np.zeros([self.G,self.G,2])\r\n else:\r\n self.grid = np.zeros([self.G,self.G,2])\r\n\r\n #Update and show progress through console\r\n progress = t/T*100\r\n if(i%1000 == 0):\r\n print(int(progress),'% done')\r\n\r\n else:\r\n print(\"Computing with the Verlet algorithm\")\r\n\r\n #Generation of the precious position (backwards euler step)\r\n X1 = self.X\r\n Y1 = self.Y\r\n X0 = X1 - self.VX*dt\r\n Y0 = Y1 - self.VY*dt\r\n\r\n for self.i in range(0,self.n):\r\n #Call verlet to compute the next position\r\n X2,Y2 = self.verlet(t,dt,np.array([X0,Y0]),np.array([X1,Y1]))\r\n t = t + dt\r\n\r\n #Add the new positions to X,Y,VX,VY\r\n self.X = np.vstack((self.X,X2))\r\n self.Y = np.vstack((self.Y,Y2))\r\n self.VX = np.vstack((self.VX,(X2-X0)/(2*dt)))\r\n self.VY = np.vstack((self.VY,(Y2-Y0)/(2*dt)))\r\n\r\n #Redefine and repeat\r\n X0,Y0 = X1,Y1\r\n X1,Y1 = X2,Y2\r\n\r\n #Update and show progress through console\r\n progress = t/T*100\r\n if(self.i%1000 == 0):\r\n print(int(progress),'% done')\r\n\r\n #Once the computation has ended, I compute the kinetic energy,\r\n #the magnitude of the velocity V and the temperature\r\n #(see doc for temperature definition)\r\n self.KE()\r\n self.V = np.sqrt((self.VX**2 + self.VY**2))\r\n self.T = (np.sum(self.V**2,axis=1)/(self.particles.size*2 - 2))\r\n\r\n #Generation of the MB functions, you can modify the definition by\r\n #changing the linspace points\r\n vs,a = np.meshgrid(np.linspace(0,self.V.max(),100),self.T)\r\n a,ts = np.meshgrid(np.linspace(0,self.V.max(),100),self.T)\r\n self.MB = (vs/(ts)*np.exp(-vs**2/(2*ts)))\r\n\r\n #JV: If we are on the Subsystems submenu, we will calculate the temperature and the MB distribution of both types of particles\r\n if(self.param[4] == \"Subsystems\"):\r\n\r\n #JV: 1st group of particles\r\n self.V1 = np.sqrt((self.VX[:,0:(self.param[5]**2)]**2 + self.VY[:,0:(self.param[5]**2)]**2))\r\n self.T1 = (np.sum(self.V1**2,axis=1)/((self.param[5]**2)*2 - 2))\r\n\r\n vs1,a1 = np.meshgrid(np.linspace(0,self.V1.max(),100),self.T1)\r\n a1,ts1 = np.meshgrid(np.linspace(0,self.V1.max(),100),self.T1)\r\n self.MB1 = (vs1/(ts1)*np.exp(-vs1**2/(2*ts1)))\r\n\r\n #JV: 2nd group\r\n self.V2 = np.sqrt((self.VX[:,(self.param[5]**2):self.particles.size]**2 + self.VY[:,(self.param[5]**2):self.particles.size]**2))\r\n self.T2 = (np.sum(self.V2**2,axis=1)/((self.particles.size-self.param[5]**2)*2 - 2))\r\n\r\n vs2,a2 = np.meshgrid(np.linspace(0,self.V2.max(),100),self.T2)\r\n a2,ts2 = np.meshgrid(np.linspace(0,self.V2.max(),100),self.T2)\r\n self.MB2 = (vs2/(ts2)*np.exp(-vs2**2/(2*ts2)))\r\n\r\n \"\"\"Here I generate the accumulated V,T and MB using lists, the reason I use lists is because if you append two numpy arrays\r\n to an empty numpy array, they merge instead of remaining separate. You could technically use splicing to save on memory\r\n but sacrificing cpu.\"\"\"\r\n\r\n self.Vacu = []\r\n self.Tacu = []\r\n self.MBacu = []\r\n self.Vacu.append(self.V[int(self.n/2),:])\r\n self.Tacu.append(np.sum(self.V[int(self.n/2),:]**2)/(self.particles.size*2 - 2))\r\n\r\n vs = np.linspace(0,self.V.max(),100)\r\n self.MBacu.append((vs/(self.Tacu[0])*np.exp(-vs**2/(2*self.Tacu[0]))))\r\n\r\n #This delta controls the time interval for accumulation, right now its every 5 units\r\n delta = 5./dt\r\n\r\n #This 40 that appers in these lines is the time from which I start accumulating\r\n #to ensure the system has reached equilibrium.\r\n for i in range(1,int((self.n-(40./dt))/delta)):\r\n self.Vacu.append(np.hstack((self.Vacu[i-1],self.V[int(40./dt)+int(i*delta),:])))\r\n self.Tacu.append(np.sum(self.Vacu[i]**2)/(self.Vacu[i].size*2 - 2))\r\n self.MBacu.append((vs/(self.Tacu[i])*np.exp(-vs**2/(2*self.Tacu[i]))))\r\n return","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def getContSpec(par):\n # read input\n if par['verbose']:\n print('\\n(*) Start\\n(*) Loading Data File: {}...'.format(par['GexpFile']))\n\n # t, Gexp = GetExpData(par['GexpFile'])\n t, Gexp, wexp = GetExpData(par['GexpFile'])\n\n if par['verbose']:\n print('(*) Initial Set up...', end=\"\")\n \n # Set up some internal variables\n n = len(t)\n ns = par['ns'] # discretization of 'tau'\n\n tmin = t[0];\n tmax = t[n-1];\n \n # determine frequency window\n if par['FreqEnd'] == 1:\n smin = np.exp(-np.pi/2) * tmin; smax = np.exp(np.pi/2) * tmax\t\t\n elif par['FreqEnd'] == 2:\n smin = tmin; smax = tmax\t\t\t\t\n elif par['FreqEnd'] == 3:\n smin = np.exp(+np.pi/2) * tmin; smax = np.exp(-np.pi/2) * tmax\t\t\n\n hs = (smax/smin)**(1./(ns-1))\n s = smin * hs**np.arange(ns)\n \n kernMat = getKernMat(s, t)\n tic = time.time()\n \n # get an initial guess for Hgs, G0\n if par['plateau']:\n Hgs, G0 = InitializeH(Gexp, wexp, s, kernMat, np.min(Gexp))\t\t\n else:\n Hgs = InitializeH(Gexp, wexp, s, kernMat)\n \n if par['verbose']:\n te = time.time() - tic\n print('\\t({0:.1f} seconds)\\n(*) Building the L-curve ...'.format(te), end=\"\")\t\n tic = time.time()\n\n # Find Optimum Lambda with 'lcurve'\n if par['lamC'] == 0:\n if par['plateau']:\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par, G0)\n else:\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par)\n else:\n lamC = par['lamC']\n\n if par['verbose']:\n te = time.time() - tic\n print('({1:.1f} seconds)\\n(*) Extracting CRS, ...\\n\\t... lamC = {0:0.3e}; '.\n format(lamC, te), end=\"\")\n \n tic = time.time()\n\n # Get the best spectrum\t\n if par['plateau']:\n H, G0 = getH(lamC, Gexp, wexp, Hgs, kernMat, G0);\n print('G0 = {0:0.3e} ...'.format(G0), end=\"\")\n else:\n H = getH(lamC, Gexp, wexp, Hgs, kernMat);\n\n #----------------------\n # Print some datafiles\n #----------------------\n\n if par['verbose']:\n te = time.time() - tic\n print('done ({0:.1f} seconds)\\n(*) Writing and Printing, ...'.format(te), end=\"\")\n\n # Save inferred G(t)\n if par['plateau']:\n K = kernel_prestore(H, kernMat, G0);\t\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e', header='G0 = {0:0.3e}'.format(G0))\n else:\n K = kernel_prestore(H, kernMat);\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e')\n \n np.savetxt('output/Gfit.dat', np.c_[t, K], fmt='%e')\n\n # print Hlam, rho-eta, and logP if lcurve has been visited\n if par['lamC'] == 0:\n if os.path.exists(\"output/Hlam.dat\"):\n os.remove(\"output/Hlam.dat\")\n \n fHlam = open('output/Hlam.dat','ab')\n for i, lamb in enumerate(lam):\n np.savetxt(fHlam, Hlam[:,i])\t\n fHlam.close()\t\n\n # print logP\n np.savetxt('output/logPlam.dat', np.c_[lam, logP])\n \n # print rho-eta\n np.savetxt('output/rho-eta.dat', np.c_[lam, rho, eta], fmt='%e')\n\n #------------\n # Graphing\n #------------\n\n if par['plotting']:\n\n # plot spectrum \"H.pdf\" with errorbars\n plt.clf()\n\n plt.semilogx(s,H,'o-')\n plt.xlabel(r'$s$')\n plt.ylabel(r'$H(s)$')\n\n # error bounds are only available if lcurve has been implemented\n if par['lamC'] == 0:\n plam = np.exp(logP); plam = plam/np.sum(plam)\t\t\t\n Hm = np.zeros(len(s))\n Hm2 = np.zeros(len(s))\n cnt = 0\n for i in range(len(lam)):\t\n #~ Hm += plam[i]*Hlam[:,i]\n #~ Hm2 += plam[i]*Hlam[:,i]**2\n # count all spectra within a threshold\n if plam[i] > 0.1:\n Hm += Hlam[:,i]\n Hm2 += Hlam[:,i]**2\n cnt += 1\n\n Hm = Hm/cnt\n dH = np.sqrt(Hm2/cnt - Hm**2)\n\n plt.semilogx(s,Hm+2.5*dH, c='gray', alpha=0.5)\n plt.semilogx(s,Hm-2.5*dH, c='gray', alpha=0.5)\n\n plt.tight_layout()\n plt.savefig('output/H.pdf')\n\n\n #\n # plot comparison with input spectrum\n #\n\n plt.clf()\n\n if par['plateau']:\n K = kernel_prestore(H, kernMat, G0);\t\n else:\n K = kernel_prestore(H, kernMat);\n\n plt.loglog(t, Gexp,'o',t, K, 'k-')\n plt.xlabel(r'$t$')\n plt.ylabel(r'$G(t)$')\n plt.tight_layout()\n plt.savefig('output/Gfit.pdf')\n\n\n #\n # if lam not explicitly specified then print rho-eta.pdf\n #\n\n try:\n lam\n except NameError:\n print(\"lamC prespecified, so not printing rho-eta.pdf/dat\")\n else:\n plt.clf()\n plt.scatter(rho, eta, marker='x')\n plt.plot(rho, eta)\n\n\n rhost = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(rho)))\n etast = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(eta)))\n\n plt.plot(rhost, etast, 'o', color='k')\n plt.xscale('log')\n plt.yscale('log')\n \n #~ print(rhost, etast)\n \n plt.xlabel(r'$\\rho$')\n plt.ylabel(r'$\\eta$')\n plt.tight_layout()\n plt.savefig('output/rho-eta.pdf')\n\n if par['verbose']:\n print('done\\n(*) End\\n')\n \n return H, lamC","def optical_kernels(K, J, Lxy, fmax, num):\n\n df = 1/Lxy\n\n # Compute TCC\n TCC, f = trans_cross_coeff(K, J, df, fmax)\n \n # Convert to 2D matrix\n N = f.size\n TCCm = np.reshape(np.reshape(TCC, (N, N, -1)), (N**2, -1))\n\n # Compute largest eigenvalues and eigenvectors\n w, v = scipy.linalg.eigh(TCCm, eigvals=(N**2 - num, N**2 - 1))\n w = np.flip(w, 0)\n v = np.flip(v, 1)\n\n # Get real-space optical kernels\n phi = []\n for i in range(num):\n Phi = np.fft.ifftshift(np.reshape(v[:,i], [N, N]))\n #phi.append(np.fft.fftshift(np.fft.ifft2(Phi)))\n phi.append(np.fft.ifft2(Phi))\n \n return w, phi","def Colect(N, R, Zeta1, Zeta2, Za, Zb):\n # Form core hamiltonian\n H[0, 0] = T11 + V11A + V11B\n H[0, 1] = T12 + V12A + V12B\n H[1, 0] = H[0, 1]\n H[1, 1] = T22 + V22A + V22B\n\n # Form overlap matrix\n S[0, 0] = 1.0\n S[0, 1] = S12\n S[1, 0] = S12\n S[1, 1] = 1.0\n\n # This is S^-1/2\n X[0, 0] = 1.0 / np.sqrt(2.0 * (1.0 + S12))\n X[1, 0] = X[0, 0]\n X[0, 1] = 1.0 / np.sqrt(2.0 * (1.0 - S12))\n X[1, 1] = -X[0, 1]\n\n # This is the coulomb and exchange term (aa|bb) and (ab|ba)\n TT[0, 0, 0, 0] = V1111\n TT[1, 0, 0, 0] = V2111\n TT[0, 1, 0, 0] = V2111\n TT[0, 0, 1, 0] = V2111\n TT[0, 0, 0, 1] = V2111\n TT[1, 0, 1, 0] = V2121\n TT[0, 1, 1, 0] = V2121\n TT[1, 0, 0, 1] = V2121\n TT[0, 1, 0, 1] = V2121\n TT[1, 1, 0, 0] = V2211\n TT[0, 0, 1, 1] = V2211\n TT[1, 1, 1, 0] = V2221\n TT[1, 1, 0, 1] = V2221\n TT[1, 0, 1, 1] = V2221\n TT[0, 1, 1, 1] = V2221\n TT[1, 1, 1, 1] = V2222","def generateHeatMask( im ):\n featref = computeFeatures(im)\n h,w,nbp = im.shape\n print(\"w:%d,h:%d\"%(w,h))\n heatMap = np.zeros((h,w,1), dtype=np.int8)\n black = [0,0,0]\n white = [255,255,255]\n rMaxDiff = 0\n for j in range(h):\n print(\"j:%d\" % j )\n for i in range(w):\n #~ print(\"i:%d\" % i )\n arDiff = []\n for color in [black,white]:\n #~ print(\"color:%s\" % color)\n imt = np.copy(im)\n \n # quite same time on my tablet !!! \n # (would have think the [] would be far fastest!)\n if 0:\n cv2.circle(imt, (i,j), 1, color )\n else:\n imt[j,i]=color\n if 0:\n cv2.imshow(\"imt\",imt)\n cv2.waitKey(1)\n #~ feat = computeFeatures(imt)\n #~ rDiff = diffFeatures(featref,feat)\n rDiff = mseFloat(im,imt)\n arDiff.append(rDiff)\n #~ print(rDiff)\n rDiff = max(arDiff)\n if rDiff > rMaxDiff:\n rMaxDiff = rDiff\n heatMap[j,i] = rDiff*10\n print(\"rMaxDiff: %5.3f\" % rMaxDiff )\n #~ print(dir(cv2))\n #~ heatMap = cv2.resize(heatMap,(w*2,h*2))\n cv2.namedWindow(\"heat\",cv2.CV_WINDOW_AUTOSIZE|cv2.WINDOW_NORMAL)\n cv2.imshow(\"heat\",heatMap)\n cv2.resizeWindow(\"heat\",600,480)\n cv2.waitKey(0)","def BACF_optimized(params):\n import math as m\n import numpy as np\n import cv2\n import time\n import matplotlib.pyplot as plt\n import matplotlib.patches as patches\n\n from resizeDFT2 import resizeDFT2\n from get_pixels import get_pixels\n from get_features import get_features\n from resp_newton import resp_newton\n from get_subwindow_no_window import get_subwindow_no_window\n\n # Setting parameters\n search_area_scale = params['search_area_scale'] # size of training/detection area proportional to the target size\n output_sigma_factor = params['output_sigma_factor']\n learning_rate = params['learning_rate']\n filter_max_area = params['filter_max_area']\n nScales = params['number_of_scales'] # number of scale resolutions to check\n scale_step = params['scale_step']\n interpolate_response = params['interpolate_response']\n\n features = params['t_features']\n video_path = params['video_path']\n s_frames = params['s_frames']\n pos = np.floor(params['init_pos']) # initial centre-point (y by x) of target bounding box\n target_sz = np.floor(params['wsize']) # initial height and height of target bounding box\n\n visualization = params['visualization']\n num_frames = params['no_fram']\n init_target_sz = target_sz\n\n # Set the features ratio to the feature-cell size\n featureRatio = params['t_global']['cell_size']\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\n\n # when the number of cells are small, choose a smaller cell size\n if 'cell_selection_thresh' in params['t_global']:\n if search_area < params['t_global']['cell_selection_thresh'] * filter_max_area:\n params['t_global']['cell_size'] = min(featureRatio,\n max(1, np.ceil(m.sqrt(np.prod(init_target_sz * search_area_scale) /\n (params['t_global']['cell_selection_thresh'] *\n filter_max_area)))))\n featureRatio = params['t_global']['cell_size']\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\n\n global_feat_params = params['t_global']\n\n if search_area > filter_max_area:\n currentScaleFactor = m.sqrt(search_area / filter_max_area)\n else:\n currentScaleFactor = 1.0\n\n # target size at the initial scale\n base_target_sz = target_sz / currentScaleFactor\n\n # window size, taking padding into account\n if params['search_area_shape'] == 'proportional':\n sz = np.floor(base_target_sz * search_area_scale) # proportional area, same aspect ratio as the target\n elif params['search_area_shape'] == 'square':\n sz = np.tile(m.sqrt(np.prod(base_target_sz * search_area_scale)), [1, 2]) # ignores target aspect ratio\n elif params['search_area_shape'] == 'fix_padding':\n sz = base_target_sz + m.sqrt(np.prod(base_target_sz * search_area_scale) +\n (base_target_sz[0] - base_target_sz[1]) / 4) - \\\n sum(base_target_sz) / 2 # const padding\n else:\n raise ValueError('Unknown \"search_area_shape\". Must be \"proportional\", \"square\", or \"fix_padding\".')\n\n # set the size to exactly match the cell size\n sz = np.round(sz[0] / featureRatio) * featureRatio\n use_sz = np.floor(sz / featureRatio)\n\n # construct the label function- correlation output, 2D gaussian function, with a peak located upon the target\n # np.roll acts a circular shift operator. This is used to compute all possible patches in the entire frame\n output_sigma = m.sqrt(np.prod(np.floor(base_target_sz / featureRatio))) * output_sigma_factor\n rg = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1)/2) + 1),\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\n cg = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\n int(-1 * np.floor((use_sz[1] - 1) / 2)))\n [rs, cs] = np.meshgrid(rg, cg)\n rs = rs.T\n cs = cs.T\n # y is the desired correlation response at each point within the size of the filter\n y = np.exp(-0.5 * ((np.power(rs, 2) + np.power(cs, 2)) / np.power(output_sigma, 2)))\n yf = np.fft.fft2(y) # fast fourier transform of y\n\n if interpolate_response == 1:\n interp_sz = use_sz * featureRatio\n else:\n interp_sz = use_sz\n\n # construct cosine window\n term1 = np.array([np.hanning(use_sz[0])])\n term2 = np.array([np.hanning(use_sz[1])])\n cos_window = np.matmul(term1.T, term2)\n cos_window = cos_window.astype('float32')\n\n # Calculate feature dimension\n try:\n im = cv2.imread(video_path + '/img/' + s_frames[0])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n try:\n im = cv2.imread(s_frames[0])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n im = cv2.imread(video_path + '/' + s_frames[0])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n\n # Check to see if it is a color image or grayscale\n if im.shape[2] == 3:\n if np.all(np.equal(im[:,:,0], im[:,:,1])):\n colorImage = False\n else:\n colorImage = True\n else:\n colorImage = False\n \n if im.shape[2] > 1 and colorImage is False:\n im = im[:,:,0]\n im = im.reshape([im.shape[0], im.shape[1], 1])\n\n # create scale factors to check for object at various scale resolutions\n if nScales > 0:\n scale_exp = np.arange(-1 * np.floor((nScales - 1) / 2), np.ceil((nScales - 1) / 2) + 1)\n scaleFactors = scale_step ** scale_exp\n min_scale_factor = scale_step ** np.ceil(m.log(max(np.divide(5, sz))) / m.log(scale_step))\n max_scale_factor = scale_step ** np.floor(m.log(min(np.divide([im.shape[0],\n im.shape[1]],\n base_target_sz))) / m.log(scale_step))\n\n if interpolate_response >= 3:\n # pre-computes the grid that is used for score optimization\n ky = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1) / 2) + 1),\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\n kx = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\n int(-1 * np.floor((use_sz[1] - 1) / 2))) # --> SAME AS MATLAB\n kx = kx.T\n newton_iterations = params['newton_iterations']\n\n # initialize the projection matrix (x,y,h,w)\n rect_position = np.zeros([num_frames, 4])\n\n # allocate memory for multi-scale tracking\n multires_pixel_template = np.zeros([int(sz[0]), int(sz[1]), im.shape[2], nScales], dtype=np.uint8)\n small_filter_sz = np.floor(base_target_sz / featureRatio)\n start_time = time.time()\n\n loop_frame = 0\n for frame in range(0, len(s_frames)):\n try:\n im = cv2.imread(video_path + '/img/' + s_frames[frame])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n try:\n im = cv2.imread(s_frames[frame])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n except:\n im = cv2.imread(video_path + '/' + s_frames[frame])\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n\n if im.shape[2] > 1 and colorImage is False:\n im = im[:, :, 0]\n im = im.reshape([im.shape[0], im.shape[1], 1])\n\n # do not estimate translation and scaling on the first frame, since we are just initializing the tracker\n if frame > 0:\n\n # The filter is applied on multiple resolutions of the search area. This is used to determine any changes in\n # scale of the target object\n for scale_ind in range(0, nScales):\n multires_pixel_template[:, :, :, scale_ind] = \\\n get_pixels(im, pos, np.round(sz * currentScaleFactor * scaleFactors[scale_ind]), sz)\n\n feat_term2, _ = get_features(multires_pixel_template, features, global_feat_params, None)\n xtf = np.zeros(feat_term2.shape, dtype=complex)\n for p in range(0, feat_term2.shape[2]):\n for n in range(0, feat_term2.shape[3]):\n xtf[:,:,p,n] = np.fft.fft2(np.multiply(feat_term2[:,:,p,n], cos_window[:, :]))\n responsef = np.sum(np.multiply(np.conj(g_f)[:, :, :, None], xtf), axis=2)\n\n # if we undersampled features, we want to interpolate the response to have the same size as the image patch\n if interpolate_response == 2:\n # use dynamic interp size\n interp_sz = np.floor(y.shape * featureRatio * currentScaleFactor)\n\n responsef_padded = resizeDFT2(responsef, interp_sz)\n\n # Get the response in the spatial domain\n response = np.zeros(responsef_padded.shape)\n for n in range(0, responsef.shape[2]):\n response[:,:,n] = np.real(np.fft.ifft2(responsef_padded[:,:,n])) # MAY HAVE AN ISSUE HERE NOT BEING SYMMETRIC -- therefore added real --> SAME AS MATLAB :D :)\n\n # find maximum peak\n if interpolate_response == 3:\n raise ValueError('Invalid parameter value for \"interpolate_response\"')\n elif interpolate_response == 4:\n [disp_row, disp_col, sind] = resp_newton(response, responsef_padded, newton_iterations, ky, kx, use_sz)\n\n # Check if the target has completely gone off the frame\n if np.isnan(disp_row) or np.isnan(disp_col):\n break\n\n # calculate translation vector\n if interpolate_response == 0 or 3 or 4:\n translation_vec = np.round(np.array([disp_row, disp_col]) * featureRatio *\n currentScaleFactor * scaleFactors[sind])\n elif interpolate_response == 1:\n translation_vec = np.round([disp_row, disp_col] * currentScaleFactor * scaleFactors[sind])\n elif interpolate_response == 2:\n translation_vec = np.round([disp_row, disp_col] * scaleFactors[sind])\n\n # set the scale\n currentScaleFactor = currentScaleFactor * scaleFactors[sind]\n\n # adjust to make sure we are not too large or too small\n if currentScaleFactor < min_scale_factor:\n currentScaleFactor = min_scale_factor\n elif currentScaleFactor > max_scale_factor:\n currentScaleFactor = max_scale_factor\n\n # update position\n old_pos = pos\n pos = pos + translation_vec\n\n # extract training sample image region\n pixels = get_pixels(im, pos, np.round(sz*currentScaleFactor), sz)\n\n # extract features and perform windowing\n feat_term, _ = get_features(pixels, features, global_feat_params, None)\n xf = np.zeros([feat_term.shape[1], feat_term.shape[1], feat_term.shape[2]], dtype=complex)\n for n in range(0, feat_term.shape[2]):\n xf[:, :, n] = np.fft.fft2(np.multiply(feat_term[:, :, n, 0], cos_window[:, :]))\n if frame == 0:\n model_xf = xf\n else:\n model_xf = ((1 - learning_rate) * model_xf) + (learning_rate * xf)\n\n g_f = np.zeros(xf.shape)\n g_f = g_f.astype('float32')\n h_f = g_f\n l_f = g_f\n\n # parameters from the original paper\n mu = 1\n betha = 10\n mumax = 10000\n i = 1\n\n T = np.prod(use_sz)\n S_xx = np.sum(np.multiply(model_xf.conj(), model_xf), axis=2)\n params['admm_iterations'] = 2\n\n while i <= params['admm_iterations']:\n # Solve for G\n B = S_xx + (T * mu)\n S_lx = np.sum(np.multiply(model_xf.conj(), l_f), axis=2)\n S_hx = np.sum(np.multiply(model_xf.conj(), h_f), axis=2)\n\n # equation (10) in original paper\n g_f = (((1 / (T * mu)) * np.multiply(yf[:, :, None], model_xf)) - ((1 / mu) * l_f) + h_f) - \\\n np.divide((((1 / (T * mu)) * np.multiply(model_xf, np.multiply(S_xx, yf)[:, :, None])) -\n ((1 / mu) * np.multiply(model_xf, S_lx[:, :, None])) +\n (np.multiply(model_xf, S_hx[:, :, None]))), B[:, :, None])\n\n # solve for H\n # Equation (6) in original paper\n h = np.zeros([g_f.shape[0], g_f.shape[1], g_f.shape[2]], dtype=complex)\n for n in range(0, g_f.shape[2]):\n h[:, :, n] = (T / ((mu * T) + params['admm_lambda'])) * np.fft.ifft2((mu * g_f[:, :, n]) + l_f[:, :, n])\n\n [sx, sy, h] = get_subwindow_no_window(h, np.floor(use_sz / 2), small_filter_sz)\n t = np.zeros([int(use_sz[0]), int(use_sz[1]), h.shape[2]], dtype=complex)\n t[int(sx[0]):int(sx[-1])+1, int(sy[0]):int(sy[-1])+1, :] = h\n\n h_f = np.zeros([t.shape[1], t.shape[1], t.shape[2]], dtype=complex)\n for n in range(0, t.shape[2]):\n h_f[:, :, n] = np.fft.fft2(t[:, :, n])\n\n # update L\n l_f = l_f + (mu * (g_f - h_f))\n\n # update mu- betha = 10\n mu = min(betha * mu, mumax)\n i = i + 1\n\n target_sz = np.floor(base_target_sz * currentScaleFactor)\n\n # save position and calculate FPS\n rect_position[loop_frame, :] = np.concatenate((pos[1::-1] - np.floor(target_sz[1::-1] / 2), target_sz[1::-1]))\n\n elapsed = time.time() - start_time\n\n # visualization\n if visualization == 1:\n rect_position_vis = np.concatenate((pos[1::-1] - (target_sz[1::-1] / 2), target_sz[1::-1]))\n im_to_show = im / 255\n if im_to_show.shape[2] == 1:\n im_to_show = np.tile(im_to_show, [1, 1, 3]) # if grayscale, ensure it plots image in grayscale\n if frame == 0:\n fig, ax = plt.subplots(1, num='Tracking')\n ax.imshow(im_to_show)\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\n linewidth=3, edgecolor='g', facecolor='none')\n ax.add_patch(rect)\n ax.annotate(str(frame + 1), [10, 10], color='c')\n ax.axis('off') # remove axis values\n ax.axis('image') # scale image appropriately\n ax.set_position([0, 0, 1, 1])\n fig.show()\n fig.canvas.draw()\n else:\n ax.clear()\n resp_sz = np.round(sz * currentScaleFactor * scaleFactors[scale_ind])\n xs = np.floor(old_pos[1]) + (np.arange(1, resp_sz[1] + 1)) - np.floor(resp_sz[1] / 2)\n ys = np.floor(old_pos[0]) + (np.arange(1, resp_sz[0] + 1)) - np.floor(resp_sz[0] / 2)\n sc_ind = np.floor((nScales - 1) / 2)\n\n ax.imshow(im_to_show)\n ax.axis('off') # remove axis values\n ax.axis('image') # scale image appropriately\n ax.set_position([0, 0, 1, 1])\n im_overlay = np.fft.fftshift(response[:,:,int(sc_ind)])\n ax.imshow(im_overlay, extent=[xs[0], xs[-1], ys[0], ys[-1]],\n alpha=0.2, cmap='hsv')\n rect.remove() # remove previous rectangle each time\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\n linewidth=3, edgecolor='g', facecolor='none')\n ax.add_patch(rect)\n frame_str = '# Frame: ' + str(loop_frame + 1) + ' / ' + str(num_frames)\n FPS_str = 'FPS: ' + str(1 / (elapsed / loop_frame))\n ax.annotate(frame_str, [20, 30], color='r', backgroundcolor='w')\n ax.annotate(FPS_str, [20, 60], color='r', backgroundcolor='w', fontsize=16)\n fig.show()\n fig.canvas.draw() # used to update the plot in real-time\n\n loop_frame += 1\n\n # Save results\n fps = loop_frame / elapsed\n results = {'res': rect_position, 'fps': fps}\n\n return results","def scale_fixed_V2B(seed=425, th=150, fmass=1, fb=1, fv=1, rfig=False):\n \n # impact parameters\n M = 1e8*u.Msun\n B0 = 19.85*u.kpc\n V0 = 220*u.km/u.s\n phi = coord.Angle(0*u.deg)\n theta = coord.Angle(th*u.deg)\n Tenc = 0.01*u.Gyr\n T = 0.5*u.Gyr\n dt = 0.1*u.Myr\n rs = 0*u.pc\n \n # potential parameters\n potential = 3\n Vh = 220*u.km/u.s\n q = 1*u.Unit(1)\n rhalo = 20*u.pc\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\n \n # setup tube\n Nstar = 3000\n wx = 30*u.kpc\n wy = 0*u.pc\n wz = 0*u.pc\n sx = 0*u.km/u.s\n \n np.random.seed(seed)\n observer = {'z_sun': 27.*u.pc, 'galcen_distance': 8.3*u.kpc, 'roll': 60*u.deg, 'galcen_coord': coord.SkyCoord(ra=300*u.deg, dec=-90*u.deg, frame='icrs')}\n vobs = {'vcirc': 220*u.km/u.s, 'vlsr': [0, 0, 0]*u.km/u.s}\n wangle = 180*u.deg\n \n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\n Bs = 20*u.kpc\n xr = Bs + np.random.randn(Nstar)*0.0*u.kpc\n x = np.sin(xphi) * xr\n y = np.cos(xphi) * xr\n z = x * 0\n vx = -np.cos(xphi) * Vh\n vy = np.sin(xphi) * Vh\n vz = vx * 0\n \n # generate stream model\n potential_perturb = 1\n par_perturb = np.array([M.si.value, 0., 0., 0.])\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V0.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n R = find_greatcircle(xeq.ra.deg[::10], xeq.dec.deg[::10])\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n \n # unperturbed stream\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V0.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream0 = {}\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\n xeq0 = xgal0.transform_to(coord.ICRS)\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\n veq0 = [None] * 3\n veq0[0] = veq0_[0].to(u.mas/u.yr)\n veq0[1] = veq0_[1].to(u.mas/u.yr)\n veq0[2] = veq0_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\n xi0 = coord.Angle(xi0*u.deg)\n \n farray = np.array([0.3, 0.5, 1, 2, 3])\n \n rasterized = False\n if rfig:\n rasterized = True\n \n plt.close()\n fig, ax = plt.subplots(4,1,figsize=(12,12), sharex=True)\n \n for e, f in enumerate(farray):\n fsqrt = np.sqrt(f)\n par_perturb = np.array([fmass*M.si.value, 0., 0., 0.])\n #B = B0\n \n dB = (B0 - Bs)*fb\n B = dB*f + Bs\n \n V = fv*V0/fsqrt\n \n #fi = np.abs(V*T/(dB/f)).decompose()\n fi = np.abs(dB/V).to(u.Myr)\n #print(fi)\n \n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\n stream = {}\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\n \n # sky coordinates\n xgal = coord.Galactocentric(stream['x'], **observer)\n xeq = xgal.transform_to(coord.ICRS)\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\n veq = [None] * 3\n veq[0] = veq_[0].to(u.mas/u.yr)\n veq[1] = veq_[1].to(u.mas/u.yr)\n veq[2] = veq_[2].to(u.km/u.s)\n \n # rotate to native coordinate system\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\n xi = coord.Angle(xi*u.deg)\n \n color = '{:f}'.format(0.65 - 0.65*(e+1)/(np.size(farray)) + 0.35)\n ms = 1.5*(e+2)\n zorder = np.size(farray)-e\n label = 'f={:g}, $t_{{imp}}$={:.1f}'.format(f, fi)\n #print(e, p, color)\n \n plt.sca(ax[0])\n plt.plot(xi.wrap_at(wangle), eta, 'o', mec='none', color=color, ms=ms, zorder=zorder, label=label, rasterized=rasterized)\n \n for i in range(3):\n plt.sca(ax[i+1])\n vexp = np.interp(xi.wrap_at(wangle), xi0.wrap_at(wangle), veq0[i].value) * veq0[i].unit\n plt.plot(xi.wrap_at(wangle), veq[i]-vexp, 'o', mec='none', color=color, ms=ms, zorder=zorder, rasterized=rasterized)\n \n # label axes\n plt.sca(ax[0])\n plt.ylabel('$\\phi_1$ [deg]')\n plt.ylim(-10,10)\n plt.xlim(65,135)\n #plt.gca().set_aspect('equal')\n plt.legend(fontsize='x-small', loc=2)\n plt.title('f M, f B | M = {:g} | B = {:g} | $\\\\theta$ = {:.0f}'.format(fmass*M, dB.to(u.pc), theta), fontsize='medium')\n \n vlabel = ['$\\mu_{\\\\alpha_\\star}$ [mas yr$^{-1}$]','$\\mu_{\\delta}$ [mas yr$^{-1}$]', '$V_r$ [km s$^{-1}$]']\n ylims = [[-0.5, 0.5], [-0.5, 0.5], [-25,25]]\n ylims = [[-1,1], [-1,1], [-50,50]]\n for i in range(3):\n plt.sca(ax[i+1])\n plt.ylabel('$\\Delta$ {}'.format(vlabel[i]))\n plt.ylim(*ylims[i])\n\n plt.xlabel('$\\phi_2$ [deg]')\n \n plt.tight_layout()\n \n if rfig:\n return fig\n else:\n plt.savefig('../plots/scale_VB_th{:03d}_{:.1f}_{:.1f}.png'.format(th, fv, fb))","def batch_sinkhorn(C_list: List[torch.FloatTensor],\n a_list: Optional[List[torch.FloatTensor]] = None,\n b_list: Optional[List[torch.FloatTensor]] = None,\n alpha_list: Optional[List[torch.FloatTensor]] = None,\n beta_list: Optional[List[torch.FloatTensor]] = None,\n epsilon_scaling: bool = True,\n return_tensor: bool = False,\n **kwargs) -> List[torch.FloatTensor]:\n # Get device and dtype\n dtype = C_list[0].dtype\n device = C_list[0].device\n\n # Get sizes\n n_list, m_list = zip(*(C.shape for C in C_list))\n\n # Initialize marginals with uniform if not provided\n if a_list is None:\n a_list = [torch.ones(n, dtype=dtype, device=device) / n for n in n_list]\n\n if b_list is None:\n b_list = [torch.ones(m, dtype=dtype, device=device) / m for m in m_list]\n\n # Initialize alpha/beta with zero if not provided\n if alpha_list is None:\n alpha_list = [torch.zeros(n, dtype=dtype, device=device) for n in n_list]\n\n if beta_list is None:\n beta_list = [torch.zeros(m, dtype=dtype, device=device) for m in m_list]\n\n # Batch everything by padding with zeros\n C_batch = pad_tensors(C_list)\n a_batch = pad_tensors(a_list)\n b_batch = pad_tensors(b_list)\n alpha_batch = pad_tensors(alpha_list)\n beta_batch = pad_tensors(beta_list)\n\n # Run batched sinkhorn\n sinkhorn_algo = sinkhorn_epsilon_scaling if epsilon_scaling else sinkhorn\n P_batch = sinkhorn_algo(\n C=C_batch,\n a=a_batch,\n b=b_batch,\n alpha=alpha_batch,\n beta=beta_batch,\n **kwargs\n )\n\n if return_tensor:\n return P_batch\n else:\n # Extract alignment matrices and throw away padding\n P_list = [P_batch[i, :n, :m] for i, (n, m) in enumerate(zip(n_list, m_list))]\n return P_list","def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \n N_res=30):\n x_eps = 0.3 # shift from Dirac point\n x_res = 20\n kx_int = 0 + x_eps # -np.pi\n kx_fin = 4*np.pi/3 + x_eps\n Dx = (kx_fin - kx_int)/x_res\n\n y_res = 20\n ky_int = 0 # -np.pi\n ky_fin = 2*np.pi/np.sqrt(3)\n Dy = (ky_fin - ky_int)/y_res\n\n Nd = self.Nd # dimension of the Hamiltonian\n Dk = np.array([Dx,Dy], float)\n\n LF = np.zeros((Nd), dtype=complex)\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n sumN = np.zeros((Nd), dtype=complex)\n E_k = np.zeros((Nd), dtype=complex)\n chernN = np.zeros((Nd), dtype=complex)\n\n # Loop over kx\n for ix in range(x_res):\n kx = kx_int + ix*Dx\n\n # Loop over ky\n for iy in range(y_res):\n ky = ky_int + iy*Dy\n\n k_vec = np.array([kx,ky], float)\n\n LF, E_k = self.latF(k_vec, Dk, self.delta)\n\n sumN += LF\n\n # # save data for plotting\n LF_arr[:,ix,iy] = LF.imag\n\n E_arr[:,ix,iy] = np.sort(E_k.real)\n\n # End of ky Loop\n # End of kx Loop\n\n chernN = sumN.imag/(2*np.pi)\n print(\"Chern number bands are (%.3f, %.3f) \" \n %(chernN[0], chernN[1]))\n print(\"Sum of all bands Chern Number is %.2f \" %(sum(chernN)))\n return chernN, E_arr\n #################### ","def convert2EbnerParam(joblib,list_prefix,directory):\n \n key=[p[0] for p in joblib]\n element=[p[1] for p in joblib]\n\n \n listSlice=element[key.index('listSlice')] #list of slice\n parameters=element[key.index('EvolutionParameters')][-1,:,:] #estimated paramters of the registration\n rejectedSlice=element[key.index('RejectedSlices')] #rejected slices\n\n \n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\n \n for i_slice in range(len(listSlice)): \n slicei=listSlice[i_slice]\n slicei.set_parameters(parameters[i_slice,:]) #set parameters to the last estimated parameters\n \n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\n\n for n in range(len(images)): #for each stack\n \n imagen = images[n]\n \n for i_slice in range(len(images[n])): #for each slices (in each stacks)\n \n slicei=imagen[i_slice]\n s = (slicei.get_orientation(),slicei.get_index_slice())\n \n if s not in rejectedSlice:\n dimension=3\n X,Y,Z= slicei.get_slice().get_fdata().shape\n center= -slicei.get_center()\n centerMat = np.eye(4)\n centerMat[0:3,3] = center[0:3]\n invcenterMat = np.eye(4)\n invcenterMat[0:3,3] = -center[0:3] \n p = slicei.get_parameters()\n matrix = mat @ centerMat @ rigidMatrix([p[0],p[1],p[2],p[3],p[4],p[5]]) @ invcenterMat @ mat\n test = sitk.AffineTransform(dimension)\n test.SetMatrix(matrix[0:3,0:3].flatten())\n test.SetTranslation(matrix[0:3,3])\n images_index = slicei.get_index_image()\n sitk.WriteTransform(test,\"%s/%s_slice%d.tfm\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\n #else:\n #print(s)","def invert_list_rsexecute_workflow(vis_list, template_model_imagelist, context, dopsf=False, normalize=True,\n facets=1, overlap=0, taper=\"tukey\", vis_slices=1, gcfcf=None, **kwargs):\n \n # Use serial invert for each element of the visibility list. This means that e.g. iteration\n # through w-planes or timeslices is done sequentially thus not incurring the memory cost\n # of doing all at once.\n if get_parameter(kwargs, \"use_serial_invert\", False):\n from rascil.workflows.serial.imaging.imaging_serial import invert_list_serial_workflow\n return [rsexecute.execute(invert_list_serial_workflow, nout=1) \\\n (vis_list=[vis_list[i]], template_model_imagelist=[template_model_imagelist[i]],\n context=context, dopsf=dopsf, normalize=normalize, vis_slices=vis_slices,\n facets=facets, gcfcf=gcfcf, **kwargs)[0]\n for i, _ in enumerate(vis_list)]\n \n if not isinstance(template_model_imagelist, collections.abc.Iterable):\n template_model_imagelist = [template_model_imagelist]\n \n c = imaging_context(context)\n vis_iter = c['vis_iterator']\n invert = c['invert']\n \n if facets % 2 == 0 or facets == 1:\n actual_number_facets = facets\n else:\n actual_number_facets = max(1, (facets - 1))\n \n def gather_image_iteration_results(results, template_model):\n result = create_empty_image_like(template_model)\n flat = create_empty_image_like(template_model)\n i = 0\n sumwt = numpy.zeros([template_model.nchan, template_model.npol])\n for dpatch in image_scatter_facets(result, facets=facets, overlap=overlap, taper=taper):\n assert i < len(results), \"Too few results in gather_image_iteration_results\"\n if results[i] is not None:\n assert len(results[i]) == 2, results[i]\n dpatch.data[...] += results[i][0].data[...]\n sumwt += results[i][1]\n i += 1\n flat = image_gather_facets(results, flat, facets=facets, overlap=overlap, taper=taper, return_flat=True)\n result.data[flat.data > 0.5] /= flat.data[flat.data > 0.5]\n result.data[flat.data <= 0.5] = 0.0\n return result, sumwt\n \n def invert_ignore_none(vis, model, gg):\n if vis is not None:\n return invert(vis, model, context=context, dopsf=dopsf, normalize=normalize,\n gcfcf=gg, **kwargs)\n else:\n return create_empty_image_like(model), numpy.zeros([model.nchan, model.npol])\n \n # If we are doing facets, we need to create the gcf for each image\n if gcfcf is None and facets == 1:\n assert len(template_model_imagelist) > 0\n gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(template_model_imagelist[0])]\n \n # Loop over all vis_lists independently\n results_vislist = list()\n if facets == 1:\n for ivis, sub_vis_list in enumerate(vis_list):\n if len(gcfcf) > 1:\n g = gcfcf[ivis]\n else:\n g = gcfcf[0]\n # Create the graph to divide the visibility into slices. This is by copy.\n sub_sub_vis_lists = rsexecute.execute(visibility_scatter, nout=vis_slices) \\\n (sub_vis_list, vis_iter, vis_slices=vis_slices)\n \n # Iterate within each sub_sub_vis_list\n vis_results = list()\n for sub_sub_vis_list in sub_sub_vis_lists:\n vis_results.append(rsexecute.execute(invert_ignore_none, pure=True)\n (sub_sub_vis_list, template_model_imagelist[ivis], g))\n results_vislist.append(sum_invert_results_rsexecute(vis_results))\n \n result = results_vislist\n else:\n for ivis, sub_vis_list in enumerate(vis_list):\n # Create the graph to divide an image into facets. This is by reference.\n facet_lists = rsexecute.execute(image_scatter_facets, nout=actual_number_facets ** 2)(\n template_model_imagelist[ivis], facets=facets, overlap=overlap, taper=taper)\n # Create the graph to divide the visibility into slices. This is by copy.\n sub_sub_vis_lists = rsexecute.execute(visibility_scatter, nout=vis_slices) \\\n (sub_vis_list, vis_iter, vis_slices=vis_slices)\n \n # Iterate within each vis_list\n vis_results = list()\n for sub_sub_vis_list in sub_sub_vis_lists:\n facet_vis_results = list()\n for facet_list in facet_lists:\n facet_vis_results.append(\n rsexecute.execute(invert_ignore_none, pure=True)(sub_sub_vis_list, facet_list, None))\n vis_results.append(rsexecute.execute(gather_image_iteration_results, nout=1)\n (facet_vis_results, template_model_imagelist[ivis]))\n results_vislist.append(sum_invert_results_rsexecute(vis_results))\n \n result = results_vislist\n return rsexecute.optimize(result)","def performance(N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w):\n \"\"\"\"I have produced two plots. The first one p24.png compares the time taken\n by solveFlunet with the three different RHS methods. We notice that the fastest\n technique is using the RHS computed in Python. This can be explained by the \n fact that in Python we have vectorized our calculations whereas in Fortran\n we used a loop for our calculations. Secondly, we also notice that solveFlunet \n is faster using the Fortran OMP code than using the Fortran code. This\n is expected since we use two threads with the Fortran OMP code instead of \n only one with the regular Fortran code. The second plot p25.png provides\n the speedup of the Fortran OMP RHS compared to the Fortran RHS.\n The speedup is less than 1 for small values of Nt but increases as Nt\n increases. It goes up to 1.6 for larger sized problems, which is quite\n satisfying. We can expect that it the speedup to reach 2 for even larger\n problem sizes.\n \"\"\"\n #I have added as inputs N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w to\n #be able to call initialize and solveFluNet\n Nt = Ntmax/10\n dt = Ntmax/10\n Ntu = np.zeros(10)\n \n #tpy,tf90 and tf90OMP are the times for our different RHS\n #methods\n tpy = np.zeros(10)\n tf90 = np.zeros(10)\n tf90OMP = np.zeros(10)\n \n #speedup is the speedup of the Fortran OMP RHS compared\n #to the Fortran RHS\n speedup = np.zeros(10)\n \n for i in range(10):\n #compute initial conditions\n init,infnode,P = initialize(N0,L,Nt,True)\n N = N0+Nt\n \n #time solveFluNet for the three different RHS\n t0 = time()\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,1)\n t1 = time()\n tpy[i] = t1-t0\n t0 = time()\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,2)\n t1 = time()\n tf90[i] = t1-t0\n t0 = time()\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,3)\n t1 = time()\n tf90OMP[i] = t1-t0\n \n #time the two Fortran RHS methods\n t0 = time()\n fn.rhs(P,init,1,a,b0,b1,g,k,w)\n tRHS = time() - t0\n t0 = time()\n fn.rhs_omp(P,init,1,a,b0,b1,g,k,w,2)\n tRHSOMP = time() - t0\n speedup[i] = tRHS/tRHSOMP\n \n Ntu[i] = Nt\n Nt = Nt+dt\n \n plt.figure()\n plt.plot(Ntu,tpy,label='Time with Python RHS')\n plt.plot(Ntu,tf90,label='Time with Fortran RHS')\n plt.plot(Ntu,tf90OMP,label='Time with Fortran OMP RHS')\n plt.legend(loc='best')\n plt.title('performance Mathilde Duverger')\n plt.xlabel('Nt')\n plt.ylabel('Time of solveFluNet')\n \n plt.figure()\n plt.plot(Ntu,speedup,label='Speedup for RHS')\n plt.legend(loc='best')\n plt.title('performance Mathilde Duverger')\n plt.xlabel('Nt')\n plt.ylabel('Speedup of the Fortran OMP code compared to the Fortran code')\n plt.show()","def ridge_cv(trn_fs, trn_data, val_fs=None, val_data=None, alphas=DEFAULT_ALPHAS, \n n_resamps=10, n_splits=10, chunk_sz=5000, dtype=np.single,pthr=0.005,\n square_alpha=False,is_verbose=False):\n #def ridge_cv(model,data,n_splits=10,n_resamps=10,alpha=DEFAULT_ALPHAS,efficient=np.nan,):\n # (trn_fs, trn_data, val_fs, val_data, alphas, nboots, chunklen, n_chunks, dtype=np.single, corrmin=0.2):\n n_resp, n_voxels = trn_data.shape\n _,n_channels = trn_fs.shape\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\n bestalphas = np.zeros((n_resamps, n_voxels)) ## Will hold the best alphas for each voxel\n trn_idx,val_idx = _utils.contig_partition(trn_fs.shape[0],n_splits)\n\n Rcmats = np.zeros((n_voxels,len(alphas),n_resamps))\n for iRpt,cvi in enumerate(np.random.permutation(n_splits)[:n_resamps]):\n if is_verbose:\n print('Running split %d/%d'%(iRpt+1,n_resamps))\n ti,vi = trn_idx[cvi],val_idx[cvi]\n trn_fs_split = trn_fs[ti,:]\n val_fs_split = trn_fs[vi,:]\n trn_data_split = trn_data[ti,:]\n val_data_split = trn_data[vi,:]\n \n # Run ridge regression to estimate predictions (within training set) for different alphas\n Rcmats[:,:,iRpt] = _fit_ridge_alpha(trn_fs_split, trn_data_split, val_fs_split, val_data_split, alphas,\n dtype=dtype, chunk_sz=chunk_sz,pthr=pthr,square_alpha=square_alpha)\n if is_verbose:\n print(\"Finding best alpha...\")\n ## Find best alpha for each voxel\n #trncc_byvox = np.nansum(Rcmats,axis=2)/np.sum(np.logical_not(np.isnan(Rcmats)),axis=2)\n trncc_byvox = np.nanmean(Rcmats,axis=2)\n # Taking mean is BS: too many voxels poorly predicted, floor effect. \n #mean_cv_corr = np.nanmean(mean_cv_corr_byvox,axis=0)\n #bestalphaind = np.argmax(mean_cv_corr)\n # Thus just count voxels over significance threshold (with a lenient threshold)\n #print(len(vi))\n sig_thresh = _sutils.pval2r(pthr,len(vi),is_two_sided=False)\n n_sig_vox_byalpha = sum(trncc_byvox>sig_thresh)-sum(trncc_byvox<-sig_thresh)\n bestalphaind = np.argmax(n_sig_vox_byalpha)\n alpha = alphas[bestalphaind]\n if is_verbose:\n print(\"Best alpha = %0.3f\"%alpha)\n \n ## Find weights for each voxel\n U,S,Vt = np.linalg.svd(trn_fs, full_matrices=False)\n # Loop over groups of voxels\n wt = np.zeros((n_channels,n_voxels),dtype=dtype)\n\n ###\n if (not val_fs is None) and (not val_data is None):\n # Validation data / model supplied implies we want predictions\n do_pred = True\n if np.sum(val_fs[:,0]) != val_fs.shape[0]:\n warnings.warn('First column of val_fs is NOT all ones! Consider including a DC term!')\n # Pre-allocate for predictions, with or without separate validation sequences to predict\n is_rpts = np.ndim(val_data)==3\n if is_rpts:\n n_rpts,n_tps_val,n_voxels_val = val_data.shape\n cc = np.zeros((n_rpts,n_voxels),dtype);\n else:\n n_rpts,(n_tps_val,n_voxels_val) = 0,val_data.shape\n cc = np.zeros((n_voxels),dtype);\n pred = np.zeros((n_tps_val,n_voxels_val),dtype)\n else:\n # No Validation data / model supplied\n do_pred = False;\n\n if is_verbose:\n predstr = ' and model predictions...' if do_pred else \"...\"\n print('Computing weights'+predstr)\n for iChunk in range(n_chunks):\n if is_verbose:\n print('Running chunk %d of %d...\\n'%(iChunk+1,n_chunks))\n ChIdx = np.arange(chunk_sz) + chunk_sz*iChunk\n ChIdx = ChIdx[ChIdx<n_voxels] # clip extra voxels in last run.\n Ychunk = trn_data[:,ChIdx]\n\n UtYchunk = np.dot(U.T, np.nan_to_num(Ychunk))\n if square_alpha:\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha**2)), UtYchunk])\n else:\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha)), UtYchunk])\n\n ## Find test correlations if validation data is present\n if do_pred:\n # Compute correlations btw validation data and model prediction\n pred[:,ChIdx] = val_fs.dot(wt[:,ChIdx]).astype(dtype) \n nnpred = np.nan_to_num(pred[:,ChIdx])\n if is_rpts:\n # The transpose here is related to deep mysteries in python. See \n cc[:,ChIdx] = np.vstack([_sutils.column_corr(nnpred,val_data[rpt,:,ChIdx].T) for rpt in range(n_rpts)])\n else:\n cc[ChIdx] = _sutils.column_corr(nnpred,val_data[:,ChIdx])\n\n # Output\n out = dict(\n weights=wt,\n alpha=alpha,\n n_sig_vox_byalpha=n_sig_vox_byalpha,\n #trncc_byvox=trncc_byvox,f\n #trncc_byvox_byalpha=Rcmats\n )\n if not val_data is None: \n out['cc'] = cc\n return out","def rk8(accel,m,r,h,v): \n k1v = accel(m,r)\n k1r = v\n k2v = accel(m,r + 0.25*k1r*h)\n k2r = v + (0.25*k1v)*h\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\n\n\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \n \n return new_v8,new_r8"],"string":"[\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # Bounds for harmonic oscillator frequencies\\n for i in range(Nvib):\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # Bounds for pseudo-hindered rotor frequency and barrier height\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n # Initial guesses within each mode type must be distinct or else the\\n # optimization will fail\\n x0 = numpy.zeros(Nvib + 2, numpy.float64)\\n # Initial guess for harmonic oscillator frequencies\\n if Nvib > 0:\\n x0[0] = 200.0\\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\\n # Initial guess for hindered rotor frequencies and barrier heights\\n x0[Nvib] = 100.0\\n x0[Nvib+1] = 300.0\\n\\n # Execute the optimization\\n fit = PseudoRotorFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n vib = list(x[0:Nvib])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[Nvib], x[Nvib+1]))\\n\\n return vib, hind\",\n \"def fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # Bounds for harmonic oscillator frequencies\\n for i in range(Nvib):\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # Bounds for hindered rotor frequencies and barrier heights\\n for i in range(Nrot):\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n # Initial guesses within each mode type must be distinct or else the\\n # optimization will fail\\n x0 = numpy.zeros(Nvib + 2*Nrot, numpy.float64)\\n # Initial guess for harmonic oscillator frequencies\\n if Nvib > 0:\\n x0[0] = 200.0\\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\\n # Initial guess for hindered rotor frequencies and barrier heights\\n if Nrot > 0:\\n x0[Nvib] = 100.0\\n x0[Nvib+1] = 100.0\\n for i in range(1, Nrot):\\n x0[Nvib+2*i] = x0[Nvib+2*i-2] + 20.0\\n x0[Nvib+2*i+1] = x0[Nvib+2*i-1] + 100.0\\n\\n # Execute the optimization\\n fit = DirectFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n vib = list(x[0:Nvib])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[Nvib+2*i], x[Nvib+2*i+1]))\\n\\n return vib, hind\",\n \"def weak_repulsion(Cents,a,k, CV_matrix,n_c,L):\\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\\n displacement = np.mod(Cents - CCW + L/2,L) - L/2\\n rij = np.sqrt(displacement[:,:,0]**2 + displacement[:,:,1]**2)\\n norm_disp = (displacement.T/rij.T).T\\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\\n V_soft = V_soft_CW + V_soft_CCW\\n F_soft = np.zeros((n_c, 2))\\n for i in range(3):\\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\\n return F_soft\",\n \"def specific_heat(Ekinv,n0,N,t0):\\n Cv = np.zeros(10)\\n for i in range(10):\\n avg_K_squared = (1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]))**2\\n FluctK = 1 / len(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]) * np.sum(Ekinv[int(n0-50+5*i):int(n0-46+5*i)]**2) - avg_K_squared\\n Cv[i] = -1 / (FluctK/ avg_K_squared * 3 * N / 2 - 1) * 3 * N / 2\\n return Cv\",\n \"def define_potts_helper_functions(k):\\n\\n @njit\\n def calc_observables(X, k=k):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n\\n Returns\\n -------\\n ndarray\\n Dimensions (n_samples, n_observables).\\n \\\"\\\"\\\"\\n\\n n = X.shape[1]\\n Y = np.zeros((len(X), n*k+n*(n-1)//2), dtype=np.int8)\\n \\n # average orientation (magnetization)\\n # note that fields for the third state are often set to 0\\n counter = 0\\n for i in range(k):\\n for j in range(n):\\n Y[:,counter] = X[:,j]==i\\n counter += 1\\n \\n # pairwise correlations\\n for i in range(n-1):\\n for j in range(i+1, n):\\n Y[:,counter] = X[:,i]==X[:,j]\\n counter += 1\\n \\n return Y\\n\\n def calc_e(X, multipliers, k=k, calc_observables=calc_observables):\\n \\\"\\\"\\\"\\n Parameters\\n ----------\\n X : ndarray of dtype np.int64\\n Dimensions (n_samples, n_spins).\\n multipliers : ndarray of dtype np.float64\\n\\n Returns\\n -------\\n ndarray\\n Energies of each observable.\\n \\\"\\\"\\\"\\n\\n return -calc_observables(X, k).dot(multipliers)\\n\\n def mch_approximation(sample, dlamda, calc_e=calc_e):\\n \\\"\\\"\\\"Function for making MCH approximation step for Potts model.\\n \\n Parameters\\n ----------\\n sample : ndarray\\n Of dimensions (n_sample, n_spins).\\n dlamda : ndarray\\n Change in parameters.\\n \\n Returns\\n -------\\n ndarray\\n Predicted correlations.\\n \\\"\\\"\\\"\\n\\n dE = calc_e(sample, dlamda)\\n ZFraction = len(dE) / np.exp(logsumexp(-dE))\\n predsisj = (np.exp(-dE[:,None]) / len(dE) * calc_observables(sample)).sum(0) * ZFraction \\n assert not ((predsisj<0).any() or\\n (predsisj>(1+1e-10)).any()),\\\"Predicted values are beyond limits, (%E,%E)\\\"%(predsisj.min(),\\n predsisj.max())\\n return predsisj\\n\\n return calc_e, calc_observables, mch_approximation\",\n \"def _allEquilibriumFunc(self,cps,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks,k1M,k3M):\\n # We move from an array to a list of 2d-array for the competition over each template:\\n\\n cp=cps[0]\\n cpt = [np.reshape(cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)],(m.shape[0],m.shape[1])) for l,m in enumerate(masks)]\\n new_cpt = [np.zeros(l.shape)+1 for l in cpt]\\n new_cp = 1\\n\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n x_eq = X0[inpIdx]/(1+E0*w_inpIdx/cp)\\n # update for fixed point:\\n new_cp += w_inpIdx*x_eq\\n # saving values\\n layerEq[inpIdx] = x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n layerEq[inpIdx] = x_eq\\n\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n new_cp += firstComplex + Inhib2/(E0*cp)*x_eq\\n new_cpt[layeridx] = np.where(layer>0,(1+k1M[layeridx]*E0*layerEq/cp),np.where(layer<0,(1+k3M[layeridx]*E0*layerEq/cp),1))\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx]/cpt[-1][outputsIdx],0)\\n\\n Inhib = np.sum(Cinhibs*olderX[-1]/kdT[-1][outputsIdx])\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]*cp+Inhib/cp))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n new_cp += Inhib2/(E0*cp)*x_eq\\n\\n #we know that the root should be larger than 1 so we artificially add a root barrier at 1.\\n diff_cps = np.zeros(cps.shape)\\n if new_cp>=1:\\n diff_cps[0] = cp - new_cp\\n else:\\n diff_cps[0] = 10**3\\n for l,m in enumerate(masks):\\n layer_new_cpt = np.reshape(new_cpt[l],(m.shape[0]*m.shape[1]))\\n layer_old_cpt = cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)]\\n diff_cps[(l*m.shape[0]*m.shape[1]+1):((l+1)*m.shape[0]*m.shape[1]+1)] = layer_old_cpt - np.where(layer_new_cpt<1,layer_old_cpt + 10**3, layer_new_cpt)\\n return diff_cps\",\n \"def weak_repulsion_boundary(Cents,a,k, CV_matrix,n_c,n_C):\\n CCW = np.dstack((roll_reverse(Cents[:,:,0]),roll_reverse(Cents[:,:,1])))#np.column_stack((Cents[:,1:3],Cents[:,0].reshape(-1,1,2)))\\n CCW_displacement = Cents - CCW\\n rij = np.sqrt(CCW_displacement[:,:,0]**2 + CCW_displacement[:,:,1]**2)\\n norm_disp = (CCW_displacement.T/rij.T).T\\n V_soft_mag = -k*(rij - 2*a)*(rij<2*a)\\n V_soft_CCW = (V_soft_mag.T*norm_disp.T).T\\n V_soft_CW = -(roll_forward(V_soft_mag).T*norm_disp.T).T\\n V_soft = V_soft_CW + V_soft_CCW\\n F_soft = np.zeros((n_c, 2))\\n for i in range(3):\\n F_soft += np.asfortranarray(CV_matrix[:, :, i])@np.asfortranarray(V_soft[:, i])\\n F_soft[n_C:] = 0\\n return F_soft\",\n \"def test_vc(integrate_activation_vc, max_ch_index, sim_map_max, L, c, h, w):\\n # get activation for each seperated vc\\n integrate_activation_vc = integrate_activation_vc.view(-1, L, c) # n, L, c\\n sim_map_max = sim_map_max.view(-1, L, 1, h, w) # n, L, 1, h, w\\n max_ch_index = max_ch_index.view(-1, L) # n, L\\n\\n all_activation_vcs = []\\n\\n for i in range(len(integrate_activation_vc)):\\n integrate_activation_vc_i = integrate_activation_vc[i] # L, c\\n all_activation_vcs.append(integrate_activation_vc_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n print(f\\\"unique_vc_i {unique_vc_i.shape}\\\")\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n activate_vc_i = integrate_activation_vc_i.clone() # L, c\\n activate_vc_i[index_vc_i, :] = 0.\\n all_activation_vcs.append(activate_vc_i)\\n \\n all_activation_vcs = torch.cat(all_activation_vcs, dim=0) # [(nk+n) * L, c]\\n \\n # decompose each mask \\n all_masks = []\\n for i in range(len(sim_map_max)):\\n sim_map_max_i = sim_map_max[i] # L, 1, h, w\\n all_masks.append(sim_map_max_i) \\n max_ch_index_i = max_ch_index[i] # L,\\n unique_vc_i = torch.unique(max_ch_index_i) # k,\\n for vc_i in unique_vc_i:\\n index_vc_i = torch.where(max_ch_index_i != vc_i)[0] # num of miss hit for that vc out of L\\n vc_sim_map_max_i = sim_map_max_i.clone() # L, 1, h, w\\n vc_sim_map_max_i[index_vc_i] = 0.\\n all_masks.append(vc_sim_map_max_i)\\n all_masks = torch.cat(all_masks, dim=0) # [(nk+n) * L, 1, h, w]\\n\\n assert all_masks.shape[0] == all_activation_vcs.shape[0], f\\\"all_masks.shape[0] {all_masks.shape[0]} != all_activation_vcs.shape[0] {all_activation_vcs.shape[0]}\\\"\\n\\n return all_activation_vcs, all_masks\",\n \"def mtvsolver(Hurst_init, aest, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0,lipschitz_constant=0, wtype=1):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurst_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(x):\\n return f(x, aest, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(x,mask))\\n\\n def unmaskvec(w):\\n return _unmask(w, mask)\\n\\n def maskvec(w):\\n return w[flat_mask]\\n\\n def f1_grad(x):\\n return gradf(x, aest, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(w, stepsize, dgap_tol, init):\\n out, info = _prox_tvl1(unmaskvec(w),\\n weight= (l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=unmaskvec(init),\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return maskvec(out.ravel()), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def WakeVorticityFromCirculation_Cont(r_cp,Gamma_cp,R,U0,Omega,bSwirl,method='analytical',bHighThrustCorr=True):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cp[0]==0:\\n r_cp[0]=r_cp[1]*0.5;\\n # Non dimensional parameters\\n k = Omega*Gamma_cp/(np.pi*U0**2)\\n vr_bar = r_cp/R \\n lambda_r = Omega*r_cp/U0\\n # Finding inductions\\n a,a_prime,misc= InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method=method,bHighThrustCorr=bHighThrustCorr)\\n # Computing convection\\n misc['Vz'] = U0*(1-2*a)\\n misc['h'] = misc['Vz']*2*np.pi/(Omega*(1+2*a_prime))\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n # Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n gamma_t = - Gamma_tilde/misc['h']\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = 0\\n Gamma_r = 0\\n return gamma_t,gamma_l,Gamma_r,misc\",\n \"def Boltzchoice(LFnum, energylist, RNs):\\n # transform list to energy values in kT according to experimental\\n # affinities and the energy window allowed by the threshold\\n energylist = cf.y0 + np.array(energylist) * cf.m\\n # calculate norm of initial list\\n Norm = sum([math.exp(-ener) for ener in energylist])\\n # calculate initial probability vector\\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\\n # list to catch indices of selected cells\\n selected = []\\n # cells to be picked: determined by the lesser of #waiters and #LFs\\n cellpick = min(len(energylist), LFnum)\\n while len(selected) < cellpick:\\n bins = np.cumsum(probs)\\n ind = np.digitize(RNs.getR(), bins)\\n selected.append(ind)\\n # now, set the probability of the selected cell to 0 and renormalise\\n # the remaining probability vector\\n newNorm = Norm - math.exp(-energylist[ind])\\n probs[ind] = 0\\n probs = probs * Norm / newNorm\\n Norm = newNorm\\n\\n return selected\",\n \"def non_max_suppression_kneron(prediction, conf_thres=0.1, iou_thres=0.6, top_k_num=3000, merge=False, classes=None, agnostic=False):\\n if prediction.dtype is torch.float16:\\n prediction = prediction.float() # to FP32\\n\\n nc = prediction[0].shape[1] - 5 # number of classes\\n xc = prediction[..., 4] > conf_thres # candidates\\n\\n # Settings\\n min_wh, max_wh = 2, 4096 # (pixels) minimum and maximum box width and height\\n max_det = 300 # maximum number of detections per image\\n time_limit = 10.0 # seconds to quit after\\n multi_label = nc > 1 # multiple labels per box (adds 0.5ms/img)\\n\\n t = time.time()\\n output = [None] * prediction.shape[0]\\n for xi, x in enumerate(prediction): # image index, image inference\\n # Apply constraints\\n # x[((x[..., 2:4] < min_wh) | (x[..., 2:4] > max_wh)).any(1), 4] = 0 # width-height\\n x = x[xc[xi]] # confidence\\n\\n # If none remain process next image\\n if not x.shape[0]:\\n continue\\n\\n # Compute conf\\n x[:, 5:] *= x[:, 4:5] # conf = obj_conf * cls_conf\\n\\n # Box (center x, center y, width, height) to (x1, y1, x2, y2)\\n box = xywh2xyxy(x[:, :4])\\n\\n # Detections matrix nx6 (xyxy, conf, cls)\\n if multi_label:\\n i, j = (x[:, 5:] > conf_thres).nonzero().t()\\n x = torch.cat((box[i], x[i, j + 5, None], j[:, None].float()), 1)\\n else: # best class only\\n conf, j = x[:, 5:].max(1, keepdim=True)\\n x = torch.cat((box, conf, j.float()), 1)[conf.view(-1) > conf_thres]\\n\\n\\n\\n # If none remain process next image\\n n = x.shape[0] # number of boxes\\n if not n:\\n continue\\n\\n # Sort by confidence\\n # x = x[x[:, 4].argsort(descending=True)]\\n\\n # Batched NMS\\n c = x[:, 5:6] * (0 if agnostic else max_wh) # classes\\n boxes, scores = x[:, :4] + c, x[:, 4] # boxes (offset by class), scores\\n # Sort by confidence\\n ind_Sort_by_confidence = x[:, 4].argsort(descending=True)\\n boxes = boxes[ind_Sort_by_confidence][:top_k_num] #\\n scores = scores[ind_Sort_by_confidence][:top_k_num] #\\n x = x[ind_Sort_by_confidence][:top_k_num] #\\n # cross classes nms\\n i = torchvision.ops.boxes.nms(boxes, scores, iou_thres)\\n if i.shape[0] > max_det: # limit detections\\n i = i[:max_det]\\n\\n\\n output[xi] = x[i]\\n if (time.time() - t) > time_limit:\\n break # time limit exceeded\\n\\n return output\",\n \"def grid_visibilities(self, visibilities, N = 120):\\n logger.info(\\\"Gridding the visibilities\\\")\\n\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\\n\\n centres = (ugrid[1:] + ugrid[:-1]) / 2\\n\\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\\n\\n if(os.path.exists(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")):\\n kernel_weights = np.load(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")\\n else:\\n kernel_weights=None\\n\\n if kernel_weights is None:\\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\\n\\n for jj, freq in enumerate(self.frequencies):\\n u_bl = (self.baselines[:,0] * freq / const.c).value\\n v_bl = (self.baselines[:,1] * freq / const.c).value\\n\\n beam, indx_u, indx_v = self.fourierBeam(centres, u_bl, v_bl, freq, N=N)\\n for kk in range(len(indx_u)):\\n visgrid[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk]) * visibilities[kk,jj]\\n\\n if kernel_weights is None:\\n weights[indx_u[kk]:indx_u[kk]+np.shape(beam[kk])[0], indx_v[kk]:indx_v[kk]+np.shape(beam[kk])[1], jj] += beam[kk] / np.sum(beam[kk])\\n\\n if kernel_weights is None:\\n kernel_weights = weights\\n\\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\\n\\n return visgrid,kernel_weights\",\n \"def _obtainBornSup(self,k6,kdT,kdI,Kactiv0,Kinhib0,Cactiv0,Cinhib0,E0,X0,masks):\\n max_cp = 1\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n for inpIdx in range(layer.shape[1]):\\n #compute of Kactivs,Kinhibs;\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #compute of \\\"weights\\\": sum of kactivs and kinhibs\\n w_inpIdx = np.sum(Kactivs)+np.sum(Kinhibs)\\n max_cp += w_inpIdx*X0[inpIdx]\\n # saving values\\n layerEq[inpIdx] = X0[inpIdx]\\n olderX[layeridx] = layerEq\\n else:\\n for inpIdx in range(layer.shape[1]):\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx],0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx],0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n layerEq[inpIdx] = x_eq\\n #compute of Kactivs,Kinhibs, for the current layer:\\n Kactivs = np.where(layer[:,inpIdx]>0,Kactiv0[layeridx][:,inpIdx],0) #This is also a matrix element wise multiplication\\n Kinhibs = np.where(layer[:,inpIdx]<0,Kinhib0[layeridx][:,inpIdx],0)\\n #Adding, to the competition over enzyme, the complex formed in this layer by this input.\\n firstComplex = np.sum(np.where(layer[:,inpIdx]>0,Kactivs*x_eq,np.where(layer[:,inpIdx]<0,Kinhibs*x_eq,0)))\\n #We must also add the effect of pseudoTempalte enzymatic complex in the previous layers which can't be computed previously because we missed x_eq\\n Inhib2 = np.sum(CinhibsOld*olderX[layeridx-1]/(kdT[layeridx-1][inpIdx]*k6[layeridx-1][inpIdx]))\\n max_cp += firstComplex + Inhib2/E0*x_eq\\n olderX[layeridx] = layerEq\\n #Finally we must add the effect of pseudoTemplate enzymatic complex in the last layers\\n for outputsIdx in range(masks[-1].shape[0]):\\n Cinhibs = np.where(masks[-1][outputsIdx,:]<0,Cinhib0[-1][outputsIdx],0)\\n Cactivs = np.where(masks[-1][outputsIdx,:]>0,Cactiv0[-1][outputsIdx],0)\\n x_eq = np.sum(Cactivs*olderX[-1]/(kdI[-1][outputsIdx]))\\n Inhib2 = np.sum(Cinhibs*olderX[-1]/(kdT[-1][outputsIdx]*k6[-1][outputsIdx]))\\n max_cp += Inhib2/E0*x_eq\\n return max_cp\",\n \"def error_specific_heat(Cv):\\n ncv = 10\\n tcv = np.linspace(0,50,ncv) \\n \\n chi = auto_correlation(tcv,Cv,ncv)\\n tau_fit = curve_fit(exp,tcv,chi)\\n tau = tau_fit[0]\\n\\n error_Cv = error(tau,ncv,Cv,tcv) \\n\\n return error_Cv\",\n \"def mtvsolverbis(Hurstaest_init, yij, varyj, nj, j1, j2,\\n mask, max_iter=100, init=None,\\n prox_max_iter=5000, tol=1e-4, call_back=None, verbose=1,\\n l=1, l1_ratio=0, wtype=1, lipschitz_constant=0):\\n\\n # shape of image box\\n \\n alpha = 1\\n\\n flat_mask = mask.ravel()\\n volume_shape = mask.shape\\n H_size = len(Hurstaest_init)\\n\\n if lipschitz_constant == 0:\\n lipschitz_constant = H_size * lipschitz_constant_gradf(j1,j2,varyj, nj, wtype)\\n\\n #init[\\\"z\\\"] = Hurst_init.copy()\\n #init[\\\"t\\\"] = 1\\n #ini[\\\"stepsize\\\"] = 1 / lipschitz_constant\\n\\n def total_energy(estimation):\\n return fbis(estimation, yij, varyj, nj, j1, j2, wtype) + l * tv(_unmask(estimation[:H_size / 2],\\n mask))\\n\\n def unmaskvec(estimation):\\n return _unmask(estimation, mask)\\n\\n def maskvec(estimation):\\n return estimation[flat_mask]\\n\\n def f1_grad(estimation):\\n return gradfbis(estimation, yij, varyj, nj, j1, j2, wtype)\\n\\n def f2_prox(estimation, stepsize, dgap_tol, init):\\n lenw = len(estimation)\\n Hurst = estimation[lenw / 2:]\\n init = unmaskvec(init[:lenw / 2]) if not init is None else init\\n\\n out, info = _prox_tvl1(unmaskvec(Hurst),\\n weight=(l + 1.e-6) * stepsize, l1_ratio=l1_ratio,\\n dgap_tol=dgap_tol, init=init,\\n max_iter=prox_max_iter, fista = False,\\n verbose=verbose)\\n #pdb.set_trace()\\n return np.concatenate((maskvec(out.ravel()),estimation[lenw / 2:])), info\\n\\n w, obj, init = mfista(\\n f1_grad, f2_prox, total_energy, lipschitz_constant, H_size,\\n dgap_factor=(.1 + l1_ratio) ** 2, tol=tol, init=init, verbose=verbose,\\n max_iter=max_iter, callback=None)\\n \\n return w, obj, init\",\n \"def grid_visibilities_parallel(self, visibilities,min_attenuation = 1e-10, N = 120):\\n\\n #Find out the number of frequencies to process per thread\\n nfreq = len(self.frequencies)\\n numperthread = int(np.ceil(nfreq/self.n_obs))\\n offset = 0\\n nfreqstart = np.zeros(self.n_obs,dtype=int)\\n nfreqend = np.zeros(self.n_obs,dtype=int)\\n infreq = np.zeros(self.n_obs,dtype=int)\\n for i in range(self.n_obs):\\n nfreqstart[i] = offset\\n nfreqend[i] = offset + numperthread\\n\\n if(i==self.n_obs-1):\\n infreq[i] = nfreq - offset\\n else:\\n infreq[i] = numperthread\\n\\n offset+=numperthread\\n\\n # Set the last process to the number of frequencies\\n nfreqend[-1] = nfreq\\n\\n processes = []\\n\\n ugrid = np.linspace(-self.uv_max, self.uv_max, self.n_uv +1 ) # +1 because these are bin edges.\\n \\n centres = (ugrid[1:] + ugrid[:-1]) / 2\\n \\n visgrid = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)), dtype=np.complex128)\\n\\n\\n if(os.path.exists(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")):\\n kernel_weights = np.load(self.datafile[0][:-4]+\\\".kernel_weights.npy\\\")\\n else:\\n kernel_weights=None\\n \\n if kernel_weights is None:\\n weights = np.zeros((self.n_uv, self.n_uv, len(self.frequencies)))\\n\\n visgrid_buff_real = []\\n visgrid_buff_imag = []\\n weights_buff = []\\n\\n #Lets split this array up into chunks\\n for i in range(self.n_obs):\\n\\n visgrid_buff_real.append(multiprocessing.RawArray(np.sctype2char(visgrid.real),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\\n visgrid_buff_imag.append(multiprocessing.RawArray(np.sctype2char(visgrid.imag),visgrid[:,:,nfreqstart[i]:nfreqend[i]].size))\\n visgrid_tmp_real = np.frombuffer(visgrid_buff_real[i])\\n visgrid_tmp_imag = np.frombuffer(visgrid_buff_imag[i])\\n visgrid_tmp_real = visgrid[:,:,nfreqstart[i]:nfreqend[i]].real.flatten()\\n visgrid_tmp_imag = visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag.flatten()\\n\\n\\n if(kernel_weights is None):\\n weights_buff.append(multiprocessing.RawArray(np.sctype2char(weights),weights[:,:,nfreqstart[i]:nfreqend[i]].size))\\n weights_tmp = np.frombuffer(weights_buff[i])\\n weights_tmp = weights[:,:,nfreqstart[i]:nfreqend[i]]\\n else:\\n weights_buff.append(None)\\n\\n processes.append(multiprocessing.Process(target=self._grid_visibilities_buff,args=(self.n_uv,visgrid_buff_real[i],visgrid_buff_imag[i],weights_buff[i], visibilities[:,nfreqstart[i]:nfreqend[i]],self.frequencies[nfreqstart[i]:nfreqend[i]],self.baselines,centres,self._instr_core.sigma(self.frequencies[nfreqstart[i]:nfreqend[i]]),min_attenuation, N) ))\\n\\n for p in processes:\\n p.start()\\n\\n for p in processes:\\n p.join()\\n\\n for i in range(self.n_obs):\\n\\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].real = np.frombuffer(visgrid_buff_real[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n visgrid[:,:,nfreqstart[i]:nfreqend[i]].imag = np.frombuffer(visgrid_buff_imag[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n\\n if(kernel_weights is None):\\n weights[:,:,nfreqstart[i]:nfreqend[i]] = np.frombuffer(weights_buff[i]).reshape(self.n_uv,self.n_uv,nfreqend[i]-nfreqstart[i])\\n\\n if kernel_weights is None:\\n kernel_weights = weights\\n \\n visgrid[kernel_weights!=0] /= kernel_weights[kernel_weights!=0]\\n\\n return visgrid,kernel_weights\",\n \"def showCortexImg(pV,nV):\\n # object arrays of the positive and negative images\\n pos_cort_img = np.empty(8, dtype=object)\\n neg_cort_img = np.empty(8, dtype=object)\\n for t in range(8):\\n # cortical mapping functions\\n lpos, rpos = cortex.cort_img(pV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\\n lneg, rneg = cortex.cort_img(nV[:,t,:], L, L_loc, R, R_loc, cort_size, G)\\n pos_cort_img[t] = np.concatenate((np.rot90(lpos),np.rot90(rpos,k=3)),axis=1)\\n neg_cort_img[t] = np.concatenate((np.rot90(lneg),np.rot90(rneg,k=3)),axis=1)\\n # stack all images into a grid\\n posRGcort = np.vstack((pos_cort_img[:4]))\\n negRGcort = np.vstack((neg_cort_img[:4]))\\n posYBcort = np.vstack((pos_cort_img[4:]))\\n negYBcort = np.vstack((neg_cort_img[4:]))\\n mergecort = np.concatenate((posRGcort,negRGcort,posYBcort,negYBcort),axis=1)\\n return mergecort\",\n \"def define_pseudo_potts_helper_functions(n, k):\\n\\n assert n>1\\n assert k>1\\n\\n @njit\\n def get_multipliers_r(r, multipliers, n=n, k=k):\\n \\\"\\\"\\\"Return r's field and all couplings to spin r.\\n\\n Parameters\\n ----------\\n r : int\\n multipliers : ndarray\\n All fields and couplings concatenated together.\\n\\n Returns\\n -------\\n ndarray\\n Relevant multipliers.\\n list\\n Index of where multipliers appear in full multipliers array.\\n \\\"\\\"\\\"\\n \\n ix = [r+n*i for i in range(k)]\\n multipliersr = np.zeros(k-1+n)\\n for i in range(k):\\n multipliersr[i] = multipliers[r+n*i]\\n\\n # fill in the couplings\\n ixcounter = k\\n for i in range(n):\\n if i!=r:\\n if i<r:\\n ix.append( sub_to_ind(n, i, r) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n else:\\n ix.append( sub_to_ind(n, r, i) + k*n )\\n multipliersr[ixcounter] = multipliers[ix[ixcounter]]\\n ixcounter += 1\\n return multipliersr, ix\\n\\n @njit\\n def calc_observables_r(r, X, n=n, k=k):\\n \\\"\\\"\\\"Return the observables relevant for calculating the conditional probability of\\n spin r.\\n\\n Parameters\\n ----------\\n r : int\\n Spin index.\\n X : ndarray\\n Data samples of dimensions (n_samples, n_dim).\\n\\n Returns\\n -------\\n ndarray\\n observables\\n list of ndarray\\n observables if spin r were to occupy all other possible states\\n ndarray\\n Each col details the occupied by spin r in each array of the previous return\\n value, i.e., the first col of this array tells me what r has been changed to\\n in the first array in the above list.\\n \\\"\\\"\\\"\\n\\n obs = np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n # keep another copy of observables where the spin iterates thru all other possible states\\n otherobs = [np.zeros((X.shape[0],k-1+n), dtype=np.int8)\\n for i in range(k-1)]\\n # note the hypothetical states occupied by spin r. this makes it easier to keep track of things later\\n otherstates = np.zeros((X.shape[0],k-1), dtype=np.int8)\\n \\n # for each data sample in X\\n for rowix in range(X.shape[0]):\\n counter = 0\\n # record state of spin r in obs and hypothetical scenarios when it is another state in otherobs\\n for i in range(k):\\n if X[rowix,r]==i:\\n obs[rowix,i] = 1\\n else:\\n otherobs[counter][rowix,i] = 1\\n otherstates[rowix,counter] = i\\n counter += 1\\n ixcounter = k\\n \\n for i in range(n-1):\\n for j in range(i+1,n):\\n if i==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,j]==state\\n kcounter += 1\\n ixcounter += 1\\n elif j==r:\\n obs[rowix,ixcounter] = X[rowix,i]==X[rowix,j]\\n kcounter = 0\\n for state in range(k):\\n if state!=X[rowix,r]:\\n otherobs[kcounter][rowix,ixcounter] = X[rowix,i]==state\\n kcounter += 1\\n ixcounter += 1\\n return obs, otherobs, otherstates\\n\\n return get_multipliers_r, calc_observables_r\",\n \"def optimize_force_field_parameters_Cv_FWHM(cgmodel, file_list, temperature_list, param_bounds_dict,\\n frame_begin=0, frame_end=-1, sample_spacing=1, sparsify_stride=1, output_data='output.nc',\\n verbose=False, n_cpu=12, min_eff_samples=50,\\n n_trial_boot=200, num_intermediate_states=0, plotfile='optimize_FWHM_iterations.pdf',\\n min_method='TNC'):\\n\\n # Parse the force field parameter change dict:\\n x0 = []\\n param_names = []\\n bounds = []\\n units = []\\n \\n for key,value in param_bounds_dict.items():\\n # value should be [(bound_lo, bound_hi)]\\n # key should be a valid force field parameter name\\n param_names.append(key)\\n # Every parameter except periodicity should have units\\n # For now, changing periodicity is not supported.\\n \\n # TODO: add support for sums of periodic torsion terms\\n units.append(value[0].unit)\\n bounds.append((value[0].value_in_unit(units[-1]),value[1].value_in_unit(units[-1])))\\n # Use mean value as starting guess:\\n x0.append((value[1].value_in_unit(units[-1])+value[0].value_in_unit(units[-1]))/2)\\n\\n if verbose:\\n print(f'param_names: {param_names}')\\n print(f'unit: {units}')\\n print(f'bounds: {bounds}')\\n print(f'x0: {x0}')\\n\\n def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n \\\"\\\"\\\"\\n Objective function to be minimized\\n \\\"\\\"\\\"\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\\n\\n # Run optimization:\\n\\n # if len(param_names) == 1:\\n # # Do scalar optimization:\\n # opt_results = minimize_scalar(get_reeval_FWHM, x0,\\n # args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\\n # frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\\n # method='bounded',\\n # bounds=[bounds[0][0],bounds[0][1]],\\n # options={'maxiter': 25},\\n # )\\n\\n # else:\\n # Do multivariate optimization:\\n opt_results = minimize(get_reeval_FWHM, x0, jac='2-point',\\n args=(cgmodel, file_list, temperature_list, output_data, param_names, units,\\n frame_begin, sample_spacing, sparsify_stride, frame_end, n_cpu, n_trial_boot, num_intermediate_states),\\n method=min_method,\\n bounds=bounds,\\n options={'maxfun': 25, 'finite_diff_rel_step': 0.005, 'eta': 0.5}, # This should be user input\\n ) \\n \\n # TODO: plot the heat capacity curves at each iteration, and make a plot of all FWHM_values \\n\\n # Construct dictionary of optimal parameters:\\n opt_param_dict = {} \\n \\n k = 0\\n for key,value in param_bounds_dict.items():\\n opt_param_dict[key] = opt_results.x[k] * units[k]\\n k += 1\\n \\n return opt_param_dict, opt_results\",\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 set_voltages(): \\n #0) set parameters\\n from project_parameters import trapFile,multipoleControls,reg,driveFrequency,ax,az,phi,coefs\\n import pickle\\n with open(trapFile,'rb') as f:\\n trap = pickle.load(f)\\n V,X,Y,Z=trap.instance.DC,trap.instance.X,trap.instance.Y,trap.instance.Z\\n tc=trap.configuration\\n C = tc.multipoleControl\\n el = []\\n #1) check if trap_knobs has been run yet, creating multipoleControl and multipoleKernel\\n if tc.trap_knobs != True:\\n return 'WARNING: You must run trap_knobs first!'\\n #2a) determine electrode voltages directly\\n elif multipoleControls: # note plurality to contrast from attribute\\n el = np.dot(C,coefs.T) # these are the electrode voltages\\n #2b) determine electrode volages indirectly\\n else:\\n charge = tc.charge\\n mass = tc.mass\\n V0 = mass*(2*np.pi*frequencyRF)**2/charge\\n U2 = az*V0/8\\n U1 = U2+ax*V0/4\\n U3 = 2*U1*np.tan(2*np.pi*(phi+tc.thetaRF)/180)\\n U1p= np.sqrt(U1**2+U3**2/2)\\n U4 = U1p*tc.Qrf[4]/tc.Qrf[1]\\n U5 = U1p*tc.Qrf[5]/tc.Qrf[1]\\n inp = np.array([E[0], E[1], E[2], U1, U2, U3, U4, U5]).T\\n mCf = tc.multipoleCoefficients[1:9,:]\\n el = np.dot(mCf.T,inp) # these are the electrode voltages\\n el = np.real(el)\\n #3) regularize if set to do so\\n reg = 0\\n if reg: \\n C = el\\n Lambda = np.linalg.lstsq(tc.multipoleKernel,C)\\n Lambda=Lambda[0]\\n el = el-(np.dot(tc.multipoleKernel,Lambda))\\n return el\",\n \"def spec_helm_decomp(k,Cu,Cv,GM=False):\\n dk = k[1]-k[0]\\n s = np.log(k)\\n\\n Fphi = np.zeros_like(Cu)\\n Fpsi = np.zeros_like(Cu)\\n Cphi = np.zeros_like(Cu)\\n Cpsi = np.zeros_like(Cu)\\n\\n # assume GM for decomposing into wave and vortex\\n if GM:\\n gm = np.load(\\\"/Users/crocha/Projects/dp_spectra/GM/gm_omega_star.npz\\\")\\n f2omg2 = gm['rgm']\\n ks = gm['k']*1.e3\\n\\n for i in range(s.size-1):\\n\\n ds = np.diff(s[i:])\\n\\n sh = sinh(s[i]-s[i:])\\n ch = cosh(s[i]-s[i:])\\n\\n # the function to integrate\\n Fp = Cu[i:]*sh + Cv[i:]*ch\\n Fs = Cv[i:]*sh + Cu[i:]*ch\\n\\n # integrate using Simpson's rule\\n Fpsi[i] = integrate.simps(Fs,s[i:])\\n Fphi[i] = integrate.simps(Fp,s[i:])\\n\\n # zero out unphysical values\\n Fpsi[Fpsi < 0.] = 0.\\n Fphi[Fphi < 0.] = 0.\\n\\n # compute rotational and divergent components\\n Cpsi = Fpsi - Fphi + Cu\\n Cphi = Fphi - Fpsi + Cv\\n\\n if GM:\\n\\n f2omg2i = np.interp(k,ks,f2omg2)\\n\\n Cv_w = f2omg2i*Fphi - Fpsi + Cv\\n Cv_v = Cv - Cv_w\\n \\n kdkromg = diff_central(ks, f2omg2)\\n kdkromg = np.interp(k,ks[1:-1],kdkromg)\\n\\n dFphi = diff_central(k, Fphi)\\n #dFphi = np.gradient(Fphi,k)\\n dFphi = np.interp(k,k[1:-1],dFphi.real)\\n E_w = Fphi - k*dFphi\\n\\n Cu_w = -k*kdkromg*Fphi + f2omg2i*(-Fpsi+Cv) + Fphi\\n Cu_v = Cu - Cu_w\\n\\n Cb_w = E_w - (Cu_w + Cv_w)/2.\\n\\n return Cpsi,Cphi, Cu_w,Cv_w, Cu_v,Cv_v, E_w, Cb_w\\n\\n else:\\n return Cpsi,Cphi\",\n \"def estimate_opt_eff(self, iv_fn_hot, iv_fn_cold,t_hot=293.,t_cold=77.,\\n channels = None, dPdT_lim=(0.,0.5)):\\n ivs_hot = np.load(iv_fn_hot).item()\\n ivs_cold = np.load(iv_fn_cold).item()\\n \\n iv_fn_raw_hot = iv_fn_hot.split('.')[0] + '_raw_data.npy'\\n iv_fn_raw_cold = iv_fn_cold.split('.')[0] + '_raw_data.npy'\\n\\n ivs_raw_hot = np.load(iv_fn_raw_hot).item()\\n ivs_raw_cold = np.load(iv_fn_raw_cold).item()\\n \\n basename_hot = ivs_raw_hot['basename']\\n basename_cold = ivs_raw_cold['basename']\\n\\n #band = ivs_raw_hot['band']\\n #assert ivs_raw_cold['band'] == band, \\\\\\n # 'Files must contain IVs from the same band'\\n group = ivs_raw_hot['bias group']\\n assert ivs_raw_cold['bias group'], \\\\\\n 'Files must contain IVs from the same bias group'\\n \\n import matplotlib.pyplot as plt\\n plot_dir = self.plot_dir\\n\\n dT = t_hot - t_cold\\n dPdT_list = []\\n n_outliers = 0\\n for ch in ivs_hot:\\n if channels is not None:\\n if ch not in channels:\\n continue\\n elif not isinstance(ch,np.int64):\\n continue\\n \\n if ch not in ivs_cold:\\n continue\\n \\n P_hot = ivs_hot[ch]['P']\\n P_cold = ivs_cold[ch]['P']\\n R_hot = ivs_hot[ch]['R']\\n R_cold = ivs_cold[ch]['R']\\n Ptrans_hot = ivs_hot[ch]['Ptrans']\\n Ptrans_cold = ivs_cold[ch]['Ptrans']\\n if Ptrans_hot is None or Ptrans_cold is None:\\n print('Missing in-transition electrical powers for Ch. %i' % (ch))\\n continue\\n dPdT = (Ptrans_cold - Ptrans_hot)/dT\\n self.log('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\\n if dPdT_lim is not None:\\n if dPdT >= dPdT_lim[0] and dPdT <= dPdT_lim[1]:\\n dPdT_list.append(dPdT)\\n else:\\n n_outliers += 1\\n else:\\n dPdT_list.append(dPdT)\\n\\n fig_pr,ax_pr = plt.subplots(1,sharex=True)\\n ax_pr.set_xlabel(r'$R_\\\\mathrm{TES}$ [$\\\\Omega$]')\\n ax_pr.set_ylabel(r'$P_\\\\mathrm{TES}$ [pW]')\\n label_hot = '%s: %.0f K' % (basename_hot,t_hot)\\n label_cold = '%s: %.0f K' % (basename_cold,t_cold)\\n ax_pr.axhline(y=Ptrans_hot,linestyle = '--',color = 'b')\\n ax_pr.axhline(y=Ptrans_cold,linestyle = '--',color = 'r')\\n ax_pr.plot(R_hot,P_hot,label=label_hot,color='b')\\n ax_pr.plot(R_cold,P_cold,label=label_cold,color='r')\\n ax_pr.legend(loc='best')\\n fig_pr.suptitle('Group {}, Ch {:03}: dP/dT = {:.3f} pW/K'.format(group, ch, dPdT))\\n ax_pr.grid()\\n \\n plot_name = basename_hot + '_' + basename_cold + '_optEff_g{}_ch{:03}.png'.format(group, ch)\\n plot_filename = os.path.join(plot_dir, plot_name)\\n self.log('Saving optical-efficiency plot to {}'.format(plot_filename))\\n plt.savefig(plot_filename,bbox_inches='tight', dpi=300)\\n plt.close()\\n\\n plt.figure()\\n plt.hist(dPdT_list,edgecolor='k')\\n plt.xlabel('dP/dT [pW/K]')\\n plt.grid()\\n dPdT_median = np.median(dPdT_list)\\n plt.title('Group {}, median = {:.3f} pW/K ({} outliers not plotted)'.format(group,dPdT_median,n_outliers))\\n plot_name = basename_hot + '_' + basename_cold + '_dPdT_hist_g{}.png'.format(group)\\n hist_filename = os.path.join(plot_dir,plot_name)\\n self.log('Saving optical-efficiency histogram to {}'.format(hist_filename))\\n plt.savefig(hist_filename,bbox_inches='tight',dpi=300)\\n plt.close()\",\n \"def main():\\n # Directory where the DICOM files are being stored (in this\\n input_path = './Inputs/valve'\\n\\n # Original image from the filepath\\n img_original = read_image(input_path)\\n\\n # Image with smoothing applied to reduce noise\\n img_smooth = sitk.CurvatureFlow(image1=img_original, timeStep=0.125, numberOfIterations=10)\\n\\n # Create labels on our smoothed image for cardiac tissue and tissue with blood\\n labels_tissue = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=325, upperThreshold=470, insideValue=1)\\n labels_blood = sitk.BinaryThreshold(image1=img_smooth, lowerThreshold=450, upperThreshold=800, insideValue=1, outsideValue=0)\\n\\n # IMPORTANT STEP: essentially, this is the key to our algorithm. By finding the \\\"blood\\\" without cardiac tissue,\\n # and then using binary hole filling with a fairly large radius, we are able to label a lot of the mitral valve\\n # area without labeling too much of the other cardiac tissue. Thus, THIS is what lets us single out the mitral\\n # valve tissue from the rest - all we need is the overlap of the two labels\\n labels_tissue_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_tissue, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_blood_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_blood, radius=[4] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve = retrieve_overlap(labels_blood_no_holes, labels_tissue_no_holes)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve, radius=[2] * 3, majorityThreshold=1, backgroundValue=0, foregroundValue=1)\\n labels_valve_no_holes = sitk.VotingBinaryHoleFilling(image1=labels_valve_no_holes, radius=[1] * 3, majorityThreshold=0, backgroundValue=1, foregroundValue=0)\\n\\n # Fix intensity scaling on our original smoothed image for pretty diagram purposes\\n img_smooth = sitk.Cast(sitk.RescaleIntensity(img_smooth), labels_tissue_no_holes.GetPixelID())\\n\\n # Use a density-based clustering algorithm to attempt to remove as much noise as possible\\n labels_valve_filtered = dbscan_filter(labels_valve_no_holes, eps=2, use_z=False)\\n labels_valve_filtered = dbscan_filter(labels_valve_filtered, eps=4)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Remove all values distant from the center of our starting location by taking advantage of kmeans\\n df = get_df_from_img(labels_valve_filtered[:, :, 0], dimensions=2)\\n x_mid = df['x'].mean()\\n y_mid = df['y'].mean()\\n df = get_df_from_img(labels_valve_filtered)\\n distance_df = df.drop('z', axis=1)\\n distance_df['x_dist'] = abs(distance_df['x'] - x_mid)\\n distance_df['y_dist'] = abs(distance_df['y'] - y_mid)\\n fit = cluster.KMeans(n_clusters=2).fit(distance_df.drop(['x', 'y'], axis=1))\\n labels = fit.labels_\\n df['label'] = pd.Series(labels)\\n counts = df['label'].value_counts().to_dict()\\n largest_cluster = max(counts.iterkeys(), key=(lambda key: counts[key]))\\n update_img_from_df(df, labels_valve_filtered, keep=largest_cluster)\\n\\n # Find likely start and end points of our image by setting a mininum number of labeled pixels\\n start, end = filter_by_label_count(labels_valve_filtered, 10)\\n img_smooth = img_smooth[:, :, start:end]\\n labels_valve_filtered = labels_valve_filtered[:, :, start:end]\\n\\n # Use a segmentation-based clustering algorithm to attempt to find each valve\\n label_segments, x_max = kmeans_segment(labels_valve_filtered, use_z=False)\\n\\n left, right = (label_segments[0], label_segments[1])\\n if x_max[0] > x_max[1]:\\n left, right = right, left\\n\\n # Finally, we can simply take the furthest point from the likely start/end points in order to get our annulus\\n # this can be done by every z value\\n left_points = {'x': [], 'y': [], 'z': []}\\n right_points = {'x': [], 'y': [], 'z': []}\\n zlen = len(sitk.GetArrayFromImage(left))\\n for z in xrange(zlen):\\n left_df = get_df_from_img(left[:, :, z], dimensions=2)\\n if len(left_df['y']) > 0:\\n index = left_df['y'].idxmin()\\n row = left_df.iloc[index]\\n left_points['x'].append(int(row['x']))\\n left_points['y'].append(int(row['y']))\\n left_points['z'].append(z)\\n\\n right_df = get_df_from_img(right[:, :, z], dimensions=2)\\n if len(right_df['x']) > 0:\\n index = right_df['x'].idxmax()\\n row = right_df.iloc[index]\\n right_points['x'].append(int(row['x']))\\n right_points['y'].append(int(row['y']))\\n right_points['z'].append(z)\\n\\n # These both represent the coordinates of our annulus ring. A simple spline can be used for interpolation between\\n # points\\n final_left = pd.DataFrame.from_dict(left_points)\\n final_right = pd.DataFrame.from_dict(right_points)\\n print('Coordinates for one side of the ring')\\n print(final_left)\\n print('\\\\n\\\\nCoordinates for the other side of the ring')\\n print(final_right)\\n\\n final_image = make_empty_img_from_img(left)\\n x = left_points['x'] + right_points['x']\\n y = left_points['y'] + right_points['y']\\n z = left_points['z'] + right_points['z']\\n for x, y, z in zip(x, y, z):\\n final_image.SetPixel(x, y, z, 1)\\n\\n show_all(img_smooth, final_image)\",\n \"def compute_autocorrelation_rlzn_ensemble(fopen_list, te):\\n print 'Compute the autocorrelation'\\n\\n # initialize components of rho\\n sumuu = 0.0\\n sumvv = 0.0\\n\\n psiuu = 0.0\\n psivv = 0.0\\n\\n sumup2 = 0.0\\n sumvp2 = 0.0\\n\\n # get characteristics of mean velocity field\\n fbs = netCDF4.Dataset('buoyancySurface.nc','r')\\n lonCell = fbs.variables['lonCell']\\n latCell = fbs.variables['latCell']\\n lon = np.degrees(np.mod(lonCell[:]+np.pi,2*np.pi)-np.pi)\\n lat = np.degrees(latCell[:])\\n hull = spatial.ConvexHull(np.vstack((lon,lat)).T) \\n triang = Triangulation(lon,lat)\\n buoy_surf_zonal = fbs.variables['buoyancySurfaceVelocityZonal']\\n buoy_surf_merid = fbs.variables['buoyancySurfaceVelocityMeridional']\\n\\n \\n # build up layers for interpolation of particle layers\\n interp_zonal = []\\n interp_merid = []\\n nlayers = len(fbs.dimensions['nBuoyancySurfaces'])\\n for alayer in np.arange(nlayers):\\n interp_zonal.append(LinearTriInterpolator(triang, buoy_surf_zonal[0,:,alayer]))\\n interp_merid.append(LinearTriInterpolator(triang, buoy_surf_merid[0,:,alayer]))\\n\\n for num, afile in enumerate(fopen_list):\\n print 'working on %d' % num\\n # interpolate mean velocities onto points for the computation\\n x = afile.variables['xParticle'][:te,:]\\n y = afile.variables['yParticle'][:te,:]\\n z = afile.variables['zParticle'][:te,:]\\n latr, lonr = proj_lat_long(x,y,z)\\n latr = np.degrees(latr)\\n lonr = np.degrees(lonr)\\n\\n ubar = np.zeros(x.shape)\\n vbar = np.zeros(x.shape)\\n nparticle_layer = x.shape[1]/nlayers\\n for alayer in np.arange(nlayers):\\n ps = np.arange(alayer*nparticle_layer,(alayer+1)*nparticle_layer)\\n ubar[:,ps] = interp_zonal[alayer](lonr[:,ps],latr[:,ps])\\n vbar[:,ps] = interp_merid[alayer](lonr[:,ps],latr[:,ps])\\n\\n # compute portions of autocorrelation\\n u = afile.variables['lonVel'][:te,:]\\n up = u - ubar\\n up0 = up[0,:]\\n\\n v = afile.variables['latVel'][:te,:]\\n vp = v - vbar\\n vp0 = vp[0,:]\\n\\n sumuu += up0*up\\n sumvv += vp0*vp\\n\\n psiuu += up0*up0\\n psivv += vp0*vp0\\n \\n sumup2 += np.nanmean(up**2.0, axis=0)\\n sumvp2 += np.nanmean(vp**2.0, axis=0)\\n \\n\\n fbs.close()\\n\\n # note division by psi removes need to divide the sums by the number of realizations\\n sumuu /= psiuu \\n sumvv /= psivv\\n\\n sumup2 /= len(fopen_list)\\n sumvp2 /= len(fopen_list)\\n\\n print 'done'\\n\\n return sumuu, sumvv, sumup2, sumvp2, lonr[0,:], latr[0,:], lon, lat, hull\",\n \"def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\\n \\n # INPUTS FROM TTTW SYSTEM\\n self.b = b #buoyancy field: [Ly,N]\\n self.u = u # x-component of velocity [Ly,N]\\n self.v = v # y-component of velocity [Ly+1,N]\\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \\n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\\n self.grid_dict = grid_dict #gridded data\\n self.f = f #coriolis parameter\\n # KPP-SPECIFIC VARIABLES \\n self.hbls = np.zeros([self.b.shape[0]])\\n self.hbbl = np.zeros([self.b.shape[0]])\\n self.ustar = []\\n self.bvf = [] \\n self.kmo = []\\n self.C_h_MO = []\\n self.kbl = []\\n self.Cr = [] \\n self.Fc = []\\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\\n self.dt = dt\",\n \"def attach_to_controller(self, controller):\\r\\n\\r\\n def cv_amp(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n return np.std(amps) / np.mean(amps) if len(amps) >= 1 else 0\\r\\n\\r\\n def cum_amp_drift(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n # return cum_feat(amps) if len(amps) >= 2 else 0\\r\\n return np.sum(np.abs(np.diff(amps))) / len(amps) if len(amps) >= 2 else 0\\r\\n\\r\\n def cum_depth_drift(cluster_id):\\r\\n depths = controller.model.spike_depths[controller.get_spike_ids(cluster_id)].data\\r\\n # return cum_feat(depths) if len(depths) >= 2 else 0\\r\\n return np.sum(np.abs(np.diff(depths))) / len(depths) if len(depths) >= 2 else 0\\r\\n\\r\\n def cv_fr(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n fr = bb.singlecell.firing_rate(ts, hist_win=0.01, fr_win=0.25)\\r\\n return np.std(fr) / np.mean(fr) if len(fr) >= 1 else 0\\r\\n\\r\\n def frac_isi_viol(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n frac_isi_viol, _, _ = isi_viol(ts, rp=0.002)\\r\\n return frac_isi_viol\\r\\n\\r\\n def frac_missing_spikes(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n try:\\r\\n frac_missing_spks, _, _ = feat_cutoff(\\r\\n amps, spks_per_bin=10, sigma=4, min_num_bins=50)\\r\\n except:\\r\\n frac_missing_spks = np.NAN\\r\\n return frac_missing_spks\\r\\n\\r\\n def fp_estimate(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n return fp_est(ts, rp=0.002)\\r\\n\\r\\n def presence_ratio(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n pr, _ = pres_ratio(ts, hist_win=10)\\r\\n return pr\\r\\n\\r\\n def presence_ratio_std(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n pr, pr_bins = pres_ratio(ts, hist_win=10)\\r\\n return pr / np.std(pr_bins)\\r\\n\\r\\n def refp_viol(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n return FP_RP(ts)\\r\\n\\r\\n def n_cutoff(cluster_id):\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n return noise_cutoff(amps, quartile_length=.25)\\r\\n\\r\\n def mean_amp_true(cluster_id):\\r\\n # Three cases: raw data\\r\\n\\r\\n # THIS APPROACH WORKS FOR BOTH SAMPLE WAVEFORMS AND RAW DATA\\r\\n # Specify 100 waveforms to average over, but may be less in the case where in the subset\\r\\n # of sample waveforms it doesn't contain 100 samples for specific cluster\\r\\n\\r\\n # N.B. These waveforms are median subtracted and have a high pass applied\\r\\n waveforms = controller._get_waveforms_with_n_spikes(\\r\\n cluster_id, 100)['data'].data\\r\\n\\r\\n # This way finds (max-min) on each channel, and then for each waveform finds the\\r\\n # maximum (max-min) on any channel and averages these\\r\\n # For each sample waveform find value on channel that has largest (max-min)\\r\\n p2p = np.max((np.max(waveforms, axis=1) - np.min(waveforms, axis=1)), axis=1)\\r\\n # Find mean p2p across all available sample waveforms\\r\\n p2p_mean = np.mean(p2p)\\r\\n\\r\\n # Alternative way\\r\\n # This way finds (max-min) on each channel, on each channel averages across all sample\\r\\n # waveforms and then finds the channel with the maximum average value\\r\\n p2p_mean_alt = np.max(np.mean(np.max(waveforms, axis=1) - np.min(waveforms, axis=1),\\r\\n axis=0))\\r\\n\\r\\n # Approach 2\\r\\n # Only works for sample waveforms\\r\\n # For non median subtracted and no high pass can access sample waveforms like this\\r\\n # spike_ids = controller.get_spike_ids(cluster_id).data\\r\\n # # Find which of the spike ids are in the subset of sample waveforms\\r\\n # _, _, idx = np.intersect1d(spike_ids,\\r\\n # controller.model.spike_waveforms['spike_ids'].data,\\r\\n # return_indices=True)\\r\\n # # Sample waveforms that are available for this cluster\\r\\n # # Shape of waveforms (n_waveforms, n_samples, n_channels)\\r\\n # # where len(idx) == n_waveforms\\r\\n # waveforms = controller.model.spike_waveforms['waveforms'][idx].data\\r\\n\\r\\n # RAW DATA CASE\\r\\n\\r\\n return p2p_mean\\r\\n\\r\\n # no waveforms\\r\\n\\r\\n # def ptp_sigma(cluster_id):\\r\\n # this also requires checking 3 cases above.\\r\\n\\r\\n def m_label(cluster_id):\\r\\n ts = controller.get_spike_times(cluster_id).data\\r\\n amps = controller.get_amplitudes(cluster_id).data\\r\\n metrics_label = int(FP_RP(ts) and noise_cutoff(amps, quartile_length=.25) < 20)\\r\\n return metrics_label\\r\\n # if amplitudes are correct (i.e. raw data or sample wfs exist):\\r\\n #metrics_label = (FP_RP(ts) and noise_cutoff(amps,quartile_length=.25)<20 and np.mean(amps)>50)\\r\\n\\r\\n # Use this dictionary to define custom cluster metrics.\\r\\n # We memcache the function so that cluster metrics are only computed once and saved\\r\\n # within the session, and also between sessions (the memcached values are also saved\\r\\n # on disk).\\r\\n controller.cluster_metrics['cv_amp'] = controller.context.memcache(cv_amp)\\r\\n controller.cluster_metrics['cum_amp_drift'] = controller.context.memcache(cum_amp_drift)\\r\\n\\r\\n # NOTE: the branch of phylib which defines model.spike_depths is not working yet\\r\\n # controller.cluster_metrics['cum_depth_drift'] = controller.context.memcache(\\r\\n # cum_depth_drift)\\r\\n\\r\\n controller.cluster_metrics['cv_fr'] = controller.context.memcache(cv_fr)\\r\\n controller.cluster_metrics['frac_isi_viol'] = controller.context.memcache(frac_isi_viol)\\r\\n controller.cluster_metrics['frac_missing_spikes'] = controller.context.memcache(\\r\\n frac_missing_spikes)\\r\\n controller.cluster_metrics['fp_estimate'] = controller.context.memcache(fp_estimate)\\r\\n controller.cluster_metrics['presence_ratio'] = controller.context.memcache(presence_ratio)\\r\\n controller.cluster_metrics['presence_ratio_std'] = controller.context.memcache(\\r\\n presence_ratio_std)\\r\\n controller.cluster_metrics['refp_viol'] = controller.context.memcache(refp_viol)\\r\\n controller.cluster_metrics['noise_cutoff'] = controller.context.memcache(n_cutoff)\\r\\n controller.cluster_metrics['mean_amp'] = controller.context.memcache(mean_amp_true)\\r\\n controller.cluster_metrics['metrics_label'] = controller.context.memcache(m_label)\",\n \"def WakeVorticityFromCt(r,Ct,R,U0,Omega):\\n if Omega==np.inf:\\n Omega=800 # TODO, implement infinite lambd formulae directly\\n Lambda=Omega*R/U0\\n bSwirl=Lambda<20\\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\\n Gamma = vk*np.pi*U0**2/Omega\\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)\",\n \"def WakeVorticityFromCt(r,Ct,R,U0,Omega):\\n if Omega==np.inf:\\n Omega=800 # TODO, implement infinite lambd formulae directly\\n Lambda=Omega*R/U0\\n bSwirl=Lambda<20\\n vk=CirculationFromPrescribedCt(r/R,Ct,Lambda,bSwirl)\\n Gamma = vk*np.pi*U0**2/Omega\\n return WakeVorticityFromCirculation_Discr(r,Gamma,R,U0,Omega,nB=1,bSwirl=bSwirl)\",\n \"def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cyl is None:\\n r_cyl = np.zeros(r_cp.shape)\\n if len(r_cyl)==1:\\n r_cyl=np.array([R])\\n else:\\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\\n else:\\n r_cyl = np.asarray(r_cyl).ravel()\\n misc={}\\n # --- Checks\\n if np.amax(r_cyl) < np.amax(r_cp):\\n warnings.warn('Cylinders are assumed to enclose the control points')\\n import pdb; pdb.set_trace()\\n if r_cyl[0] == 0:\\n raise Exception('First cylinder at 0, impossible')\\n\\n ## Interpolating Circulation on the control points\\n Gamma_cp = Gamma_cp * nB # IMPORTANT\\n lambda_rcp = Omega*r_cp/U0\\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\\n ## Some init\\n\\n n = len(r_cyl)\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n # --- Case 1: Using k / ct to determine gamma\\n # Using a_prime to correct Ct\\n # Tangential convection velocity\\n if not bTanInd_k:\\n ap_cyl_conv = 0 * Gamma_cp\\n else:\\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\\n # See Equation (26) of [1]: a'_c,i = (\\\\Gamma_i+\\\\Gamma_i+1)/(4 pi Omega R_i^2)\\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\\n # --- Allocation\\n b = np.zeros(n) # Cummulative sum of gamma_bar\\n S = np.zeros(n) # Term under the square root\\n Sbis = np.zeros(n) # Term under the square root, account\\n Ctrot = np.zeros(n)\\n Ctrot_loc = np.zeros(n)\\n Cti = np.zeros(n)\\n Cteff = np.zeros(n)\\n gamma_t_bar = np.zeros(n)\\n # --- Init\\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\\n lambda_R = Omega * r_cyl / U0\\n # Looping through radii in reversed order\\n for i in np.arange(n-1,-1,-1):\\n if i==n-1:\\n b[i] = 1\\n S[i] = 1 - C[i]\\n Sbis[i] = 1 - C[i]\\n Ctrot[i] = 0\\n Ctrot_loc[i] = 0\\n else:\\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\\n if not bSwirl:\\n Ctrot[i] = 0\\n Cti[i] = k_r[i]\\n else:\\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\\n Sbis[i] = 1 - Cteff[i]\\n if bSwirl :\\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\\n else:\\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \\n# print('b',b,'S',S)\\n if bHighThrustCorr:\\n if (Cteff[i] > Ct_c):\\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\\n #if np.abs(imag(gamma_t_bar(i))) > 0:\\n # gamma_t_bar[i] = - b[i] + 0\\n Vc = U0 * (b + gamma_t_bar / 2)\\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\\n\\n\\n # Analytical 1\\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\\n a_1=a_1[-1::-1]\\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\\n a=a_1;\\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\\n # # Analytical 2\\n # a_2=-(gamma_t_hat/2)/U0;\\n # a=a_2;\\n #else\\n # a=a_1;\\n #end\\n if bSwirl:\\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\\n else:\\n a_prime=a*0\\n\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n misc['h'] = h\\n\\n # --- Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n #gamma_t = - Gamma_tilde/h\\n gamma_t = gamma_t_bar * U0\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = None\\n Gamma_r = None\\n\\n return gamma_t,gamma_l,Gamma_r, misc\",\n \"def WakeVorticityFromCirculation_Discr(r_cp,Gamma_cp,R,U0,Omega,nB,bSwirl,method='analytical',bTanInd_k=True,bHighThrustCorr=True,r_cyl=None):\\n r_cp = np.asarray(r_cp).ravel()\\n Gamma_cp = np.asarray(Gamma_cp).ravel()\\n if r_cyl is None:\\n r_cyl = np.zeros(r_cp.shape)\\n if len(r_cyl)==1:\\n r_cyl=np.array([R])\\n else:\\n r_cyl[:-1] = (r_cp[1:] + r_cp[:-1])/2\\n r_cyl[-1] = r_cp[-1] + (r_cp[-1]-r_cp[-2])/2\\n else:\\n r_cyl = np.asarray(r_cyl).ravel()\\n misc={}\\n # --- Checks\\n if np.amax(r_cyl) < np.amax(r_cp):\\n warnings.warn('Cylinders are assumed to enclose the control points')\\n import pdb; pdb.set_trace()\\n if r_cyl[0] == 0:\\n raise Exception('First cylinder at 0, impossible')\\n\\n ## Interpolating Circulation on the control points\\n Gamma_cp = Gamma_cp * nB # IMPORTANT\\n lambda_rcp = Omega*r_cp/U0\\n k_r = Gamma_cp*Omega/(np.pi*U0**2) # Equation (27) of [Superp]\\n Ct_KJ_cp = k_r * (1+k_r / (4*lambda_rcp**2)) # Equation (32) of [Superp]\\n ## Some init\\n\\n n = len(r_cyl)\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n # --- Case 1: Using k / ct to determine gamma\\n # Using a_prime to correct Ct\\n # Tangential convection velocity\\n if not bTanInd_k:\\n ap_cyl_conv = 0 * Gamma_cp\\n else:\\n # Tangential convection velocity as the mean of velocity on both side of the cylinder)\\n # See Equation (26) of [1]: a'_c,i = (\\\\Gamma_i+\\\\Gamma_i+1)/(4 pi Omega R_i^2)\\n ap_cyl_conv = np.zeros(Gamma_cp.shape)\\n ap_cyl_conv[:-1] = (Gamma_cp[:-1] + Gamma_cp[1:])/(4*np.pi*Omega*r_cyl[:-1])**2\\n ap_cyl_conv[-1] = Gamma_cp[-1]/(4*np.pi*Omega*r_cyl[-1])**2\\n # --- Allocation\\n b = np.zeros(n) # Cummulative sum of gamma_bar\\n S = np.zeros(n) # Term under the square root\\n Sbis = np.zeros(n) # Term under the square root, account\\n Ctrot = np.zeros(n)\\n Ctrot_loc = np.zeros(n)\\n Cti = np.zeros(n)\\n Cteff = np.zeros(n)\\n gamma_t_bar = np.zeros(n)\\n # --- Init\\n C = Gamma_cp*Omega/(np.pi*U0**2)*(1 + ap_cyl_conv)\\n lambda_R = Omega * r_cyl / U0\\n # Looping through radii in reversed order\\n for i in np.arange(n-1,-1,-1):\\n if i==n-1:\\n b[i] = 1\\n S[i] = 1 - C[i]\\n Sbis[i] = 1 - C[i]\\n Ctrot[i] = 0\\n Ctrot_loc[i] = 0\\n else:\\n b[i] = 1 + np.sum(gamma_t_bar[i+1:]) # Eq.(25)\\n S[i] = b[i]**2 - (k_r[i] - k_r[i+1])*(1 + ap_cyl_conv[i]) # Eq.(28)\\n Ctrot_loc[i] = (k_r[i+1]/2)**2*(1/lambda_R[i]**2-1/lambda_R[i+1]**2) # Eq.(33)\\n if not bSwirl:\\n Ctrot[i] = 0\\n Cti[i] = k_r[i]\\n else:\\n Ctrot[i] = np.sum(Ctrot_loc[i+1:])\\n Cti[i] = k_r[i]*(1+k_r[i]/(4*lambda_R[i]**2)) # Eq.(32)\\n Cteff[i] = Cti[i] - Ctrot[i] #Eq.(38)\\n Sbis[i] = 1 - Cteff[i]\\n if bSwirl :\\n gamma_t_bar[i] = - b[i] + np.sqrt(Sbis[i]) #Eq.(28)\\n else:\\n gamma_t_bar[i] = - b[i] + np.sqrt(S[i]) \\n# print('b',b,'S',S)\\n if bHighThrustCorr:\\n if (Cteff[i] > Ct_c):\\n aeff = (Cteff[i] - 4*ac**2)/(4*(1-2*ac)) # Eq.(40)\\n gamma_t_bar[i] = - b[i] + (1-2*aeff) # Eq.(41)\\n #if np.abs(imag(gamma_t_bar(i))) > 0:\\n # gamma_t_bar[i] = - b[i] + 0\\n Vc = U0 * (b + gamma_t_bar / 2)\\n h = 2*np.pi*Vc/(Omega*(1+ap_cyl_conv))\\n #print('Vc',Vc,'b',b,'gamma_t_bar',gamma_t_bar,'ap',ap_cyl_conv,'Omega',Omega,'h',h)\\n\\n\\n # Analytical 1\\n a_1=-np.cumsum(gamma_t_bar[-1::-1]/2);\\n a_1=a_1[-1::-1]\\n #if isequal(Algo.VCYL.PitchMethod,'Analytical')\\n a=a_1;\\n #elif isequal(Algo.VCYL.PitchMethod,'WrongAnalytical')\\n # # Analytical 2\\n # a_2=-(gamma_t_hat/2)/U0;\\n # a=a_2;\\n #else\\n # a=a_1;\\n #end\\n if bSwirl:\\n a_prime=Gamma_cp/(4*np.pi*Omega*r_cp**2)\\n else:\\n a_prime=a*0\\n\\n misc['a'] = a\\n misc['a_prime'] = a_prime\\n misc['Gamma_cp'] = Gamma_cp\\n misc['r_cp'] = r_cp\\n misc['h'] = h\\n\\n # --- Vortex intensities\\n Gamma_tilde = Gamma_cp - np.concatenate((Gamma_cp[1:],[0])) #Gamma_tilde = Gamma_i-Gamma_{i+1}\\n #gamma_t = - Gamma_tilde/h\\n gamma_t = gamma_t_bar * U0\\n if bSwirl:\\n gamma_l = Gamma_tilde/(2*np.pi*r_cp)\\n Gamma_r = - Gamma_cp[0]\\n else:\\n gamma_l = None\\n Gamma_r = None\\n\\n return gamma_t,gamma_l,Gamma_r, misc\",\n \"def compute_mixing_coefficients_bot(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n\\n v_upts = TTTW_func.v2u(self.v)\\n\\n self.sigma_bot = []\\n self.Kv0 = np.zeros([Ly,N+1])\\n self.Kt0 = np.zeros([Ly,N+1])\\n for j in range(Ly):\\n # turbulent velocity sclaes with buoyancy effects neglected\\n ustar2 = self.r_D[j] * np.sqrt(self.u[j,0]**2 + v_upts[j,0]**2)\\n wm = self.vonKar * np.sqrt(ustar2)\\n ws = wm\\n \\n for k in range(1,N):\\n k_w = k\\n k_r = k - 1\\n\\n if k_w < self.kbl[j]: # NEED Zob\\n sigma = np.min( [ ((z_u_w[j,k_w] - z_u_w[j,0] + self.Zob) / (self.hbbl[j] + self.Zob)),1.])\\n if j ==1:\\n self.sigma_bot.append(sigma)\\n a1 = sigma - 2.\\n a2 = 3. - 2.*sigma\\n a3 = sigma - 1.\\n\\n self.Kv0[j,k_w] = wm * self.hbbl[j] * ( sigma * (1. + sigma * ( a1 + a2*self.Gm1_bot[j]+a3*self.dGm1_dS_bot[j]))) \\n self.Kt0[j,k_w] = ws * self.hbbl[j] * ( sigma * (1. + sigma * ( a1 + a2*self.Gt1_bot[j]+a3*self.dGt1_dS_bot[j])))\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def compute_mixing_coefficients_surf(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n\\n # SET UP NEW MIXING COEFFICIENT ARRAYS\\n self.Kv_surf = np.zeros([Ly,N+1])\\n self.Kt_surf = np.zeros([Ly,N+1])\\n \\n self.ghat = np.zeros([Ly,N+1])\\n \\n\\n #################################\\n # \\tSURFACE KPP\\n ################################\\n #---> j-loop\\n \\n self.wm2 = []\\n self.ws2 = []\\n self.sigma_y = []\\n for j in range(Ly):\\n #--> k-loop (top to kbl[j])\\n # in fortran k=N-1,kbl(j),-1\\n for k in range(N-1,self.kbl[j]-1,-1):\\n k_w = k\\n k_r = k-1\\n\\n Bfsfc = self.Bfsfc_bl[j]\\n zscale = z_u_w[j,N] - z_u_w[j,k_w]\\n \\n # CALCULATE TURBULENT VELOCITY SCALES\\n wm,ws = self.lmd_wscale_wm_and_ws(Bfsfc,zscale,self.ustar[j],self.hbls[j])\\n self.wm2.append(wm)\\n self.ws2.append(ws)\\n # COMPUTE VERTICAL MIXING COEFFICIENTS\\n sigma = (z_u_w[j,N] - z_u_w[j,k_w]) / np.max([self.hbls[j],self.eps])\\n self.sigma1 = sigma #for debugging\\n if j == 25: \\n self.sigma_y.append(sigma)\\n a1 = sigma - 2.\\n a2 = 3.-2.*sigma\\n a3 = sigma - 1.\\n\\n if sigma < 0.07:\\n cff = 0.5 * (sigma-0.07)**2/0.07\\n else:\\n cff = 0\\n \\n \\n if k == N-1: \\n self.wm_debug = wm\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n\\n self.Kv_surf[j,k_w] = wm * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gm1[j]+a3*self.dGm1_dS[j])))\\n\\n if k == N-1:\\n self.ws_debug = ws\\n self.hbls_debug = self.hbls[j]\\n self.cff_debug = cff\\n self.sigma_debug = sigma\\n self.a1_debug = a1\\n self.a2_debug = a2\\n self.a3_debug = a3\\n \\n self.Kt_surf[j,k_w] = ws * self.hbls[j] * ( cff + sigma * (1. + sigma * (\\\\\\n a1 + a2*self.Gt1[j]+a3*self.dGt1_dS[j])))\\n #---> end k-loop \\n if self.LMD_NONLOCAL:\\n if Bfsfc < 0:\\n self.ghat[j,k_w] = 0\\n self.ghat[j,k_w] = self.Cg * sigma * (1.-sigma)**2\\n else:\\n self.ghat[j,k_w] = 0.\\n\\n # ADD CONVECTIVE ADJUSTMENT IN SURFACE MIXED LAYER \\n if self.LMD_CONVEC and self.MLCONVEC: \\n for k in range(N-1,int(self.kbl[j]-1),-1):\\n k_w = k\\n k_r = k -1\\n\\n if self.bvf[j,k_w] < 0:\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.ffac*self.nu0c\\n\\n # ADD CONVECTIVE ADJUSTMENT BELOW SURFACE MIXED LAYER\\n # IF BKPP IS SWITCHED OFF!!\\n for k in range(int(self.kbl[j]-1),-1,-1):\\n k_w = k\\n k_r = k -1\\n if self.LMD_NONLOCAL:\\n self.ghat[j,k_w] = 0\\n if self.LMD_CONVEC and self.LMD_BKPP == False:\\n if self.bvf[j,k_w] < 0:\\n self.Kv_surf[j,k_w] = self.Kv_surf[j,k_w] + self.nu0c\\n self.Kt_surf[j,k_w] = self.Kt_surf[j,k_w] + self.nu0c\\n \\n\\n #---> end j-loop\",\n \"def weight_list_rsexecute_workflow(vis_list, model_imagelist, gcfcf=None, weighting='uniform', robustness=0.0,\\n **kwargs):\\n if gcfcf is None:\\n gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(m, oversampling=1) for m in model_imagelist]\\n \\n def grid_wt(vis, model, g):\\n if vis is not None:\\n if model is not None:\\n griddata = create_griddata_from_image(model, vis)\\n if isinstance(vis, BlockVisibility):\\n griddata = grid_blockvisibility_weight_to_griddata(vis, griddata, g[0][1])\\n else:\\n griddata = grid_visibility_weight_to_griddata(vis, griddata, g[0][1])\\n \\n return griddata\\n else:\\n return None\\n else:\\n return None\\n \\n weight_list = [rsexecute.execute(grid_wt, pure=True, nout=1)(vis_list[i], model_imagelist[i],\\n gcfcf)\\n for i in range(len(vis_list))]\\n \\n merged_weight_grid = rsexecute.execute(griddata_merge_weights, nout=1)(weight_list)\\n merged_weight_grid = rsexecute.persist(merged_weight_grid, broadcast=True)\\n \\n def re_weight(vis, model, gd, g):\\n if gd is not None:\\n if vis is not None:\\n # Ensure that the griddata has the right axes so that the convolution\\n # function mapping works\\n agd = create_griddata_from_image(model, vis)\\n agd.data = gd[0].data\\n if isinstance(vis, BlockVisibility):\\n vis = griddata_blockvisibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\\n else:\\n vis = griddata_visibility_reweight(vis, agd, g[0][1], weighting=weighting, robustness=robustness)\\n return vis\\n else:\\n return None\\n else:\\n return vis\\n \\n result = [rsexecute.execute(re_weight, nout=1)\\n (v, model_imagelist[i], merged_weight_grid, gcfcf)\\n for i, v in enumerate(vis_list)]\\n \\n return rsexecute.optimize(result)\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def compute_gain( hv, cv, thot, tcold):\\n\\n nData = len(cv) \\n epsilons = np.full( nData, EPSILON)\\n\\n # For full Temp calibration, a spectrum taken at high elevation, away from \\n # The galactic plan is used.\\n dv = hv - cv \\n dv = np.maximum( dv, epsilons)\\n hv = np.maximum( hv, epsilons)\\n\\n # use the comparison of hot and cold to get gain without trx contribution\\n gain = (thot - tcold)/dv\\n\\n trx = gain*cv \\n trx = trx - tcold # correct for cold load input in counts\\n\\n n6 = int(nData/6)\\n n56 = 5*n6\\n\\n trxmedian = np.median( trx[n6:n56])\\n gain = (thot + trxmedian)/hv\\n \\n return trxmedian, gain # channel by channel gain in K/counts\",\n \"def non_interacting_conductivity(self,\\n sigma=0.04,\\n freq_range=(0.0, 6.0, 1000),\\n imag_dielectric=False,\\n broadening='lorentz'):\\n cell_area = np.abs(float(np.cross(self.a1, self.a2)))*len(self.k_grid)\\n broad_fnc = get_broadening_function(broadening, sigma)\\n\\n frequency_grid = np.linspace(*freq_range)\\n energy_increment = np.abs(frequency_grid[1] - frequency_grid[0])\\n num_freqs, min_freq = len(frequency_grid), min(frequency_grid)\\n output_grid = np.zeros(num_freqs)\\n\\n energy_power = 1 + int(imag_dielectric)\\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\\n prefactor = prefactor/cell_area\\n\\n # Assuming x polarisation for now\\n position_dipole_matrix = self.construct_position_dipole_matrix()\\n\\n n_shift = self.n_spins*self.n_orbs\\n for idx1, kpt in enumerate(self.k_grid):\\n for s0 in range(self.n_spins):\\n velocity_matrix = self.load_velocity_matrix(idx1)\\n bands = self.exciton_obj.get_number_conduction_valence_bands(\\n idx1, s0\\n )\\n v_num, c_num = bands\\n eigvals = np.array(\\n self.file_storage['eigensystem']['eigenvalues'][idx1]\\n )\\n\\n j1 = n_shift*idx1 + (self.n_spins - 1)*s0*self.n_orbs\\n j2 = j1 + self.n_orbs\\n eigvecs = np.array(\\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\\n )\\n for v, c in product(range(v_num), range(c_num)):\\n cb_vector = eigvecs[:, v_num + c]\\n vb_vector = eigvecs[:, v]\\n cb_energy, vb_energy = eigvals[v_num + c], eigvals[v]\\n energy_diff = (cb_energy - vb_energy)\\n\\n energy_diff_pow = energy_diff**energy_power\\n matrix_elem = velocity_matrix_element(vb_vector,\\n cb_vector,\\n velocity_matrix)\\n if self.use_dipole_term:\\n position_dipole_term = get_position_dipole_element(\\n vb_vector,\\n cb_vector,\\n vb_energy,\\n cb_energy,\\n position_dipole_matrix\\n )\\n matrix_elem = matrix_elem + position_dipole_term\\n\\n main_term = np.abs(matrix_elem)**2/energy_diff_pow\\n closest_idx = (energy_diff - min_freq)//energy_increment\\n idx_reach = self.reach_multiplier*(sigma//energy_increment)\\n\\n lower_idx = max([closest_idx - idx_reach, 0])\\n upper_idx = min([closest_idx + idx_reach, num_freqs - 1])\\n\\n for idx2 in range(int(lower_idx), int(upper_idx)):\\n smearing = broad_fnc(energy_diff, frequency_grid[idx2])\\n output = prefactor*main_term*smearing\\n output_grid[idx2] += output\\n\\n return frequency_grid, output_grid\",\n \"def one_iteration_step(self, tsm, tank, chp, kessel, cvalve, heizkurve, t_a, el_heat_status, actual_time, heatc_conf):\\n #print('\\\\n chp = {}; kessel = {}; t2 = {}; t3 = {}'.format(chp.get_status(), kessel.get_status(), self.t2, self.t3))\\n # combined heat and power unit - link outputs\\n wyn = chp.get_chp()\\n #self.t27 = wyn[1] # tin in °C = self.t1 = wyn[t1]\\n self.t26 = wyn[2] # tout in °C = chp.get_out_temp = wyn[2]\\n m3 = wyn[3] # mstr in kg/s \\n self.V_3 = m3 / utils.rho_fluid_water(self.t26, self.p_atm, 1) # volume flow incoming to chp from tank\\n V_chp = chp.get_volume_flow_at_output() # volume flow outoming from chp into tank\\n # combined heat and power unit - link inputs\\n chp.set_inp_temp(self.t27) # temperature incoming from tank to chp\\n\\n # ..............................................................\\n\\n # gas boiler - link outputs\\n wyn = kessel.get_kessel()\\n #self.t29 = wyn[1] # tin in °C - incoming into gas heater\\n self.t28 = wyn[2] # tout in °C - outcoming from gas heater\\n m4 = wyn[3] # mstr in kg/s - incoming into gas heater\\n self.V_4 = kessel.get_volume_flow_at_input()\\n V_kessel = kessel.get_volume_flow_at_output()\\n # gas boiler - link inputs\\n kessel.set_inp_temp(self.t29)\\n #kessel.calc_mass_flow()\\n\\n # ..............................................................\\n # at first no delay - just linking chp and heater\\n # delay due to the seuence of commands ie equal to the Timestep length\\n self.t27 = self.t1\\n self.t29 = self.t1\\n # ..............................................................\\n\\n # heating circuit\\n self.t23 = self.t20 # no delay assumed\\n #print('t20 = {}; t23 = {}'.format(self.t20, self.t23))\\n self.t25 = heizkurve.get_supply_temperature(t_a)\\n self.t24 = heizkurve.get_return_temperature(t_a)\\n heizkurve.calc_volume_flow()\\n\\n # comprehensive control algorithm - it stays\\n (m23, m25, m4) = self.control_internal_1(heizkurve, kessel, chp, cvalve, t_a, actual_time, m4, heatc_conf)\\n\\n m_bypass = m25 - m23\\n rho23 = utils.rho_fluid_water(self.t23, self.p_atm, 1)\\n V_23 = m23 / rho23 # in m3/s = kg/s / kg/m3\\n #print('V_23 = {}; m23 = {}; rho23 = {}; t23 = {}'.format(V_23,m23, rho23, self.t23))\\n m24 = m23\\n rho24 = utils.rho_fluid_water(self.t24, self.p_atm, 1)\\n V_24 = m24 / rho24\\n \\n # demand for domestic hot water\\n m22 = self.V_1 * utils.rho_fluid_water(self.t22, self.p_atm, 1) # in kg/s = m3/s * kg/m3\\n #m22 = 0.01 # kg/s\\n # ..............................................................\\n\\n t_ambient = 15.0\\n # storage tank - calculation\\n tank.calculate_storage_tank_obj(tsm, # time step manager\\n self.t23, # hk_inp_temp\\n V_23, # hk_inp_volfl_m3s\\n self.t24, # hk_out_temp\\n self.t27, # chp_inp_temp\\n self.t26, # chp_out_temp\\n self.V_3, # chp_inp_volfl_m3s\\n self.t29, # gb_inp_temp\\n self.t28, # gp_out_temp\\n self.V_4, # gb_inp_volfl_m3s\\n self.t22, # dhw_inp_temp\\n self.t21, # dhw_out_temp\\n self.V_1, # dhw_inp_volfl_m3s\\n el_heat_status, # el_heat_status\\n actual_time, # time in the timestamp format\\n t_ambient) # ambient temperature of the tank - defines heat losses to the outside\\n \\n self.t21 = tank.get_temp_dhw()\\n #self.t27 = \\n #self.t29 = \\n #self.t23 = \\n \\n # storage tank - linking\\n [self.t1, self.t2, self.t3, self.t4, self.t5, self.t6, self.t7, self.t8, self.t9, self.t10, \\n self.t11, self.t12, self.t13, self.t14, self.t15, self.t16, self.t17, self.t18, self.t19, self.t20] = tank.output_temperatures()\\n\\n # ..............................................................\\n # get rid of this part\\n #self.control_internal_2(chp, kessel, actual_time, m4)\\n # ..............................................................\\n heizwert_in_MJ_per_kg = 50.0 # kg/m3 N ~CH4\\n gas_density = 0.79 # kg/m3 N ~Erdgas\\n Z_boiler = kessel.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\\n self.Z_2 = chp.get_gas_mstr(heizwert_in_MJ_per_kg) / gas_density\\n self.Z_1 = self.Z_2 + Z_boiler\\n \\n self.Wh1 = -1.0 * chp.get_el_prod()\\n self.Wh2 = tank.get_el_heater_consumption()\\n self.Wh3 = self.Wh1 + self.Wh2 + self.electricity_consumption_kWh\\n #print('END chp = {}; kessel = {}; heating = {}; t2 = {}; t3 = {};V1 = {}; V2 = {}; V3 = {}; V4 = {}; t_a = {}'.format(chp.get_status(), kessel.get_status(), heizkurve.get_status(), self.t2, self.t3, self.V_1, self.V_2, self.V_3, self.V_4, t_a))\",\n \"def vote_for_k(utilities, k):\\n utilities = np.asarray(utilities)\\n n_cands = utilities.shape[1]\\n if k == 'half':\\n # \\\"It is interesting to observe that the vote-for-k and vote-for-(n-k)\\n # voting systems are equally effective.\\\"\\n # So for 7 candidates, we could use either k=4 or k=3 (= 7//2)\\n # TODO: Though this seems only true with infinite voters?\\n k = n_cands // 2\\n elif -n_cands < k < 0:\\n k = n_cands + k\\n elif not 0 < k < n_cands:\\n raise ValueError(f'k of {k} not possible with {n_cands} candidates')\\n\\n # Efficiently get indices of top k candidates for each voter\\n # https://stackoverflow.com/a/23734295/125507\\n # TODO: How are tied utilities handled, such as top 2 with 3 tied? Random?\\n top_k = np.argpartition(utilities, -k, axis=1)[:, -k:]\\n\\n # Create blank ballots\\n approvals = np.zeros(utilities.shape, np.uint8)\\n\\n # Fill in approvals\\n # TODO: Not sure if this is the most efficient way\\n approvals[np.arange(len(approvals))[:, np.newaxis], top_k] = 1\\n return approvals\",\n \"def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\\n\\n # def Q_gen(I, R):\\n # w = I * I * R\\n # return w\\n\\n # def Q_rad_in(I_sun, A_s, a_s):\\n # w = I_sun * D * a_s\\n # return w\\n\\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\\n # w = htcoeff * A_s * (T_line - T_amb)\\n # return w\\n\\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\\n # return w\\n\\n def reynolds(V, D, v, Mair=1.103):\\n r = V * D / v\\n return r\\n\\n def nusselt(Re, Pr):\\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\\n c = (Re / 282000) ** (5.0/8.0)\\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\\n return n\\n\\n def air_prop(T_amb):\\n # temp v k Pr\\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\\n [250, 11.44e-6, 22.3e-3, 0.720],\\n [300, 15.89e-6, 26.3e-3, 0.707],\\n [350, 20.92e-6, 30.0e-3, 0.700],\\n [400, 26.41e-6, 33.8e-3, 0.690],\\n [450, 32.39e-6, 37.3e-3, 0.686],\\n [500, 38.79e-6, 40.7e-3, 0.684],\\n [550, 45.57e-6, 43.9e-3, 0.683],\\n [600, 52.69e-6, 46.9e-3, 0.685]])\\n\\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\\n 0, air_prop[:,1:])\\n return v, k, Pr\\n\\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\\n if 273 <= T_line <= 323:\\n R = ((R_lo + \\n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\\n *(T_line - T_range[0]))/N_cond)\\n elif T_line > 323:\\n R = ((R_mid + \\n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\\n *(T_line - T_range[1]))/N_cond)\\n else:\\n R = R_lo\\n print('Out of bounds')\\n return R\\n\\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\\n temp_factor = 1\\n wind_factor = 1\\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\\n\\n T_amb = T_amb*temp_factor\\n V = V*wind_factor\\n\\n v, k, Pr = air_prop(T_amb)\\n Re = reynolds(V, D, v)\\n htcoeff = nusselt(Re, Pr) * k / D\\n\\n def T_line(T_init):\\n \\n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\\n print R\\n\\n C4 = e_s * sigma * D * math.pi\\n C3 = 0.0\\n C2 = 0.0\\n C1 = htcoeff * D * math.pi\\n C0 = - ( I ** 2 * R\\n + I_sun * a_s * D\\n + htcoeff * D * math.pi * T_amb\\n + e_s * D * math.pi * sigma * (T_amb ** 4))\\n\\n return np.roots([C4, C3, C2, C1, C0])\\n\\n T_c = T_amb\\n \\n for i in range(n_iter):\\n T_arr = T_line(T_c)\\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\\n print T_c\\n\\n return T_c\",\n \"def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n pad=np.random.rand(nspad)/100\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_norm_padded=np.hstack((pad,trc_norm))\\n trc_entropy=self.entropy(trc_norm_padded,50)\\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\\n for i,j in enumerate(trc):\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def hcn_tf(Y,t,voltage_clamp_func,voltage_clamp_params):\\n \\n v = voltage_clamp_func(t,voltage_clamp_params)\\n n_s = Y[0]\\n n_f = Y[1]\\n \\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\\n ninf_f = ninf_s\\n\\n if v > -70.0:\\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\\n else:\\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\\n\\n dns = (ninf_s - n_s)/tau_ns\\n dnf = (ninf_f - n_f)/tau_nf\\n \\n return [dns, dnf]\",\n \"def init_kern_act(num_pitches):\\n\\n kern_act = []\\n\\n for i in range(num_pitches):\\n kern_act.append(Matern32(1, lengthscales=1.0, variance=3.5))\\n return kern_act\",\n \"def ridge_joint(trn_fs,trn_data,alphas,val_fs=None,val_data=None,square_alphas=False,chunk_sz=5000,is_verbose=True):\\n\\n n_resp, n_voxels = trn_data.shape\\n n_channels = np.sum([tfs.shape[1] for tfs in trn_fs])\\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\\n\\n if square_alphas:\\n alphas = [a**2 for a in alphas]\\n\\n num_train_points = float(list(trn_data.shape)[0])\\n num_val_points = float(list(val_data.shape)[0])\\n\\n n_abc = [np.minimum(*t_fs.shape) for t_fs in trn_fs]\\n ######################################################################################\\n ### --- First up: compute modified covariance matrix & scaled/rotated stimulus --- ###\\n ######################################################################################\\n # Perform SVD on training sets for all three models \\n if is_verbose:\\n print(\\\"computing SVD\\\")\\n U_trn,W_trn,Vt_trn = [],[],[]\\n for t_fs in trn_fs:\\n uu,ww,vv = np.linalg.svd(trn_stim_A, full_matrices=False)\\n U_trn.append(uu)\\n W_trn.append(ww)\\n Vt_trn.append(vv)\\n\\n # The square of Ws (the singular values from the SVD) are the eigenvalues of the covariance matrix but have not been divided by n-1.\\n L = [ww**2/float(num_train_points-1) for ww in W_trn]\\n\\n ### --- IDK WTF. Ask Wendino. --- ###\\n ## to change: make sure that Ws are in the right units (divided by n-1) when bootstrapping, so that alphas are already in correct units\\n ## at that point you can change the lines below and not divide alpha by (n-1)\\n # TO DO: make this more than one line for clarity.\\n w_alpha_trn = [np.diag(np.sqrt(1./(LL + aa)/(num_train_points-1))) for LL,aa in zip(L,alphas)]\\n #w1_alpha_trn = sqrt(1./(L1+ alphas_A2[0]/(num_train_points-1))) \\n #w1_alpha_trn = diag(w1_alpha_trn) #%turn it from an array to a matrix\\n\\n # Create & combine rotated & scaled stimulus space \\n X_prime_trn_t = [ww.dot(vv).dot(t_fs) for ww,vv,t_fs in zip(W_trn,Vt_trn,trn_fs)]\\n #S1_prime_trn_t = np.dot(np.dot(w1_alpha_trn, Vt1_trn), trn_stim_A.T) #w1_alpha_trn = 1200x1200, Vt1_trn = 1200x1200, trn_stim_A.T = 1200x3737\\n Xcomb_prime_trn_t = np.vstack(X_prime_trn_t)\\n\\n # Create & modify covariance matrix\\n stim_cov_mat_r = X_prime_trn_t.dot(X_prime_trn_t.T) / float(num_train_points-1)\\n cov_diag = np.sqrt(np.diag(stim_cov_mat_r))\\n full_mat_cov_diag = np.tile(cov_diag, [cov_diag.shape[0], 1])\\n # re-do w/ simpler syntax?\\n all_divisor = np.multiply(full_mat_cov_diag.T, full_mat_cov_diag) \\n corr_mat_r = np.divide(stim_cov_mat_r, all_divisor)\\n\\n ### --- Clean up the correlation matrix to have zeros where we know they exist and use that data to set a threshold --- ###\\n idx_ct = np.cumsum([0]+n_abc)\\n idxs = [(a,b) for a,b in zip(idx_ct[:-1],idx_ct[1:])]\\n # Block diagonal components of covariance matrix\\n for n,(ii,jj) in zip(n_abc,idxs):\\n corr_mat_r[ii:jj] = np.eye(n)\\n # Off-diagonal elements: ignore for now? \\n #for i1,i2 in zip(idxs[:-1],idxs[1:]):\\n # (ii,jj),(kk,ll) = i1,i2\\n \\n\\n # ##### --- WORKING HERE - SEE IPYTHON NOTEBOOK --- #########\\n # upper_right_corr = np.ravel(corr_mat_r[0:nA, nA:])\\n # middle_right_corr = np.ravel(corr_mat_r[nA:(nA+nB),(nA+nB):])\\n # right_corr = np.hstack([upper_right_corr, middle_right_corr])\\n # s_right_corr = argsort(right_corr)\\n # # WTF is this?\\n # #corr_cutoff = 954 # WH magic number; something to do with the fact that it's needless to have \\n # # ALL the block-diagonal diagonals, since we have limited data\\n # #goodcorrs_idx = np.hstack([s_right_corr[0:corr_cutoff], s_right_corr[-1:-(corr_cutoff+1):-1]])\\n\\n # new_right_corrs = np.squeeze(np.zeros([s_right_corr.shape[0],1]))\\n # #new_right_corrs[goodcorrs_idx] = right_corr[goodcorrs_idx]\\n # new_upper_right_corrs = np.reshape(new_right_corrs[0:(nB+nC)*nA],[nA,nB+nC])\\n # new_lower_left_corrs = new_upper_right_corrs.T\\n # new_middle_right_corrs = np.reshape(new_right_corrs[(nB+nC)*nA:],[nB,nC])\\n # new_middle_left_corrs = new_middle_right_corrs.T\\n\\n # ##NEED TO CHANGE THIS: REMOVE HARDCODED MATRIX SIZES\\n # new_corr_mat_r = copy.copy(corr_mat_r)\\n # new_corr_mat_r[0:nA, nA:]= new_upper_right_corrs\\n # new_corr_mat_r[nA:(nA+nB), (nA+nB):] = new_middle_right_corrs\\n # new_corr_mat_r[(nA+nB):, nA:(nA+nB)]= new_middle_left_corrs # More like bottom middle\\n # new_corr_mat_r[nA:,0:nA] = new_lower_left_corrs # \\n # new_corr_mat_r[0:nA,0:nA]= np.identity(nA)\\n # new_corr_mat_r[nA:(nA+nB), nA:(nA+nB)] = np.identity(nB)\\n # new_corr_mat_r[(nA+nB):,(nA+nB):] = np.identity(nC)\\n\\n #perform eigenvalue decomposition (WHAT FOR? delete this?)\\n #w, v = np.linalg.eigh(new_corr_mat_r)\\n # Invert modified covariance matrix\\n #corr_r_inv = np.linalg.inv(new_corr_mat_r)\\n corr_r_inv = np.linalg.inv(corr_mat_r)\\n #for \\n ##create filter\\n dot1 = np.dot(X_prime_trn_t, trn_data) #precompute for speed\\n dot2 = np.dot(corr_r_inv, dot1) #precompute for speed\\n # Weights\\n h_123_prime = np.divide(dot2, (float(num_train_points-1)))\\n\\n\\n ##create estimated responses from training data\\n #r_hat = np.dot(X_prime_trn_t.T, h_123_prime) # not usually done...\\n #if do_pred:\\n #validation set results\\n val_stim_A_prime = np.dot(np.dot(w1_alpha_r, Vt1_r), val_stim_A.T)\\n val_stim_B_prime = np.dot(np.dot(w2_alpha_r, Vh2_r), val_stim_B.T)\\n val_stim_C_prime = np.dot(np.dot(w3_alpha_r, Vh3_r), val_stim_C.T)\\n #S1_prime = S1_prime[0:200,:]\\n #S2_prime = S2_prime[0:200,:]\\n\\n S123_val_prime_t = np.vstack([val_stim_A_prime, val_stim_B_prime, val_stim_C_prime])\\n\\n #create validation set correlations\\n r_hat_val = np.dot(S123_val_prime_t.T, h_123_prime)\\n\\n\\n #look at performance\\n valcorr = _sutils.column_corr(r_hat_val, val_data)\\n out = dict(\\n #weights=wt,\\n #alphas=alphas,\\n #n_sig_vox_byalpha=n_sig_vox_byalpha,\\n cc=valcorr\\n )\\n return out\",\n \"def hcn_kn(Y,t,voltage_clamp_func,voltage_clamp_params):\\n\\n v = voltage_clamp_func(t,voltage_clamp_params)\\n n_s = Y[0]\\n n_f = Y[1]\\n\\n ninf_s = 1/(1 + np.exp((v+87.2)/9.7))\\n ninf_f = ninf_s\\n\\n if v > -70.0:\\n tau_ns = 300.0 + 542.0 * np.exp((v+25.0)/20.0)\\n tau_nf = 140.0 + 50.0 * np.exp(-(v+25.0)/20.0)\\n else:\\n tau_ns = 2500.0 + 100.0 * np.exp((v+240.0)/50.0)\\n tau_nf = 250.0 + 12.0 * np.exp((v+240.0)/50.0)\\n\\n dns = (ninf_s - n_s)/tau_ns\\n dnf = (ninf_f - n_f)/tau_nf\\n\\n return [dns, dnf]\",\n \"def fit_full(self,K):\\r\\n #Initial values - Posterior distribution parameters: q(f|X,Y) = N(f|mu,Sigma)\\r\\n mu = np.zeros(self.N)\\r\\n Sigma = K.copy()\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n Initial values - Cavity distribution parameters:\\r\\n q_(f|mu_,sigma2_) = Product{q_i(f|mu_i,sigma2_i)}\\r\\n sigma_ = 1./tau_\\r\\n mu_ = v_/tau_\\r\\n \\\"\\\"\\\"\\r\\n self.tau_ = np.empty(self.N,dtype=float)\\r\\n self.v_ = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Initial values - Marginal moments\\r\\n z = np.empty(self.N,dtype=float)\\r\\n self.Z_hat = np.empty(self.N,dtype=float)\\r\\n phi = np.empty(self.N,dtype=float)\\r\\n mu_hat = np.empty(self.N,dtype=float)\\r\\n sigma2_hat = np.empty(self.N,dtype=float)\\r\\n\\r\\n #Approximation\\r\\n epsilon_np1 = self.epsilon + 1.\\r\\n epsilon_np2 = self.epsilon + 1.\\r\\n \\tself.iterations = 0\\r\\n self.np1 = [self.tau_tilde.copy()]\\r\\n self.np2 = [self.v_tilde.copy()]\\r\\n while epsilon_np1 > self.epsilon or epsilon_np2 > self.epsilon:\\r\\n update_order = np.random.permutation(self.N)\\r\\n for i in update_order:\\r\\n #Cavity distribution parameters\\r\\n self.tau_[i] = 1./Sigma[i,i] - self.eta*self.tau_tilde[i]\\r\\n self.v_[i] = mu[i]/Sigma[i,i] - self.eta*self.v_tilde[i]\\r\\n #Marginal moments\\r\\n self.Z_hat[i], mu_hat[i], sigma2_hat[i] = self.noise_model_list[self.index[i]].moments_match(self._transf_data[i],self.tau_[i],self.v_[i])\\r\\n #Site parameters update\\r\\n Delta_tau = self.delta/self.eta*(1./sigma2_hat[i] - 1./Sigma[i,i])\\r\\n Delta_v = self.delta/self.eta*(mu_hat[i]/sigma2_hat[i] - mu[i]/Sigma[i,i])\\r\\n self.tau_tilde[i] += Delta_tau\\r\\n self.v_tilde[i] += Delta_v\\r\\n #Posterior distribution parameters update\\r\\n DSYR(Sigma,Sigma[:,i].copy(), -float(Delta_tau/(1.+ Delta_tau*Sigma[i,i])))\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n self.iterations += 1\\r\\n #Sigma recomptutation with Cholesky decompositon\\r\\n Sroot_tilde_K = np.sqrt(self.tau_tilde)[:,None]*K\\r\\n B = np.eye(self.N) + np.sqrt(self.tau_tilde)[None,:]*Sroot_tilde_K\\r\\n L = jitchol(B)\\r\\n V,info = dtrtrs(L,Sroot_tilde_K,lower=1)\\r\\n Sigma = K - np.dot(V.T,V)\\r\\n mu = np.dot(Sigma,self.v_tilde)\\r\\n epsilon_np1 = sum((self.tau_tilde-self.np1[-1])**2)/self.N\\r\\n epsilon_np2 = sum((self.v_tilde-self.np2[-1])**2)/self.N\\r\\n self.np1.append(self.tau_tilde.copy())\\r\\n self.np2.append(self.v_tilde.copy())\\r\\n\\r\\n return self._compute_GP_variables()\",\n \"def demo3(image_paths, arch, topk, stride, n_batches, output_dir, cuda):\\n\\n device = get_device(cuda)\\n\\n # Synset words\\n classes = get_classtable()\\n\\n # Model from torchvision\\n model = models.__dict__[arch](pretrained=True)\\n model = torch.nn.DataParallel(model)\\n model.to(device)\\n model.eval()\\n\\n # Images\\n images, _ = load_images(image_paths)\\n images = torch.stack(images).to(device)\\n\\n print(\\\"Occlusion Sensitivity:\\\")\\n\\n patche_sizes = [10, 15, 25, 35, 45, 90]\\n\\n logits = model(images)\\n probs = F.softmax(logits, dim=1)\\n probs, ids = probs.sort(dim=1, descending=True)\\n\\n for i in range(topk):\\n for p in patche_sizes:\\n print(\\\"Patch:\\\", p)\\n sensitivity = occlusion_sensitivity(\\n model, images, ids[:, [i]], patch=p, stride=stride, n_batches=n_batches\\n )\\n\\n # Save results as image files\\n for j in range(len(images)):\\n print(\\\"\\\\t#{}: {} ({:.5f})\\\".format(j, classes[ids[j, i]], probs[j, i]))\\n\\n # save_sensitivity(\\n # filename=osp.join(\\n # output_dir,\\n # \\\"{}-{}-sensitivity-{}-{}.png\\\".format(\\n # j, arch, p, classes[ids[j, i]]\\n # ),\\n # ),\\n # maps=sensitivity[j],\\n # )\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\n \"def model(**params):\\n N_frb = 0\\n vs = []\\n hs = []\\n cs = []\\n ncands = []\\n\\n for cand in candlist:\\n c_res = calculate_metric_terms(\\n cand, cluster_function=cluster_function, debug=False, plot=False, **params\\n )\\n t, frb_found, h, c, v = c_res\\n vs.append(v)\\n hs.append(h)\\n cs.append(c)\\n ncands.append(t)\\n\\n if frb_found:\\n N_frb += 1\\n\\n vs = np.array(vs)\\n hs = np.array(hs)\\n cs = np.array(cs)\\n c_avg = np.average(cs, axis=0, weights=ncands)\\n h_avg = np.average(hs, axis=0, weights=ncands)\\n v_avg = np.average(vs, axis=0, weights=ncands)\\n recall = N_frb / len(vs)\\n score = v_avg * recall\\n\\n return score\",\n \"def ghosal_edge(img,Ks,thr=1,thrmax=0.995,lmin = 0.5,phimin=1.4,thresholding=True, debug=False):\\n\\ttotaltime = time.time()\\n\\tkerneltime = time.time()\\n\\t# Ks must be odd\\n\\tif Ks%2 != 1:\\n\\t\\tprint(\\\"Ks must be odd! Continuing with Ks = Ks-1\\\")\\n\\t\\tKs = Ks-1\\n\\t# define the rectangular kernels\\n\\t#Vc00 = np.zeros((Ks,Ks),dtype=complex)\\n\\tVc11 = np.zeros((Ks,Ks),dtype=complex)\\n\\tVc20 = np.zeros((Ks,Ks),dtype=complex)\\n\\tofs = 1 *(1-1/Ks) # offset for centering kernel around 0,0\\n\\tfor i in range(Ks):\\n\\t\\tfor j in range(Ks):\\n\\t\\t\\tKx = 2*j/Ks-ofs # limits of integration between -1 and 1\\n\\t\\t\\tKy = 2*i/Ks-ofs\\n\\t\\t\\tif Kx**2+Ky**2 <= 1: # only a circle\\n\\t\\t\\t\\t#Vc00[i,j] = 1 # the conjugate of V00\\n\\t\\t\\t\\tVc11[i,j] = Kx-Ky*1j # ...\\n\\t\\t\\t\\tVc20[i,j] = 2*Kx**2+2*Ky**2-1\\n\\tkerneltime = time.time() - kerneltime\\n\\t\\n\\t# Kernel Plots\\n\\t#\\tVCplot = Vc00\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Vc11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Vc20\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real w K Vc20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag w K Vc20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\t# do the convolution with the images to get the zernike moments\\n\\tAnorm = lambda n : (n+1)/np.pi\\t# a normalization value\\n\\tconvolvetime = time.time()\\n\\t#A00 = scig.convolve2d(img,Vc00,mode='same')\\n\\t#\\tA11 = Anorm(1)*scig.convolve2d(img,Vc11,mode='same')\\n\\t#\\tA20 = Anorm(2)*scig.convolve2d(img,Vc20,mode='same')\\n\\tA11 = Anorm(1)*scig.oaconvolve(img,Vc11,mode='same')\\n\\tA20 = Anorm(2)*scig.oaconvolve(img,Vc20,mode='same')\\n\\tconvolvetime = time.time() - convolvetime\\n\\t# Plot Zernike moments\\n\\t#\\tVCplot = A00\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A00\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = A11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = A20\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A20\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\tparamstime = time.time()\\n\\t# calculate the edge paramters\\n\\t#\\ttanphi = np.imag(A11)/np.real(A11)\\n\\t#\\tphi = np.arctan(tanphi)\\n\\t#\\tcosphi = np.cos(phi)\\n\\t#\\tsinphi = cosphi*tanphi\\n\\t#\\tAl11 = np.real(A11)*cosphi+np.imag(A11)*sinphi\\n\\t\\n\\tphi = np.arctan(np.imag(A11)/np.real(A11))\\n\\tAl11 = np.real(A11)*np.cos(phi)+np.imag(A11)*np.sin(phi)\\n\\t\\n\\t#\\tAl11 = A11*np.exp(-phi*1j)\\n\\tl = A20/Al11 # A20 has no imaginary component so A20 = A'20\\n\\n\\tk = 3*Al11/(2*(1-l**2)**(3/2))\\n\\tparamstime = time.time() - paramstime\\n\\t\\n\\t# Plot edge paramters\\n\\t#\\tVCplot = phi\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real phi\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag phi\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = Al11\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real A\\\\'11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag A\\\\'11\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = l\\n\\t#\\tplt.pcolormesh(np.real(VCplot))#,vmin=-5,vmax=5\\n\\t#\\tplt.title(\\\"real l\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot)) # ,vmin=-5,vmax=5\\n\\t#\\tplt.title(\\\"imag l\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tVCplot = k\\n\\t#\\tplt.pcolormesh(np.real(VCplot))\\n\\t#\\tplt.title(\\\"real k\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t#\\tplt.pcolormesh(np.imag(VCplot))\\n\\t#\\tplt.title(\\\"imag k\\\")\\n\\t#\\tplt.colorbar()\\n\\t#\\tplt.show()\\n\\t\\n\\t\\n\\ttreattime = time.time()\\n\\tif thresholding==True:\\n\\t\\t# do the thresholding\\n\\t\\tif (thrmax<0)&(thr>0):\\n\\t\\t\\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])\\n\\t\\telif thrmax>0:\\n\\t\\t\\tknorm = np.sort(k.flatten())[[int(thr*np.size(k)),int(thrmax*np.size(k))]]\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)&(abs(k)>knorm[0])&(abs(k)<knorm[1])\\n\\t\\telif thr<0:\\n\\t\\t\\tidx = (abs(l)<lmin)&(abs(phi)>phimin)\\n\\t\\t\\tknorm = np.sort(k[idx].flatten())[int(thr)]\\n\\t\\t\\tidx = idx&(abs(k)>abs(knorm))\\n\\t\\tne = np.sum(idx)\\n\\telif thresholding==False:\\n\\t\\traise ValueError(\\\"this option is not still uncer development\\\")\\n\\t\\t# no thresholding\\n\\t\\tidx = np.ones(np.shape(l),dtype=bool)\\n\\t\\tne =np.sum(idx)\\n\\telse:\\n\\t\\traise ValueError(\\\"thresholding should be boolean\\\")\\n\\t\\n\\t# put all detected points in a vector of (x,y) values\\n\\tedg = np.zeros((ne,2))\\n\\torg = np.zeros((ne,2))\\n\\tnx,ny = np.shape(img)\\n\\te = 0\\n\\tfor i in range(nx):\\n\\t\\tfor j in range(ny):\\n\\t\\t\\tif idx[i,j]:\\n\\t\\t\\t\\tedg[e]=np.array([i,j]) + l[i,j]*Ks/2*np.array(\\n\\t\\t\\t\\t\\t[np.sin(phi[i,j]),-np.cos(phi[i,j])])\\n\\t\\t\\t\\torg[e]=np.array([i,j])\\n\\t\\t\\t\\te +=1\\n\\ttreattime = time.time() - treattime\\n\\ttotaltime = time.time() - totaltime\\n\\tprint(\\\"total %0.5f\\tconvolution %0.5f\\tthresholding %0.5f\\tparamters %0.5f\\tkernel %0.5f\\\"%(totaltime,convolvetime,treattime,paramstime,kerneltime))\\n\\t\\n\\tif debug==True:\\n\\t\\treturn edg, org, k, l, phi\\n\\telse:\\n\\t\\treturn edg, org\",\n \"def init():\\n\\tN = np.int32(DIM) #prepare for stitching\\n\\t#HII_DIM = np.int32(HII_DIM)\\n\\tf_pixel_factor = DIM/HII_DIM;\\n\\tscale = np.float32(BOX_LEN)/DIM\\n\\tHII_scale = np.float32(BOX_LEN)/HII_DIM\\n\\tshape = (N,N,N)\\n\\t\\n\\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\\n\\n\\tkernel_source = open(cmd_folder+\\\"/initialize.cu\\\").read()\\n\\tkernel_code = kernel_source % {\\n\\n\\t\\t'DELTAK': DELTA_K,\\n\\t\\t'VOLUME': VOLUME,\\n\\t\\t'DIM': DIM\\n\\t}\\n\\tmain_module = nvcc.SourceModule(kernel_code)\\n\\tinit_kernel = main_module.get_function(\\\"init_kernel\\\")\\n\\tHII_filter = main_module.get_function(\\\"HII_filter\\\")\\n\\tadj_complex_conj = main_module.get_function(\\\"adj_complex_conj\\\")\\n\\tsubsample_kernel = main_module.get_function(\\\"subsample\\\")\\n\\tvelocity_kernel = main_module.get_function(\\\"set_velocity\\\")\\n\\tpspec_texture = main_module.get_texref(\\\"pspec\\\")\\n\\n\\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\\n\\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\\n\\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\\n\\n\\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\\n\\tinit_kernel(largebox_d, np.int32(DIM), block=block_size, grid=grid_size)\\n\\n\\t#import IPython; IPython.embed()\\n\\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\\n\\tinit_kernel(largebox_d_imag, np.int32(DIM), block=block_size, grid=grid_size)\\n\\n\\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\\n\\n\\t#adj_complex_conj(largebox_d, DIM, block=block_size, grid=grid_size)\\n\\tlargebox = largebox_d.get()\\n\\t#np.save(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc\\\".format(DIM, BOX_LEN), largebox)\\n\\n\\t#save real space box before smoothing\\n\\tplan = Plan(shape, dtype=np.complex64)\\n\\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\tlargebox_d /= scale**3\\n\\tnp.save(parent_folder+\\\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(DIM, BOX_LEN), largebox_d.real.get_async())\\n\\n\\t#save real space box after smoothing and subsampling\\n\\t# host largebox is still in k space, no need to reload from disk\\n\\tlargebox_d = gpuarray.to_gpu(largebox)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tHII_filter(largebox_d, N, ZERO, smoothR, block=block_size, grid=grid_size);\\n\\tplan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\tlargebox_d /= scale**3\\n\\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\\n\\tsubsample_kernel(largebox_d.real, smallbox_d, N, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_grid_size) #subsample in real space\\n\\tnp.save(parent_folder+\\\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(HII_DIM, BOX_LEN), smallbox_d.get_async())\\n\\n\\t# reload the k-space box for velocity boxes\\n\\tlargebox_d = gpuarray.to_gpu(largebox)\\n\\t\\n\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tlargevbox_d = gpuarray.zeros((DIM,DIM,DIM), dtype=np.complex64)\\n\\tsmallbox_d = gpuarray.zeros(HII_shape, dtype=np.float32)\\n\\tfor num, mode in enumerate(['x', 'y', 'z']):\\n\\t\\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(num), block=block_size, grid=grid_size)\\n\\t\\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=grid_size)\\n\\t\\tplan.execute(largevbox_d, inverse=True)\\n\\t\\tlargevbox_d /= scale**3\\n\\t\\t#import IPython; IPython.embed()\\n\\t\\tsubsample_kernel(largevbox_d.real, smallbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_grid_size)\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\\\".format(mode, HII_DIM, BOX_LEN), smallbox_d.get())\\n\\n\\treturn\",\n \"def normal_modes_gHST(R, NL, KL, params, dispersion=[], spin_dir=[], sublattice_labels=[], b='hang', spring='auto',\\n pin='auto'):\\n try:\\n NP, NN = np.shape(NL)\\n except:\\n '''There is only one particle.'''\\n NP = 1\\n NN = 0\\n\\n M1 = np.zeros((2 * NP, 2 * NP))\\n M2 = np.zeros((2 * NP, 2 * NP))\\n if spring == 'auto':\\n spring = params['k'] * params['l'] ** 2 / (params['I3'] * np.abs(params['w3']))\\n # If there is more than one particle, and if the speeds vary from particle to particle,\\n # then make spring the same length as a dynamical matrix column\\n if len(spring) > 0:\\n if (abs(spring - spring[0]) > 1e-9).any():\\n # The rotation rates vary from particle to particle, so reshape\\n spring_new = np.zeros_like(spring)\\n dmyi = 0 # a new index ('dummy i')\\n for ii in range(NP):\\n # Since 2 dof for position of pivot of gHST, double the size\\n spring_new[dmyi] = spring[ii]\\n spring_new[dmyi + 1] = spring[ii]\\n dmyi += 2\\n else:\\n # the elements are all identical, so just keep the first one\\n spring = spring[0]\\n\\n if pin == 'auto':\\n gn = params['Mm'] * params['g']\\n pin = params['l'] * gn / (params['I3'] * np.abs(params['w3']))\\n # If there is more than one particle, and if the speeds vary from particle to particle,\\n # then make pin the same length as a dynamical matrix column\\n if len(pin) > 0:\\n if (abs(pin - pin[0]) > 1e-9).any():\\n # The rotation rates vary from particle to particle, so reshape\\n pin_new = np.zeros_like(pin)\\n dmyi = 0 # a new index ('dummy i')\\n for ii in range(NP):\\n # Since 2 dof for position of pivot of gHST, double the size\\n pin_new[dmyi] = pin[ii]\\n pin_new[dmyi + 1] = pin[ii]\\n dmyi += 2\\n else:\\n # the elements are all identical, so just keep the first one\\n pin = pin[0]\\n\\n m2_shape = np.shape(M2)\\n\\n if b == 'hang':\\n b = np.zeros(NP)\\n elif b == 'stand':\\n b = np.ones(NP)\\n\\n if spin_dir == []:\\n '''Assume antialigned with a, aligned with body axis 3'''\\n spin_dir = np.ones(NP)\\n\\n print 'Constructing dynamical matrix...'\\n for i in range(NP):\\n for nn in range(NN):\\n\\n ni = NL[i, nn] # the number of the gyroscope i is connected to (particle j)\\n k = KL[i, nn] # true connection?\\n\\n if len(dispersion) > 1:\\n disp = 1. / (1. + dispersion[i])\\n else:\\n disp = 1.\\n\\n diffx = R[ni, 0] - R[i, 0]\\n diffy = R[ni, 1] - R[i, 1]\\n alphaij = 0.\\n\\n rij_mag = np.sqrt(diffx ** 2 + diffy ** 2)\\n\\n if k != 0:\\n alphaij = np.arctan2(diffy, diffx)\\n\\n # for periodic systems, KL is -1 for particles on opposing boundaries\\n if KL[i, nn] == -1:\\n alphaij = (np.pi + alphaij) % (2 * pi)\\n\\n # What is this for?\\n if KL[i, nn] == -2: # will only happen on first or last gyro in a line\\n if i == 0 or i == (NP - 1):\\n print i, '--> NL=-2 for this particle'\\n yy = np.where(KL[i] == 1)\\n dx = R[NL[i, yy], 0] - R[NL[i, yy], 0]\\n dy = R[NL[i, yy], 1] - R[NL[i, yy], 1]\\n al = (np.arctan2(dy, dx)) % (2 * pi)\\n alphaij = np.pi - al\\n if i == 1:\\n alphaij = np.pi - ((90 / 2) * np.pi / 180.)\\n else:\\n alphaij = - ((90 / 2) * np.pi / 180.)\\n\\n Cos = np.cos(alphaij)\\n Sin = np.sin(alphaij)\\n\\n if abs(Cos) < 10E-8:\\n Cos = 0.0\\n\\n if abs(Sin) < 10E-8:\\n Sin = 0\\n\\n Cos2 = Cos ** 2\\n Sin2 = Sin ** 2\\n CosSin = Cos * Sin\\n\\n # -1 for aligned with a, 1 for aligned with 3.\\n # dir factor :== 1/(-1)^c = (-1)^c\\n dir_factor = spin_dir[i]\\n\\n if len(sublattice_labels) > 0:\\n if sublattice_labels[i] == 1:\\n extra_factor = 1. * del_A_B\\n # print self.del_A_B\\n elif sublattice_labels[i] == 0:\\n extra_factor = 1.\\n else:\\n extra_factor = 1.\\n else:\\n extra_factor = 1.\\n\\n M1[2 * i, 2 * i] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxi\\n M1[2 * i, 2 * i + 1] += -disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyi\\n M1[2 * i, 2 * ni] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dxi - dxj\\n M1[2 * i, 2 * ni + 1] += disp * k * Sin2 * ((-1) ** b[i]) * dir_factor # dxi - dyj\\n\\n # (y components)\\n M1[2 * i + 1, 2 * i] += disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxi\\n M1[2 * i + 1, 2 * i + 1] += disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyi\\n M1[2 * i + 1, 2 * ni] += -disp * k * Cos2 * ((-1) ** b[i]) * dir_factor # dyi - dxj\\n M1[2 * i + 1, 2 * ni + 1] += -disp * k * CosSin * ((-1) ** b[i]) * dir_factor # dyi - dyj\\n\\n # if i==0:\\n # print '\\\\n --- \\\\n added M1[2*i+1, 2*i] = ',disp*k*Cos2 *((-1)**b[i]) *dir_factor\\n # print 'dir_factor = ', dir_factor\\n # print 'k = ', k\\n # print 'else =', ((-1)**b[i]) *dir_factor\\n\\n # pinning/gravitational matrix\\n M2[2 * i, 2 * i + 1] = (1.) * disp * dir_factor * extra_factor\\n M2[2 * i + 1, 2 * i] = -(1.) * disp * dir_factor * extra_factor\\n\\n # self.pin_array.append(2*pi*1*extra_factor)\\n # Assumes:\\n # (-1)**c adot = - spring* (-1)**b SUM{ z x nij*(nij.(dri-drj)) } + pin\\n matrix = - (-spring * M1 + pin * M2)\\n\\n return matrix\",\n \"def HKS(evals,evects, time_list,scaled=False):\\n evals_s = np.asarray(evals).flatten()\\n t_list = np.asarray(time_list).flatten()\\n\\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\\n\\n if scaled:\\n inv_scaling = coefs.sum(1) # (num_T)\\n return (1/inv_scaling)[None,:] * natural_HKS\\n\\n else:\\n return natural_HKS\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\\n\\n # Compute constants.\\n kT = kB * temperature\\n gamma = collision_rate\\n\\n # Create a new custom integrator.\\n super(VVVRIntegrator, self).__init__(timestep)\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addGlobalVariable(\\\"b\\\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addPerDofVariable(\\\"x1\\\", 0) # position before application of constraints\\n\\n #\\n # Allow context updating here.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Velocity perturbation.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Metropolized symplectic step.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x + v*dt\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m + (x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Velocity randomization\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\",\n \"def InductionsFromCirculation_VC_Cont(vr_bar,lambda_r,k,bSwirl,method='analytical',bHighThrustCorr=True,Cq=None):\\n # Critical values for high-thrust Spera correction\\n ac = 0.34\\n Ct_c = 4*ac*(1-ac)\\n misc={}\\n # Safety\\n if lambda_r[0]==0:\\n lambda_r[0]=lambda_r[1]*0.01;\\n # --- Finding Cylinders intensities\\n if method.lower()=='analytical':\\n if bSwirl:\\n a_prime = k/(4*lambda_r**2) # NOTE: entirely determined from Gamma! Eq.(38)\\n Ir=np.arange(len(k)-1,-1,-1)\\n Ct_rot = -8*sciint.cumtrapz(lambda_r[Ir]**2*a_prime[Ir]**2/vr_bar[Ir], vr_bar[Ir])# Eq.(6)\\n Ct_rot = np.concatenate(([0],Ct_rot))\\n Ct_rot=Ct_rot[Ir];\\n else:\\n a_prime = k*0\\n Ct_rot = k*0\\n Ct_KJ = k*(1+a_prime)\\n Ct_eff = Ct_KJ-Ct_rot \\n a=np.zeros(vr_bar.shape)\\n if bHighThrustCorr:\\n Icorr=Ct_eff> Ct_c\\n Inorm=Ct_eff<=Ct_c\\n # Spera correction\\n a[Icorr]=(Ct_eff[Icorr]-4*ac**2)/(4*(1-2*ac));\\n a[Inorm]=1/2*(1-np.sqrt(1-Ct_eff[Inorm]))\\n else:\\n a=1/2*(1-np.sqrt(1-Ct_eff));\\n\\n # Using Cq\\n if Cq is not None:\\n a_2 = 1 - lambda_r*Cq/k\\n k2 = Cq*lambda_r/(1-a)\\n a_prime = k2/(4*lambda_r**2)\\n misc['k_Cq'] = k2\\n else:\\n raise NotImplementedError('')\\n misc['Ct_KJ'] = Ct_KJ\\n misc['Ct_eff'] = Ct_eff\\n misc['Ct_rot'] = Ct_rot\\n return a,a_prime,misc\",\n \"def _psicomputations(self, kern, Z, variational_posterior, return_psi2_n=False):\\n variance, lengthscale = kern.variance, kern.lengthscale\\n N,M,Q = self.get_dimensions(Z, variational_posterior)\\n self._initGPUCache(N,M,Q)\\n self.sync_params(lengthscale, Z, variational_posterior.mean, variational_posterior.variance)\\n \\n psi1_gpu = self.gpuCache['psi1_gpu']\\n psi2_gpu = self.gpuCache['psi2_gpu']\\n psi2n_gpu = self.gpuCache['psi2n_gpu']\\n l_gpu = self.gpuCache['l_gpu']\\n Z_gpu = self.gpuCache['Z_gpu']\\n mu_gpu = self.gpuCache['mu_gpu']\\n S_gpu = self.gpuCache['S_gpu']\\n log_denom1_gpu = self.gpuCache['log_denom1_gpu']\\n log_denom2_gpu = self.gpuCache['log_denom2_gpu']\\n\\n psi0 = np.empty((N,))\\n psi0[:] = variance\\n self.g_psi1computations.prepared_call((self.blocknum,1),(self.threadnum,1,1),psi1_gpu.gpudata, log_denom1_gpu.gpudata, np.float64(variance),l_gpu.gpudata,Z_gpu.gpudata,mu_gpu.gpudata,S_gpu.gpudata, np.int32(N), np.int32(M), np.int32(Q))\\n self.g_psi2computations.prepared_call((self.blocknum,1),(self.threadnum,1,1),psi2_gpu.gpudata, psi2n_gpu.gpudata, log_denom2_gpu.gpudata, np.float64(variance),l_gpu.gpudata,Z_gpu.gpudata,mu_gpu.gpudata,S_gpu.gpudata, np.int32(N), np.int32(M), np.int32(Q))\\n # t = self.g_psi1computations(psi1_gpu, log_denom1_gpu, np.float64(variance),l_gpu,Z_gpu,mu_gpu,S_gpu, np.int32(N), np.int32(M), np.int32(Q), block=(self.threadnum,1,1), grid=(self.blocknum,1),time_kernel=True)\\n # print 'g_psi1computations '+str(t)\\n # t = self.g_psi2computations(psi2_gpu, psi2n_gpu, log_denom2_gpu, np.float64(variance),l_gpu,Z_gpu,mu_gpu,S_gpu, np.int32(N), np.int32(M), np.int32(Q), block=(self.threadnum,1,1), grid=(self.blocknum,1),time_kernel=True)\\n # print 'g_psi2computations '+str(t)\\n \\n if self.GPU_direct:\\n return psi0, psi1_gpu, psi2_gpu\\n else:\\n if return_psi2_n:\\n return psi0, psi1_gpu.get(), psi2n_gpu.get()\\n else:\\n return psi0, psi1_gpu.get(), psi2_gpu.get()\",\n \"def CLOMPR(task,sketch,featureMap,K,bounds,dimensions_to_consider=None, nb_cat_per_dim=None,nIterations=None, nRepetitions=1, ftol=1e-6, verbose=0 ):\\n\\n ## 0) Defining all the tools we need\\n ####################################\\n ## 0.1) Handle input\\n\\n ## 0.1.1) task name\\n if task.lower() in [\\\"km\\\",\\\"ckm\\\",\\\"kmeans\\\",\\\"k-means\\\"]:\\n task = \\\"kmeans\\\"\\n task_finetuning = \\\"kmeans\\\"\\n elif task.lower() in [\\\"gmm\\\",\\\"gaussian mixture model\\\"]:\\n task = \\\"gmm\\\"\\n task_finetuning = \\\"gmm\\\"\\n elif task.lower() in [\\\"gmm-nondiag\\\"]:\\n task = \\\"gmm\\\"\\n task_finetuning = \\\"gmm-nondiag\\\"\\n else:\\n raise ValueError('The task argument does not match one of the available options.')\\n\\n ## 0.1.2) sketch feature function\\n if isinstance(featureMap,SimpleFeatureMap):\\n d_all = featureMap.d\\n m = featureMap.m\\n else:\\n raise ValueError('The featureMap argument does not match one of the supported formats.')\\n\\n # Restrict the dimension\\n if dimensions_to_consider is None:\\n dimensions_to_consider = np.arange(d_all)\\n dimensions_to_ignore = np.delete(np.arange(d_all), dimensions_to_consider)\\n d = dimensions_to_consider.size\\n \\n # Pre-compute sketch of unused dimensions\\n z_to_ignore = fourierSketchOfBox(bounds.T,featureMap,nb_cat_per_dim, dimensions_to_consider = dimensions_to_ignore)\\n # Compensate the normalization constant and the dithering which will be taken into account in the centroid sketch\\n z_to_ignore = z_to_ignore/(featureMap(np.zeros(d_all))) # giving zeros yields the dithering and the c_norm\\n \\n # Restrict the featureMap for the centroids\\n Phi = copy(featureMap) # Don't touch to the inital map, Phi is featureMap restricted to relevant dims\\n Phi.d = d\\n Phi.Omega = featureMap.Omega[dimensions_to_consider]\\n \\n ## 0.1.3) nb of iterations\\n if nIterations is None:\\n nIterations = 2*K # By default: CLOMP-*R* (repeat twice)\\n \\n ## 0.1.4) Bounds of the optimization problems\\n if bounds is None:\\n lowb = -np.ones(d) # by default data is assumed normalized\\n uppb = +np.ones(d)\\n if verbose > 0: print(\\\"WARNING: data is assumed to be normalized in [-1,+1]^d\\\")\\n else:\\n lowb = bounds[0][dimensions_to_consider]\\n uppb = bounds[1][dimensions_to_consider] # Bounds for one centroid\\n\\n # Format the bounds for the optimization solver\\n if task_finetuning == \\\"kmeans\\\":\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the centroids\\n elif task_finetuning == \\\"gmm\\\":\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\\n elif task_finetuning == \\\"gmm-nondiag\\\":\\n # Usual bounds of GMM\\n boundstheta = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n for i in range(d): boundstheta.append([varianceLowerBound,(uppb[i]-lowb[i])**2]) # bounds for the variance\\n \\n # Bounds for the nondiagonal problem\\n boundstheta_finetuning = np.array([lowb,uppb]).T.tolist() # bounds for the means\\n varianceLowerBound = 1e-8\\n varianceUpperBound = ((uppb-lowb).max()/2)**2\\n\\n _lowb_var = -varianceUpperBound*np.ones((d,d))\\n np.fill_diagonal(_lowb_var, varianceLowerBound)\\n _uppb_var = +varianceUpperBound*np.ones((d,d))\\n\\n _boundsvar = np.append(_lowb_var.reshape(-1),_uppb_var.reshape(-1)).reshape(2,d**2).T.tolist()\\n for _i in _boundsvar: boundstheta_finetuning.append(_i) # bounds for the variance\\n \\n\\n ## 0.1.5) Misc. initializations\\n # Chosen method for the optimization solver\\n opt_method = 'L-BFGS-B' # could also consider 'TNC'\\n # Separated real and imaginary part of the sketch\\n sketch_ri = np.r_[sketch.real, sketch.imag]\\n if task == \\\"kmeans\\\":\\n thetadim = d\\n elif task == \\\"gmm\\\":\\n thetadim = 2*d\\n elif task == \\\"gmm-nondiag\\\":\\n thetadim = d*(d+1)\\n\\n\\n ## THE ACTUAL ALGORITHM\\n #######################\\n bestResidualNorm = np.inf \\n bestTheta = None\\n bestalpha = None\\n for iRun in range(nRepetitions):\\n \\n ## 1) Initialization\\n r = sketch # residual\\n Theta = np.empty([0,thetadim]) # Theta is a nbAtoms-by-atomDimension array\\n A = np.empty([m,0]) # Contains the sketches of the atoms\\n\\n ## 2) Main optimization\\n for i in range(nIterations):\\n ## 2.1] Step 1 : find new atom theta most correlated with residual\\n # Initialize the new atom\\n if task == \\\"kmeans\\\":\\n th_0 = np.random.uniform(lowb,uppb)\\n elif task == \\\"gmm\\\":\\n mu0 = np.random.uniform(lowb,uppb) # initial mean\\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\\n th_0 = _stackAtom(\\\"gmm\\\",mu0,sig0)\\n \\n elif task == \\\"gmm-nondiag\\\":\\n # Solve once for diagonal\\n mu0 = np.random.uniform(lowb,uppb) # initial mean\\n sig0 = (10**np.random.uniform(-0.8,-0.1,d) * (uppb-lowb))**2 # initial covariances\\n th_0 = _stackAtom(\\\"gmm\\\",mu0,sig0)\\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(\\\"gmm\\\",Phi,th,r,z_to_ignore,verbose),\\n x0 = th_0, method=opt_method, jac=True,\\n bounds=boundstheta_gmm)\\n\\n (mu0,sig0) = _destackAtom(\\\"gmm\\\",sol.x,d)\\n\\n th_0 = _stackAtom(\\\"gmm-nondiag\\\",mu0,np.diag(sig0))\\n\\n # And solve with LBFGS \\n sol = minimize(lambda th: _CLOMPR_step1_fun_grad(task,Phi,th,r,z_to_ignore,verbose),\\n x0 = th_0, method=opt_method, jac=True,\\n bounds=boundstheta)\\n new_theta = sol.x\\n \\n if task == \\\"gmm-nondiag\\\":\\n new_theta = _makeGMMfeasible(new_theta,d)\\n\\n ## 2.2] Step 2 : add it to the support\\n Theta = np.append(Theta,[new_theta],axis=0)\\n A = np.c_[A,_sketchAtom(task,Phi,new_theta,z_to_ignore)] # Add a column to the A matrix\\n\\n ## 2.3] Step 3 : if necessary, hard-threshold to nforce sparsity\\n if Theta.shape[0] > K:\\n norms = np.linalg.norm(A,axis=0)\\n norms[np.where(norms < 1e-15)[0]] = 1e-15 # Avoid /0\\n A_norm = A/norms # normalize, unlike step 4\\n A_normri = np.r_[A_norm.real, A_norm.imag] \\n (beta,_) = nnls(A_normri,sketch_ri) # non-negative least squares\\n index_to_delete = np.argmin(beta)\\n Theta = np.delete(Theta, index_to_delete, axis=0)\\n A = np.delete(A, index_to_delete, axis=1)\\n if index_to_delete == K:\\n continue # No gain to be expected wrt previous iteration\\n\\n ## 2.4] Step 4 : project to find weights\\n Ari = np.r_[A.real, A.imag]\\n (alpha,_) = nnls(Ari,sketch_ri) # non-negative least squares\\n\\n\\n\\n ## 2.5] Step 5\\n p0 = _stackTheta(task,Theta,alpha) # Initialize at current solution \\n # Compute the bounds for step 5 : boundsOfOneAtom * numberAtoms then boundsOneWeight * numberAtoms\\n boundsThetaAlpha = boundstheta * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\\n # Solve\\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task,Phi,p,sketch,z_to_ignore),\\n x0 = p0, method=opt_method, jac=True,\\n bounds=boundsThetaAlpha, options={'ftol': ftol}) \\n (Theta,alpha) = _destackTheta(task,sol.x,Phi.d)\\n \\n # Make covariances feasible\\n if task == \\\"gmm-nondiag\\\":\\n for k in range(Theta.shape[0]):\\n Theta[k] = _makeGMMfeasible(Theta[k],d)\\n\\n # The atoms have changed: we must re-compute A\\n A = np.empty([m,0])\\n for theta_i in Theta:\\n Apthi = _sketchAtom(task,Phi,theta_i,z_to_ignore)\\n A = np.c_[A,Apthi]\\n # Update residual\\n r = sketch - A@alpha\\n\\n ## 3) Finalization boundstheta_finetuning\\n # Last optimization with the default (fine-grained) tolerance\\n if task_finetuning == \\\"gmm-nondiag\\\":\\n if verbose > 0: print('finetuning')\\n Theta_new = np.zeros((K,d*(d+1))) # Expand to have full cov matrix\\n for k in range(K):\\n (mu,sig2) = _destackAtom(\\\"gmm\\\",Theta[k],d)\\n # put current sol on the diagonal of full covariance matrix\\n Theta_new[k] = _stackAtom(\\\"gmm-nondiag\\\",mu,np.diag(sig2))\\n Theta = Theta_new # overwrite\\n \\n boundsThetaAlpha = boundstheta_finetuning * Theta.shape[0] + [[1e-9,2]] * Theta.shape[0]\\n \\n if task_finetuning == \\\"gmm-nondiag\\\" or ftol >= 1e-8:\\n p0 = _stackTheta(task_finetuning,Theta,alpha)\\n \\n sol = minimize(lambda p: _CLOMPR_step5_fun_grad(task_finetuning,Phi,p,sketch,z_to_ignore),\\n x0 = p0, method=opt_method, jac=True,\\n bounds=boundsThetaAlpha) # Here ftol is much smaller\\n (Theta,alpha) = _destackTheta(task_finetuning,sol.x,Phi.d) \\n \\n \\n # Normalize alpha\\n alpha /= np.sum(alpha)\\n \\n \\n runResidualNorm = np.linalg.norm(sketch - A@alpha)\\n if verbose>1: print('Run {}, residual norm is {} (best: {})'.format(iRun,runResidualNorm,bestResidualNorm))\\n if runResidualNorm <= bestResidualNorm:\\n bestResidualNorm = runResidualNorm\\n bestTheta = Theta\\n bestalpha = alpha\\n \\n ## FORMAT OUTPUT\\n if task == \\\"kmeans\\\":\\n return (bestalpha,bestTheta)\\n elif task == \\\"gmm\\\" or task == \\\"gmm-nondiag\\\":\\n return _ThetasToGMM(task_finetuning,bestTheta,bestalpha)\\n\\n return None\",\n \"def face_template_matching(visible_image, thermal_image, bboxlist):\\n x1, y1, x2, y2, confidence = bboxlist\\n template = np.mean(\\n visible_image[int(bboxlist[1]):int(bboxlist[3]), int(bboxlist[0]):int(bboxlist[2]), :], axis=-1)\\n image = thermal_image[int(bboxlist[1]):int(bboxlist[3]), :]\\n corr_coeff = cv2.matchTemplate(image.astype(np.float32), template.astype(np.float32), cv2.TM_CCOEFF_NORMED)\\n corr_coeff = np.squeeze(corr_coeff)\\n delta_x = np.argmax(corr_coeff) - x1\\n visible_crops = np.array(bboxlist[:4], dtype=\\\"int\\\")\\n thermal_crops = np.array([x1 + delta_x, y1, x2 + delta_x, y2], dtype=\\\"int\\\")\\n visible_face = crop_face(visible_image, visible_crops, mode=\\\"visible\\\")\\n thermal_face = crop_face(thermal_image, thermal_crops, mode=\\\"thermal\\\")\\n return visible_face, thermal_face\",\n \"def integrate_verlet(X, V, iparams, blist, sp):\\n T, E = np.zeros(sp.Nt), np.zeros(sp.Nt)\\n N = len(X)\\n Vtemp = np.zeros(X.shape)\\n Fnew = np.zeros(X.shape)\\n ti = time.time()\\n\\n F = force_list(X, V, iparams, blist, \\\\\\n sp.L, sp.gamma, sp.kT, sp.dt, sp.rc)\\n T[0] = temperature(V)\\n E[0] = tot_KE(V) + tot_PE(X, iparams, blist, sp.rc)\\n save_xyzmatrix(\\\"Dump/dump_%i.xyz\\\" % 0, blist, X)\\n\\n for i in range(1, sp.Nt):\\n # 1. GW formulation DIVERGES TWICE AS MUCH AS 3rd!\\n# X = X + V * sp.dt + F * sp.dt**2 / 2.0\\n# Vtemp = V + F * sp.dt / 2.0\\n# Fnew = force_list(X, Vtemp, iparams, blist, \\\\\\n# sp.L, sp.gamma, sp.kT, sp.dt, sp.rc)\\n# V = Vtemp + (F + Fnew) * sp.dt / 2\\n# F = Fnew\\n\\n # 2. Wiki formulation without half-step velocity\\n X = X + V * sp.dt + F * sp.dt**2 / 2.0\\n Fnew = force_list(X, V, iparams, blist, \\\\\\n sp.L, sp.gamma, sp.kT, sp.dt, sp.rc)\\n V = V + (F + Fnew) * sp.dt / 2.0\\n F = Fnew\\n\\n X = X % sp.L\\n\\n KE = tot_KE(V)\\n E[i] = KE + tot_PE(X, iparams, blist, sp.rc)\\n T[i] = KE / (3.0 / 2.0 * N)\\n tf = time.time()\\n if (i+1) % sp.thermo == 0:\\n save_xyzmatrix(\\\"Dump/dump_%i.xyz\\\" % (i+1), blist, X)\\n print(\\\"Step: %i | t: %.3f | T: %.5f | E: %.3e | Time: %.2f\\\" % \\\\\\n (i+1, i * sp.dt, T[i], E[i], tf - ti))\\n return T, E\",\n \"def solve_system_for_vv_harmonic_weak_Maass_waveforms_new(H, W, N=None, gr=False, cn=False, verbose=0):\\n V = W['V']\\n Ms = W['Ms']\\n Mf = W['Mf']\\n # WR=W['WR']\\n X = H.multiplier()\\n WM = H.multiplier().weil_module()\\n nc = W['nc']\\n Ml = Mf - Ms + 1\\n get_reduced_matrix = gr\\n verbose = H._verbose\\n comp_norm = cn\\n r = W['r'] # WM.rank()\\n if verbose > 0:\\n print(\\\"Ml={0}\\\".format(Ml))\\n print(\\\"nv={0}\\\".format(nc))\\n # if W['sym_type']==1:\\n # setD=range(WM.rank()/2+1) # 0,1,...,N\\n # #setD=range(WR.N+1) # 0,1,...,N\\n # elif W['sym_type']==-1:\\n # setD=range(1,WM.rank()/2) # 1,2,...,N-1 (since -0=0 and -N=N)\\n setD = X.D()\\n Ds = setD[0]\\n num_comp = nc * r\\n if num_comp != len(setD):\\n raise Exception(\\\" Wrong dimension of input matrix! r={0},nc={1},setD={2}\\\".format(r, nc, setD))\\n if V.ncols() != Ml * num_comp or V.nrows() != Ml * num_comp:\\n raise Exception(\\\" Wrong dimension of input matrix!\\\")\\n if N is None:\\n SetCs = [[]]\\n Vals = [{}]\\n for b in WM.basis():\\n if WM.Q(b) == 0:\\n SetCs[0].append((b, 0))\\n Vals[0][(b, 0)] = 0\\n comp_dim = 1\\n else:\\n SetCs = N['SetCs']\\n Vals = N['Vals']\\n comp_dim = N['comp_dim']\\n\\n # for a in Vals.keys():\\n # Vals[a]=mpmath.mp.mpc(Vals[a])\\n if Ms < 0:\\n use_sym = 0\\n else:\\n use_sym = 1\\n if verbose > 0:\\n print(\\\"Before SetCs={0}\\\".format(SetCs))\\n if use_sym == 1:\\n if len(SetCs[0]) > 0:\\n num_set = 0\\n for (r, m) in SetCs[0]:\\n if r in X.D(): # )_as_int:\\n num_set = num_set + 1\\n else:\\n num_set = len(SetCs[0])\\n t = V[0, 0]\\n CF = MPComplexField(H._prec)\\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(comp_dim))\\n RHS = Matrix_complex_dense(MS, 0, True, True)\\n # if W.has_key('RHS'):\\n # if(W['RHS'].ncols()!=comp_dim):\\n # raise ValueError,\\\"Inum_comporrect number of right hand sides!\\\"\\n MS = MatrixSpace(CF, int(Ml * num_comp - num_set), int(Ml * num_comp - num_set))\\n LHS = Matrix_complex_dense(MS, 0, True, True)\\n if verbose > 0:\\n print(\\\"Ml={0}\\\".format(Ml))\\n print(\\\"num_set={0}\\\".format(num_set))\\n print(\\\"num_comp={0}\\\".format(num_comp))\\n print(\\\"SetCs={0}\\\".format(SetCs))\\n print(\\\"setD={0}\\\".format(setD))\\n print(\\\"Vals={0}\\\".format(Vals))\\n print(\\\"V.rows={0}\\\".format(V.nrows()))\\n print(\\\"V.cols={0}\\\".format(V.ncols()))\\n print(\\\"LHS.rows={0}\\\".format(LHS.nrows()))\\n print(\\\"LHS.cols={0}\\\".format(LHS.ncols()))\\n print(\\\"RHS.rows={0}\\\".format(RHS.nrows()))\\n print(\\\"RHS.cols={0}\\\".format(RHS.ncols()))\\n print(\\\"use_sym={0}\\\".format(use_sym))\\n print(\\\"N={0}\\\".format(N))\\n\\n num_rhs = 0\\n if 'RHS' in W:\\n num_rhs = W['RHS'].ncols()\\n else:\\n num_rhs = 1\\n if num_rhs != 1 and num_rhs != comp_dim:\\n raise ValueError(\\\"Need same number of right hand sides (or just one) as the number of set coefficients!\\\")\\n\\n if V.nrows() != num_comp * Ml:\\n raise ArithmeticError(\\\" Matrix does not have correct size!\\\")\\n roffs = 0\\n for a in range(num_comp):\\n for n in range(Ms, Mf + 1):\\n r = a * Ml + n - Ms\\n if SetCs[0].count((a + Ds, n)) > 0 and a + Ds in setD:\\n # print \\\" set row a,n=\\\",a,n\\n roffs = roffs + 1\\n continue\\n for fn_j in range(comp_dim):\\n # ztmp=CF(ztmp.real(),ztmp.imag())\\n if verbose > 3:\\n print(\\\"fn_j={0}\\\".format(fn_j))\\n print(\\\"r,roffs={0},{1},{2}\\\".format(r, roffs, r - roffs))\\n if num_rhs == comp_dim:\\n rhs_j = fn_j\\n else:\\n rhs_j = 0\\n if 'RHS' in W:\\n RHS[r - roffs, fn_j] = -W['RHS'][r, rhs_j]\\n else:\\n RHS[r - roffs, fn_j] = 0\\n for (i, cset) in SetCs[fn_j]:\\n if i in setD:\\n v = Vals[fn_j][(i, cset)]\\n # k = i*Ml+cset-Ms\\n k = (i - Ds) * Ml + cset - Ms\\n if verbose > 3:\\n print(\\\"fi,cset={0},{1}\\\".format(i, cset))\\n print(\\\"r,k={0},{1}\\\".format(r, k))\\n tmp = CF(v) * V[r, k]\\n RHS[r - roffs, fn_j] = RHS[r - roffs, fn_j] - tmp\\n coffs = 0\\n for b in range(num_comp):\\n for l in range(Ms, Mf + 1):\\n k = b * Ml + l - Ms\\n if SetCs[0].count((b + Ds, l)) > 0 and b + Ds in setD:\\n coffs = coffs + 1\\n continue\\n if verbose > 3:\\n print(\\\"r,k={0},{1}\\\".format(r, k))\\n print(\\\"r-roffs,k-coffs={0},{1}\\\".format(r - roffs, k - coffs))\\n LHS[r - roffs, k - coffs] = V[r, k]\\n # print \\\"LHS[\\\",r,k,\\\"]=\\\",LHS[r-roffs,k-coffs]\\n # else:\\n # LHS = V\\n # RHS = -W['RHS']\\n if get_reduced_matrix:\\n return [LHS, RHS]\\n maxit = 100\\n i = 0\\n done = False\\n dps0 = CF.prec()\\n while (not done and i <= maxit):\\n try:\\n Q, R = LHS.qr_decomposition()\\n done = True\\n except ZeroDivisionError:\\n t = int(ceil(-log(smallest_inf_norm(LHS), 10)))\\n dps = t + 5 * i\\n i = i + 1\\n print(\\\"raising number of digits to:{0}\\\".format(dps))\\n LHS.set_prec(dps)\\n # raise ZeroDivisionError,\\\"Need higher precision! Use > %s digits!\\\" % t\\n if i >= maxit:\\n raise ZeroDivisionError(\\\"Can not raise precision enough to solve system! Should need > {0} digits! and {1} digits was not enough!\\\".format(t, dps))\\n if comp_norm:\\n max_norm = LHS.norm()\\n for j in range(LHS.rows):\\n # y=mpmath_ctx.matrix(LHS.rows,int(1)); y[j,0]=1\\n y = Vector_complex_dense(vector(CF, LHS.rows).parent(), 0)\\n y[j] = 1\\n TMP = RHS.solve(b) # pmath_ctx.U_solve(A, b)\\n tmpnorm = max(list(map(abs, TMP)))\\n if(tmpnorm > max_norm):\\n max_norm = tmpnorm\\n print(\\\"max norm of V^-1={0}\\\".format(max_norm))\\n X = dict()\\n for fn_j in range(comp_dim):\\n X[fn_j] = dict() # mpmath.matrix(int(Ml),int(1))\\n # b = mpmath_ctx.L_solve(A, RHS.column(fn_j), p)\\n v = RHS.column(fn_j)\\n print(\\\"len(B)={0}\\\".format(len(v)))\\n TMP = LHS.solve(v)\\n # TMP = mpmath_ctx.U_solve(A, b)\\n roffs = 0\\n # res = mpmath_ctx.norm(mpmath_ctx.residual(LHS, TMP, RHS.column(fn_j)))\\n res = (LHS * TMP - v).norm()\\n print(\\\"res(\\\", fn_j, \\\")={0}\\\".format(res))\\n for ai in range(num_comp):\\n X[fn_j][ai] = dict()\\n for n in range(Ms, Mf + 1):\\n ni = Ml * ai + n - Ms\\n if SetCs[fn_j].count((ai + Ds, n)) > 0 and ai + Ds in setD:\\n roffs = roffs + 1\\n X[fn_j][ai][n] = CF(Vals[fn_j][(ai + Ds, n)])\\n continue\\n # if verbose>0:\\n # print \\\"ni-roffs=\\\",ni-roffs\\n X[fn_j][ai][n] = TMP[ni - roffs]\\n return X\",\n \"def __init__(self, num_heads: int, size: int, size_v: int, dropout: float = 0.1):\\n super(ContMultiHeadedAttention, self).__init__()\\n\\n assert size % num_heads == 0\\n\\n self.head_size = head_size = size // num_heads\\n self.model_size = size\\n self.num_heads = num_heads\\n\\n self.k_layer = nn.Linear(size, num_heads * head_size)\\n self.v_layer = nn.Linear(size_v, num_heads * head_size)\\n self.q_layer = nn.Linear(size, num_heads * head_size)\\n\\n self.output_layer = nn.Linear(size, size_v)\\n self.softmax = nn.Softmax(dim=-1)\\n self.dropout = nn.Dropout(dropout)\",\n \"def init_stitch(N):\\n\\tif N is None:\\n\\t\\tN = np.int32(HII_DIM) #prepare for stitching\\n\\tMETA_GRID_SIZE = DIM/N\\n\\tM = np.int32(HII_DIM/META_GRID_SIZE)\\n\\t#HII_DIM = np.int32(HII_DIM)\\n\\tf_pixel_factor = DIM/HII_DIM;\\n\\tscale = np.float32(BOX_LEN/DIM)\\n\\tprint 'scale', scale\\n\\tHII_scale = np.float32(BOX_LEN/HII_DIM)\\n\\tshape = (DIM,DIM,N)\\n\\tstitch_grid_size = (DIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tDIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tN/(block_size[0]))\\n\\tHII_stitch_grid_size = (HII_DIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tHII_DIM/(block_size[0]),\\n\\t\\t\\t\\t\\t\\tM/(block_size[0]))\\n\\t#ratio of large box to small size\\n\\tkernel_source = open(cmd_folder+\\\"/initialize_stitch.cu\\\").read()\\n\\tkernel_code = kernel_source % {\\n\\n\\t\\t'DELTAK': DELTA_K,\\n\\t\\t'DIM': DIM, \\n\\t\\t'VOLUME': VOLUME,\\n\\t\\t'META_BLOCKDIM': N\\n\\t}\\n\\tmain_module = nvcc.SourceModule(kernel_code)\\n\\tinit_stitch = main_module.get_function(\\\"init_kernel\\\")\\n\\tHII_filter = main_module.get_function(\\\"HII_filter\\\")\\n\\tsubsample_kernel = main_module.get_function(\\\"subsample\\\")\\n\\tvelocity_kernel = main_module.get_function(\\\"set_velocity\\\")\\n\\tpspec_texture = main_module.get_texref(\\\"pspec\\\")\\n\\tMRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=0)\\n\\tplan2d = Plan((np.int64(DIM), np.int64(DIM)), dtype=np.complex64)\\n\\tplan1d = Plan((np.int64(DIM)), dtype=np.complex64)\\n\\tprint \\\"init pspec\\\"\\n\\tinterpPspec, interpSize = init_pspec() #interpPspec contains both k array and P array\\n\\tinterp_cu = cuda.matrix_to_array(interpPspec, order='F')\\n\\tcuda.bind_array_to_texref(interp_cu, pspec_texture)\\n\\t#hbox_large = pyfftw.empty_aligned((DIM, DIM, DIM), dtype='complex64')\\n\\thbox_large = np.zeros((DIM, DIM, DIM), dtype=np.complex64)\\n\\t#hbox_small = np.zeros(HII_shape, dtype=np.float32)\\n\\t#hbox_large = n\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\n\\t# Set up pinned memory for transfer\\n\\t#largebox_hs = cuda.aligned_empty(shape=shape, dtype=np.float32, alignment=resource.getpagesize())\\n\\tlargebox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.float32)\\n\\tlargecbox_pin = cuda.pagelocked_empty(shape=shape, dtype=np.complex64)\\n\\n\\tlargebox_d = gpuarray.zeros(shape, dtype=np.float32)\\n\\tlargebox_d_imag = gpuarray.zeros(shape, dtype=np.float32)\\n\\tprint \\\"init boxes\\\"\\n\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\t# MRGgen = MRG32k3aRandomNumberGenerator(seed_getter=seed_getter_uniform, offset=meta_x*N**3)\\n\\t\\tinit_stitch(largebox_d, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\\n\\t\\tinit_stitch(largebox_d_imag, DIM, np.int32(meta_z),block=block_size, grid=stitch_grid_size)\\n\\t\\tlargebox_d *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\t\\tlargebox_d_imag *= MRGgen.gen_normal(shape, dtype=np.float32)\\n\\t\\tlargebox_d = largebox_d + np.complex64(1.j) * largebox_d_imag\\n\\t\\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\\n\\t\\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largecbox_pin.copy()\\n\\t#if want to get velocity need to use this\\n\\tif True:\\n\\t\\tprint \\\"saving kbox\\\"\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN), hbox_large)\\n\\n\\tprint \\\"Executing FFT on device\\\"\\n\\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\\n\\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\\n\\tprint hbox_large.dtype\\n\\tprint \\\"Finished FFT on device\\\"\\n\\tnp.save(parent_folder+\\\"/Boxes/deltax_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN), hbox_large)\\n\\t\\n\\tif True:\\n\\t\\tprint \\\"loading kbox\\\"\\n\\t\\thbox_large = np.load(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN))\\n\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\\n\\t\\t#cuda.memcpy_htod_async(largebox_d, largebox_pin)\\n\\t\\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\tHII_filter(largebox_d, DIM, np.int32(meta_z), ZERO, smoothR, block=block_size, grid=stitch_grid_size);\\n\\t\\thbox_large[:, :, meta_z*N:(meta_z+1)*N] = largebox_d.get_async()\\n\\t#import IPython; IPython.embed()\\n\\tprint \\\"Executing FFT on host\\\"\\n\\t#hbox_large = hifft(hbox_large).astype(np.complex64).real\\n\\t#hbox_large = pyfftw.interfaces.numpy_fft.ifftn(hbox_large).real\\n\\thbox_large = fft_stitch(N, plan2d, plan1d, hbox_large, largebox_d).real\\n\\tprint \\\"Finished FFT on host\\\"\\n\\t#import IPython; IPython.embed()\\n\\n\\t# for meta_x in xrange(META_GRID_SIZE):\\n\\t# \\tfor meta_y in xrange(META_GRID_SIZE):\\n\\t# \\t\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t# \\t\\t\\tlargebox_d = gpuarray.to_gpu(hbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N])\\n\\t# \\t\\t\\tHII_filter(largebox_d, N, np.int32(meta_x), np.int32(meta_y), np.int32(meta_z), ZERO, smoothR, block=block_size, grid=grid_size);\\n\\t# \\t\\t\\thbox_large[meta_x*N:(meta_x+1)*N, meta_y*N:(meta_y+1)*N, meta_z*N:(meta_z+1)*N] = largebox_d.get()\\n\\t#plan = Plan(shape, dtype=np.complex64)\\n\\t#plan.execute(largebox_d, inverse=True) #FFT to real space of smoothed box\\n\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\n\\n\\t# This saves a large resolution deltax\\n\\n\\t\\n\\tprint \\\"downsampling\\\"\\n\\tsmallbox_d = gpuarray.zeros((HII_DIM,HII_DIM,M), dtype=np.float32)\\n\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\tlargebox_pin = hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy()\\n\\t\\tcuda.memcpy_dtoh_async(largecbox_pin, largebox_d)\\n\\t\\t#largebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\tlargebox_d /= scale**3 #\\n\\t\\tsubsample_kernel(largebox_d, smallbox_d, DIM, HII_DIM, PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size) #subsample in real space\\n\\t\\thbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallbox_d.get_async()\\n\\tnp.save(parent_folder+\\\"/Boxes/smoothed_deltax_z0.00_{0:d}_{1:.0f}Mpc\\\".format(HII_DIM, BOX_LEN), hbox_small)\\n\\t#import IPython; IPython.embed()\\n\\n\\n\\t# To get velocities: reload the k-space box\\n\\thbox_large = np.load(parent_folder+\\\"/Boxes/deltak_z0.00_{0:d}_{1:.0f}Mpc.npy\\\".format(DIM, BOX_LEN))\\n\\thvbox_large = np.zeros((DIM, DIM, DIM), dtype=np.float32)\\n\\thvbox_small = np.zeros(HII_shape, dtype=np.float32)\\n\\tsmoothR = np.float32(L_FACTOR*BOX_LEN/HII_DIM)\\n\\tlargevbox_d = gpuarray.zeros((DIM,DIM,N), dtype=np.complex64)\\n\\tsmallvbox_d = gpuarray.zeros((HII_DIM, HII_DIM, M), dtype=np.float32)\\n\\tfor num, mode in enumerate(['x', 'y', 'z']):\\n\\t\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\t\\tlargebox_d = gpuarray.to_gpu_async(hbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\t\\t#largebox_d /= VOLUME #divide by VOLUME if using fft (vs ifft)\\n\\t\\t\\tvelocity_kernel(largebox_d, largevbox_d, DIM, np.int32(meta_z), np.int32(num), block=block_size, grid=stitch_grid_size)\\n\\t\\t\\tHII_filter(largevbox_d, DIM, ZERO, smoothR, block=block_size, grid=stitch_grid_size)\\n\\t\\t\\tprint hvbox_large.shape, largevbox_d.shape\\n\\t\\t\\thvbox_large[:, :, meta_z*N:(meta_z+1)*N] = largevbox_d.get_async()\\n\\t\\thvbox_large = fft_stitch(N, plan2d, plan1d, hvbox_large, largevbox_d).real\\n\\t\\tfor meta_z in xrange(META_GRID_SIZE):\\n\\t\\t\\tlargevbox_d = gpuarray.to_gpu_async(hvbox_large[:, :, meta_z*N:(meta_z+1)*N].copy())\\n\\t\\t\\tsubsample_kernel(largevbox_d.real, smallvbox_d, DIM, HII_DIM,PIXEL_FACTOR, block=block_size, grid=HII_stitch_grid_size)\\n\\t\\t\\thvbox_small[:, :, meta_z*M:(meta_z+1)*M] = smallvbox_d.get_async()\\n\\t\\tnp.save(parent_folder+\\\"/Boxes/v{0}overddot_{1:d}_{2:.0f}Mpc\\\".format(mode, HII_DIM, BOX_LEN), smallvbox_d.get())\\n\\n\\treturn\",\n \"def cvstem0(self,xs,ps,alp):\\n epsilon = self.epsilon\\n Ncv = np.size(xs,0)\\n n = self.n\\n I = np.identity(n)\\n Ws = []\\n for k in range(Ncv):\\n Ws.append(cp.Variable((n,n),PSD=True))\\n nu = cp.Variable(nonneg=True)\\n chi = cp.Variable(nonneg=True)\\n errtxt = \\\"https://github.com/AstroHiro/ncm#troubleshooting\\\"\\n if len(sig(self.Afun).parameters) == 1:\\n fun1 = self.Afun\\n self.Afun = lambda x,p: fun1(x)\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Cfun).parameters) == 1):\\n fun2 = self.Cfun\\n self.Cfun = lambda x,p: fun2(x)\\n if self.iEC == \\\"est\\\":\\n Af = self.Afun\\n Cf = self.Cfun\\n J = (self.d1_over*self.b_over*chi\\\\\\n +self.d2_over*self.c_over*self.g_over*nu)/alp\\n elif self.iEC == \\\"con\\\":\\n Af = lambda x,p: self.Afun(x,p).T\\n Cf = lambda x,p: self.h_or_g(x,p).T\\n J = self.d1_over*self.b_over*chi/alp+self.d2_over*nu\\n else:\\n raise ValueError('Invalid iEC: iEC = \\\"est\\\" or \\\"con\\\"')\\n constraints = []\\n for k in range(Ncv):\\n x = xs[k,:]\\n p = ps[k,:]\\n Ax = Af(x,p)\\n Cx = Cf(x,p)\\n W = Ws[k]\\n constraints += [chi*I-W >> 0,W-I >> 0]\\n constraints += [-2*alp*W-((W-I)/self.dt+W@Ax+Ax.T@W-2*nu*Cx.T@Cx)\\\\\\n >> epsilon*I]\\n prob = cp.Problem(cp.Minimize(J),constraints)\\n prob.solve(solver=cp.MOSEK)\\n cvx_status = prob.status\\n if cvx_status in [\\\"infeasible\\\",\\\"infeasible_inaccurate\\\"]:\\n raise ValueError(\\\"Problem infeasible: see \\\"+errtxt)\\n elif cvx_status in [\\\"unbounded\\\",\\\"unbounded_inaccurate\\\"]:\\n raise ValueError(\\\"Problem unbounded: \\\"+errtxt)\\n Wsout = []\\n for k in range(Ncv):\\n Wk = Ws[k].value/nu.value\\n Wsout.append(Wk)\\n self.Ws = Wsout\\n self.nu = nu.value\\n self.chi = chi.value\\n self.Jcv = prob.value\\n self.cvx_status = cvx_status\\n pass\",\n \"def dispersion_2(ztop, vp, vs, rh, Curves,\\n h=0.005, dcl=0.005, dcr=0.005, keepnans=False):\\n Waves, Types, Modes, Freqs = zip(*Curves)\\n for w, t, m, F, V in dispersion_1(\\\\\\n ztop, vp, vs, rh,\\n Waves, Types, Modes, Freqs,\\n h=h, dcl=dcl, dcr=dcr, keepnans=keepnans):\\n yield w, t, m, F, V\",\n \"def interacting_conductivity(self,\\n sigma=0.04,\\n freq_range=(0.0, 6.0, 1000),\\n imag_dielectric=False,\\n broadening='lorentz'):\\n cell_area = np.abs(np.cross(self.a1, self.a2))*len(self.k_grid)\\n broad_fnc = get_broadening_function(broadening, sigma)\\n\\n frequency_grid = np.linspace(*freq_range)\\n output_grid = np.zeros(len(frequency_grid))\\n\\n energy_power = 1 + int(imag_dielectric)\\n prefactor = e_charge_2_over_epsilon0 if imag_dielectric else 1\\n prefactor = prefactor/cell_area\\n\\n # Assuming x polarisation for now\\n position_dipole_matrix = self.construct_position_dipole_matrix()\\n\\n n_shift = self.n_spins*self.n_orbs\\n cutoff_band_min_maxes = self.exciton_obj.get_cutoff_band_min_maxes()\\n # Construct vector of velocity matrix elements to dot with the\\n # bse eigenvector.\\n velocity_element_lists = []\\n for s0 in range(self.n_spins):\\n velocity_elements = []\\n for idx_1, kpt in enumerate(self.k_grid):\\n velocity_matrix = self.load_velocity_matrix(idx_1)\\n bands = self.exciton_obj.get_number_conduction_valence_bands(\\n idx_1, s0\\n )\\n v_num, c_num = bands\\n v_min = 0\\n if self.exciton_obj.energy_cutoff is not None:\\n v_min = int(cutoff_band_min_maxes[s0][idx_1][0])\\n c_num = int(cutoff_band_min_maxes[s0][idx_1][1]) + 1\\n v_num = v_num - v_min\\n j1 = n_shift*idx_1 + s0*self.n_orbs\\n j2 = j1 + n_shift - (1 - s0)*self.n_orbs*(self.n_spins - 1)\\n eigvecs = np.array(\\n self.file_storage['eigensystem']['eigenvectors'][j1:j2, :]\\n )\\n if self.use_dipole_term:\\n eigvals = np.array(\\n self.file_storage['eigensystem']['eigenvalues'][idx_1]\\n )\\n else:\\n eigvals = None\\n for c, v in product(range(c_num), range(v_num)):\\n cb_vector = eigvecs[:, v_min + v_num + c]\\n vb_vector = eigvecs[:, v_min + v]\\n\\n matrix_elem = velocity_matrix_element(cb_vector,\\n vb_vector,\\n velocity_matrix)\\n if self.use_dipole_term:\\n cb_energy = eigvals[v_min + v_num + c]\\n vb_energy = eigvals[v_min + v]\\n position_dipole_term = get_position_dipole_element(\\n vb_vector,\\n cb_vector,\\n vb_energy,\\n cb_energy,\\n position_dipole_matrix\\n )\\n matrix_elem = matrix_elem + position_dipole_term\\n velocity_elements.append(matrix_elem)\\n velocity_elements = np.array(velocity_elements, dtype=complex)\\n velocity_element_lists.append(velocity_elements)\\n\\n bse_eigsys = self.exciton_obj.get_bse_eigensystem_direct(solve=True)\\n for s0 in range(self.n_spins):\\n for idx_1 in range(len(bse_eigsys[s0][0])):\\n bse_vector = bse_eigsys[s0][1][:, idx_1]\\n bse_value = bse_eigsys[s0][0][idx_1]\\n energy_denominator = bse_value**energy_power\\n interact_elem = np.dot(bse_vector, velocity_element_lists[s0])\\n for idx_2, omega in enumerate(frequency_grid):\\n smearing = broad_fnc(bse_value, omega)\\n main_term = np.abs(interact_elem)**2/energy_denominator\\n output = prefactor*main_term*smearing\\n output_grid[idx_2] += output\\n\\n return frequency_grid, output_grid\",\n \"def _computeEquilibriumValue(self,cp,kdT,kdI,Cactiv0,Cinhib0,E0,X0,masks,observed=None,verbose=False):\\n # We move from an array to a list of 2d-array for the competition over each template:\\n olderX = [np.zeros(m.shape[1]) for m in masks]\\n for layeridx,layer in enumerate(masks):\\n layerEq = np.zeros(layer.shape[1])\\n if(layeridx==0):\\n if verbose:\\n print(\\\" input to python:\\\",X0,\\\" with cp: \\\",cp)\\n for inpIdx in range(layer.shape[1]):\\n # The first layer is a one to one non-linearity leading to an equation of the second order:\\n if self.k1M[layeridx][inpIdx,inpIdx]*E0*self.TA0[layeridx][inpIdx,inpIdx]/cp == 0:\\n x_eq = X0[inpIdx]\\n else:\\n bOnA = X0[inpIdx]-self.TA0[layeridx][inpIdx,inpIdx]- cp/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0)\\n if verbose:\\n print(\\\"bOnA python\\\",bOnA)\\n print(\\\"second part\\\",4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))\\n x_eq = 1/2*(bOnA + (bOnA**2+4*cp*X0[inpIdx]/(self.k1M[layeridx][inpIdx,inpIdx]*self.E0))**0.5)\\n # saving values\\n layerEq[inpIdx] = x_eq\\n olderX[layeridx] = layerEq\\n\\n else:\\n for inpIdx in range(layer.shape[1]):\\n\\n #compute of Cactivs,Cinhibs, the denominator marks the template's variation from equilibrium\\n #Terms for the previous layers\\n CactivsOld = np.where(masks[layeridx-1][inpIdx,:]>0,Cactiv0[layeridx-1][inpIdx]/(1+self.k1M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\\n CinhibsOld = np.where(masks[layeridx-1][inpIdx,:]<0,Cinhib0[layeridx-1][inpIdx]/(1+self.k3M[layeridx-1][inpIdx]*olderX[layeridx-1]*self.E0/cp),0)\\n Inhib = np.sum(CinhibsOld*olderX[layeridx-1]/kdT[layeridx-1][inpIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[layeridx-1]/(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n if verbose:\\n print(\\\"numerateur: \\\",np.sum(CactivsOld*olderX[layeridx-1]), \\\" denominateur: \\\",np.sum(kdI[layeridx-1][inpIdx]*cp+Inhib/cp))\\n layerEq[inpIdx] = x_eq\\n #compute of Kactivs,Kinhibs, for the current layer:\\n olderX[layeridx] = layerEq\\n if verbose and layeridx==1:\\n print(\\\"python second layer:\\\",layerEq)\\n if verbose and layeridx==2:\\n print(\\\"python third layer: \\\",layerEq)\\n #Compute equilibrium for last layers:\\n layerEq = np.zeros(masks[-1].shape[0])\\n for outputIdx in range(masks[-1].shape[0]):\\n\\n CactivsOld = np.where(masks[-1][outputIdx,:]>0,Cactiv0[-1][outputIdx]/(1+self.k1M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\\n CinhibsOld = np.where(masks[-1][outputIdx,:]<0,Cinhib0[-1][outputIdx]/(1+self.k3M[-1][outputIdx]*olderX[-1]*self.E0/cp),0)\\n Inhib = np.sum(CinhibsOld*olderX[-1]/kdT[-1][outputIdx])\\n #computing of new equilibrium\\n x_eq = np.sum(CactivsOld*olderX[-1]/(kdI[-1][outputIdx]*cp+Inhib/cp))\\n layerEq[outputIdx]=x_eq\\n olderX = olderX + [layerEq]\\n\\n if observed is not None:\\n try:\\n assert len(observed)==2\\n except:\\n raise Exception(\\\"please provide a tuple of size two for observed indicating the value to use.\\\")\\n return olderX[observed[0]][observed[1]]\\n return olderX\",\n \"def config_hog_search(self, img):\\n img = img.astype(np.float32)/255 # scale image: (png: 0-1, jpg: 0-255)\\n img_crop = img[self.ys[0]:self.ys[1], :, :] # crop img to relative dimensions (ROI)\\n clr_trf = cvf.transform_colorspace(img_crop, self.color_space) # transform color space from RGB\\n clr_trf = cvu.scale_image(clr_trf, self.scale) # scale rather than selecting diffferent window sizes\\n ch1, ch2, ch3 = [clr_trf[:,:,ch] for ch in range(3)] # HOG operates on per channel basis\\n\\n # get hog features as multi-dimensional array per channel for the entire image\\n params={'orient':self.orient, 'pix_per_cell':self.pix_per_cell, 'cells_per_block':self.cells_per_block}\\n params.update({'vis':False, 'feature_vec':False})\\n hog1,hog2,hog3 = [cvf.get_hog_features(ch, **params) for ch in ([ch1,ch2,ch3])]\\n # block configurations\\n self.nfeat_per_block = self.orient*self.cells_per_block**2\\n self.nblocks_per_window = (self.window //self.pix_per_cell) -1\\n # number_blocks: define number of hog cells across an image according to channel dimensions\\n # number_steps: define number of steps to occur across hog array to extract features\\n rows, cols = ch1.shape[:2]\\n number_blocks = lambda max_dim, pix_per_cell: (max_dim // pix_per_cell) -1\\n number_steps = lambda nblocks, nblocks_window, cells_step: (nblocks - nblocks_window)//cells_step\\n self.nxblocks, self.nyblocks = number_blocks(cols, self.pix_per_cell), number_blocks(rows, self.pix_per_cell)\\n nxsteps, nysteps = \\\\\\n [number_steps(it, self.nblocks_per_window, self.cells_per_step) for it in (self.nxblocks, self.nyblocks) ]\\n return clr_trf, (nxsteps, nysteps), (hog1,hog2,hog3)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def predit_vehicles(img, windows,\\n scaler = None,\\n classifier = None,\\n decision = DECISION_THRESHOLD,\\n view=True,\\n save_path=None,\\n prefix=None,\\n debug=True):\\n car_features_list = []\\n for window in windows:\\n sub_img = cv2.resize(\\n get_sub_image(img, window), CLASSIFIER_IMG_SIZE)\\n one_features = extract_one_features(\\n sub_img,\\n cspace=CSPACE, spatial_size=(32, 32),\\n hist_bins=32, hist_range=(0, 256),\\n orient=ORIENTS_HOG, pix_per_cell=PIX_PER_CELL,\\n cell_per_block=CELLS_PER_BLOCK,\\n hog_channel=HOG_CHANNEL)\\n car_features_list.append(\\n # scaler.transform(np.asarray(one_features, dtype=np.float64)))\\n one_features)\\n scaled_list = scaler.fit_transform(car_features_list)\\n #if view:\\n # show_features(scaled_list)\\n decs = classifier.decision_function(scaled_list)\\n #predicts = classifier.predict(scaled_list)\\n #predicts_bool = predicts.astype(np.bool)\\n\\n car_windows = []\\n #for p, w in zip(predicts_bool, windows):\\n # if p:\\n for d, w in zip(decs, windows):\\n if (d > decision): ## positive decision threshold\\n # print (\\\"dec\\\", d)\\n car_windows.append(w)\\n #if view:\\n # show_grid_view(img, car_windows)\\n if save_path is not None:\\n save_sub_images(img, car_windows,\\n path=save_path,\\n prefix=prefix,\\n size=CLASSIFIER_IMG_SIZE)\\n return car_windows\",\n \"def setCtrls(self, fks, ik, upv):\\n # type: (list[str], str, str) -> None\\n\\n self.fkCtrls = [self._getNode(x) for x in fks]\\n self.fkTargets = [self._getMth(x) for x in fks]\\n\\n self.ikCtrl = self._getNode(ik)\\n self.ikTarget = self._getMth(ik)\\n\\n self.upvCtrl = self._getNode(upv)\\n self.upvTarget = self._getMth(upv)\\n\\n self.ikRotCtrl = self._getNode(ik.replace(\\\"_ik_\\\", \\\"_rot_\\\"))\\n self.ikRotTarget = self.ikTarget\",\n \"def plot_dispersion(kpts, enk):\\n\\n # Lattice constant and reciprocal lattice vectors\\n # b1 = 2 pi/a (kx - ky + kz)\\n # b2 = 2 pi/a (kx + ky - kz)\\n # b3 = 2 pi/a (-kx + ky + kz)\\n a = 5.556 # [A]\\n b1 = (2 * np.pi / a) * np.array([1, -1, 1])\\n b2 = (2 * np.pi / a) * np.array([1, 1, -1])\\n b3 = (2 * np.pi / a) * np.array([-1, 1, 1])\\n\\n # L point in BZ is given by 0.5*b1 + 0.5*b2 + 0.5*b3\\n # X point in BZ is given by 0.5*b2 + 0.5*b3\\n lpoint = 0.5 * (b1 + b2 + b3)\\n xpoint = 0.5 * (b2 + b3)\\n\\n # We can find kpoints along a path just by considering a dot product with lpoint and xpoint vectors.\\n # Any kpoints with angle smaller than some tolerance are considered on the path and we can plot their frequencies\\n deg2rad = 2 * np.pi / 360\\n ang_tol = 1 * deg2rad # 1 degree in radians\\n\\n print(list(kpts))\\n\\n enkonly = np.array(enk['energy [Ryd]'])[:, np.newaxis]\\n enkinds = np.array(enk['q_inds'])\\n kptsonly = np.array(kpts[['kx [1/A]', 'ky [1/A]', 'kz [1/A]']]) / (2 * np.pi / a)\\n kptsinds = np.array(kpts['q_inds'])\\n kptsmag = np.linalg.norm(kptsonly, axis=1)[:, np.newaxis]\\n\\n dot_l = np.zeros(len(kpts))\\n dot_x = np.zeros(len(kpts))\\n\\n # Separate assignment for gamma point to avoid divide by zero error\\n nongamma = kptsmag != 0\\n dot_l[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, lpoint[:, np.newaxis])[nongamma],\\n kptsmag[nongamma]) / np.linalg.norm(lpoint)\\n dot_x[np.squeeze(nongamma)] = np.divide(np.dot(kptsonly, xpoint[:, np.newaxis])[nongamma],\\n kptsmag[nongamma]) / np.linalg.norm(xpoint)\\n dot_l[np.squeeze(kptsmag == 0)] = 0\\n dot_x[np.squeeze(kptsmag == 0)] = 0\\n\\n lpath = np.logical_or(np.arccos(dot_l) < ang_tol, np.squeeze(kptsmag == 0))\\n xpath = np.logical_or(np.arccos(dot_x) < ang_tol, np.squeeze(kptsmag == 0))\\n\\n linds = kptsinds[lpath]\\n xinds = kptsinds[xpath]\\n lkmag = kptsmag[lpath]\\n xkmag = kptsmag[xpath]\\n\\n plt.figure()\\n\\n for i, ki in enumerate(linds):\\n energies = enkonly[enkinds == ki, 0]\\n thiskmag = lkmag[i]\\n if len(energies) > 1:\\n veck = np.ones((len(energies), 1)) * thiskmag\\n plt.plot(veck, energies, '.', color='C0')\\n else:\\n plt.plot(thiskmag, energies, '.', color='C0')\\n\\n for i, ki in enumerate(xinds):\\n energies = enkonly[enkinds == ki, 0]\\n thiskmag = lkmag[i]\\n if len(energies) > 1:\\n veck = np.ones((len(energies), 1)) * thiskmag\\n plt.plot(-1 * veck, energies, '.', color='C1')\\n else:\\n plt.plot(-1 * thiskmag, energies, '.', color='C1')\\n\\n plt.xlabel('k magnitude')\\n plt.ylabel('Energy in Ry')\",\n \"def kViterbi(crf_obj, emissions, topK, mask):\\n assert topK >=1\\n if topK == 1:\\n seq_length = emissions.size(1)\\n best_path = crf_obj.decode(emissions, mask)\\n observation = pad_seq(best_path, seq_length, crf_obj.batch_first, 0)\\n best_probs = calculate_prob_byObser(crf_obj, emissions, observation, mask)\\n return best_path, best_probs.squeeze()\\n\\n crf_obj._validate(emissions, mask=mask)\\n if mask is None:\\n mask = emissions.new_ones(emissions.shape[:2], dtype=torch.uint8)\\n if crf_obj.batch_first:\\n emissions = emissions.transpose(0, 1)\\n mask = mask.transpose(0, 1)\\n normalizer = crf_obj._compute_normalizer(emissions, mask)\\n # ===============start main part========================\\n # emissions: (seq_length, batch_size, num_tags)\\n # mask: (seq_length, batch_size)\\n assert emissions.dim() == 3 and mask.dim() == 2\\n assert emissions.shape[:2] == mask.shape\\n assert emissions.size(2) == crf_obj.num_tags\\n assert mask[0].all()\\n\\n seq_length, batch_size = mask.shape\\n\\n # Start transition and first emission\\n # score is a tensor of size(batch_size, num_tags, topK) where for each\\n # batch, value at tags i and top j stores the scores of the j-th best tag\\n # sequence so far that ends with tag i\\n #\\n # pre_states saves the previous tag where the j-th best path that ends with tag i currently\\n score = emissions.new_zeros((seq_length, batch_size, crf_obj.num_tags, topK))\\n score[0,:,:,0] = crf_obj.start_transitions + emissions[0] # batch x num_tags\\n\\n pre_states = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\\n for i in range(crf_obj.num_tags):\\n for b in range(batch_size):\\n for k in range(topK):\\n pre_states[0,b,i,k] = i # should be start transition\\n\\n # The ranking of multiple paths through same state\\n rank = np.zeros((seq_length, batch_size, crf_obj.num_tags, topK), int)\\n for t in range(1, seq_length):\\n next_score_list = []\\n for k in range(topK):\\n broadcast_score = score[t-1,:,:,k].unsqueeze(2) #(batch_size, num_tags, 1)\\n broadcast_emissions = emissions[t].unsqueeze(1) #(batch_size, 1, num_tags)\\n\\n # Compute the score tensor of size (batch_size, num_tags, num_tags)\\n # where for each sample, entry at row i and column j stores\\n # the sum of scores of all possible tag sequences so far that end\\n # with transitioning from tag i to tag j and emitting\\n # shape: (batch_size, num_tags, num_tags)\\n next_score = broadcast_score + crf_obj.transitions + broadcast_emissions\\n next_score_list.append(next_score)\\n\\n for b in range(batch_size):\\n if mask[t,b]:\\n for cur_state in range(crf_obj.num_tags):\\n h = []\\n for pre_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n heapq.heappush(h, (-1*next_score_list[k][b, pre_state, cur_state], pre_state))\\n\\n # Get the sorted list\\n h_sorted = [heapq.heappop(h) for _ in range(topK)] #get topK path into cur_state\\n # We need to keep a ranking if a path crosses a state more than once\\n rankDict = dict()\\n # Retain the topK scoring paths\\n for k in range(topK):\\n score[t, b, cur_state, k] = score[t, b, cur_state, k] + (h_sorted[k][0].data * -1)\\n pre_states[t, b, cur_state, k] = h_sorted[k][1]\\n state = h_sorted[k][1]\\n if state in rankDict:\\n rankDict[state] = rankDict[state]+1\\n else:\\n rankDict[state] = 0\\n rank[t, b, cur_state, k] = rankDict[state]\\n else:\\n for cur_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n score[t, b, cur_state, k]=score[t-1, b, cur_state, k]\\n\\n\\n batch_path = []\\n batch_path_prob = []\\n seq_ends = mask.long().sum(dim=0) - 1 # seq_len x batch # assume seq_ends=8, seq_len=9\\n for b in range(batch_size):\\n h = []\\n for cur_state in range(crf_obj.num_tags):\\n for k in range(topK):\\n heapq.heappush(h, ( -1 * (score[seq_ends[b], b, cur_state, k]+crf_obj.end_transitions[cur_state]),\\n cur_state, k))\\n h_sorted = [heapq.heappop(h) for _ in range(topK)]\\n k_list = np.zeros((topK, seq_ends[b]+1), int) # k x 9\\n k_list_probs = list()\\n for k in range(topK):\\n prob = h_sorted[k][0]\\n state = h_sorted[k][1]\\n rankK = h_sorted[k][2]\\n\\n k_list_probs.append((prob*-1)-(normalizer[b]))\\n k_list[k][seq_ends[b]] = state # assign index 8 == last one\\n for t in range(seq_ends[b]-1, -1, -1): # t = 7,6,5,4,3,2,1,0\\n nextState = k_list[k][t+1]\\n preState = pre_states[t+1, b, nextState, rankK]\\n k_list[k][t] = preState\\n rankK = rank[t+1,b,nextState,rankK]\\n batch_path.append(k_list.tolist())\\n batch_path_prob.append(k_list_probs)\\n if crf_obj.batch_first:\\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions.transpose(0,1), mask.transpose(0,1), topK)\\n else:\\n batch_probs = recalculate_probs(crf_obj, batch_path, emissions, mask, topK)\\n return batch_path, batch_probs\",\n \"def kick_from_eccentric_tides(self):\\n\\n inv_r_7 = self.inv_r**7\\n r0_5 = self.pair[0].radius ** 5\\n r1_5 = self.pair[1].radius ** 5\\n m0_2 = self.pair[0].mass * self.pair[0].mass\\n m1_2 = self.pair[1].mass * self.pair[1].mass\\n\\n ftr = -3.0 * inv_r_7 * constants.G * ((m1_2 * r0_5 * self.pair[0].kaps + m0_2 * r1_5 * self.pair[1].kaps) + # Non-dissipative\\n 3 * self.inv_r * self.rdot_mag *\\n (m1_2 * r0_5 * self.pair[0].kaps * self.pair[0].taulag\\n + m0_2 * r1_5 * self.pair[1].kaps * self.pair[1].taulag)) # Dissipative\\n\\n hutforce = ftr * self.inv_r * self.pos\\n kick0 = (1.0 / self.pair[0].mass) * hutforce * self.dt\\n kick1 = (-1.0 / self.pair[1].mass) * hutforce * self.dt\\n\\n self.pair[0].velocity += kick0\\n self.pair[1].velocity += kick1\",\n \"def cvstem(self):\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Cfun).parameters) == 1):\\n fun1 = self.Cfun\\n self.Cfun = lambda x,p: fun1(x)\\n if (self.iEC == \\\"est\\\") and (len(sig(self.Gw).parameters) == 1):\\n fun2 = self.Gw\\n self.Gw = lambda x,p: fun2(x)\\n if self.iEC == \\\"est\\\":\\n self.c_over = self.matrix_2bound(self.Cfun)\\n self.g_over = self.matrix_2bound(self.Gw)\\n if (len(sig(self.Bw).parameters) == 1):\\n fun3 = self.Bw\\n self.Bw = lambda x,p: fun3(x)\\n self.b_over = self.matrix_2bound(self.Bw)\\n self.linesearch()\\n alp = self.alp_opt\\n Nx = self.Nx\\n Nsplit = 1\\n Np = int(Nx/Nsplit)\\n Nr = np.remainder(Nx,Nsplit)\\n xpmin = np.hstack((self.xlims[0,:],self.plims[0,:]))\\n xpmax = np.hstack((self.xlims[1,:],self.plims[1,:]))\\n Nxp = self.n+self.n_p\\n xps = np.random.uniform(xpmin,xpmax,size=(Nx,Nxp))\\n xs_opt,ps_opt,_ = np.hsplit(xps,np.array([self.n,Nxp]))\\n Ws_opt = []\\n chi_opt = 0\\n nu_opt = 0\\n print(\\\"========================================================\\\")\\n print(\\\"====== SAMPLING OF CONTRACTION METRICS BY CV-STEM ======\\\")\\n print(\\\"========================================================\\\")\\n for p in range(Np):\\n if np.remainder(p,int(Np/10)) == 0:\\n print(\\\"# sampled metrics: \\\",p*Nsplit,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*p:Nsplit*(p+1),:]\\n ps_p = ps_opt[Nsplit*p:Nsplit*(p+1),:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n if Nr != 0:\\n print(\\\"# samples metrics: \\\",Nx,\\\"...\\\")\\n xs_p = xs_opt[Nsplit*(p+1):Nx,:]\\n ps_p = ps_opt[Nsplit*(p+1):Nx,:]\\n self.cvstem0(xs_p,ps_p,alp)\\n Ws_opt += self.Ws\\n if self.nu >= nu_opt:\\n nu_opt = self.nu\\n if self.chi >= chi_opt:\\n chi_opt = self.chi\\n self.xs_opt = xs_opt\\n self.ps_opt = ps_opt\\n self.Ws_opt = Ws_opt\\n self.chi_opt = chi_opt\\n self.nu_opt = nu_opt\\n if self.iEC == \\\"est\\\":\\n self.Jcv_opt = (self.d1_over*self.b_over*np.sqrt(chi_opt)\\\\\\n +self.d2_over*self.c_over*self.g_over*nu_opt)/alp\\n print(\\\"Optimal steady-state estimation error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n elif self.iEC == \\\"con\\\":\\n self.Jcv_opt = self.d1_over*self.b_over*np.sqrt(chi_opt)/alp\\n print(\\\"Optimal steady-state tracking error =\\\",\\\\\\n \\\"{:.2f}\\\".format(self.Jcv_opt))\\n else:\\n raise ValueError('Invalid iEC: iEC = \\\"est\\\" or \\\"con\\\"')\\n self.M2cholM()\\n path = \\\"models/optvals/\\\"+self.fname\\n if os.path.exists(path) == False:\\n try:\\n os.makedirs(path)\\n except: \\n raise OSError(\\\"Creation of directory %s failed\\\" %path)\\n else:\\n print (\\\"Successfully created directory %s \\\" %path)\\n else:\\n print (\\\"Directory %s already exists\\\" %path)\\n np.save(path+\\\"/alp_opt.npy\\\",alp)\\n np.save(path+\\\"/chi_opt.npy\\\",self.chi_opt)\\n np.save(path+\\\"/nu_opt.npy\\\",self.nu_opt)\\n np.save(path+\\\"/Jcv_opt.npy\\\",self.Jcv_opt)\\n print(\\\"========================================================\\\")\\n print(\\\"==== SAMPLING OF CONTRACTION METRICS BY CV-STEM END ====\\\")\\n print(\\\"========================================================\\\\n\\\\n\\\")\\n pass\",\n \"def rk_adaptive(accel,m,r,h,v,recur,emin=10**-12,emax=10**-8,hmax=.1,hmin=.01,recurmax=100):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 4th order calculation\\n new_v4 = v + h*(25/216.*k1v + 1408/2565.*k3v + 2197/4104.*k4v - 1/5.*k5v)\\n new_r4 = r + h*(25/216.*k1r + 1408/2565.*k3r + 2197/4104.*k4r - 1/5.*k5r)\\n \\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n\\n # Calculate truncation error between 5th and 4th order\\n eps = np.abs( (np.max(np.abs(new_r5)) - np.max(np.abs(new_r4))) / np.max(np.abs(new_r4)))\\n \\n # Compare eps to emin and emax and update h accordingly\\n if np.max(eps) < emin:\\n if h*2.0 < hmax:\\n h *= 2.0\\n new_v = new_v5\\n new_r = new_r5 \\n \\n if np.max(eps) > emax:\\n if h/2.0 > hmin:\\n h /= 2.0\\n print h\\n # Error too large, call rk_adaptive again with smaller h\\n if recur < recurmax:\\n recur += 1\\n rk_adaptive(accel,m,r,h,v,recur)\\n new_v = new_v5\\n new_r = new_r5\\n \\n else:\\n new_v = new_v5\\n new_r = new_r5\\n \\n return new_v, new_r, h\",\n \"def prepare_CvD16_for_M2L_calc(templates_lam_range, verbose=False):\\n import glob\\n import os\\n template_glob=os.path.expanduser('~/z/Data/stellarpops/CvD2/vcj_models/VCJ_*.s100')\\n\\n vcj_models=sorted(glob.glob(template_glob))\\n temp_lamdas, x35, x3, x23, kroupa, flat=np.genfromtxt(vcj_models[-1], unpack=True)\\n\\n n_ages=7\\n n_zs=5\\n n_imfs=5\\n\\n \\n\\n\\n Zs=['m1.5', 'm1.0', 'm0.5', 'p0.0', 'p0.2']\\n ages=[1.0, 3.0, 5.0, 7.0, 9.0, 11.0, 13.5]\\n model_imfs_order=['x35', 'x3', 'x23', 'kroupa', 'flat']\\n\\n t_mask = ((temp_lamdas > templates_lam_range[0]) & (temp_lamdas <templates_lam_range[1]))\\n\\n\\n\\n y=x35[t_mask]\\n x=temp_lamdas[t_mask]\\n\\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\\n new_x=temp_lamdas[t_mask][0]+0.9*(np.arange(np.ceil((temp_lamdas[t_mask][-1]-temp_lamdas[t_mask][0])/0.9))+1)\\n interp=si.interp1d(x, y, fill_value='extrapolate')\\n out=interp(new_x)\\n\\n templates=np.empty((len(out), n_ages, n_zs, n_imfs))\\n\\n\\n\\n for a, Z in enumerate(Zs): \\n for b, age in enumerate(ages):\\n model=glob.glob(os.path.expanduser('~/z/Data/stellarpops/CvD2/vcj_models/VCJ_*{}*{}.ssp.s100'.format(Z, age)))[0]\\n if verbose:\\n print 'Loading {}'.format(model)\\n data=np.genfromtxt(model)\\n\\n for c, counter in enumerate(reversed(range(1, data.shape[-1]))):\\n \\n #Interpolate templates onto a uniform wavelength grid and then log-rebin\\n y=data[:, counter][t_mask] \\n x=temp_lamdas[t_mask]\\n #Make a new lamda array, carrying on the delta lamdas of high resolution bit\\n new_x=temp_lamdas[t_mask][0]+0.9*(np.arange(np.ceil((temp_lamdas[t_mask][-1]-temp_lamdas[t_mask][0])/0.9))+1)\\n\\n interp=si.interp1d(x, y, fill_value='extrapolate')\\n out=interp(new_x) \\n\\n templates[:, b, a, c]=out\\n\\n return templates, new_x\",\n \"def evolve(self, k_vec, Nt,**kwargs):\\n \\n M_eff = np.eye((self.Nd), dtype=complex) # aux matrix\\n T = 1.\\n for it in range(Nt):\\n \\n # update the Hamiltonian for time-inteval\\n self.updateH(k_vec, it)\\n\\n # return eigenenergies and vectors\\n E_k, U = lg.eig(self.H_kc) \\n\\n # U^-1 * exp(H_d) U\\n U_inv = lg.inv(U)\\n\\n # construct a digonal matrix out of a vector\\n M1 = (np.exp(-1.j*E_k*T) * U_inv.T).T\\n\\n #MM = np.dot(U_inv,np.dot(H_M, U))\\n MM = np.dot(U,M1)\\n M_eff = np.dot(M_eff,MM)\\n # end of loop\\n Ek, Uk = lg.eig( M_eff )\\n idx = (np.log(Ek).imag).argsort()\\n Efl_k = np.log(Ek).imag[idx]\\n Ufl_k = Uk[idx]\\n return Efl_k, Ufl_k\",\n \"def jackknifed_coh_variance(tx, ty, eigvals, adaptive=True):\\r\\n\\r\\n K = tx.shape[0]\\r\\n\\r\\n # calculate leave-one-out estimates of MSC (magnitude squared coherence)\\r\\n jk_coh = []\\r\\n # coherence is symmetric (right??)\\r\\n sides = 'onesided'\\r\\n all_orders = set(range(K))\\r\\n\\r\\n import nitime.algorithms as alg\\r\\n\\r\\n # get the leave-one-out estimates\\r\\n for i in range(K):\\r\\n items = list(all_orders.difference([i]))\\r\\n tx_i = np.take(tx, items, axis=0)\\r\\n ty_i = np.take(ty, items, axis=0)\\r\\n eigs_i = np.take(eigvals, items)\\r\\n if adaptive:\\r\\n wx, _ = adaptive_weights(tx_i, eigs_i, sides=sides)\\r\\n wy, _ = adaptive_weights(ty_i, eigs_i, sides=sides)\\r\\n else:\\r\\n wx = wy = eigs_i[:, None]\\r\\n # The CSD\\r\\n sxy_i = alg.mtm_cross_spectrum(tx_i, ty_i, (wx, wy), sides=sides)\\r\\n # The PSDs\\r\\n sxx_i = alg.mtm_cross_spectrum(tx_i, tx_i, wx, sides=sides)\\r\\n syy_i = alg.mtm_cross_spectrum(ty_i, ty_i, wy, sides=sides)\\r\\n # these are the | c_i | samples\\r\\n msc = np.abs(sxy_i)\\r\\n msc /= np.sqrt(sxx_i * syy_i)\\r\\n jk_coh.append(msc)\\r\\n\\r\\n jk_coh = np.array(jk_coh)\\r\\n # now normalize the coherence estimates and take the mean\\r\\n normalize_coherence(jk_coh, 2 * K - 2, copy=False) # inplace\\r\\n jk_avg = np.mean(jk_coh, axis=0)\\r\\n\\r\\n jk_var = (jk_coh - jk_avg)\\r\\n np.power(jk_var, 2, jk_var)\\r\\n jk_var = jk_var.sum(axis=0)\\r\\n\\r\\n # Do/Don't use the alternative scaling here??\\r\\n f = float(K - 1) / K\\r\\n\\r\\n jk_var *= f\\r\\n\\r\\n return jk_var\",\n \"def tuto_kernel_overview(optimize=True, plot=True):\\r\\n ker1 = GPy.kern.rbf(1) # Equivalent to ker1 = GPy.kern.rbf(input_dim=1, variance=1., lengthscale=1.)\\r\\n ker2 = GPy.kern.rbf(input_dim=1, variance = .75, lengthscale=2.)\\r\\n ker3 = GPy.kern.rbf(1, .5, .5)\\r\\n\\r\\n print ker2\\r\\n\\r\\n if plot:\\r\\n ker1.plot()\\r\\n ker2.plot()\\r\\n ker3.plot()\\r\\n\\r\\n k1 = GPy.kern.rbf(1,1.,2.)\\r\\n k2 = GPy.kern.Matern32(1, 0.5, 0.2)\\r\\n\\r\\n # Product of kernels\\r\\n k_prod = k1.prod(k2) # By default, tensor=False\\r\\n k_prodtens = k1.prod(k2,tensor=True)\\r\\n\\r\\n # Sum of kernels\\r\\n k_add = k1.add(k2) # By default, tensor=False\\r\\n k_addtens = k1.add(k2,tensor=True)\\r\\n\\r\\n k1 = GPy.kern.rbf(1,1.,2)\\r\\n k2 = GPy.kern.periodic_Matern52(1,variance=1e3, lengthscale=1, period = 1.5, lower=-5., upper = 5)\\r\\n\\r\\n k = k1 * k2 # equivalent to k = k1.prod(k2)\\r\\n print k\\r\\n\\r\\n # Simulate sample paths\\r\\n X = np.linspace(-5,5,501)[:,None]\\r\\n Y = np.random.multivariate_normal(np.zeros(501),k.K(X),1)\\r\\n\\r\\n k1 = GPy.kern.rbf(1)\\r\\n k2 = GPy.kern.Matern32(1)\\r\\n k3 = GPy.kern.white(1)\\r\\n\\r\\n k = k1 + k2 + k3\\r\\n print k\\r\\n\\r\\n k.constrain_positive('.*var')\\r\\n k.constrain_fixed(np.array([1]),1.75)\\r\\n k.tie_params('.*len')\\r\\n k.unconstrain('white')\\r\\n k.constrain_bounded('white',lower=1e-5,upper=.5)\\r\\n print k\\r\\n\\r\\n k_cst = GPy.kern.bias(1,variance=1.)\\r\\n k_mat = GPy.kern.Matern52(1,variance=1., lengthscale=3)\\r\\n Kanova = (k_cst + k_mat).prod(k_cst + k_mat,tensor=True)\\r\\n print Kanova\\r\\n\\r\\n # sample inputs and outputs\\r\\n X = np.random.uniform(-3.,3.,(40,2))\\r\\n Y = 0.5*X[:,:1] + 0.5*X[:,1:] + 2*np.sin(X[:,:1]) * np.sin(X[:,1:])\\r\\n\\r\\n # Create GP regression model\\r\\n m = GPy.models.GPRegression(X, Y, Kanova)\\r\\n\\r\\n if plot:\\r\\n fig = pb.figure(figsize=(5,5))\\r\\n ax = fig.add_subplot(111)\\r\\n m.plot(ax=ax)\\r\\n\\r\\n pb.figure(figsize=(20,3))\\r\\n pb.subplots_adjust(wspace=0.5)\\r\\n axs = pb.subplot(1,5,1)\\r\\n m.plot(ax=axs)\\r\\n pb.subplot(1,5,2)\\r\\n pb.ylabel(\\\"= \\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,3)\\r\\n m.plot(ax=axs, which_parts=[False,True,False,False])\\r\\n pb.ylabel(\\\"cst +\\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,4)\\r\\n m.plot(ax=axs, which_parts=[False,False,True,False])\\r\\n pb.ylabel(\\\"+ \\\",rotation='horizontal',fontsize='30')\\r\\n axs = pb.subplot(1,5,5)\\r\\n pb.ylabel(\\\"+ \\\",rotation='horizontal',fontsize='30')\\r\\n m.plot(ax=axs, which_parts=[False,False,False,True])\\r\\n\\r\\n return(m)\",\n \"def rk5(accel,m,r,h,v):\\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (3/32.*k1r + 9/32.*k2r)*h)\\n k3r = v + (3/32.*k1v + 9/32.*k2v)*h\\n k4v = accel(m,r + (1932/2197.*k1r - 7200/2197.*k2r + 7296/2197.*k3r)*h)\\n k4r = v + (1932/2197.*k1v - 7200/2197.*k2v + 7296/2197.*k3v)*h\\n k5v = accel(m,r + (439/216.*k1r - 8*k2r + 3680/513.*k3r - 845/4104.*k4r)*h)\\n k5r = v + (439/216.*k1v - 8*k2v + 3680/513.*k3v - 845/4104.*k4v)*h\\n k6v = accel(m,r - (8/27.*k1r + 2*k2r - 3544/2565.*k3r + 1859/4104.*k4r - 11/40.*k5r)*h)\\n k6r = v - (8/27.*k1v + 2*k2v - 3544/2565.*k3v + 1859/4104.*k4v - 11/40.*k5v)*h\\n\\n # 5th order calculation\\n new_v5 = v + h*(16/135.*k1v + 6656/12825.*k3v+28561/56430.*k4v - 9/50.*k5v + 2/55.*k6v) \\n new_r5 = r + h*(16/135.*k1r + 6656/12825.*k3r+28561/56430.*k4r - 9/50.*k5r + 2/55.*k6r) \\n \\n return new_v5, new_r5\",\n \"def model(cp_list,cp_now):\\r\\n global record\\r\\n distance_threshold = 0.5\\r\\n model_path = \\\"trained_knn_model.clf\\\"\\r\\n \\r\\n # Load a trained KNN model (if one was passed in)\\r\\n with open(model_path, 'rb') as f:\\r\\n knn_clf = pickle.load(f)\\r\\n\\r\\n for X_img in cp_list:\\r\\n # Load image file and find face locations\\r\\n X_face_locations = face_recognition.face_locations(X_img)\\r\\n\\r\\n # If no faces are found in the image, return an empty result.\\r\\n if len(X_face_locations) == 0:\\r\\n return []\\r\\n\\r\\n # Find encodings for faces in the test iamge\\r\\n faces_encodings = face_recognition.face_encodings(X_img, known_face_locations=X_face_locations)\\r\\n\\r\\n # Use the KNN model to find the best matches for the test face\\r\\n closest_distances = knn_clf.kneighbors(faces_encodings, n_neighbors=1)\\r\\n are_matches = [closest_distances[0][i][0] <= distance_threshold for i in range(len(X_face_locations))]\\r\\n # Predict classes and remove classifications that aren't within the threshold\\r\\n for pred, rec in zip(knn_clf.predict(faces_encodings), are_matches):\\r\\n if rec:\\r\\n name = pred\\r\\n else:\\r\\n name = \\\"unknown\\\"\\r\\n if name not in record:\\r\\n end = datetime.now()\\r\\n record.append(name)\\r\\n record_time.append(end-cp_now)\",\n \"def component_func(B, C, F, list_funcs, len_kegg, threshold=0.05):\\n\\n size_label = 18\\n size_tick = 18\\n sns.set_style(\\\"darkgrid\\\")\\n\\n list_funcs = list_funcs[0:len_kegg]\\n B = B[0:len_kegg]\\n C = C[0:len_kegg]\\n\\n idx_p = [idx*2+0 for idx in range(B.shape[1]/2)]\\n idx_m = [idx*2+1 for idx in range(B.shape[1]/2)]\\n is_p = F[:,idx_p].mean(axis=1) - F[:,idx_m].mean(axis=1) > threshold\\n is_m = F[:,idx_m].mean(axis=1) - F[:,idx_p].mean(axis=1) > threshold\\n is_p = [idx for idx, val in enumerate(is_p) if val]\\n is_m = [idx for idx, val in enumerate(is_m) if val]\\n is_n = [idx for idx in range(C.shape[1]) if (idx not in is_p) and (idx not in is_m)]\\n\\n fig = plt.figure(figsize=(6, 6))\\n\\n for idx_c in range(C.shape[1]):\\n clone_num = idx_c +1\\n if idx_c in is_p:\\n color=\\\"green\\\"\\n label = \\\"C\\\"+str(clone_num)+\\\"|P\\\"\\n elif idx_c in is_m:\\n color=\\\"red\\\"\\n label = \\\"C\\\"+str(clone_num)+\\\"|M\\\"\\n else:\\n color = \\\"royalblue\\\"\\n label = \\\"C\\\"+str(clone_num)\\n\\n if clone_num in [1]:\\n marker = \\\"$1$\\\"\\n elif clone_num in [2]:\\n marker = \\\"$2$\\\"\\n elif clone_num in [3]:\\n marker = \\\"$3$\\\"\\n elif clone_num in [4]:\\n marker = \\\"$4$\\\"\\n elif clone_num in [5]:\\n marker = \\\"$5$\\\"\\n elif clone_num in [6]:\\n marker = \\\"$6$\\\"\\n else:\\n print(\\\"error\\\")\\n plt.plot(C[:,idx_c],range(len_kegg), color=color, marker=marker, markersize=10, linestyle=\\\"\\\",label=label, alpha=0.5)\\n\\n plt.yticks(range(len_kegg), list_funcs)\\n plt.xlabel(\\\"Pathway strength\\\", fontsize=size_label)\\n plt.legend()\\n plt.tick_params(labelsize=size_tick-4)\\n plt.show()\\n ##fig.savefig(\\\"figures/fig7compfunc.pdf\\\", bbox_inches=\\\"tight\\\")\",\n \"def solveverlet(self,T,dt):\\r\\n t = 0.\\r\\n self.dt = dt\\r\\n self.n = int(T/dt)\\r\\n L = self.param[2]\\r\\n N = self.particles.size\\r\\n\\r\\n self.U = np.zeros([self.n])\\r\\n\\r\\n progress = t/T*100\\r\\n\\r\\n #JV: Here we define the number of the GxG grid that we will need to calcule the entropy, change in order to change the precision of this grid\\r\\n self.G = 7\\r\\n\\r\\n #JV: We create a list that will be useful for the walls submenu, that will help us in the border conditions of the wall, see in vel_verlet()\\r\\n self.bouncing = np.zeros(self.particles.size)\\r\\n\\r\\n if(self.param[4] == \\\"Subsystems\\\"): #JV: If we are on \\\"Subsystems\\\", we will count different the types of particles\\r\\n self.grid = np.zeros([self.G,self.G,2])\\r\\n else:\\r\\n self.grid = np.zeros([self.G,self.G,2]) #JV: When we are not in \\\"Subsystems\\\", we will have the same type of variable, but will only use the [:,:,0] (this is because numba has problems otherwise)\\r\\n\\r\\n self.entropy_val = 0\\r\\n\\r\\n #JV: If we are simulating the brownian simulation, we initialize the array that will keep track if the brownian particle goes through a wall\\r\\n if(self.param[4] == \\\"Brownian\\\"):\\r\\n self.wallcount = np.zeros([2])\\r\\n else:\\r\\n self.wallcount = np.zeros([2]) #JV: We have to keep both in the same type of variables, otherwise numba will have problems. So now this conditional block is quite poinless. TO-ERASE\\r\\n\\r\\n np.vectorize(lambda i: i.reset())(self.particles) #This line resets the particles to their initial position\\r\\n\\r\\n self.vel_verlet_on = True #JV: If it's true, it will compute with the velocity verlet algorithm, if it's not, it will compute with normal verlet\\r\\n\\r\\n self.Nlist = int(1*(self.particles.size)**(1/2)) #JV:This variable defines the number of close particles that will be stored in the list (go to close_particles_list() for more info)\\r\\n #print(self.Nlist)\\r\\n\\r\\n #X,Y,VX,VY has the trajectories of the particles with two indexes that\\r\\n #access time and particles, respectively\\r\\n self.X = np.vectorize(lambda i: i.r[0])(self.particles)\\r\\n self.Y = np.vectorize(lambda i: i.r[1])(self.particles)\\r\\n self.VX = np.vectorize(lambda i: i.v[0])(self.particles)\\r\\n self.VY = np.vectorize(lambda i: i.v[1])(self.particles)\\r\\n\\r\\n MX, MXT = np.meshgrid(self.X[:],self.X[:])\\r\\n MY, MYT = np.meshgrid(self.Y[:],self.Y[:])\\r\\n\\r\\n #JV: So dx is a nxn simetric array with 0 in the diagonal, and each position is the corresponding distance between the particles,\\r\\n # so the position [1,2] is the distance between partcle 1 and 2 (x1-x2), and so on\\r\\n dx = MXT - MX\\r\\n dx = dx\\r\\n\\r\\n dy = MYT - MY\\r\\n dy = dy\\r\\n\\r\\n r2 = np.square(dx)+np.square(dy)\\r\\n\\r\\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: we first calculate the matrix that contains in every row the indexs of the m closest particles\\r\\n\\r\\n if(self.vel_verlet_on == True):\\r\\n #JV: We define the variables that we will need in the velocity verlet algorithm\\r\\n print(\\\"Computing with the Velocity-Verlet algorithm\\\")\\r\\n X0 = self.X\\r\\n Y0 = self.Y\\r\\n VX0 = self.VX\\r\\n VY0 = self.VY\\r\\n\\r\\n X1 = self.X\\r\\n Y1 = self.Y\\r\\n VX1 = self.VX\\r\\n VY1 = self.VY\\r\\n\\r\\n MX, MXT = np.meshgrid(X0[:],X0[:],copy=False)\\r\\n MY, MYT = np.meshgrid(Y0[:],Y0[:],copy=False)\\r\\n dx = MXT - MX\\r\\n dx = dx\\r\\n\\r\\n dy = MYT - MY\\r\\n dy = dy\\r\\n\\r\\n r2 = np.square(dx)+np.square(dy)\\r\\n\\r\\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\\r\\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\\r\\n\\r\\n a0 = (1/self.m)*np.transpose(fv(X0[:],Y0[:],dx,dy,r2,t/self.dt,False,self.param[2],self.particles.size,self.U,self.dt,self.close_list,self.Nlist,self.vel_verlet_on,self.R,self.param[3],self.param[4],self.param[5],self.grid,self.G,self.wallcount,self.X2))\\r\\n\\r\\n for i in range(0, self.n):\\r\\n r1 = np.array([X0,Y0]) + np.array([VX0,VY0])*dt + 0.5*a0*dt**2\\r\\n\\r\\n MX, MXT = np.meshgrid(r1[0,:],r1[0,:],copy=False)\\r\\n MY, MYT = np.meshgrid(r1[1,:],r1[1,:],copy=False)\\r\\n dx = MXT - MX\\r\\n dx = dx\\r\\n\\r\\n dy = MYT - MY\\r\\n dy = dy\\r\\n\\r\\n r2 = np.square(dx)+np.square(dy)\\r\\n\\r\\n if(self.param[3] == \\\"Free!\\\"):\\r\\n #JV: We do this to get the actual distance in the case of the \\\"Free!\\\" simulation, in which there is no elastic collision between the particles and the boundaries\\r\\n dx_v2 = (np.abs(dx.copy())-1*L)\\r\\n r2_v2 = dx_v2**2+dy**2\\r\\n dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\\r\\n r2 = np.where(r2 > r2_v2,r2_v2,r2)\\r\\n dy_v2 = (np.abs(dy.copy())-1*L)\\r\\n r2_v2 = dx**2+dy_v2**2\\r\\n dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\\r\\n r2 = np.where(r2 > r2_v2,r2_v2,r2)\\r\\n r2_v2 = dx_v2**2+dy_v2**2\\r\\n dx = np.where(r2 > r2_v2,dx_v2*np.sign(dx),dx)\\r\\n dy = np.where(r2 > r2_v2,dy_v2*np.sign(dy),dy)\\r\\n r2 = np.where(r2 > r2_v2,r2_v2,r2)\\r\\n\\r\\n #JV: call velocityverlet to compute the next position\\r\\n if(np.round((t/self.dt*dt)%0.5,1) == 0): #JV: every certain amount of steps we update the list\\r\\n self.close_list = close_particles_list(r2,self.Nlist,self.particles.size,self.param[2]) #JV: matrix that contains in every row the indexs of the m closest particles\\r\\n\\r\\n X1,Y1,VX1,VY1,a1 = vel_verlet(t,dt,np.array([X0,Y0]),np.array([VX0,VY0]),a0,dx,dy,r2,self.close_list,self.m,self.R,L,N,self.param[3],self.param[4],self.param[7],self.param[8],self.param[9],self.U,self.Nlist,self.vel_verlet_on,self.param[5],self.grid,self.G,self.wallcount,self.X2,self.bouncing)\\r\\n\\r\\n #JV: Now we check where this particle is in a RxR grid, that will help us to calcule the entropy. We do not do this for the Brownian mode because we don't compute the entropy in that case.\\r\\n if(self.param[4] != \\\"Brownian\\\"):\\r\\n for h in range(0, N):\\r\\n if(self.param[4] == \\\"Subsystems\\\"):\\r\\n if(h < self.param[5]**2): #JV: self.param[5] stores the number of n1xn1 type 1 particles\\r\\n self.grid[int((X1[h]+0.495*L) / (L/self.G)), int((Y1[h]+0.495*L) / (L/self.G)),0] += 1\\r\\n else:\\r\\n self.grid[int((X1[h]+0.495*L) / (L/self.G)), int((Y1[h]+0.495*L) / (L/self.G)),1] += 1\\r\\n else:\\r\\n self.grid[int((X1[h]+0.495*L) / (L/self.G)), int((Y1[h]+0.495*L) / (L/self.G))] += 1\\r\\n\\r\\n if(self.param[4] == \\\"Brownian\\\"):\\r\\n if(self.wallcount[0] == 0):\\r\\n self.X2 = np.append(self.X2,(abs(X1[N-1]))**2)\\r\\n else:\\r\\n self.X2 = np.append(self.X2,(L*self.wallcount[0]+(X1[N-1]))**2)\\r\\n self.entropy = np.append(self.entropy,self.entropy_val)\\r\\n\\r\\n t += dt\\r\\n\\r\\n self.X = np.vstack((self.X,X1))\\r\\n self.Y = np.vstack((self.Y,Y1))\\r\\n self.VX = np.vstack((self.VX, VX1))\\r\\n self.VY = np.vstack((self.VY, VY1))\\r\\n a0 = a1\\r\\n\\r\\n #Redefine and repeat\\r\\n X0,Y0 = X1,Y1\\r\\n VX0,VY0 = VX1,VY1\\r\\n\\r\\n #JV: Every amount of steps of time we calculate the entropy\\r\\n update_entropy = 2\\r\\n if(i % update_entropy == 0):\\r\\n\\r\\n self.entropy_val = 0\\r\\n sumagrid = np.sum(self.grid)\\r\\n\\r\\n if(self.param[4] == \\\"Subsystems\\\"):\\r\\n sumagrid_subs = np.zeros([2])\\r\\n sumagrid_subs[0] = np.sum(self.grid[:,:,0]) #JV: Number of type-0 particles\\r\\n sumagrid_subs[1] = sumagrid - sumagrid_subs[0] #JV: Number of type-1 particles\\r\\n\\r\\n for j in range(self.G):\\r\\n for k in range(self.G):\\r\\n for l in range(2):\\r\\n if ((self.grid[j,k,0]+self.grid[j,k,1]) != 0):\\r\\n # pji = float(self.grid[j,k,l])/(update_entropy*(self.grid[j,k,0]+self.grid[j,k,1]))\\r\\n pji = float((self.grid[j,k,l]/(sumagrid_subs[l]/(sumagrid_subs[0]+sumagrid_subs[1])))/(update_entropy*(self.grid[j,k,0]/(sumagrid_subs[0]/(sumagrid_subs[0]+sumagrid_subs[1])))+(self.grid[j,k,1]/(sumagrid_subs[1]/(sumagrid_subs[0]+sumagrid_subs[1])))))\\r\\n else:\\r\\n pji = 0\\r\\n if(pji != 0):\\r\\n self.entropy_val += -pji*np.log(pji) #JV: We will only calculate the value when pji != 0\\r\\n\\r\\n self.entropy_val = self.entropy_val /(self.G**2)\\r\\n\\r\\n else:\\r\\n for j in range(self.G):\\r\\n for k in range(self.G):\\r\\n pji = float(self.grid[j,k,0])/(update_entropy*sumagrid)\\r\\n if(pji != 0):\\r\\n self.entropy_val += -pji*np.log(pji)\\r\\n\\r\\n self.entropy_val = self.entropy_val /(self.G**2)\\r\\n\\r\\n if(self.param[4] == \\\"Subsystems\\\"):\\r\\n self.grid = np.zeros([self.G,self.G,2])\\r\\n else:\\r\\n self.grid = np.zeros([self.G,self.G,2])\\r\\n\\r\\n #Update and show progress through console\\r\\n progress = t/T*100\\r\\n if(i%1000 == 0):\\r\\n print(int(progress),'% done')\\r\\n\\r\\n else:\\r\\n print(\\\"Computing with the Verlet algorithm\\\")\\r\\n\\r\\n #Generation of the precious position (backwards euler step)\\r\\n X1 = self.X\\r\\n Y1 = self.Y\\r\\n X0 = X1 - self.VX*dt\\r\\n Y0 = Y1 - self.VY*dt\\r\\n\\r\\n for self.i in range(0,self.n):\\r\\n #Call verlet to compute the next position\\r\\n X2,Y2 = self.verlet(t,dt,np.array([X0,Y0]),np.array([X1,Y1]))\\r\\n t = t + dt\\r\\n\\r\\n #Add the new positions to X,Y,VX,VY\\r\\n self.X = np.vstack((self.X,X2))\\r\\n self.Y = np.vstack((self.Y,Y2))\\r\\n self.VX = np.vstack((self.VX,(X2-X0)/(2*dt)))\\r\\n self.VY = np.vstack((self.VY,(Y2-Y0)/(2*dt)))\\r\\n\\r\\n #Redefine and repeat\\r\\n X0,Y0 = X1,Y1\\r\\n X1,Y1 = X2,Y2\\r\\n\\r\\n #Update and show progress through console\\r\\n progress = t/T*100\\r\\n if(self.i%1000 == 0):\\r\\n print(int(progress),'% done')\\r\\n\\r\\n #Once the computation has ended, I compute the kinetic energy,\\r\\n #the magnitude of the velocity V and the temperature\\r\\n #(see doc for temperature definition)\\r\\n self.KE()\\r\\n self.V = np.sqrt((self.VX**2 + self.VY**2))\\r\\n self.T = (np.sum(self.V**2,axis=1)/(self.particles.size*2 - 2))\\r\\n\\r\\n #Generation of the MB functions, you can modify the definition by\\r\\n #changing the linspace points\\r\\n vs,a = np.meshgrid(np.linspace(0,self.V.max(),100),self.T)\\r\\n a,ts = np.meshgrid(np.linspace(0,self.V.max(),100),self.T)\\r\\n self.MB = (vs/(ts)*np.exp(-vs**2/(2*ts)))\\r\\n\\r\\n #JV: If we are on the Subsystems submenu, we will calculate the temperature and the MB distribution of both types of particles\\r\\n if(self.param[4] == \\\"Subsystems\\\"):\\r\\n\\r\\n #JV: 1st group of particles\\r\\n self.V1 = np.sqrt((self.VX[:,0:(self.param[5]**2)]**2 + self.VY[:,0:(self.param[5]**2)]**2))\\r\\n self.T1 = (np.sum(self.V1**2,axis=1)/((self.param[5]**2)*2 - 2))\\r\\n\\r\\n vs1,a1 = np.meshgrid(np.linspace(0,self.V1.max(),100),self.T1)\\r\\n a1,ts1 = np.meshgrid(np.linspace(0,self.V1.max(),100),self.T1)\\r\\n self.MB1 = (vs1/(ts1)*np.exp(-vs1**2/(2*ts1)))\\r\\n\\r\\n #JV: 2nd group\\r\\n self.V2 = np.sqrt((self.VX[:,(self.param[5]**2):self.particles.size]**2 + self.VY[:,(self.param[5]**2):self.particles.size]**2))\\r\\n self.T2 = (np.sum(self.V2**2,axis=1)/((self.particles.size-self.param[5]**2)*2 - 2))\\r\\n\\r\\n vs2,a2 = np.meshgrid(np.linspace(0,self.V2.max(),100),self.T2)\\r\\n a2,ts2 = np.meshgrid(np.linspace(0,self.V2.max(),100),self.T2)\\r\\n self.MB2 = (vs2/(ts2)*np.exp(-vs2**2/(2*ts2)))\\r\\n\\r\\n \\\"\\\"\\\"Here I generate the accumulated V,T and MB using lists, the reason I use lists is because if you append two numpy arrays\\r\\n to an empty numpy array, they merge instead of remaining separate. You could technically use splicing to save on memory\\r\\n but sacrificing cpu.\\\"\\\"\\\"\\r\\n\\r\\n self.Vacu = []\\r\\n self.Tacu = []\\r\\n self.MBacu = []\\r\\n self.Vacu.append(self.V[int(self.n/2),:])\\r\\n self.Tacu.append(np.sum(self.V[int(self.n/2),:]**2)/(self.particles.size*2 - 2))\\r\\n\\r\\n vs = np.linspace(0,self.V.max(),100)\\r\\n self.MBacu.append((vs/(self.Tacu[0])*np.exp(-vs**2/(2*self.Tacu[0]))))\\r\\n\\r\\n #This delta controls the time interval for accumulation, right now its every 5 units\\r\\n delta = 5./dt\\r\\n\\r\\n #This 40 that appers in these lines is the time from which I start accumulating\\r\\n #to ensure the system has reached equilibrium.\\r\\n for i in range(1,int((self.n-(40./dt))/delta)):\\r\\n self.Vacu.append(np.hstack((self.Vacu[i-1],self.V[int(40./dt)+int(i*delta),:])))\\r\\n self.Tacu.append(np.sum(self.Vacu[i]**2)/(self.Vacu[i].size*2 - 2))\\r\\n self.MBacu.append((vs/(self.Tacu[i])*np.exp(-vs**2/(2*self.Tacu[i]))))\\r\\n return\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def getContSpec(par):\\n # read input\\n if par['verbose']:\\n print('\\\\n(*) Start\\\\n(*) Loading Data File: {}...'.format(par['GexpFile']))\\n\\n # t, Gexp = GetExpData(par['GexpFile'])\\n t, Gexp, wexp = GetExpData(par['GexpFile'])\\n\\n if par['verbose']:\\n print('(*) Initial Set up...', end=\\\"\\\")\\n \\n # Set up some internal variables\\n n = len(t)\\n ns = par['ns'] # discretization of 'tau'\\n\\n tmin = t[0];\\n tmax = t[n-1];\\n \\n # determine frequency window\\n if par['FreqEnd'] == 1:\\n smin = np.exp(-np.pi/2) * tmin; smax = np.exp(np.pi/2) * tmax\\t\\t\\n elif par['FreqEnd'] == 2:\\n smin = tmin; smax = tmax\\t\\t\\t\\t\\n elif par['FreqEnd'] == 3:\\n smin = np.exp(+np.pi/2) * tmin; smax = np.exp(-np.pi/2) * tmax\\t\\t\\n\\n hs = (smax/smin)**(1./(ns-1))\\n s = smin * hs**np.arange(ns)\\n \\n kernMat = getKernMat(s, t)\\n tic = time.time()\\n \\n # get an initial guess for Hgs, G0\\n if par['plateau']:\\n Hgs, G0 = InitializeH(Gexp, wexp, s, kernMat, np.min(Gexp))\\t\\t\\n else:\\n Hgs = InitializeH(Gexp, wexp, s, kernMat)\\n \\n if par['verbose']:\\n te = time.time() - tic\\n print('\\\\t({0:.1f} seconds)\\\\n(*) Building the L-curve ...'.format(te), end=\\\"\\\")\\t\\n tic = time.time()\\n\\n # Find Optimum Lambda with 'lcurve'\\n if par['lamC'] == 0:\\n if par['plateau']:\\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par, G0)\\n else:\\n lamC, lam, rho, eta, logP, Hlam = lcurve(Gexp, wexp, Hgs, kernMat, par)\\n else:\\n lamC = par['lamC']\\n\\n if par['verbose']:\\n te = time.time() - tic\\n print('({1:.1f} seconds)\\\\n(*) Extracting CRS, ...\\\\n\\\\t... lamC = {0:0.3e}; '.\\n format(lamC, te), end=\\\"\\\")\\n \\n tic = time.time()\\n\\n # Get the best spectrum\\t\\n if par['plateau']:\\n H, G0 = getH(lamC, Gexp, wexp, Hgs, kernMat, G0);\\n print('G0 = {0:0.3e} ...'.format(G0), end=\\\"\\\")\\n else:\\n H = getH(lamC, Gexp, wexp, Hgs, kernMat);\\n\\n #----------------------\\n # Print some datafiles\\n #----------------------\\n\\n if par['verbose']:\\n te = time.time() - tic\\n print('done ({0:.1f} seconds)\\\\n(*) Writing and Printing, ...'.format(te), end=\\\"\\\")\\n\\n # Save inferred G(t)\\n if par['plateau']:\\n K = kernel_prestore(H, kernMat, G0);\\t\\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e', header='G0 = {0:0.3e}'.format(G0))\\n else:\\n K = kernel_prestore(H, kernMat);\\n np.savetxt('output/H.dat', np.c_[s, H], fmt='%e')\\n \\n np.savetxt('output/Gfit.dat', np.c_[t, K], fmt='%e')\\n\\n # print Hlam, rho-eta, and logP if lcurve has been visited\\n if par['lamC'] == 0:\\n if os.path.exists(\\\"output/Hlam.dat\\\"):\\n os.remove(\\\"output/Hlam.dat\\\")\\n \\n fHlam = open('output/Hlam.dat','ab')\\n for i, lamb in enumerate(lam):\\n np.savetxt(fHlam, Hlam[:,i])\\t\\n fHlam.close()\\t\\n\\n # print logP\\n np.savetxt('output/logPlam.dat', np.c_[lam, logP])\\n \\n # print rho-eta\\n np.savetxt('output/rho-eta.dat', np.c_[lam, rho, eta], fmt='%e')\\n\\n #------------\\n # Graphing\\n #------------\\n\\n if par['plotting']:\\n\\n # plot spectrum \\\"H.pdf\\\" with errorbars\\n plt.clf()\\n\\n plt.semilogx(s,H,'o-')\\n plt.xlabel(r'$s$')\\n plt.ylabel(r'$H(s)$')\\n\\n # error bounds are only available if lcurve has been implemented\\n if par['lamC'] == 0:\\n plam = np.exp(logP); plam = plam/np.sum(plam)\\t\\t\\t\\n Hm = np.zeros(len(s))\\n Hm2 = np.zeros(len(s))\\n cnt = 0\\n for i in range(len(lam)):\\t\\n #~ Hm += plam[i]*Hlam[:,i]\\n #~ Hm2 += plam[i]*Hlam[:,i]**2\\n # count all spectra within a threshold\\n if plam[i] > 0.1:\\n Hm += Hlam[:,i]\\n Hm2 += Hlam[:,i]**2\\n cnt += 1\\n\\n Hm = Hm/cnt\\n dH = np.sqrt(Hm2/cnt - Hm**2)\\n\\n plt.semilogx(s,Hm+2.5*dH, c='gray', alpha=0.5)\\n plt.semilogx(s,Hm-2.5*dH, c='gray', alpha=0.5)\\n\\n plt.tight_layout()\\n plt.savefig('output/H.pdf')\\n\\n\\n #\\n # plot comparison with input spectrum\\n #\\n\\n plt.clf()\\n\\n if par['plateau']:\\n K = kernel_prestore(H, kernMat, G0);\\t\\n else:\\n K = kernel_prestore(H, kernMat);\\n\\n plt.loglog(t, Gexp,'o',t, K, 'k-')\\n plt.xlabel(r'$t$')\\n plt.ylabel(r'$G(t)$')\\n plt.tight_layout()\\n plt.savefig('output/Gfit.pdf')\\n\\n\\n #\\n # if lam not explicitly specified then print rho-eta.pdf\\n #\\n\\n try:\\n lam\\n except NameError:\\n print(\\\"lamC prespecified, so not printing rho-eta.pdf/dat\\\")\\n else:\\n plt.clf()\\n plt.scatter(rho, eta, marker='x')\\n plt.plot(rho, eta)\\n\\n\\n rhost = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(rho)))\\n etast = np.exp(np.interp(np.log(lamC), np.log(lam), np.log(eta)))\\n\\n plt.plot(rhost, etast, 'o', color='k')\\n plt.xscale('log')\\n plt.yscale('log')\\n \\n #~ print(rhost, etast)\\n \\n plt.xlabel(r'$\\\\rho$')\\n plt.ylabel(r'$\\\\eta$')\\n plt.tight_layout()\\n plt.savefig('output/rho-eta.pdf')\\n\\n if par['verbose']:\\n print('done\\\\n(*) End\\\\n')\\n \\n return H, lamC\",\n \"def optical_kernels(K, J, Lxy, fmax, num):\\n\\n df = 1/Lxy\\n\\n # Compute TCC\\n TCC, f = trans_cross_coeff(K, J, df, fmax)\\n \\n # Convert to 2D matrix\\n N = f.size\\n TCCm = np.reshape(np.reshape(TCC, (N, N, -1)), (N**2, -1))\\n\\n # Compute largest eigenvalues and eigenvectors\\n w, v = scipy.linalg.eigh(TCCm, eigvals=(N**2 - num, N**2 - 1))\\n w = np.flip(w, 0)\\n v = np.flip(v, 1)\\n\\n # Get real-space optical kernels\\n phi = []\\n for i in range(num):\\n Phi = np.fft.ifftshift(np.reshape(v[:,i], [N, N]))\\n #phi.append(np.fft.fftshift(np.fft.ifft2(Phi)))\\n phi.append(np.fft.ifft2(Phi))\\n \\n return w, phi\",\n \"def Colect(N, R, Zeta1, Zeta2, Za, Zb):\\n # Form core hamiltonian\\n H[0, 0] = T11 + V11A + V11B\\n H[0, 1] = T12 + V12A + V12B\\n H[1, 0] = H[0, 1]\\n H[1, 1] = T22 + V22A + V22B\\n\\n # Form overlap matrix\\n S[0, 0] = 1.0\\n S[0, 1] = S12\\n S[1, 0] = S12\\n S[1, 1] = 1.0\\n\\n # This is S^-1/2\\n X[0, 0] = 1.0 / np.sqrt(2.0 * (1.0 + S12))\\n X[1, 0] = X[0, 0]\\n X[0, 1] = 1.0 / np.sqrt(2.0 * (1.0 - S12))\\n X[1, 1] = -X[0, 1]\\n\\n # This is the coulomb and exchange term (aa|bb) and (ab|ba)\\n TT[0, 0, 0, 0] = V1111\\n TT[1, 0, 0, 0] = V2111\\n TT[0, 1, 0, 0] = V2111\\n TT[0, 0, 1, 0] = V2111\\n TT[0, 0, 0, 1] = V2111\\n TT[1, 0, 1, 0] = V2121\\n TT[0, 1, 1, 0] = V2121\\n TT[1, 0, 0, 1] = V2121\\n TT[0, 1, 0, 1] = V2121\\n TT[1, 1, 0, 0] = V2211\\n TT[0, 0, 1, 1] = V2211\\n TT[1, 1, 1, 0] = V2221\\n TT[1, 1, 0, 1] = V2221\\n TT[1, 0, 1, 1] = V2221\\n TT[0, 1, 1, 1] = V2221\\n TT[1, 1, 1, 1] = V2222\",\n \"def generateHeatMask( im ):\\n featref = computeFeatures(im)\\n h,w,nbp = im.shape\\n print(\\\"w:%d,h:%d\\\"%(w,h))\\n heatMap = np.zeros((h,w,1), dtype=np.int8)\\n black = [0,0,0]\\n white = [255,255,255]\\n rMaxDiff = 0\\n for j in range(h):\\n print(\\\"j:%d\\\" % j )\\n for i in range(w):\\n #~ print(\\\"i:%d\\\" % i )\\n arDiff = []\\n for color in [black,white]:\\n #~ print(\\\"color:%s\\\" % color)\\n imt = np.copy(im)\\n \\n # quite same time on my tablet !!! \\n # (would have think the [] would be far fastest!)\\n if 0:\\n cv2.circle(imt, (i,j), 1, color )\\n else:\\n imt[j,i]=color\\n if 0:\\n cv2.imshow(\\\"imt\\\",imt)\\n cv2.waitKey(1)\\n #~ feat = computeFeatures(imt)\\n #~ rDiff = diffFeatures(featref,feat)\\n rDiff = mseFloat(im,imt)\\n arDiff.append(rDiff)\\n #~ print(rDiff)\\n rDiff = max(arDiff)\\n if rDiff > rMaxDiff:\\n rMaxDiff = rDiff\\n heatMap[j,i] = rDiff*10\\n print(\\\"rMaxDiff: %5.3f\\\" % rMaxDiff )\\n #~ print(dir(cv2))\\n #~ heatMap = cv2.resize(heatMap,(w*2,h*2))\\n cv2.namedWindow(\\\"heat\\\",cv2.CV_WINDOW_AUTOSIZE|cv2.WINDOW_NORMAL)\\n cv2.imshow(\\\"heat\\\",heatMap)\\n cv2.resizeWindow(\\\"heat\\\",600,480)\\n cv2.waitKey(0)\",\n \"def BACF_optimized(params):\\n import math as m\\n import numpy as np\\n import cv2\\n import time\\n import matplotlib.pyplot as plt\\n import matplotlib.patches as patches\\n\\n from resizeDFT2 import resizeDFT2\\n from get_pixels import get_pixels\\n from get_features import get_features\\n from resp_newton import resp_newton\\n from get_subwindow_no_window import get_subwindow_no_window\\n\\n # Setting parameters\\n search_area_scale = params['search_area_scale'] # size of training/detection area proportional to the target size\\n output_sigma_factor = params['output_sigma_factor']\\n learning_rate = params['learning_rate']\\n filter_max_area = params['filter_max_area']\\n nScales = params['number_of_scales'] # number of scale resolutions to check\\n scale_step = params['scale_step']\\n interpolate_response = params['interpolate_response']\\n\\n features = params['t_features']\\n video_path = params['video_path']\\n s_frames = params['s_frames']\\n pos = np.floor(params['init_pos']) # initial centre-point (y by x) of target bounding box\\n target_sz = np.floor(params['wsize']) # initial height and height of target bounding box\\n\\n visualization = params['visualization']\\n num_frames = params['no_fram']\\n init_target_sz = target_sz\\n\\n # Set the features ratio to the feature-cell size\\n featureRatio = params['t_global']['cell_size']\\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\\n\\n # when the number of cells are small, choose a smaller cell size\\n if 'cell_selection_thresh' in params['t_global']:\\n if search_area < params['t_global']['cell_selection_thresh'] * filter_max_area:\\n params['t_global']['cell_size'] = min(featureRatio,\\n max(1, np.ceil(m.sqrt(np.prod(init_target_sz * search_area_scale) /\\n (params['t_global']['cell_selection_thresh'] *\\n filter_max_area)))))\\n featureRatio = params['t_global']['cell_size']\\n search_area = np.prod(init_target_sz / featureRatio * search_area_scale)\\n\\n global_feat_params = params['t_global']\\n\\n if search_area > filter_max_area:\\n currentScaleFactor = m.sqrt(search_area / filter_max_area)\\n else:\\n currentScaleFactor = 1.0\\n\\n # target size at the initial scale\\n base_target_sz = target_sz / currentScaleFactor\\n\\n # window size, taking padding into account\\n if params['search_area_shape'] == 'proportional':\\n sz = np.floor(base_target_sz * search_area_scale) # proportional area, same aspect ratio as the target\\n elif params['search_area_shape'] == 'square':\\n sz = np.tile(m.sqrt(np.prod(base_target_sz * search_area_scale)), [1, 2]) # ignores target aspect ratio\\n elif params['search_area_shape'] == 'fix_padding':\\n sz = base_target_sz + m.sqrt(np.prod(base_target_sz * search_area_scale) +\\n (base_target_sz[0] - base_target_sz[1]) / 4) - \\\\\\n sum(base_target_sz) / 2 # const padding\\n else:\\n raise ValueError('Unknown \\\"search_area_shape\\\". Must be \\\"proportional\\\", \\\"square\\\", or \\\"fix_padding\\\".')\\n\\n # set the size to exactly match the cell size\\n sz = np.round(sz[0] / featureRatio) * featureRatio\\n use_sz = np.floor(sz / featureRatio)\\n\\n # construct the label function- correlation output, 2D gaussian function, with a peak located upon the target\\n # np.roll acts a circular shift operator. This is used to compute all possible patches in the entire frame\\n output_sigma = m.sqrt(np.prod(np.floor(base_target_sz / featureRatio))) * output_sigma_factor\\n rg = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1)/2) + 1),\\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\\n cg = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\\n int(-1 * np.floor((use_sz[1] - 1) / 2)))\\n [rs, cs] = np.meshgrid(rg, cg)\\n rs = rs.T\\n cs = cs.T\\n # y is the desired correlation response at each point within the size of the filter\\n y = np.exp(-0.5 * ((np.power(rs, 2) + np.power(cs, 2)) / np.power(output_sigma, 2)))\\n yf = np.fft.fft2(y) # fast fourier transform of y\\n\\n if interpolate_response == 1:\\n interp_sz = use_sz * featureRatio\\n else:\\n interp_sz = use_sz\\n\\n # construct cosine window\\n term1 = np.array([np.hanning(use_sz[0])])\\n term2 = np.array([np.hanning(use_sz[1])])\\n cos_window = np.matmul(term1.T, term2)\\n cos_window = cos_window.astype('float32')\\n\\n # Calculate feature dimension\\n try:\\n im = cv2.imread(video_path + '/img/' + s_frames[0])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n try:\\n im = cv2.imread(s_frames[0])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n im = cv2.imread(video_path + '/' + s_frames[0])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n\\n # Check to see if it is a color image or grayscale\\n if im.shape[2] == 3:\\n if np.all(np.equal(im[:,:,0], im[:,:,1])):\\n colorImage = False\\n else:\\n colorImage = True\\n else:\\n colorImage = False\\n \\n if im.shape[2] > 1 and colorImage is False:\\n im = im[:,:,0]\\n im = im.reshape([im.shape[0], im.shape[1], 1])\\n\\n # create scale factors to check for object at various scale resolutions\\n if nScales > 0:\\n scale_exp = np.arange(-1 * np.floor((nScales - 1) / 2), np.ceil((nScales - 1) / 2) + 1)\\n scaleFactors = scale_step ** scale_exp\\n min_scale_factor = scale_step ** np.ceil(m.log(max(np.divide(5, sz))) / m.log(scale_step))\\n max_scale_factor = scale_step ** np.floor(m.log(min(np.divide([im.shape[0],\\n im.shape[1]],\\n base_target_sz))) / m.log(scale_step))\\n\\n if interpolate_response >= 3:\\n # pre-computes the grid that is used for score optimization\\n ky = np.roll(np.arange(-1 * np.floor((use_sz[0] - 1) / 2), np.ceil((use_sz[0] - 1) / 2) + 1),\\n int(-1 * np.floor((use_sz[0] - 1) / 2)))\\n kx = np.roll(np.arange(-1 * np.floor((use_sz[1] - 1) / 2), np.ceil((use_sz[1] - 1) / 2) + 1),\\n int(-1 * np.floor((use_sz[1] - 1) / 2))) # --> SAME AS MATLAB\\n kx = kx.T\\n newton_iterations = params['newton_iterations']\\n\\n # initialize the projection matrix (x,y,h,w)\\n rect_position = np.zeros([num_frames, 4])\\n\\n # allocate memory for multi-scale tracking\\n multires_pixel_template = np.zeros([int(sz[0]), int(sz[1]), im.shape[2], nScales], dtype=np.uint8)\\n small_filter_sz = np.floor(base_target_sz / featureRatio)\\n start_time = time.time()\\n\\n loop_frame = 0\\n for frame in range(0, len(s_frames)):\\n try:\\n im = cv2.imread(video_path + '/img/' + s_frames[frame])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n try:\\n im = cv2.imread(s_frames[frame])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n except:\\n im = cv2.imread(video_path + '/' + s_frames[frame])\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n\\n if im.shape[2] > 1 and colorImage is False:\\n im = im[:, :, 0]\\n im = im.reshape([im.shape[0], im.shape[1], 1])\\n\\n # do not estimate translation and scaling on the first frame, since we are just initializing the tracker\\n if frame > 0:\\n\\n # The filter is applied on multiple resolutions of the search area. This is used to determine any changes in\\n # scale of the target object\\n for scale_ind in range(0, nScales):\\n multires_pixel_template[:, :, :, scale_ind] = \\\\\\n get_pixels(im, pos, np.round(sz * currentScaleFactor * scaleFactors[scale_ind]), sz)\\n\\n feat_term2, _ = get_features(multires_pixel_template, features, global_feat_params, None)\\n xtf = np.zeros(feat_term2.shape, dtype=complex)\\n for p in range(0, feat_term2.shape[2]):\\n for n in range(0, feat_term2.shape[3]):\\n xtf[:,:,p,n] = np.fft.fft2(np.multiply(feat_term2[:,:,p,n], cos_window[:, :]))\\n responsef = np.sum(np.multiply(np.conj(g_f)[:, :, :, None], xtf), axis=2)\\n\\n # if we undersampled features, we want to interpolate the response to have the same size as the image patch\\n if interpolate_response == 2:\\n # use dynamic interp size\\n interp_sz = np.floor(y.shape * featureRatio * currentScaleFactor)\\n\\n responsef_padded = resizeDFT2(responsef, interp_sz)\\n\\n # Get the response in the spatial domain\\n response = np.zeros(responsef_padded.shape)\\n for n in range(0, responsef.shape[2]):\\n response[:,:,n] = np.real(np.fft.ifft2(responsef_padded[:,:,n])) # MAY HAVE AN ISSUE HERE NOT BEING SYMMETRIC -- therefore added real --> SAME AS MATLAB :D :)\\n\\n # find maximum peak\\n if interpolate_response == 3:\\n raise ValueError('Invalid parameter value for \\\"interpolate_response\\\"')\\n elif interpolate_response == 4:\\n [disp_row, disp_col, sind] = resp_newton(response, responsef_padded, newton_iterations, ky, kx, use_sz)\\n\\n # Check if the target has completely gone off the frame\\n if np.isnan(disp_row) or np.isnan(disp_col):\\n break\\n\\n # calculate translation vector\\n if interpolate_response == 0 or 3 or 4:\\n translation_vec = np.round(np.array([disp_row, disp_col]) * featureRatio *\\n currentScaleFactor * scaleFactors[sind])\\n elif interpolate_response == 1:\\n translation_vec = np.round([disp_row, disp_col] * currentScaleFactor * scaleFactors[sind])\\n elif interpolate_response == 2:\\n translation_vec = np.round([disp_row, disp_col] * scaleFactors[sind])\\n\\n # set the scale\\n currentScaleFactor = currentScaleFactor * scaleFactors[sind]\\n\\n # adjust to make sure we are not too large or too small\\n if currentScaleFactor < min_scale_factor:\\n currentScaleFactor = min_scale_factor\\n elif currentScaleFactor > max_scale_factor:\\n currentScaleFactor = max_scale_factor\\n\\n # update position\\n old_pos = pos\\n pos = pos + translation_vec\\n\\n # extract training sample image region\\n pixels = get_pixels(im, pos, np.round(sz*currentScaleFactor), sz)\\n\\n # extract features and perform windowing\\n feat_term, _ = get_features(pixels, features, global_feat_params, None)\\n xf = np.zeros([feat_term.shape[1], feat_term.shape[1], feat_term.shape[2]], dtype=complex)\\n for n in range(0, feat_term.shape[2]):\\n xf[:, :, n] = np.fft.fft2(np.multiply(feat_term[:, :, n, 0], cos_window[:, :]))\\n if frame == 0:\\n model_xf = xf\\n else:\\n model_xf = ((1 - learning_rate) * model_xf) + (learning_rate * xf)\\n\\n g_f = np.zeros(xf.shape)\\n g_f = g_f.astype('float32')\\n h_f = g_f\\n l_f = g_f\\n\\n # parameters from the original paper\\n mu = 1\\n betha = 10\\n mumax = 10000\\n i = 1\\n\\n T = np.prod(use_sz)\\n S_xx = np.sum(np.multiply(model_xf.conj(), model_xf), axis=2)\\n params['admm_iterations'] = 2\\n\\n while i <= params['admm_iterations']:\\n # Solve for G\\n B = S_xx + (T * mu)\\n S_lx = np.sum(np.multiply(model_xf.conj(), l_f), axis=2)\\n S_hx = np.sum(np.multiply(model_xf.conj(), h_f), axis=2)\\n\\n # equation (10) in original paper\\n g_f = (((1 / (T * mu)) * np.multiply(yf[:, :, None], model_xf)) - ((1 / mu) * l_f) + h_f) - \\\\\\n np.divide((((1 / (T * mu)) * np.multiply(model_xf, np.multiply(S_xx, yf)[:, :, None])) -\\n ((1 / mu) * np.multiply(model_xf, S_lx[:, :, None])) +\\n (np.multiply(model_xf, S_hx[:, :, None]))), B[:, :, None])\\n\\n # solve for H\\n # Equation (6) in original paper\\n h = np.zeros([g_f.shape[0], g_f.shape[1], g_f.shape[2]], dtype=complex)\\n for n in range(0, g_f.shape[2]):\\n h[:, :, n] = (T / ((mu * T) + params['admm_lambda'])) * np.fft.ifft2((mu * g_f[:, :, n]) + l_f[:, :, n])\\n\\n [sx, sy, h] = get_subwindow_no_window(h, np.floor(use_sz / 2), small_filter_sz)\\n t = np.zeros([int(use_sz[0]), int(use_sz[1]), h.shape[2]], dtype=complex)\\n t[int(sx[0]):int(sx[-1])+1, int(sy[0]):int(sy[-1])+1, :] = h\\n\\n h_f = np.zeros([t.shape[1], t.shape[1], t.shape[2]], dtype=complex)\\n for n in range(0, t.shape[2]):\\n h_f[:, :, n] = np.fft.fft2(t[:, :, n])\\n\\n # update L\\n l_f = l_f + (mu * (g_f - h_f))\\n\\n # update mu- betha = 10\\n mu = min(betha * mu, mumax)\\n i = i + 1\\n\\n target_sz = np.floor(base_target_sz * currentScaleFactor)\\n\\n # save position and calculate FPS\\n rect_position[loop_frame, :] = np.concatenate((pos[1::-1] - np.floor(target_sz[1::-1] / 2), target_sz[1::-1]))\\n\\n elapsed = time.time() - start_time\\n\\n # visualization\\n if visualization == 1:\\n rect_position_vis = np.concatenate((pos[1::-1] - (target_sz[1::-1] / 2), target_sz[1::-1]))\\n im_to_show = im / 255\\n if im_to_show.shape[2] == 1:\\n im_to_show = np.tile(im_to_show, [1, 1, 3]) # if grayscale, ensure it plots image in grayscale\\n if frame == 0:\\n fig, ax = plt.subplots(1, num='Tracking')\\n ax.imshow(im_to_show)\\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\\n linewidth=3, edgecolor='g', facecolor='none')\\n ax.add_patch(rect)\\n ax.annotate(str(frame + 1), [10, 10], color='c')\\n ax.axis('off') # remove axis values\\n ax.axis('image') # scale image appropriately\\n ax.set_position([0, 0, 1, 1])\\n fig.show()\\n fig.canvas.draw()\\n else:\\n ax.clear()\\n resp_sz = np.round(sz * currentScaleFactor * scaleFactors[scale_ind])\\n xs = np.floor(old_pos[1]) + (np.arange(1, resp_sz[1] + 1)) - np.floor(resp_sz[1] / 2)\\n ys = np.floor(old_pos[0]) + (np.arange(1, resp_sz[0] + 1)) - np.floor(resp_sz[0] / 2)\\n sc_ind = np.floor((nScales - 1) / 2)\\n\\n ax.imshow(im_to_show)\\n ax.axis('off') # remove axis values\\n ax.axis('image') # scale image appropriately\\n ax.set_position([0, 0, 1, 1])\\n im_overlay = np.fft.fftshift(response[:,:,int(sc_ind)])\\n ax.imshow(im_overlay, extent=[xs[0], xs[-1], ys[0], ys[-1]],\\n alpha=0.2, cmap='hsv')\\n rect.remove() # remove previous rectangle each time\\n rect = patches.Rectangle(rect_position_vis[0:2], rect_position_vis[2], rect_position_vis[3],\\n linewidth=3, edgecolor='g', facecolor='none')\\n ax.add_patch(rect)\\n frame_str = '# Frame: ' + str(loop_frame + 1) + ' / ' + str(num_frames)\\n FPS_str = 'FPS: ' + str(1 / (elapsed / loop_frame))\\n ax.annotate(frame_str, [20, 30], color='r', backgroundcolor='w')\\n ax.annotate(FPS_str, [20, 60], color='r', backgroundcolor='w', fontsize=16)\\n fig.show()\\n fig.canvas.draw() # used to update the plot in real-time\\n\\n loop_frame += 1\\n\\n # Save results\\n fps = loop_frame / elapsed\\n results = {'res': rect_position, 'fps': fps}\\n\\n return results\",\n \"def scale_fixed_V2B(seed=425, th=150, fmass=1, fb=1, fv=1, rfig=False):\\n \\n # impact parameters\\n M = 1e8*u.Msun\\n B0 = 19.85*u.kpc\\n V0 = 220*u.km/u.s\\n phi = coord.Angle(0*u.deg)\\n theta = coord.Angle(th*u.deg)\\n Tenc = 0.01*u.Gyr\\n T = 0.5*u.Gyr\\n dt = 0.1*u.Myr\\n rs = 0*u.pc\\n \\n # potential parameters\\n potential = 3\\n Vh = 220*u.km/u.s\\n q = 1*u.Unit(1)\\n rhalo = 20*u.pc\\n par_pot = np.array([Vh.si.value, q.value, rhalo.si.value])\\n \\n # setup tube\\n Nstar = 3000\\n wx = 30*u.kpc\\n wy = 0*u.pc\\n wz = 0*u.pc\\n sx = 0*u.km/u.s\\n \\n np.random.seed(seed)\\n observer = {'z_sun': 27.*u.pc, 'galcen_distance': 8.3*u.kpc, 'roll': 60*u.deg, 'galcen_coord': coord.SkyCoord(ra=300*u.deg, dec=-90*u.deg, frame='icrs')}\\n vobs = {'vcirc': 220*u.km/u.s, 'vlsr': [0, 0, 0]*u.km/u.s}\\n wangle = 180*u.deg\\n \\n xphi = np.linspace(-0.3*np.pi,0.3*np.pi, Nstar)\\n Bs = 20*u.kpc\\n xr = Bs + np.random.randn(Nstar)*0.0*u.kpc\\n x = np.sin(xphi) * xr\\n y = np.cos(xphi) * xr\\n z = x * 0\\n vx = -np.cos(xphi) * Vh\\n vy = np.sin(xphi) * Vh\\n vz = vx * 0\\n \\n # generate stream model\\n potential_perturb = 1\\n par_perturb = np.array([M.si.value, 0., 0., 0.])\\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V0.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n R = find_greatcircle(xeq.ra.deg[::10], xeq.dec.deg[::10])\\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n \\n # unperturbed stream\\n par_perturb = np.array([0*M.si.value, 0., 0., 0.])\\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B0.si.value, phi.rad, V0.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream0 = {}\\n stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal0 = coord.Galactocentric(stream0['x'], **observer)\\n xeq0 = xgal0.transform_to(coord.ICRS)\\n veq0_ = gc.vgal_to_hel(xeq0, stream0['v'], **vobs)\\n veq0 = [None] * 3\\n veq0[0] = veq0_[0].to(u.mas/u.yr)\\n veq0[1] = veq0_[1].to(u.mas/u.yr)\\n veq0[2] = veq0_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n xi0, eta0 = myutils.rotate_angles(xeq0.ra, xeq0.dec, R)\\n xi0 = coord.Angle(xi0*u.deg)\\n \\n farray = np.array([0.3, 0.5, 1, 2, 3])\\n \\n rasterized = False\\n if rfig:\\n rasterized = True\\n \\n plt.close()\\n fig, ax = plt.subplots(4,1,figsize=(12,12), sharex=True)\\n \\n for e, f in enumerate(farray):\\n fsqrt = np.sqrt(f)\\n par_perturb = np.array([fmass*M.si.value, 0., 0., 0.])\\n #B = B0\\n \\n dB = (B0 - Bs)*fb\\n B = dB*f + Bs\\n \\n V = fv*V0/fsqrt\\n \\n #fi = np.abs(V*T/(dB/f)).decompose()\\n fi = np.abs(dB/V).to(u.Myr)\\n #print(fi)\\n \\n x1, x2, x3, v1, v2, v3 = interact.interact(par_perturb, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, par_pot, potential, potential_perturb, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value)\\n stream = {}\\n stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc)\\n stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s)\\n \\n # sky coordinates\\n xgal = coord.Galactocentric(stream['x'], **observer)\\n xeq = xgal.transform_to(coord.ICRS)\\n veq_ = gc.vgal_to_hel(xeq, stream['v'], **vobs)\\n veq = [None] * 3\\n veq[0] = veq_[0].to(u.mas/u.yr)\\n veq[1] = veq_[1].to(u.mas/u.yr)\\n veq[2] = veq_[2].to(u.km/u.s)\\n \\n # rotate to native coordinate system\\n xi, eta = myutils.rotate_angles(xeq.ra, xeq.dec, R)\\n xi = coord.Angle(xi*u.deg)\\n \\n color = '{:f}'.format(0.65 - 0.65*(e+1)/(np.size(farray)) + 0.35)\\n ms = 1.5*(e+2)\\n zorder = np.size(farray)-e\\n label = 'f={:g}, $t_{{imp}}$={:.1f}'.format(f, fi)\\n #print(e, p, color)\\n \\n plt.sca(ax[0])\\n plt.plot(xi.wrap_at(wangle), eta, 'o', mec='none', color=color, ms=ms, zorder=zorder, label=label, rasterized=rasterized)\\n \\n for i in range(3):\\n plt.sca(ax[i+1])\\n vexp = np.interp(xi.wrap_at(wangle), xi0.wrap_at(wangle), veq0[i].value) * veq0[i].unit\\n plt.plot(xi.wrap_at(wangle), veq[i]-vexp, 'o', mec='none', color=color, ms=ms, zorder=zorder, rasterized=rasterized)\\n \\n # label axes\\n plt.sca(ax[0])\\n plt.ylabel('$\\\\phi_1$ [deg]')\\n plt.ylim(-10,10)\\n plt.xlim(65,135)\\n #plt.gca().set_aspect('equal')\\n plt.legend(fontsize='x-small', loc=2)\\n plt.title('f M, f B | M = {:g} | B = {:g} | $\\\\\\\\theta$ = {:.0f}'.format(fmass*M, dB.to(u.pc), theta), fontsize='medium')\\n \\n vlabel = ['$\\\\mu_{\\\\\\\\alpha_\\\\star}$ [mas yr$^{-1}$]','$\\\\mu_{\\\\delta}$ [mas yr$^{-1}$]', '$V_r$ [km s$^{-1}$]']\\n ylims = [[-0.5, 0.5], [-0.5, 0.5], [-25,25]]\\n ylims = [[-1,1], [-1,1], [-50,50]]\\n for i in range(3):\\n plt.sca(ax[i+1])\\n plt.ylabel('$\\\\Delta$ {}'.format(vlabel[i]))\\n plt.ylim(*ylims[i])\\n\\n plt.xlabel('$\\\\phi_2$ [deg]')\\n \\n plt.tight_layout()\\n \\n if rfig:\\n return fig\\n else:\\n plt.savefig('../plots/scale_VB_th{:03d}_{:.1f}_{:.1f}.png'.format(th, fv, fb))\",\n \"def batch_sinkhorn(C_list: List[torch.FloatTensor],\\n a_list: Optional[List[torch.FloatTensor]] = None,\\n b_list: Optional[List[torch.FloatTensor]] = None,\\n alpha_list: Optional[List[torch.FloatTensor]] = None,\\n beta_list: Optional[List[torch.FloatTensor]] = None,\\n epsilon_scaling: bool = True,\\n return_tensor: bool = False,\\n **kwargs) -> List[torch.FloatTensor]:\\n # Get device and dtype\\n dtype = C_list[0].dtype\\n device = C_list[0].device\\n\\n # Get sizes\\n n_list, m_list = zip(*(C.shape for C in C_list))\\n\\n # Initialize marginals with uniform if not provided\\n if a_list is None:\\n a_list = [torch.ones(n, dtype=dtype, device=device) / n for n in n_list]\\n\\n if b_list is None:\\n b_list = [torch.ones(m, dtype=dtype, device=device) / m for m in m_list]\\n\\n # Initialize alpha/beta with zero if not provided\\n if alpha_list is None:\\n alpha_list = [torch.zeros(n, dtype=dtype, device=device) for n in n_list]\\n\\n if beta_list is None:\\n beta_list = [torch.zeros(m, dtype=dtype, device=device) for m in m_list]\\n\\n # Batch everything by padding with zeros\\n C_batch = pad_tensors(C_list)\\n a_batch = pad_tensors(a_list)\\n b_batch = pad_tensors(b_list)\\n alpha_batch = pad_tensors(alpha_list)\\n beta_batch = pad_tensors(beta_list)\\n\\n # Run batched sinkhorn\\n sinkhorn_algo = sinkhorn_epsilon_scaling if epsilon_scaling else sinkhorn\\n P_batch = sinkhorn_algo(\\n C=C_batch,\\n a=a_batch,\\n b=b_batch,\\n alpha=alpha_batch,\\n beta=beta_batch,\\n **kwargs\\n )\\n\\n if return_tensor:\\n return P_batch\\n else:\\n # Extract alignment matrices and throw away padding\\n P_list = [P_batch[i, :n, :m] for i, (n, m) in enumerate(zip(n_list, m_list))]\\n return P_list\",\n \"def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \\n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \\n N_res=30):\\n x_eps = 0.3 # shift from Dirac point\\n x_res = 20\\n kx_int = 0 + x_eps # -np.pi\\n kx_fin = 4*np.pi/3 + x_eps\\n Dx = (kx_fin - kx_int)/x_res\\n\\n y_res = 20\\n ky_int = 0 # -np.pi\\n ky_fin = 2*np.pi/np.sqrt(3)\\n Dy = (ky_fin - ky_int)/y_res\\n\\n Nd = self.Nd # dimension of the Hamiltonian\\n Dk = np.array([Dx,Dy], float)\\n\\n LF = np.zeros((Nd), dtype=complex)\\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n sumN = np.zeros((Nd), dtype=complex)\\n E_k = np.zeros((Nd), dtype=complex)\\n chernN = np.zeros((Nd), dtype=complex)\\n\\n # Loop over kx\\n for ix in range(x_res):\\n kx = kx_int + ix*Dx\\n\\n # Loop over ky\\n for iy in range(y_res):\\n ky = ky_int + iy*Dy\\n\\n k_vec = np.array([kx,ky], float)\\n\\n LF, E_k = self.latF(k_vec, Dk, self.delta)\\n\\n sumN += LF\\n\\n # # save data for plotting\\n LF_arr[:,ix,iy] = LF.imag\\n\\n E_arr[:,ix,iy] = np.sort(E_k.real)\\n\\n # End of ky Loop\\n # End of kx Loop\\n\\n chernN = sumN.imag/(2*np.pi)\\n print(\\\"Chern number bands are (%.3f, %.3f) \\\" \\n %(chernN[0], chernN[1]))\\n print(\\\"Sum of all bands Chern Number is %.2f \\\" %(sum(chernN)))\\n return chernN, E_arr\\n #################### \",\n \"def convert2EbnerParam(joblib,list_prefix,directory):\\n \\n key=[p[0] for p in joblib]\\n element=[p[1] for p in joblib]\\n\\n \\n listSlice=element[key.index('listSlice')] #list of slice\\n parameters=element[key.index('EvolutionParameters')][-1,:,:] #estimated paramters of the registration\\n rejectedSlice=element[key.index('RejectedSlices')] #rejected slices\\n\\n \\n images,mask = createVolumesFromAlist(listSlice.copy()) #list of images corresponding to differents original stacks\\n \\n for i_slice in range(len(listSlice)): \\n slicei=listSlice[i_slice]\\n slicei.set_parameters(parameters[i_slice,:]) #set parameters to the last estimated parameters\\n \\n mat = np.array([[-1,0,0,0],[0,-1,0,0],[0,0,1,0],[0,0,0,1]]) #matrix to convert affine matrix from nibabel to itk\\n\\n for n in range(len(images)): #for each stack\\n \\n imagen = images[n]\\n \\n for i_slice in range(len(images[n])): #for each slices (in each stacks)\\n \\n slicei=imagen[i_slice]\\n s = (slicei.get_orientation(),slicei.get_index_slice())\\n \\n if s not in rejectedSlice:\\n dimension=3\\n X,Y,Z= slicei.get_slice().get_fdata().shape\\n center= -slicei.get_center()\\n centerMat = np.eye(4)\\n centerMat[0:3,3] = center[0:3]\\n invcenterMat = np.eye(4)\\n invcenterMat[0:3,3] = -center[0:3] \\n p = slicei.get_parameters()\\n matrix = mat @ centerMat @ rigidMatrix([p[0],p[1],p[2],p[3],p[4],p[5]]) @ invcenterMat @ mat\\n test = sitk.AffineTransform(dimension)\\n test.SetMatrix(matrix[0:3,0:3].flatten())\\n test.SetTranslation(matrix[0:3,3])\\n images_index = slicei.get_index_image()\\n sitk.WriteTransform(test,\\\"%s/%s_slice%d.tfm\\\" %(directory,list_prefix[images_index],slicei.get_index_slice())) #save rigid transformation, computed at the barycenter of the image, adatpted to itk\\n #else:\\n #print(s)\",\n \"def invert_list_rsexecute_workflow(vis_list, template_model_imagelist, context, dopsf=False, normalize=True,\\n facets=1, overlap=0, taper=\\\"tukey\\\", vis_slices=1, gcfcf=None, **kwargs):\\n \\n # Use serial invert for each element of the visibility list. This means that e.g. iteration\\n # through w-planes or timeslices is done sequentially thus not incurring the memory cost\\n # of doing all at once.\\n if get_parameter(kwargs, \\\"use_serial_invert\\\", False):\\n from rascil.workflows.serial.imaging.imaging_serial import invert_list_serial_workflow\\n return [rsexecute.execute(invert_list_serial_workflow, nout=1) \\\\\\n (vis_list=[vis_list[i]], template_model_imagelist=[template_model_imagelist[i]],\\n context=context, dopsf=dopsf, normalize=normalize, vis_slices=vis_slices,\\n facets=facets, gcfcf=gcfcf, **kwargs)[0]\\n for i, _ in enumerate(vis_list)]\\n \\n if not isinstance(template_model_imagelist, collections.abc.Iterable):\\n template_model_imagelist = [template_model_imagelist]\\n \\n c = imaging_context(context)\\n vis_iter = c['vis_iterator']\\n invert = c['invert']\\n \\n if facets % 2 == 0 or facets == 1:\\n actual_number_facets = facets\\n else:\\n actual_number_facets = max(1, (facets - 1))\\n \\n def gather_image_iteration_results(results, template_model):\\n result = create_empty_image_like(template_model)\\n flat = create_empty_image_like(template_model)\\n i = 0\\n sumwt = numpy.zeros([template_model.nchan, template_model.npol])\\n for dpatch in image_scatter_facets(result, facets=facets, overlap=overlap, taper=taper):\\n assert i < len(results), \\\"Too few results in gather_image_iteration_results\\\"\\n if results[i] is not None:\\n assert len(results[i]) == 2, results[i]\\n dpatch.data[...] += results[i][0].data[...]\\n sumwt += results[i][1]\\n i += 1\\n flat = image_gather_facets(results, flat, facets=facets, overlap=overlap, taper=taper, return_flat=True)\\n result.data[flat.data > 0.5] /= flat.data[flat.data > 0.5]\\n result.data[flat.data <= 0.5] = 0.0\\n return result, sumwt\\n \\n def invert_ignore_none(vis, model, gg):\\n if vis is not None:\\n return invert(vis, model, context=context, dopsf=dopsf, normalize=normalize,\\n gcfcf=gg, **kwargs)\\n else:\\n return create_empty_image_like(model), numpy.zeros([model.nchan, model.npol])\\n \\n # If we are doing facets, we need to create the gcf for each image\\n if gcfcf is None and facets == 1:\\n assert len(template_model_imagelist) > 0\\n gcfcf = [rsexecute.execute(create_pswf_convolutionfunction)(template_model_imagelist[0])]\\n \\n # Loop over all vis_lists independently\\n results_vislist = list()\\n if facets == 1:\\n for ivis, sub_vis_list in enumerate(vis_list):\\n if len(gcfcf) > 1:\\n g = gcfcf[ivis]\\n else:\\n g = gcfcf[0]\\n # Create the graph to divide the visibility into slices. This is by copy.\\n sub_sub_vis_lists = rsexecute.execute(visibility_scatter, nout=vis_slices) \\\\\\n (sub_vis_list, vis_iter, vis_slices=vis_slices)\\n \\n # Iterate within each sub_sub_vis_list\\n vis_results = list()\\n for sub_sub_vis_list in sub_sub_vis_lists:\\n vis_results.append(rsexecute.execute(invert_ignore_none, pure=True)\\n (sub_sub_vis_list, template_model_imagelist[ivis], g))\\n results_vislist.append(sum_invert_results_rsexecute(vis_results))\\n \\n result = results_vislist\\n else:\\n for ivis, sub_vis_list in enumerate(vis_list):\\n # Create the graph to divide an image into facets. This is by reference.\\n facet_lists = rsexecute.execute(image_scatter_facets, nout=actual_number_facets ** 2)(\\n template_model_imagelist[ivis], facets=facets, overlap=overlap, taper=taper)\\n # Create the graph to divide the visibility into slices. This is by copy.\\n sub_sub_vis_lists = rsexecute.execute(visibility_scatter, nout=vis_slices) \\\\\\n (sub_vis_list, vis_iter, vis_slices=vis_slices)\\n \\n # Iterate within each vis_list\\n vis_results = list()\\n for sub_sub_vis_list in sub_sub_vis_lists:\\n facet_vis_results = list()\\n for facet_list in facet_lists:\\n facet_vis_results.append(\\n rsexecute.execute(invert_ignore_none, pure=True)(sub_sub_vis_list, facet_list, None))\\n vis_results.append(rsexecute.execute(gather_image_iteration_results, nout=1)\\n (facet_vis_results, template_model_imagelist[ivis]))\\n results_vislist.append(sum_invert_results_rsexecute(vis_results))\\n \\n result = results_vislist\\n return rsexecute.optimize(result)\",\n \"def performance(N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w):\\n \\\"\\\"\\\"\\\"I have produced two plots. The first one p24.png compares the time taken\\n by solveFlunet with the three different RHS methods. We notice that the fastest\\n technique is using the RHS computed in Python. This can be explained by the \\n fact that in Python we have vectorized our calculations whereas in Fortran\\n we used a loop for our calculations. Secondly, we also notice that solveFlunet \\n is faster using the Fortran OMP code than using the Fortran code. This\\n is expected since we use two threads with the Fortran OMP code instead of \\n only one with the regular Fortran code. The second plot p25.png provides\\n the speedup of the Fortran OMP RHS compared to the Fortran RHS.\\n The speedup is less than 1 for small values of Nt but increases as Nt\\n increases. It goes up to 1.6 for larger sized problems, which is quite\\n satisfying. We can expect that it the speedup to reach 2 for even larger\\n problem sizes.\\n \\\"\\\"\\\"\\n #I have added as inputs N0,L,Ntmax,T,Ntime,a,b0,b1,g,k,w to\\n #be able to call initialize and solveFluNet\\n Nt = Ntmax/10\\n dt = Ntmax/10\\n Ntu = np.zeros(10)\\n \\n #tpy,tf90 and tf90OMP are the times for our different RHS\\n #methods\\n tpy = np.zeros(10)\\n tf90 = np.zeros(10)\\n tf90OMP = np.zeros(10)\\n \\n #speedup is the speedup of the Fortran OMP RHS compared\\n #to the Fortran RHS\\n speedup = np.zeros(10)\\n \\n for i in range(10):\\n #compute initial conditions\\n init,infnode,P = initialize(N0,L,Nt,True)\\n N = N0+Nt\\n \\n #time solveFluNet for the three different RHS\\n t0 = time()\\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,1)\\n t1 = time()\\n tpy[i] = t1-t0\\n t0 = time()\\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,2)\\n t1 = time()\\n tf90[i] = t1-t0\\n t0 = time()\\n solveFluNet(T,Ntime,a,b0,b1,g,k,w,init,P,N,3)\\n t1 = time()\\n tf90OMP[i] = t1-t0\\n \\n #time the two Fortran RHS methods\\n t0 = time()\\n fn.rhs(P,init,1,a,b0,b1,g,k,w)\\n tRHS = time() - t0\\n t0 = time()\\n fn.rhs_omp(P,init,1,a,b0,b1,g,k,w,2)\\n tRHSOMP = time() - t0\\n speedup[i] = tRHS/tRHSOMP\\n \\n Ntu[i] = Nt\\n Nt = Nt+dt\\n \\n plt.figure()\\n plt.plot(Ntu,tpy,label='Time with Python RHS')\\n plt.plot(Ntu,tf90,label='Time with Fortran RHS')\\n plt.plot(Ntu,tf90OMP,label='Time with Fortran OMP RHS')\\n plt.legend(loc='best')\\n plt.title('performance Mathilde Duverger')\\n plt.xlabel('Nt')\\n plt.ylabel('Time of solveFluNet')\\n \\n plt.figure()\\n plt.plot(Ntu,speedup,label='Speedup for RHS')\\n plt.legend(loc='best')\\n plt.title('performance Mathilde Duverger')\\n plt.xlabel('Nt')\\n plt.ylabel('Speedup of the Fortran OMP code compared to the Fortran code')\\n plt.show()\",\n \"def ridge_cv(trn_fs, trn_data, val_fs=None, val_data=None, alphas=DEFAULT_ALPHAS, \\n n_resamps=10, n_splits=10, chunk_sz=5000, dtype=np.single,pthr=0.005,\\n square_alpha=False,is_verbose=False):\\n #def ridge_cv(model,data,n_splits=10,n_resamps=10,alpha=DEFAULT_ALPHAS,efficient=np.nan,):\\n # (trn_fs, trn_data, val_fs, val_data, alphas, nboots, chunklen, n_chunks, dtype=np.single, corrmin=0.2):\\n n_resp, n_voxels = trn_data.shape\\n _,n_channels = trn_fs.shape\\n n_chunks = np.ceil(n_voxels/np.float(chunk_sz)).astype(np.int32)\\n bestalphas = np.zeros((n_resamps, n_voxels)) ## Will hold the best alphas for each voxel\\n trn_idx,val_idx = _utils.contig_partition(trn_fs.shape[0],n_splits)\\n\\n Rcmats = np.zeros((n_voxels,len(alphas),n_resamps))\\n for iRpt,cvi in enumerate(np.random.permutation(n_splits)[:n_resamps]):\\n if is_verbose:\\n print('Running split %d/%d'%(iRpt+1,n_resamps))\\n ti,vi = trn_idx[cvi],val_idx[cvi]\\n trn_fs_split = trn_fs[ti,:]\\n val_fs_split = trn_fs[vi,:]\\n trn_data_split = trn_data[ti,:]\\n val_data_split = trn_data[vi,:]\\n \\n # Run ridge regression to estimate predictions (within training set) for different alphas\\n Rcmats[:,:,iRpt] = _fit_ridge_alpha(trn_fs_split, trn_data_split, val_fs_split, val_data_split, alphas,\\n dtype=dtype, chunk_sz=chunk_sz,pthr=pthr,square_alpha=square_alpha)\\n if is_verbose:\\n print(\\\"Finding best alpha...\\\")\\n ## Find best alpha for each voxel\\n #trncc_byvox = np.nansum(Rcmats,axis=2)/np.sum(np.logical_not(np.isnan(Rcmats)),axis=2)\\n trncc_byvox = np.nanmean(Rcmats,axis=2)\\n # Taking mean is BS: too many voxels poorly predicted, floor effect. \\n #mean_cv_corr = np.nanmean(mean_cv_corr_byvox,axis=0)\\n #bestalphaind = np.argmax(mean_cv_corr)\\n # Thus just count voxels over significance threshold (with a lenient threshold)\\n #print(len(vi))\\n sig_thresh = _sutils.pval2r(pthr,len(vi),is_two_sided=False)\\n n_sig_vox_byalpha = sum(trncc_byvox>sig_thresh)-sum(trncc_byvox<-sig_thresh)\\n bestalphaind = np.argmax(n_sig_vox_byalpha)\\n alpha = alphas[bestalphaind]\\n if is_verbose:\\n print(\\\"Best alpha = %0.3f\\\"%alpha)\\n \\n ## Find weights for each voxel\\n U,S,Vt = np.linalg.svd(trn_fs, full_matrices=False)\\n # Loop over groups of voxels\\n wt = np.zeros((n_channels,n_voxels),dtype=dtype)\\n\\n ###\\n if (not val_fs is None) and (not val_data is None):\\n # Validation data / model supplied implies we want predictions\\n do_pred = True\\n if np.sum(val_fs[:,0]) != val_fs.shape[0]:\\n warnings.warn('First column of val_fs is NOT all ones! Consider including a DC term!')\\n # Pre-allocate for predictions, with or without separate validation sequences to predict\\n is_rpts = np.ndim(val_data)==3\\n if is_rpts:\\n n_rpts,n_tps_val,n_voxels_val = val_data.shape\\n cc = np.zeros((n_rpts,n_voxels),dtype);\\n else:\\n n_rpts,(n_tps_val,n_voxels_val) = 0,val_data.shape\\n cc = np.zeros((n_voxels),dtype);\\n pred = np.zeros((n_tps_val,n_voxels_val),dtype)\\n else:\\n # No Validation data / model supplied\\n do_pred = False;\\n\\n if is_verbose:\\n predstr = ' and model predictions...' if do_pred else \\\"...\\\"\\n print('Computing weights'+predstr)\\n for iChunk in range(n_chunks):\\n if is_verbose:\\n print('Running chunk %d of %d...\\\\n'%(iChunk+1,n_chunks))\\n ChIdx = np.arange(chunk_sz) + chunk_sz*iChunk\\n ChIdx = ChIdx[ChIdx<n_voxels] # clip extra voxels in last run.\\n Ychunk = trn_data[:,ChIdx]\\n\\n UtYchunk = np.dot(U.T, np.nan_to_num(Ychunk))\\n if square_alpha:\\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha**2)), UtYchunk])\\n else:\\n wt[:,ChIdx] = reduce(np.dot, [Vt.T, np.diag(S/(S**2+alpha)), UtYchunk])\\n\\n ## Find test correlations if validation data is present\\n if do_pred:\\n # Compute correlations btw validation data and model prediction\\n pred[:,ChIdx] = val_fs.dot(wt[:,ChIdx]).astype(dtype) \\n nnpred = np.nan_to_num(pred[:,ChIdx])\\n if is_rpts:\\n # The transpose here is related to deep mysteries in python. See \\n cc[:,ChIdx] = np.vstack([_sutils.column_corr(nnpred,val_data[rpt,:,ChIdx].T) for rpt in range(n_rpts)])\\n else:\\n cc[ChIdx] = _sutils.column_corr(nnpred,val_data[:,ChIdx])\\n\\n # Output\\n out = dict(\\n weights=wt,\\n alpha=alpha,\\n n_sig_vox_byalpha=n_sig_vox_byalpha,\\n #trncc_byvox=trncc_byvox,f\\n #trncc_byvox_byalpha=Rcmats\\n )\\n if not val_data is None: \\n out['cc'] = cc\\n return out\",\n \"def rk8(accel,m,r,h,v): \\n k1v = accel(m,r)\\n k1r = v\\n k2v = accel(m,r + 0.25*k1r*h)\\n k2r = v + (0.25*k1v)*h\\n k3v = accel(m,r + (5/72.*k1r + 1/72.*k2r)*h)\\n k3r = v + (5/72.*k1v + 1/72.*k2v)*h\\n k4v = accel(m,r + (1/32.*k1r +3/32.*k3r)*h)\\n k4r = v + (1/32.*k1v +3/32.*k3v)*h\\n k5v = accel(m,r + (106/125.*k1r- 408/125.*k3r + 352/125.*k4r)*h)\\n k5r = v + (106/125.*k1v- 408/125.*k3v + 352/125.*k4v)*h\\n k6v = accel(m,r + (1/48.*k1r+ 8/33.*k4r - 125/528.*k5r)*h)\\n k6r = v + (1/48.*k1v+ 8/33.*k4v - 125/528.*k5v)*h\\n k7v = accel(m,r + (-13893*k1r+ 39936*k4r -64125*k5r+ 60720*k6r)*h/26411.)\\n k7r = v +(-13893*k1v+ 39936*k4v -64125*k5v+ 60720*k6v)*h/26411.\\n k8v = accel(m,r + (37/392.*k1r+ 1625/9408.*k5r -2/15.*k6r+ 61/6720*k7r)*h)\\n k8r = v + (37/392.*k1v+ 1625/9408.*k5v -2/15.*k6v+ 61/6720*k7v)*h\\n k9v = accel(m,r +(17176/25515.*k1r - 47104/25515.*k4r + 1325/504.*k5r - 41792/25515.*k6r + 20237/145800.*k7r + 4312/6075.*k8r)*h)\\n k9r = v + (17176/25515.*k1v - 47104/25515.*k4v + 1325/504.*k5v - 41792/25515.*k6v + 20237/145800.*k7v + 4312/6075.*k8v)*h\\n k10v = accel(m,r + ( -23834/180075.*k1r - 77824/1980825.*k4r- 636635/633864.*k5r + 254048/300125.*k6r - 183/7000.*k7r + 8/11.*k8r - 324/3773.*k9r)*h)\\n k10r = v + ( -23834/180075.*k1v - 77824/1980825.*k4v- 636635/633864.*k5v + 254048/300125.*k6v - 183/7000.*k7v + 8/11.*k8v - 324/3773.*k9v)*h\\n k11v= accel(m,r + (12733/7600.*k1r - 20032/5225.*k4r + 456485/80256.*k5r - 42599/7125.*k6r + 339227/912000.*k7r - 1029/4108.*k8r + 1701/1408.*k9r + 5145/2432.*k10r)*h)\\n k11r = v + (12733/7600.*k1v - 20032/5225.*k4v + 456485/80256.*k5v - 42599/7125.*k6v + 339227/912000.*k7v - 1029/4108.*k8v + 1701/1408.*k9v + 5145/2432.*k10v)*h\\n k12v = accel(m,r + h*(-27061/204120.*k1r + 40448/280665.*k4r -1353775/1197504.*k5r + 17662/25515.*k6r - 71687/1166400.*k7r + 98/225.*k8r + 1/16.*k9r + 3773/11664.*k10r))\\n k12r = v + h*(-27061/204120.*k1v + 40448/280665.*k4v -1353775/1197504.*k5v + 17662/25515.*k6v - 71687/1166400.*k7v + 98/225.*k8v + 1/16.*k9v + 3773/11664.*k10v)\\n k13v = accel(m,r + h*(11203/8680.*k1r - 38144/11935.*k4r + 2354425/458304.*k5r - 84046/16275.*k6r + 673309/1636800.*k7r + 4704/8525.*k8r + 9477/10912.*k9r - 1029/992.*k10r + 19/341.*k12r))\\n k13r = v + h*(11203/8680.*k1v - 38144/11935.*k4v + 2354425/458304.*k5v - 84046/16275.*k6v + 673309/1636800.*k7v + 4704/8525.*k8v + 9477/10912.*k9v - 1029/992.*k10v + 19/341.*k12v)\\n\\n\\n new_v8 = v + h*(13/288.*k1v +32/125.*k6v + 31213/144000.*k7v + 2401/12375.*k8v + 1701/14080.*k9v + 2401/19200.*k10v + 19/450.*k11v) \\n new_r8 = r + h*(13/288.*k1r +32/125.*k6r + 31213/144000.*k7r + 2401/12375.*k8r + 1701/14080.*k9r + 2401/19200.*k10r + 19/450.*k11r) \\n \\n return new_v8,new_r8\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68661004","0.631563","0.6123873","0.5089853","0.50879455","0.49770182","0.4871406","0.48591155","0.484959","0.47010407","0.4681783","0.46318635","0.45723057","0.45695278","0.45665184","0.4564709","0.45531625","0.4551914","0.45249","0.4496649","0.44724518","0.44636872","0.44634536","0.44486085","0.44423738","0.4430942","0.44207963","0.4413507","0.43917766","0.43914366","0.43914366","0.4387744","0.4387744","0.43780404","0.43725199","0.4349843","0.43460354","0.43427566","0.43353954","0.43293154","0.4327694","0.4320309","0.43137926","0.43133053","0.43116525","0.43059978","0.43024173","0.4293755","0.4291154","0.42905867","0.42867476","0.42843902","0.4282721","0.42723978","0.4267287","0.42542428","0.42396548","0.42335197","0.42289764","0.42275742","0.42245924","0.42230377","0.42184556","0.42103812","0.4206185","0.4203969","0.42038113","0.42035452","0.42023388","0.42000633","0.41969156","0.41921818","0.41881248","0.4185298","0.41834563","0.41812015","0.41801825","0.41759476","0.41723704","0.416539","0.4165237","0.4160476","0.41580957","0.4157205","0.41543213","0.4152933","0.41462868","0.41457993","0.41435963","0.4136559","0.41333184","0.41332287","0.4132991","0.4132291","0.41319993","0.41313887","0.41310626","0.41282701","0.41248488","0.41215867"],"string":"[\n \"0.68661004\",\n \"0.631563\",\n \"0.6123873\",\n \"0.5089853\",\n \"0.50879455\",\n \"0.49770182\",\n \"0.4871406\",\n \"0.48591155\",\n \"0.484959\",\n \"0.47010407\",\n \"0.4681783\",\n \"0.46318635\",\n \"0.45723057\",\n \"0.45695278\",\n \"0.45665184\",\n \"0.4564709\",\n \"0.45531625\",\n \"0.4551914\",\n \"0.45249\",\n \"0.4496649\",\n \"0.44724518\",\n \"0.44636872\",\n \"0.44634536\",\n \"0.44486085\",\n \"0.44423738\",\n \"0.4430942\",\n \"0.44207963\",\n \"0.4413507\",\n \"0.43917766\",\n \"0.43914366\",\n \"0.43914366\",\n \"0.4387744\",\n \"0.4387744\",\n \"0.43780404\",\n \"0.43725199\",\n \"0.4349843\",\n \"0.43460354\",\n \"0.43427566\",\n \"0.43353954\",\n \"0.43293154\",\n \"0.4327694\",\n \"0.4320309\",\n \"0.43137926\",\n \"0.43133053\",\n \"0.43116525\",\n \"0.43059978\",\n \"0.43024173\",\n \"0.4293755\",\n \"0.4291154\",\n \"0.42905867\",\n \"0.42867476\",\n \"0.42843902\",\n \"0.4282721\",\n \"0.42723978\",\n \"0.4267287\",\n \"0.42542428\",\n \"0.42396548\",\n \"0.42335197\",\n \"0.42289764\",\n \"0.42275742\",\n \"0.42245924\",\n \"0.42230377\",\n \"0.42184556\",\n \"0.42103812\",\n \"0.4206185\",\n \"0.4203969\",\n \"0.42038113\",\n \"0.42035452\",\n \"0.42023388\",\n \"0.42000633\",\n \"0.41969156\",\n \"0.41921818\",\n \"0.41881248\",\n \"0.4185298\",\n \"0.41834563\",\n \"0.41812015\",\n \"0.41801825\",\n \"0.41759476\",\n \"0.41723704\",\n \"0.416539\",\n \"0.4165237\",\n \"0.4160476\",\n \"0.41580957\",\n \"0.4157205\",\n \"0.41543213\",\n \"0.4152933\",\n \"0.41462868\",\n \"0.41457993\",\n \"0.41435963\",\n \"0.4136559\",\n \"0.41333184\",\n \"0.41332287\",\n \"0.4132991\",\n \"0.4132291\",\n \"0.41319993\",\n \"0.41313887\",\n \"0.41310626\",\n \"0.41282701\",\n \"0.41248488\",\n \"0.41215867\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5910316"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":88352,"cells":{"query":{"kind":"string","value":"Return the heat capacity in J/molK at the given set of temperatures `Tlist` in K for the harmonic oscillator with a frequency `freq` in cm^1."},"document":{"kind":"string","value":"def harmonicOscillator_heatCapacity(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x"},"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 getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy","def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def heatCapacity(self, Tk=None, Tc=None):\n Tk = getTk(Tc, Tk)\n self.checkPropertyTempRange(\"heat capacity\", Tk)\n return (\n sum(\n [\n +1.38642e-13 * Tk**4,\n -6.47481e-10 * Tk**3,\n +1.02345e-06 * Tk**2,\n -4.32829e-04 * Tk,\n +1.06133e00,\n ]\n )\n * 1000.0\n ) # kJ / kg K to J / kg K","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def thermal(isatom, freq, scalfac,linnonlin,T):\n if isatom != \"true\":\n nfreq = len(freq)\n\n vib_temp = []\n for ifreq in range(nfreq):\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\n vib_temp.append(vib_temp_new)\n\n dE_vib = 0\n for ifreq in range(nfreq):\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\n\n dE_ZPE = 0.5 * sum(freq) * cmi2au\n\n if linnonlin == \"L\":\n dE_rot = kB * T * j2au\n elif linnonlin == \"NL\":\n dE_rot = kB * T * j2au * (3.0/2.0)\n else:\n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"ERROR: unknown entry for linear/nonlinear\")\n else:\n dE_ZPE = 0\n dE_vib = 0\n dE_rot = 0\n\n dE_tra = kB * T * j2au * (3.0/2.0)\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\n\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)","def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq","def heat_capacity(r, phi, q, kT):\n pot = q*(phi - phi[0])\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\n c = np.trapz(np.exp(-pot/kT) * r, r)\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)","def fuel_cond(T):\n\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\n \n return kc","def volumetric_heat_capacity(temperature):\n a = -2.4083\n b = 7.6006\n c = -8.2982\n d = 7.3301\n e = -4.2386\n f = 1.4294\n g = -0.24396\n h = 0.015236\n i = 0.0\n log_t = math.log10(temperature)\n f_exp = a + b*log_t + c*log_t**2.0 + d*log_t**3.0 + e*log_t**4.0 + f*log_t**5.0 + g*log_t**6.0 + \\\n h*log_t**7.0 + i*log_t**8.0\n g10_cp = 10.0**f_exp\n return g10_cp * G10NISTMaterialProperties.density","def compute_energy_density(kT):\n h=u.planck\n c=u.speed_of_light\n pi=np.pi\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)","def thermodynamic_temperature(frequency, T_cmb=None):\n nu = frequency.to(si.GHz, spectral())\n\n if T_cmb is None:\n from astropy.cosmology import default_cosmology\n\n T_cmb = default_cosmology.get().Tcmb0\n\n def f(nu, T_cmb=T_cmb):\n x = _si.h * nu / _si.k_B / T_cmb\n return x**2 * np.exp(x) / np.expm1(x) ** 2\n\n def convert_Jy_to_K(x_jybm):\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\n astrophys.Jy\n )\n return x_jybm / factor\n\n def convert_K_to_Jy(x_K):\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\n si.K\n )\n return x_K / factor\n\n return Equivalency(\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\n \"thermodynamic_temperature\",\n {\"frequency\": frequency, \"T_cmb\": T_cmb},\n )","def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\n kB = 1.380658e-16\n h = 6.6260755e-27\n c = 29979245800.\n nu = freqGHz*1.e9\n x = h*nu/(kB*T0)\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\n cNu *= 1e23\n return cNu","def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\n # low temperatures - high numbers\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)","def __setSpectrum__(self):\n \n self.Ck = []\n TempCk = []\n TempOneCk = OneCk()\n \n # Process 1st frequency\n Tb = self.freqs[1].totalJ\n \n for b in range(-Tb, Tb, 1):\n TempOneCk.freq = b*self.freqs[1].Vph\n TempOneCk.Amp = self.freqs[1].Cjk(b)\n self.Ck.append(TempOneCk)\n \n # Process additional frequencies\n CkSize = len(self.Ck)\n Added = FALSE\n \n for f in range(2, len(self.freqs), 1):\n # Reset temporary variables\n Tb = self.freqs[f].totalJ\n TempCk = []\n \n # Calculate each Ck coefficient\n for b in range(-Tb, Tb, 1):\n for k in range(CkSize):\n TempOneCk.Amp = Ck[k].Amp * self.freq[f].Cjk(b)\n \n # Check to see if Amp is big enough to keep\n if( abs(TempOneCk.Amp) > self.min_Ck ):\n Added = FALSE\n TempOneCk.freq = self.Ck[k].freq + b*self.freqs.Vph\n \n # If freq is already in Ck, add new value to old,\n # if not, add new value and freq to spectrum\n for c in TempCk:\n if abs(c.freq-TempOneCk.freq < DOUBLE_PRECISION):\n c.Amp += TempOneCk.Amp\n Added = TRUE\n break\n \n if (not Added):\n TempCk.append(TempOneCk)\n \n self.Ck = TempCk\n CkSize = len(self.Ck)","def chemical_potential(T, pressure):\n import numpy as np\n\n kb = 1.38064852e-23 # Boltzmann constant (J K^{-1})\n planck = 6.62607004e-34 # Planck constant\n mass = 2.0 * 1.00784 * 1.6737236e-27 # Mass of H2 in Kg\n beta = 1.0 / (kb * T) # Thermodynamic beta\n\n # Thermal wavelength\n thermal_wav = planck * planck * beta / (2 * np.pi * mass)\n thermal_wav = thermal_wav ** (1/2.)\n\n # Calculate chemical potential \n chemical_pot = np.log(pressure * thermal_wav ** 3 * beta) * T\n \n return chemical_pot","def get_quantum_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n f = 0\n for m in self.input.structure.get_masses():\n hbar_omega = (\n HBAR\n * np.sqrt(self.input.spring_constant / m)\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\n )\n f += (3.0 / 2) * hbar_omega + (\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\n )\n return f","def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_P_low *= (\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n )\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\n # low temperatures - high numbers\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)","def k_Li86(wind_ms, temp_C):\n from numpy import zeros_like\n\n U = wind_ms\n T = temp_C\n\n Sc = schmidt_number(T)\n k = zeros_like(temp_C)\n\n i1 = U <= 3.6\n i2 = (U > 3.6) & (U < 13.0)\n i3 = U >= 13.0\n\n k[i1] = (0.17 * U[i1]) * (Sc[i1] / 600) ** (-2.0 / 3.0)\n k[i2] = ((U[i2] - 3.4) * 2.8) * (600 / Sc[i2]) ** 0.5\n k[i3] = ((U[i3] - 8.4) * 5.9) * (600 / Sc[i3]) ** 0.5\n\n return k","def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n C_T = (\n 2 ** (1 / 4)\n * np.sqrt(gbar)\n / np.pi\n * np.sqrt(vv)\n * tt ** (5 / 4)\n * _1d_call(_fdk, y, k=1 / 2)\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\n )\n return C_T","def energy_due_to_vibrations(self, T, cf):\n E = 0.0\n for key, value in self.eci_per_kbT:\n E += value * cf[key] * kB * T\n return E","def CMB_spec(eng, temp):\n if np.issubdtype(type(eng), float):\n eng = np.array([eng])\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\n\n if np.issubdtype(type(eng), float): \n return phot_spec_density[0] \n else: \n return phot_spec_density","def vib_energy(frequency, temp):\n\n # vibrational temperature\n\n vtemp = plank_const * speed_ol / boltz_const * frequency\n\n vtemp = np.matrix(vtemp)\n\n temp = 1 / np.matrix(temp)\n\n # need to convert to array, because the element wise exponential\n # cannot work with matrix\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\n\n # energy is a np.matrix, need to convert to array\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\n energy = np.array(energy)[0]\n\n return energy","def system_temp(freq_hz):\n freqs = np.array([0.05e9, 0.07e9, 0.11e9, 0.17e9, 0.25e9, 0.35e9, 0.45e9,\n 0.55e9, 0.65e9])\n t_sys = np.array([4.0409e3, 1.5029e3, 0.6676e3, 0.2936e3, 0.1402e3, 0.0873e3,\n 0.0689e3, 0.0607e3, 0.0613e3])\n f = interp1d(np.log10(freqs), np.log10(t_sys), kind='cubic')\n return 10**f(np.log10(freq_hz))","def calc_entropy(frequency_wn, temperature):\r\n\tentropy = 0\r\n\tfrequency = [entry * SPEED_OF_LIGHT for entry in frequency_wn]\r\n\tfor entry in frequency:\r\n\t\tfactor = ((PLANCK_CONSTANT*entry)/(BOLTZMANN_CONSTANT*temperature))\r\n\t\ttemp = factor*(1/(math.exp(factor)-1)) - math.log(1-math.exp(-factor))\r\n\t\ttemp = temp*GAS_CONSTANT/4.184\r\n\t\tentropy = entropy + temp \r\n\treturn entropy","def hz_to_mel(frequencies, htk=False):\n\n frequencies = np.asanyarray(frequencies)\n\n if htk:\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\n\n # Fill in the linear part\n f_min = 0.0\n f_sp = 200.0 / 3\n\n mels = (frequencies - f_min) / f_sp\n\n # Fill in the log-scale part\n\n min_log_hz = 1000.0 # beginning of log region (Hz)\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\n logstep = np.log(6.4) / 27.0 # step size for log region\n\n if frequencies.ndim:\n # If we have array data, vectorize\n log_t = frequencies >= min_log_hz\n mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep\n elif frequencies >= min_log_hz:\n # If we have scalar data, heck directly\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\n\n return mels","def temperature(k, kmax):\n return 1.0 / 500 * (1.0 / k - 1.0 / kmax)","def hz_to_mel(frequencies, htk=False):\n\n frequencies = np.asanyarray(frequencies)\n\n if htk:\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\n\n # Fill in the linear part\n f_min = 0.0\n f_sp = 200.0 / 3\n\n mels = (frequencies - f_min) / f_sp\n\n # Fill in the log-scale part\n\n min_log_hz = 1000.0 # beginning of log region (Hz)\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\n logstep = np.log(6.4) / 27.0 # step size for log region\n\n if frequencies.ndim:\n # If we have array data, vectorize\n log_t = (frequencies >= min_log_hz)\n mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep\n elif frequencies >= min_log_hz:\n # If we have scalar data, heck directly\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\n\n return mels","def get_classical_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n\n return (\n -3\n * len(self.input.structure)\n * np.log(np.pi / (self.input.spring_constant * beta))\n / (2 * beta)\n )","def clumps_finding(text, k, t, L):\n frequent_patterns = []\n clumps = [0 for i in range(0, 4**k)]\n for i in range(0, len(text) - L + 1):\n subtext = text[i:i + L]\n freq_array = compute_freq(subtext, k)\n for index, freq in enumerate(freq_array):\n if freq >= t:\n clumps[index] = 1\n for index, clump in enumerate(clumps):\n if clump == 1:\n pattern = number_to_pattern(index, k)\n frequent_patterns.append(pattern)\n return frequent_patterns","def getPartitionFunction(self, Tlist):\n\t\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\n\t\t# Active K-rotor\n\t\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\n\t\tif len(rotors) == 0:\n\t\t\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\n\t\t\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\t# Other modes\n\t\tfor mode in self.modes:\n\t\t\tQ0 = mode.getPartitionFunction(Tlist)\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\treturn Q","def add_energy(self, T=0, beta=0, Mkep=0, mu=1, gamma=5/3., Tmin=0., AU=1):\n \n if self.npart == 0:\n self.u = array([])\n return\n\n print(' Adding temperature...')\n\n radii = norm(self.pos - self.center, axis=1)\n \n if T < 0:\n print(' Setting Temperature according to c_s(r)**2, with c_s(r) = h * v_kep(r),')\n if not hasattr(self, 'v_kep'): self.v_kep = sqrt(Mkep * G / radii)\n c_s = self.h * self.v_kep\n if gamma <= 0: gamma_cs = 1\n else: gamma_cs = gamma\n if mu <= 0:\n if gamma == 1.4: mu_cs = 2.01 # Adiabatic molecular\n else: mu_cs = 1.005 # Adiabatic/Isothermal atomic\n\n print(' using gamma = {:.3f}, and mu = {:.3f}...'.format(gamma_cs, mu_cs)) \n \n T = c_s**2 * mu_cs * mP / (gamma_cs * KB)\n\n else:\n T = full(self.npart, T * (radii / AU)**beta)\n\n\n T[T < Tmin] = Tmin \n \n # This following settings are still being tested if correct\n \n if mu <= 0:\n print(' Calculating mu used in code...')\n mu = full(self.npart, 0.5) # Ionized\n mu[T < 1.e4] = 1.005 # Atomic\n mu[T < 2.e3] = 2.01 # Molecular (Optional)\n\n if gamma <= 0:\n print(' Calculating gamma used in code...')\n gamma = full(self.npart, 5/3.) # Adiabatic monoatomic\n gamma[T < 2.e3] = 1.4\t # Adiabatic diatomic\n\n factor = KB / (mP * mu * (gamma - 1))\n \n if max(T) == min(T): print(\" Temperature: {} [K]\".format(T[0]))\n else:\n print(' Maximum temperature: {:.2f} [K]'.format(max(T)))\n print(' Minimum temperature: {:.2f} [K]'.format(min(T)))\n \n\n self.u = T * factor","def cooled_surface_temp(T:np.ndarray) -> float:\n \n return T.dot(cs_temp_weights)","def get_kt(temps, delta_gibbs_ts):\n # rate coefficient from Eyring equation\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular","def __init__(self, temperature=298.0 * simtk.unit.kelvin, nsteps=10, timestep=1 * simtk.unit.femtoseconds):\n\n super(HMCIntegrator, self).__init__(timestep)\n\n # Compute the thermal energy.\n kT = kB * temperature\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"naccept\", 0) # number accepted\n self.addGlobalVariable(\"ntrials\", 0) # number of Metropolization trials\n\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addPerDofVariable(\"sigma\", 0)\n self.addGlobalVariable(\"ke\", 0) # kinetic energy\n self.addPerDofVariable(\"xold\", 0) # old positions\n self.addGlobalVariable(\"Eold\", 0) # old energy\n self.addGlobalVariable(\"Enew\", 0) # new energy\n self.addGlobalVariable(\"accept\", 0) # accept or reject\n self.addPerDofVariable(\"x1\", 0) # for constraints\n\n #\n # Pre-computation.\n # This only needs to be done once, but it needs to be done for each degree of freedom.\n # Could move this to initialization?\n #\n self.addComputePerDof(\"sigma\", \"sqrt(kT/m)\")\n\n #\n # Allow Context updating here, outside of inner loop only.\n #\n self.addUpdateContextState()\n\n #\n # Draw new velocity.\n #\n self.addComputePerDof(\"v\", \"sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Store old position and energy.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Eold\", \"ke + energy\")\n self.addComputePerDof(\"xold\", \"x\")\n\n #\n # Inner symplectic steps using velocity Verlet.\n #\n for step in range(nsteps):\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x+dt*v\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m+(x-x1)/dt\")\n self.addConstrainVelocities()\n\n #\n # Accept/reject step.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Enew\", \"ke + energy\")\n self.addComputeGlobal(\"accept\", \"step(exp(-(Enew-Eold)/kT) - uniform)\")\n self.addComputePerDof(\"x\", \"x*accept + xold*(1-accept)\")\n\n #\n # Accumulate statistics.\n #\n self.addComputeGlobal(\"naccept\", \"naccept + accept\")\n self.addComputeGlobal(\"ntrials\", \"ntrials + 1\")","def generate_Lk_by_Ck(fptree, data_set, Ck,dim, min_support, support_data):\n Lk = set()\n item_count = {}\n t_num = float(len(data_set))\n if dim == 1:\n for t in data_set:\n for item in Ck:\n if item.issubset(t):\n if item not in item_count:\n item_count[item] = 1\n else:\n item_count[item] += 1\n t_num = float(len(data_set))\n else:\n for item in Ck:\n array = list(item)\n subData, support = fptree.getSubData(array[len(array) - 1], dim)\n for i in range(0, len(subData)):\n if item.issubset(subData[i]):\n if item not in item_count:\n item_count[item] = support[i]\n else:\n item_count[item] += support[i]\n for item in item_count:\n if (item_count[item] / t_num) >= min_support:\n Lk.add(item)\n support_data[item] = item_count[item] / t_num\n\n return Lk","def kin_energy (self):\n\n for planet in self.planets:\n planet.kenergy = 0.5*planet.mass*((np.linalg.norm(planet.velocity))**2) # every 'kenergy' depends by the body's mass and velocity","def __call__(self, T_HTF_inlet, m_in, htf):\n # Function maps inputs ( T [K], P [Pa] ) to outputs (C [J/kg-K])\n # We apply it: inputs ( T [C], P [Pa] ) to outputs (C [J/kg-K])\n T_min, T_max = T_HTF_inlet, self.T_exhaust_inlet\n T_mean = 0.5 * (T_min + T_max)\n C_p_exhaust = PropsSI('C',\n 'T', T_mean + 273.15,\n 'P', self.P_exhaust_inlet,\n 'Air')\n C_exhaust = C_p_exhaust * self.m_exhaust # [J/K]\n C_HTF = htf.lookup('C',T_mean) * m_in\n\n # This should be true\n C_min, C_max = C_exhaust, C_HTF\n C_r = C_min / C_max\n if C_r > 1:\n raise ValueError(\"HTF stream should have greater capacity (C_r = {})\".format(C_r))\n DeltaT_max = self.T_exhaust_inlet - T_HTF_inlet\n Q_max = C_min * DeltaT_max\n Q = self.effectiveness * Q_max\n T_HTF_outlet = T_HTF_inlet + Q / C_HTF\n T_exhaust_outlet = self.T_exhaust_inlet - Q / C_exhaust\n\n # TODO: adjust for (water) flow rate\n DeltaP_HTF = -6e3 # [Pa]\n DeltaP_exhaust = -300 # [Pa]\n \n return Q, T_HTF_outlet, T_exhaust_outlet, DeltaP_HTF, DeltaP_exhaust","def zpkfreqz(z, p, k, worN=None):\n if worN is None or isinstance(worN, int):\n N = worN or 512\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\n else:\n ws = worN\n\n h = []\n for wk in ws:\n zm1 = mp.exp(1j * wk)\n numer = _prod([zm1 - t for t in z])\n denom = _prod([zm1 - t for t in p])\n hk = k * numer / denom\n h.append(hk)\n return ws, h","def HKS(evals,evects, time_list,scaled=False):\n evals_s = np.asarray(evals).flatten()\n t_list = np.asarray(time_list).flatten()\n\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\n\n if scaled:\n inv_scaling = coefs.sum(1) # (num_T)\n return (1/inv_scaling)[None,:] * natural_HKS\n\n else:\n return natural_HKS","def MCS(n,k):\n\tglobal dict_all\n\tdict_val=copy.deepcopy(dict_all)\n\t#start_time = time.time()\n\tfinal = {}\t\t\t\t\t # Store all result with the count as key. For example final[1]=[[1,0,0],[0,1,1]]\n\tseq = []\t\t\t\t\t\t# Store the count with no duplication\n\tfor i in range(n):\n\t\tleaf={}\t\t\t\t\t\t# leaf is the dictionary to store the random value of each leaf\n\t\t#count=0\n\t\tfor i in leaves:\n\t\t\tleaf[i] = choice([0,1])\n\t\t\tdict_val[i]=leaf[i]\n\t\t\t#count += leaf[i]\n\t\tresult = Cal_FT(dict_val)\t\n\t\t'''\n\t\tif result:\n\t\t\tcutset = []\n\t\t\tfor i in leaves:\n\t\t\t\tcutset.append(str(leaf[i]))\n\t\t\tcutset=\"\".join(cutset)\n\t\t\tif cutset not in final:\n\t\t\t\tfinal[cutset]=count\n\tfinal_sorted=sorted(zip(final.values(),final.keys())) \t\t\t\t#Order the cutset by its count\n\tfor i in range(k):\t\t\t\t\t\t\t\t\t\t\t\t\t#Print the first k result\n\t\tcutset=list(final_sorted[i][1])\n\t\tresult=[]\n\t\tfor index in range(len(cutset)):\n\t\t\tif cutset[index] is \"1\":\n\t\t\t\tresult.append(leaves[index])\n\t\tprint result\n\t#end_time=time.time()\n\t#print \"Running time is\", end_time-start_time\n\t'''","def readenergy(self, filelist):\r\n \r\n energy=[]\r\n tmpenergy=[]\r\n for filename in filelist:\r\n if not(os.path.exists(filename)):\r\n if self._resultfile: self._resultfile.write('Output file: \"'+filename+'\" does not exist. Restart your calculation. \\n')\r\n else: print 'Output file: \"'+filename+'\" does not exist. Restart your calculation. \\n'\r\n sys.exit()\r\n else:\r\n tmpdat=[]\r\n for key in self._keydict:\r\n infile=open(filename)\r\n lenstart=len(key['start'])\r\n lenblock=len(key['startblock'])\r\n if lenblock:\r\n tmp=''\r\n readlist=[]\r\n readout=0\r\n startblock=0\r\n startcol=[]\r\n lcount=0\r\n count=0\r\n for tmpc in infile:\r\n if tmp>'':\r\n # We are in the area that we should read.\r\n if tmpc.count(key['stop']):\r\n tmp=''\r\n else:\r\n # We are currently in a data block.\r\n if readout:\r\n if (ischar and tmpc.count(key['stopblock'])) or (not(ischar) and len(tmpc)<=1):\r\n readout=readout-1\r\n else:\r\n # Read the columns.\r\n if lcount==0:\r\n for i in range(0, len(startcol)):\r\n tmpenergy.append([float(key['factor'])*float(tmpc[startcol[i][0]:startcol[i][0]+startcol[i][1]]),''])\r\n ilast=startlen\r\n count=0\r\n # Get the labeling information form the block.\r\n if key['type']=='label' or key['type']=='': \r\n # For type=label we read the symmetry of the orbitals. And put it at the end of the list containing the energy values.\r\n for i in range(ilast, len(tmpc)-1):\r\n if tmpc[i:i+1]==' ':\r\n if i-ilast>1:\r\n if int(tmpc[ilast:i]): \r\n if len(tmpenergy[ecount][1]): tmpenergy[ecount][1]=tmpenergy[ecount][1]+'<->'+readlist[lcount+count]\r\n else: tmpenergy[ecount][1]=readlist[lcount+count]\r\n count=count+1\r\n ilast=i\r\n ecount=ecount+1\r\n else:\r\n if self._resultfile: self._resultfile.write('ERROR: (parsedirac.dat). Type of data block is not implemented. '+key['type']+' key= '+key['key']+' \\n')\r\n else: print 'ERROR: (parsedirac.dat). Type of data block is not implemented. type=\"'+key['type']+'\" key= '+key['key']+' \\n'\r\n sys.exit()\r\n elif tmpc.count(key['startblock']):\r\n try:\r\n readout=float(key['stopblock'])\r\n ischar=0\r\n except:\r\n readout=1\r\n ischar=1\r\n # If readout=0 we only need to read to the end of this line.\r\n if readout==0:\r\n ilast=tmpc.index(key['startblock'])+len(key['startblock'])\r\n for i in range(ilast, len(tmpc)):\r\n if tmpc[i:i+1] in (' ', '\\n'):\r\n if (i-ilast)>1:\r\n try:\r\n tmpdat.append(key['factor']*float(tmpc[ilast+1:i]))\r\n except:\r\n if self._resultfile: self.resultfile.write('ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\n'+tmpc+'\\n')\r\n else: print 'ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\n'+tmpc+'\\n'\r\n ilast=i\r\n else:\r\n # Read the positions of the columns containing energy information.\r\n for col in key['columns']:\r\n if tmpc.count(col):\r\n startcol.append((tmpc.index(col),len(col))) \r\n startlen=tmpc.index(key['startblock'])+len(key['startblock'])\r\n ilast=startlen\r\n lcount=lcount+count\r\n count=0\r\n ecount=0\r\n # Read the labels after the block start commando.\r\n for i in range(ilast, len(tmpc)-1):\r\n if tmpc[i:i+1]==' ':\r\n if i-ilast>1:\r\n readlist.append(tmpc[ilast+1:i])\r\n count=count+1\r\n ilast=i\r\n elif tmpc.count(key['start']):\r\n tmp=key['start']\r\n tmpenergy=[]\r\n tmpdat.append(tmpenergy)\r\n else:\r\n # If we read only one line, find it and read all numbers on it.\r\n for tmpc in infile: \r\n tmpn=tmpc.count(key['start'])\r\n if tmpn:\r\n ilast=tmpc.index(key['start'])+len(key['start'])\r\n for i in range(ilast, len(tmpc)):\r\n if tmpc[i:i+1] in (' ', '\\n'):\r\n if (i-ilast)>1:\r\n try:\r\n tmpdat.append(key['factor']*float(tmpc[ilast+1:i]))\r\n except:\r\n if self._resultfile: self.resultfile.write('ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\n'+tmpc+'\\n')\r\n else: print 'ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\n'+tmpc+'\\n'\r\n ilast=i\r\n infile.close()\r\n energy.append(tmpdat)\r\n return energy","def total_band_energy(vals, T, Ec):\n vals = np.sort(np.concatenate(vals))\n occup = occup_TK(vals, T=T, spin=2)\n return np.dot(vals, occup)-Ec","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for low temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n S_low = (\n -gbar\n * np.sqrt(2)\n / (6 * np.pi ** 2)\n * tt_low ** (3 / 2)\n * vv_low\n * (\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\n )\n )\n # low temperatures - high numbers\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((S_low, S_high)).reshape(y.shape)","def heat(self, delta_temp):\n return self.heat_capacity * self.mass * delta_temp","def half_space_cooling_temperature(z, t, T1, T0, kappa):\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]","def C_T(self):\n return self.generic_getter(\n get_sound_speed_temperature, \"C_T\", \"convert_sound_speed\"\n )","def temperature_energy():\n e = _si.e.value\n k_B = _si.k_B.value\n return Equivalency(\n [(si.K, si.eV, lambda x: x / (e / k_B), lambda x: x * (e / k_B))],\n \"temperature_energy\",\n )","def conductivity(self, T):\n m = self.mass\n mu = self.viscosity(T)\n K = (15/4) * kB * mu / m\n return K","def HeatEqn_FT(D, L, x, t, u_0):\n n = x.size\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\n u_0t = np.fft.fft(u_0)\n\n U = np.zeros((t.size, x.size))\n for ti in range(t.size):\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\n\n return U","def effective_temperature(R,times):\n T_eff = np.empty((len(R),times))\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \n for i in range (len(R)):\n for t in range(times): \n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\n return T_eff","def hz2mel(freq):\n return 2595. * np.log10(1+freq/700.0)","def get_freq_grid():\n (bins_per_octave, n_octaves, _, _, f_min, _) = get_hcqt_params()\n freq_grid = librosa.cqt_frequencies(\n bins_per_octave*n_octaves, f_min, bins_per_octave=bins_per_octave\n )\n return freq_grid","def k_Wa92(wind_second_moment, temp_C):\n\n U2 = wind_second_moment\n\n Sc = schmidt_number(temp_C)\n k = (0.31 * U2) * (660 / Sc) ** 0.5\n\n return k","def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\n pi, ids = induced_distribution(hmsm, 0, level)\n\n discrete_free_energy = np.ndarray(pi.shape)\n for i, id in enumerate(ids):\n discrete_free_energy[i] = \\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\n boltzmann = np.exp(-discrete_free_energy/kT)\n boltzmann *= (1/np.sum(boltzmann))\n return D_KL(boltzmann, pi)","def main():\n # Reading the list of temps\n the_list = read_list()\n\n # Getting a temp to count and running frequency function\n count_temp = int(input(\"Enter a value you would like the frequency of: \"))\n\n # calling the frequency function\n frequency(count_temp, the_list)","def temperature(self):\n value = float(self._parent.query('R{}'.format(self._idx))[1:])\n return pq.Quantity(value, pq.Kelvin)","def getHeatFlux(self, T):\n\t\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\n\t\treturn Q","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","def zenith_gain(freq):\n parfile = open(project_path\n + \"DSS-28_technical/efficiency_vs_freq_pars.pkl\",\"r\")\n pars = cPickle.load(parfile)\n parfile.close()\n effic = {}\n avg_effic = 0\n for key in list(pars.keys()):\n effic[key] = pars[key](freq)/100.\n avg_effic += effic[key]\n # right now I don't know what Pol A and Pol B are\n avg_effic /= len(list(pars.keys()))\n return avg_effic","def get_sound_speed_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n C_S = (\n np.sqrt(5)\n * np.sqrt(gbar)\n * 2 ** (1 / 4)\n / (3 * np.pi)\n * tt ** (5 / 4)\n * np.sqrt(vv * _1d_call(_fdk, y, k=3 / 2))\n )\n return C_S","def Kgrid(struc, Kresol=0.10, dimension=3):\n a, b, c, alpha, beta, gamma = struc.get_cell_lengths_and_angles()\n vol = struc.get_volume()\n dist = np.zeros(3);\n dist[2] = np.abs(vol/(a*b*np.sin(np.radians(gamma))))\n dist[1] = np.abs(vol/(a*c*np.sin(np.radians(beta))))\n dist[0] = np.abs(vol/(b*c*np.sin(np.radians(alpha))))\n Kpoints = np.ceil(1./(dist*Kresol))\n if dimension == 2:\n Kpoints[-1] = 1;\n #print(a, b, c, alpha, beta, gamma)\n #print(vol/(a*b*np.sin(gamma)), a*b, np.sin(gamma))\n #print(vol/(a*c*np.sin(beta)), a*c, np.sin(beta))\n #print(vol/(b*c*np.sin(alpha)), b*c, np.sin(alpha))\n #print(Kpoints)\n #import sys; sys.exit()\n return Kpoints.astype(int)","def getMolarFluxes(self,T):\n\t\tsigma = 0.1 # Hertz-Knudsen condensation/evaporation coefficient\n\t\t# see doi:10.1103/PhysRevE.59.429\n\t\t# http://www.mie.utoronto.ca/labs/tkl/publications/WardFangExpress.pdf\n\t\tvp = self.getVaporPressures(T)\n\t\tmw = self.molar_masses*0.001 / 6.02E23 # mass of molecule in kg\n\t\tkb = 1.38E-23 # m^2 kg s^-2 K^-1 !!\n\t\tJe = vp / numpy.sqrt(2*numpy.pi * mw * kb * T) \n\t\treturn Je/ 6.02E23","def fahrenheit(T_in_celsius):\n return (T_in_celsius * 9 / 5) + 32","def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\n\n # Initialize constants.\n kT = kB * temperature\n gamma = collision_rate\n\n # Create a new custom integrator.\n super(GHMCIntegrator, self).__init__(timestep)\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addGlobalVariable(\"b\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\n self.addPerDofVariable(\"sigma\", 0)\n self.addGlobalVariable(\"ke\", 0) # kinetic energy\n self.addPerDofVariable(\"vold\", 0) # old velocities\n self.addPerDofVariable(\"xold\", 0) # old positions\n self.addGlobalVariable(\"Eold\", 0) # old energy\n self.addGlobalVariable(\"Enew\", 0) # new energy\n self.addGlobalVariable(\"accept\", 0) # accept or reject\n self.addGlobalVariable(\"naccept\", 0) # number accepted\n self.addGlobalVariable(\"ntrials\", 0) # number of Metropolization trials\n self.addPerDofVariable(\"x1\", 0) # position before application of constraints\n\n #\n # Pre-computation.\n # This only needs to be done once, but it needs to be done for each degree of freedom.\n # Could move this to initialization?\n #\n self.addComputePerDof(\"sigma\", \"sqrt(kT/m)\")\n\n #\n # Allow context updating here.\n #\n self.addUpdateContextState()\n\n #\n # Constrain positions.\n #\n self.addConstrainPositions()\n\n #\n # Velocity perturbation.\n #\n self.addComputePerDof(\"v\", \"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Metropolized symplectic step.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Eold\", \"ke + energy\")\n self.addComputePerDof(\"xold\", \"x\")\n self.addComputePerDof(\"vold\", \"v\")\n self.addComputePerDof(\"v\", \"v + 0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x + v*dt\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v + 0.5*dt*f/m + (x-x1)/dt\")\n self.addConstrainVelocities()\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Enew\", \"ke + energy\")\n self.addComputeGlobal(\"accept\", \"step(exp(-(Enew-Eold)/kT) - uniform)\")\n self.addComputePerDof(\"x\", \"x*accept + xold*(1-accept)\")\n self.addComputePerDof(\"v\", \"v*accept - vold*(1-accept)\")\n\n #\n # Velocity randomization\n #\n self.addComputePerDof(\"v\", \"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Accumulate statistics.\n #\n self.addComputeGlobal(\"naccept\", \"naccept + accept\")\n self.addComputeGlobal(\"ntrials\", \"ntrials + 1\")","def categoryFrequency(categoryList): #TODO delete units\n n=len(categoryList)\n freq = dict()\n for i in categoryList:\n if i in freq.keys():\n freq[i]=freq[i]+1/float(n)\n else:\n freq[i]=1/float(n)\n sortedFreq=sorted([(v,k) for (k,v) in freq.items()], reverse = True)[:10]\n freq=dict([(k,v) for (v,k) in sortedFreq])\n return freq","def __init__(self):\n \n # list of all frequencies\n self.freqs = []\n \n # list of frequencies with Z != 0\n self.freqsToSolve = []\n \n # minimum Ck value to be kept\n self.min_Ck = 1.0e-18\n \n # Ck spectrum (list of OneCk objects)\n self.Ck = []","def helmholtzenergy(temp,pres):\n g = liq_g(0,0,temp,pres)\n g_p = liq_g(0,1,temp,pres)\n f = g - pres*g_p\n return f","def add_clump_forming_kmers(counts, clumpFormingKmers):\n for kmer in counts:\n if counts[kmer] >= t:\n clumpFormingKmers.add(kmer)\n\n return clumpFormingKmers","def tristimulus_weighting_factors_ASTME2022(cmfs, illuminant, shape, k=None):\n\n if cmfs.shape.interval != 1:\n raise ValueError('\"{0}\" shape \"interval\" must be 1!'.format(cmfs))\n\n if illuminant.shape.interval != 1:\n raise ValueError(\n '\"{0}\" shape \"interval\" must be 1!'.format(illuminant))\n\n global _TRISTIMULUS_WEIGHTING_FACTORS_CACHE\n if _TRISTIMULUS_WEIGHTING_FACTORS_CACHE is None:\n _TRISTIMULUS_WEIGHTING_FACTORS_CACHE = CaseInsensitiveMapping()\n\n name_twf = ', '.join((cmfs.name, illuminant.name, str(shape), str(k)))\n if name_twf in _TRISTIMULUS_WEIGHTING_FACTORS_CACHE:\n return _TRISTIMULUS_WEIGHTING_FACTORS_CACHE[name_twf]\n\n Y = cmfs.values\n S = illuminant.values\n\n interval_i = DEFAULT_INT_DTYPE(shape.interval)\n W = S[::interval_i, np.newaxis] * Y[::interval_i, :]\n\n # First and last measurement intervals *Lagrange Coefficients*.\n c_c = lagrange_coefficients_ASTME2022(interval_i, 'boundary')\n # Intermediate measurement intervals *Lagrange Coefficients*.\n c_b = lagrange_coefficients_ASTME2022(interval_i, 'inner')\n\n # Total wavelengths count.\n w_c = len(Y)\n # Measurement interval interpolated values count.\n r_c = c_b.shape[0]\n # Last interval first interpolated wavelength.\n w_lif = w_c - (w_c - 1) % interval_i - 1 - r_c\n\n # Intervals count.\n i_c = W.shape[0]\n i_cm = i_c - 1\n\n # \"k\" is used as index in the nested loop.\n k_n = k\n\n for i in range(3):\n # First interval.\n for j in range(r_c):\n for k in range(3):\n W[k, i] = W[k, i] + c_c[j, k] * S[j + 1] * Y[j + 1, i]\n\n # Last interval.\n for j in range(r_c):\n for k in range(i_cm, i_cm - 3, -1):\n W[k, i] = (W[k, i] + c_c[r_c - j - 1, i_cm - k] * S[j + w_lif]\n * Y[j + w_lif, i])\n\n # Intermediate intervals.\n for j in range(i_c - 3):\n for k in range(r_c):\n w_i = (r_c + 1) * (j + 1) + 1 + k\n W[j, i] = W[j, i] + c_b[k, 0] * S[w_i] * Y[w_i, i]\n W[j + 1, i] = W[j + 1, i] + c_b[k, 1] * S[w_i] * Y[w_i, i]\n W[j + 2, i] = W[j + 2, i] + c_b[k, 2] * S[w_i] * Y[w_i, i]\n W[j + 3, i] = W[j + 3, i] + c_b[k, 3] * S[w_i] * Y[w_i, i]\n\n # Extrapolation of potential incomplete interval.\n for j in range(\n DEFAULT_INT_DTYPE(w_c - ((w_c - 1) % interval_i)), w_c, 1):\n W[i_cm, i] = W[i_cm, i] + S[j] * Y[j, i]\n\n W *= 100 / np.sum(W, axis=0)[1] if k_n is None else k_n\n\n _TRISTIMULUS_WEIGHTING_FACTORS_CACHE[name_twf] = W\n\n return W","def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq / 700.0))","def F2K(T_F):\n return 5./9.*(T_F+459.67)","def _convert_frequency(self, frequency):\n\n # Assert frequency lies within allowed range\n FTW_step = self.clock_freq/2**32\n FTW = round(frequency/FTW_step)\n Min_freq = 0\n Max_freq = (2**32-1)*FTW_step\n\n assert FTW >= 0, 'Minimum frequency is %r' %Min_freq\n assert FTW <= 2**32, 'Maximum frequency is %r' %Max_freq\n\n # Compute frequency tuning word for given frequency and clock frequency\n # Write FTW in list of 4 bytes (CFTW0 is a 32-bit register)\n return [FTW.to_bytes(4, 'big')[i] for i in range(4)]","def better_clumps_finding(text, k, t, L):\n frequent_patterns = []\n clumps = [0 for i in range(0, 4**k)]\n first_subtext = text[:L]\n freq_array = compute_freq(first_subtext, k)\n for index, freq in enumerate(freq_array):\n if freq >= t:\n clumps[index] = 1\n for i in range(1, len(text) - L + 1):\n old_kmer = text[i - 1:i - 1 + k]\n old_kmer_number = pattern_to_number(old_kmer)\n freq_array[old_kmer_number] -= 1\n new_kmer = text[i + L:i + L + k]\n new_kmer_number = pattern_to_number(new_kmer)\n freq_array[new_kmer_number] += 1\n if freq_array[new_kmer_number] >= t:\n clumps[new_kmer_number] = 1\n for index, clump in enumerate(clumps):\n if clump == 1:\n pattern = number_to_pattern(index, k)\n frequent_patterns.append(pattern) \n return frequent_patterns","def k_Ni00(wind_ms, temp_C):\n\n U = wind_ms\n\n Sc = schmidt_number(temp_C)\n k = (0.333 * U + 0.222 * U ** 2) * (600 / Sc) ** 0.5\n\n return k","def rough_frequency_samples(m1, m2, flow, fmax, df_min):\n kmin = int(flow / df_min)\n kmax = int(fmax / df_min)\n k = kmin\n ksamples = []\n while k < kmax:\n ksamples.append(k)\n k += int(1.0 / rough_time_estimate(m1, m2, k * df_min) / df_min)\n ksamples.append(kmax)\n return numpy.array(ksamples)","def get_frequency(self, c):\n yield self.wm.write(\":READ:POW?\\r\\n\")\n yield self.wm.write(\":READ:FREQ?\\r\\n\")\n freq = yield self.wm.read_very_eager()\n if freq != '':\n\n temp = freq.split()\n temp = map(float,temp)\n temp.sort()\n if temp[len(temp)-1] >40.0:\n freq = temp[len(temp)-1]\n self.freq_changed((freq))\n self.freq = freq\n if temp[0] < 40.0:\n amp = temp[0]\n self.amp_changed((amp))\n self.amp = amp\n returnValue(self.freq)","def totalInfilHorton1time(f0, fc, k, t):\n numerator = (f0 - fc)*(1 - np.exp(-k*t))\n Ft = (fc*t) + (numerator/k)\n return Ft","def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\n\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\n\td = dist * 1e3 * pc\n\t# Radius (in unit of pc)\n\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\n\t# Mass\n\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\n\t# Number density\n\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\n\t# Sigmav of 2.33H\n\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\n\t# Virial\n\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\n\t# Virial parameter with B-field, assume 1 mG\n\tB = 1 * 1e-3 # G\n\trho = density * 2.8 * mp # g/cm3\n\talfven = B / np.sqrt(4*np.pi*rho)\n\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\n\n\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B","def main(l, k):\n S = 0\n T = product(xrange(2), repeat=k)\n for ts in T:\n tmp = []\n\n for t, c in zip(ts, cs):\n tmp.append(((-1)*c)**t)\n\n S += (sum(tmp)**l)\n val = (sum(tmp)**l)\n print val\n return S / float(2**(k))","def main(l, k):\n S = 0\n T = product(xrange(2), repeat=k)\n for ts in T:\n tmp = []\n\n for t, c in zip(ts, cs):\n tmp.append(((-1)*c)**t)\n\n S += (sum(tmp)**l)\n val = (sum(tmp)**l)\n print val\n return S / float(2**(k))","def zzx_mul_term(f, c, k):\n if not c or not f:\n return []\n else:\n return [ c * coeff for coeff in f ] + [INT_ZERO]*k","def get_kf_kms(self):\n kfkms = np.array([ self.kf / (ss.velfac * 3.085678e24/ss.units.UnitLength_in_cm) for ss in self.spectrae])\n return kfkms","def flux_sensitivity(freq_hz, t_acc=5, bw_hz=100e3, num_antennas=256, eta=1,\n t_sys=None, a_eff=None):\n t_sys = system_temp(freq_hz) if t_sys is None else t_sys\n a_eff = (element_effective_area(freq_hz) * num_antennas) if a_eff is None \\\n else a_eff\n sefd = (2 * const.k_B.value * t_sys * eta) / a_eff\n sigma_s = (sefd * 1e26) / sqrt(2 * bw_hz * t_acc)\n return sigma_s","def KE_ejected_electron(frequency=1,workFunction=1, units=eV):\n\n var = sy.var('h nu W')\n par = units['h'], frequency, workFunction\n\n y = h*nu - W\n\n return dic_result(var,par,y)","def cel_to_fahren(temp_list):\n fahren_list = [round(temp*9/5+32) for temp in temp_list]\n return fahren_list","def chunkedClumpFinder(sequence, k, L, t):\n\n frequentPatterns = set([])\n for i in range(len(sequence)):\n window = sequence[i:i + L]\n frequencies = {}\n\n for j in range(len(window)):\n pattern = window[j:j + k]\n if pattern not in frequencies:\n frequencies[pattern] = 1\n else:\n frequencies[pattern] += 1\n for p in frequencies:\n if frequencies[p] >= t:\n frequentPatterns.add(p)\n return frequentPatterns","def k_Sw07(wind_second_moment, temp_C):\n\n U2 = wind_second_moment\n\n Sc = schmidt_number(temp_C)\n k = (0.27 * U2) * (660 / Sc) ** 0.5\n\n return k","def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr","def __call__(self, T_HTF_inlet, m_in, htf):\n T_min, T_max = T_HTF_inlet, self.T_exhaust_inlet\n # Function maps inputs ( T [K], P [Pa] ) to outputs (H [J/kg])\n # We apply it: inputs ( T [C], P [Pa] ) to outputs (H [J/kg])\n H_exhaust = lambda(T): PropsSI('H',\n 'T', T + 273.15,\n 'P', self.P_exhaust_inlet,\n 'Air')\n H_exhaust_max = H_exhaust(T_max)\n DeltaH_exhaust_max = H_exhaust_max - H_exhaust(T_min)\n # Q_max = C_min * DeltaT_max\n Q_max = self.m_exhaust * DeltaH_exhaust_max\n Q = self.effectiveness * Q_max\n # Now find the temperatures that give this value.\n # For the exhaust stream we have an inverse.\n H_exhaust_outlet = H_exhaust_max - DeltaH_exhaust_max * self.effectiveness\n # Function maps inputs ( T [K], P [Pa] ) to outputs (H [J/kg])\n # We apply it: inputs ( T [C], P [Pa] ) to outputs (H [J/kg])\n T_exhaust_outlet = -273.15 + PropsSI('T',\n 'H', H_exhaust_outlet,\n 'P', self.P_exhaust_inlet,\n 'Air')\n DeltaH_HTF = Q / m_in\n H_HTF_min = htf.h(T_HTF_inlet)\n self.H_HTF_max = H_HTF_min + DeltaH_HTF\n self.H_HTF_err = lambda(T): htf.h(T) - self.H_HTF_max\n self.T_HTF_outlet = fsolve(self.H_HTF_err, T_HTF_inlet)\n T_HTF_outlet = self.T_HTF_outlet[0]\n\n # TODO: adjust for (water) flow rate\n DeltaP_HTF = -6e3 # [Pa]\n DeltaP_exhaust = -300 # [kPa]\n \n return Q, T_HTF_outlet, T_exhaust_outlet, DeltaP_HTF, DeltaP_exhaust","def distribution_planck_nu(frequency=1,temperature=1, units=SI,printA=False):\n\n var = sy.var('pi nu h c k t')\n par = np.pi, frequency, units['h'], units['c'], units['k'], temperature\n\n y = ( 8 * pi * nu**2 * h * nu ) / ( c**3 * (sy.exp(h*nu/k/t) - 1) )\n\n return dic_result(var,par,y)","def setTemp(self, T):\n kb = 1.380658*10**-23\n v = np.sqrt(2)*np.sqrt(kb)*np.sqrt(T) / np.sqrt(m)\n for p in self.listOfParticles:\n # Downscale the direction vector\n p.V = p.V.scale(1)\n # Scale the direction vector to fit the temperature\n p.V = p.V.scale(v)","def element_area_and_temperature(freq_hz):\n # Element noise data.\n noise_data = {\n 'freqs': [0.05e9, 0.07e9, 0.11e9, 0.17e9, 0.25e9, 0.35e9,\n 0.45e9, 0.55e9, 0.65e9],\n 'a_eff': [1.8791, 1.8791, 1.8694, 1.3193, 0.6080, 0.2956,\n 0.2046, 0.1384, 0.0792],\n 't_sys': [4.0409e3, 1.5029e3, 0.6676e3, 0.2936e3, 0.1402e3, 0.0873e3,\n 0.0689e3, 0.0607e3, 0.0613e3]\n }\n log_freq = numpy.log10(freq_hz)\n freqs = numpy.array(noise_data['freqs'])\n a_eff = numpy.array(noise_data['a_eff'])\n t_sys = numpy.array(noise_data['t_sys'])\n f_cut = 2\n\n # Interpolate to get effective area.\n if freq_hz <= freqs[f_cut]:\n f = scipy.interpolate.interp1d(numpy.log10(freqs[:f_cut+1]), \n numpy.log10(a_eff[:f_cut+1]), kind='slinear')\n a_eff = 10**f(log_freq)\n else:\n f = scipy.interpolate.interp1d(numpy.log10(freqs[f_cut:]), \n numpy.log10(a_eff[f_cut:]), kind='cubic')\n a_eff = 10**f(log_freq)\n\n # Interpolate to get system temperature.\n f = scipy.interpolate.interp1d(numpy.log10(freqs), \n numpy.log10(t_sys), kind='cubic')\n t_sys = 10**f(log_freq)\n return a_eff, t_sys","def to_kwh(m):\n cp = 4243.5 # specific heat of water [J/ kg K]\n dT = 179 # change in steam temperature [deg C]\n h_in = 196 # inlet enthalpy [BTU/lb]\n h_out = 1368 # outlet enthalpy [BTU/lb]\n\n # times 0.29307107 to convert from BTU/hr to kilowatts\n kwh = (m * (h_out - h_in)) * 0.29307107\n return kwh"],"string":"[\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy\",\n \"def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def heatCapacity(self, Tk=None, Tc=None):\\n Tk = getTk(Tc, Tk)\\n self.checkPropertyTempRange(\\\"heat capacity\\\", Tk)\\n return (\\n sum(\\n [\\n +1.38642e-13 * Tk**4,\\n -6.47481e-10 * Tk**3,\\n +1.02345e-06 * Tk**2,\\n -4.32829e-04 * Tk,\\n +1.06133e00,\\n ]\\n )\\n * 1000.0\\n ) # kJ / kg K to J / kg K\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def thermal(isatom, freq, scalfac,linnonlin,T):\\n if isatom != \\\"true\\\":\\n nfreq = len(freq)\\n\\n vib_temp = []\\n for ifreq in range(nfreq):\\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\\n vib_temp.append(vib_temp_new)\\n\\n dE_vib = 0\\n for ifreq in range(nfreq):\\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\\n\\n dE_ZPE = 0.5 * sum(freq) * cmi2au\\n\\n if linnonlin == \\\"L\\\":\\n dE_rot = kB * T * j2au\\n elif linnonlin == \\\"NL\\\":\\n dE_rot = kB * T * j2au * (3.0/2.0)\\n else:\\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"ERROR: unknown entry for linear/nonlinear\\\")\\n else:\\n dE_ZPE = 0\\n dE_vib = 0\\n dE_rot = 0\\n\\n dE_tra = kB * T * j2au * (3.0/2.0)\\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\\n\\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)\",\n \"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def heat_capacity(r, phi, q, kT):\\n pot = q*(phi - phi[0])\\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\\n c = np.trapz(np.exp(-pot/kT) * r, r)\\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)\",\n \"def fuel_cond(T):\\n\\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\\n \\n return kc\",\n \"def volumetric_heat_capacity(temperature):\\n a = -2.4083\\n b = 7.6006\\n c = -8.2982\\n d = 7.3301\\n e = -4.2386\\n f = 1.4294\\n g = -0.24396\\n h = 0.015236\\n i = 0.0\\n log_t = math.log10(temperature)\\n f_exp = a + b*log_t + c*log_t**2.0 + d*log_t**3.0 + e*log_t**4.0 + f*log_t**5.0 + g*log_t**6.0 + \\\\\\n h*log_t**7.0 + i*log_t**8.0\\n g10_cp = 10.0**f_exp\\n return g10_cp * G10NISTMaterialProperties.density\",\n \"def compute_energy_density(kT):\\n h=u.planck\\n c=u.speed_of_light\\n pi=np.pi\\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)\",\n \"def thermodynamic_temperature(frequency, T_cmb=None):\\n nu = frequency.to(si.GHz, spectral())\\n\\n if T_cmb is None:\\n from astropy.cosmology import default_cosmology\\n\\n T_cmb = default_cosmology.get().Tcmb0\\n\\n def f(nu, T_cmb=T_cmb):\\n x = _si.h * nu / _si.k_B / T_cmb\\n return x**2 * np.exp(x) / np.expm1(x) ** 2\\n\\n def convert_Jy_to_K(x_jybm):\\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\\n astrophys.Jy\\n )\\n return x_jybm / factor\\n\\n def convert_K_to_Jy(x_K):\\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\\n si.K\\n )\\n return x_K / factor\\n\\n return Equivalency(\\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\\n \\\"thermodynamic_temperature\\\",\\n {\\\"frequency\\\": frequency, \\\"T_cmb\\\": T_cmb},\\n )\",\n \"def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\\n kB = 1.380658e-16\\n h = 6.6260755e-27\\n c = 29979245800.\\n nu = freqGHz*1.e9\\n x = h*nu/(kB*T0)\\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\\n cNu *= 1e23\\n return cNu\",\n \"def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\\n # low temperatures - high numbers\\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)\",\n \"def __setSpectrum__(self):\\n \\n self.Ck = []\\n TempCk = []\\n TempOneCk = OneCk()\\n \\n # Process 1st frequency\\n Tb = self.freqs[1].totalJ\\n \\n for b in range(-Tb, Tb, 1):\\n TempOneCk.freq = b*self.freqs[1].Vph\\n TempOneCk.Amp = self.freqs[1].Cjk(b)\\n self.Ck.append(TempOneCk)\\n \\n # Process additional frequencies\\n CkSize = len(self.Ck)\\n Added = FALSE\\n \\n for f in range(2, len(self.freqs), 1):\\n # Reset temporary variables\\n Tb = self.freqs[f].totalJ\\n TempCk = []\\n \\n # Calculate each Ck coefficient\\n for b in range(-Tb, Tb, 1):\\n for k in range(CkSize):\\n TempOneCk.Amp = Ck[k].Amp * self.freq[f].Cjk(b)\\n \\n # Check to see if Amp is big enough to keep\\n if( abs(TempOneCk.Amp) > self.min_Ck ):\\n Added = FALSE\\n TempOneCk.freq = self.Ck[k].freq + b*self.freqs.Vph\\n \\n # If freq is already in Ck, add new value to old,\\n # if not, add new value and freq to spectrum\\n for c in TempCk:\\n if abs(c.freq-TempOneCk.freq < DOUBLE_PRECISION):\\n c.Amp += TempOneCk.Amp\\n Added = TRUE\\n break\\n \\n if (not Added):\\n TempCk.append(TempOneCk)\\n \\n self.Ck = TempCk\\n CkSize = len(self.Ck)\",\n \"def chemical_potential(T, pressure):\\n import numpy as np\\n\\n kb = 1.38064852e-23 # Boltzmann constant (J K^{-1})\\n planck = 6.62607004e-34 # Planck constant\\n mass = 2.0 * 1.00784 * 1.6737236e-27 # Mass of H2 in Kg\\n beta = 1.0 / (kb * T) # Thermodynamic beta\\n\\n # Thermal wavelength\\n thermal_wav = planck * planck * beta / (2 * np.pi * mass)\\n thermal_wav = thermal_wav ** (1/2.)\\n\\n # Calculate chemical potential \\n chemical_pot = np.log(pressure * thermal_wav ** 3 * beta) * T\\n \\n return chemical_pot\",\n \"def get_quantum_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n f = 0\\n for m in self.input.structure.get_masses():\\n hbar_omega = (\\n HBAR\\n * np.sqrt(self.input.spring_constant / m)\\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\\n )\\n f += (3.0 / 2) * hbar_omega + (\\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\\n )\\n return f\",\n \"def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_P_low *= (\\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n )\\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n # low temperatures - high numbers\\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)\",\n \"def k_Li86(wind_ms, temp_C):\\n from numpy import zeros_like\\n\\n U = wind_ms\\n T = temp_C\\n\\n Sc = schmidt_number(T)\\n k = zeros_like(temp_C)\\n\\n i1 = U <= 3.6\\n i2 = (U > 3.6) & (U < 13.0)\\n i3 = U >= 13.0\\n\\n k[i1] = (0.17 * U[i1]) * (Sc[i1] / 600) ** (-2.0 / 3.0)\\n k[i2] = ((U[i2] - 3.4) * 2.8) * (600 / Sc[i2]) ** 0.5\\n k[i3] = ((U[i3] - 8.4) * 5.9) * (600 / Sc[i3]) ** 0.5\\n\\n return k\",\n \"def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n C_T = (\\n 2 ** (1 / 4)\\n * np.sqrt(gbar)\\n / np.pi\\n * np.sqrt(vv)\\n * tt ** (5 / 4)\\n * _1d_call(_fdk, y, k=1 / 2)\\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\\n )\\n return C_T\",\n \"def energy_due_to_vibrations(self, T, cf):\\n E = 0.0\\n for key, value in self.eci_per_kbT:\\n E += value * cf[key] * kB * T\\n return E\",\n \"def CMB_spec(eng, temp):\\n if np.issubdtype(type(eng), float):\\n eng = np.array([eng])\\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\\n\\n if np.issubdtype(type(eng), float): \\n return phot_spec_density[0] \\n else: \\n return phot_spec_density\",\n \"def vib_energy(frequency, temp):\\n\\n # vibrational temperature\\n\\n vtemp = plank_const * speed_ol / boltz_const * frequency\\n\\n vtemp = np.matrix(vtemp)\\n\\n temp = 1 / np.matrix(temp)\\n\\n # need to convert to array, because the element wise exponential\\n # cannot work with matrix\\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\\n\\n # energy is a np.matrix, need to convert to array\\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\\n energy = np.array(energy)[0]\\n\\n return energy\",\n \"def system_temp(freq_hz):\\n freqs = np.array([0.05e9, 0.07e9, 0.11e9, 0.17e9, 0.25e9, 0.35e9, 0.45e9,\\n 0.55e9, 0.65e9])\\n t_sys = np.array([4.0409e3, 1.5029e3, 0.6676e3, 0.2936e3, 0.1402e3, 0.0873e3,\\n 0.0689e3, 0.0607e3, 0.0613e3])\\n f = interp1d(np.log10(freqs), np.log10(t_sys), kind='cubic')\\n return 10**f(np.log10(freq_hz))\",\n \"def calc_entropy(frequency_wn, temperature):\\r\\n\\tentropy = 0\\r\\n\\tfrequency = [entry * SPEED_OF_LIGHT for entry in frequency_wn]\\r\\n\\tfor entry in frequency:\\r\\n\\t\\tfactor = ((PLANCK_CONSTANT*entry)/(BOLTZMANN_CONSTANT*temperature))\\r\\n\\t\\ttemp = factor*(1/(math.exp(factor)-1)) - math.log(1-math.exp(-factor))\\r\\n\\t\\ttemp = temp*GAS_CONSTANT/4.184\\r\\n\\t\\tentropy = entropy + temp \\r\\n\\treturn entropy\",\n \"def hz_to_mel(frequencies, htk=False):\\n\\n frequencies = np.asanyarray(frequencies)\\n\\n if htk:\\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\\n\\n # Fill in the linear part\\n f_min = 0.0\\n f_sp = 200.0 / 3\\n\\n mels = (frequencies - f_min) / f_sp\\n\\n # Fill in the log-scale part\\n\\n min_log_hz = 1000.0 # beginning of log region (Hz)\\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\\n logstep = np.log(6.4) / 27.0 # step size for log region\\n\\n if frequencies.ndim:\\n # If we have array data, vectorize\\n log_t = frequencies >= min_log_hz\\n mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep\\n elif frequencies >= min_log_hz:\\n # If we have scalar data, heck directly\\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\\n\\n return mels\",\n \"def temperature(k, kmax):\\n return 1.0 / 500 * (1.0 / k - 1.0 / kmax)\",\n \"def hz_to_mel(frequencies, htk=False):\\n\\n frequencies = np.asanyarray(frequencies)\\n\\n if htk:\\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\\n\\n # Fill in the linear part\\n f_min = 0.0\\n f_sp = 200.0 / 3\\n\\n mels = (frequencies - f_min) / f_sp\\n\\n # Fill in the log-scale part\\n\\n min_log_hz = 1000.0 # beginning of log region (Hz)\\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\\n logstep = np.log(6.4) / 27.0 # step size for log region\\n\\n if frequencies.ndim:\\n # If we have array data, vectorize\\n log_t = (frequencies >= min_log_hz)\\n mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep\\n elif frequencies >= min_log_hz:\\n # If we have scalar data, heck directly\\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\\n\\n return mels\",\n \"def get_classical_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n\\n return (\\n -3\\n * len(self.input.structure)\\n * np.log(np.pi / (self.input.spring_constant * beta))\\n / (2 * beta)\\n )\",\n \"def clumps_finding(text, k, t, L):\\n frequent_patterns = []\\n clumps = [0 for i in range(0, 4**k)]\\n for i in range(0, len(text) - L + 1):\\n subtext = text[i:i + L]\\n freq_array = compute_freq(subtext, k)\\n for index, freq in enumerate(freq_array):\\n if freq >= t:\\n clumps[index] = 1\\n for index, clump in enumerate(clumps):\\n if clump == 1:\\n pattern = number_to_pattern(index, k)\\n frequent_patterns.append(pattern)\\n return frequent_patterns\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\\n\\t\\t# Active K-rotor\\n\\t\\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\\n\\t\\tif len(rotors) == 0:\\n\\t\\t\\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\\n\\t\\t\\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\t# Other modes\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tQ0 = mode.getPartitionFunction(Tlist)\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\treturn Q\",\n \"def add_energy(self, T=0, beta=0, Mkep=0, mu=1, gamma=5/3., Tmin=0., AU=1):\\n \\n if self.npart == 0:\\n self.u = array([])\\n return\\n\\n print(' Adding temperature...')\\n\\n radii = norm(self.pos - self.center, axis=1)\\n \\n if T < 0:\\n print(' Setting Temperature according to c_s(r)**2, with c_s(r) = h * v_kep(r),')\\n if not hasattr(self, 'v_kep'): self.v_kep = sqrt(Mkep * G / radii)\\n c_s = self.h * self.v_kep\\n if gamma <= 0: gamma_cs = 1\\n else: gamma_cs = gamma\\n if mu <= 0:\\n if gamma == 1.4: mu_cs = 2.01 # Adiabatic molecular\\n else: mu_cs = 1.005 # Adiabatic/Isothermal atomic\\n\\n print(' using gamma = {:.3f}, and mu = {:.3f}...'.format(gamma_cs, mu_cs)) \\n \\n T = c_s**2 * mu_cs * mP / (gamma_cs * KB)\\n\\n else:\\n T = full(self.npart, T * (radii / AU)**beta)\\n\\n\\n T[T < Tmin] = Tmin \\n \\n # This following settings are still being tested if correct\\n \\n if mu <= 0:\\n print(' Calculating mu used in code...')\\n mu = full(self.npart, 0.5) # Ionized\\n mu[T < 1.e4] = 1.005 # Atomic\\n mu[T < 2.e3] = 2.01 # Molecular (Optional)\\n\\n if gamma <= 0:\\n print(' Calculating gamma used in code...')\\n gamma = full(self.npart, 5/3.) # Adiabatic monoatomic\\n gamma[T < 2.e3] = 1.4\\t # Adiabatic diatomic\\n\\n factor = KB / (mP * mu * (gamma - 1))\\n \\n if max(T) == min(T): print(\\\" Temperature: {} [K]\\\".format(T[0]))\\n else:\\n print(' Maximum temperature: {:.2f} [K]'.format(max(T)))\\n print(' Minimum temperature: {:.2f} [K]'.format(min(T)))\\n \\n\\n self.u = T * factor\",\n \"def cooled_surface_temp(T:np.ndarray) -> float:\\n \\n return T.dot(cs_temp_weights)\",\n \"def get_kt(temps, delta_gibbs_ts):\\n # rate coefficient from Eyring equation\\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, nsteps=10, timestep=1 * simtk.unit.femtoseconds):\\n\\n super(HMCIntegrator, self).__init__(timestep)\\n\\n # Compute the thermal energy.\\n kT = kB * temperature\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"naccept\\\", 0) # number accepted\\n self.addGlobalVariable(\\\"ntrials\\\", 0) # number of Metropolization trials\\n\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addGlobalVariable(\\\"ke\\\", 0) # kinetic energy\\n self.addPerDofVariable(\\\"xold\\\", 0) # old positions\\n self.addGlobalVariable(\\\"Eold\\\", 0) # old energy\\n self.addGlobalVariable(\\\"Enew\\\", 0) # new energy\\n self.addGlobalVariable(\\\"accept\\\", 0) # accept or reject\\n self.addPerDofVariable(\\\"x1\\\", 0) # for constraints\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Allow Context updating here, outside of inner loop only.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Draw new velocity.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Store old position and energy.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Eold\\\", \\\"ke + energy\\\")\\n self.addComputePerDof(\\\"xold\\\", \\\"x\\\")\\n\\n #\\n # Inner symplectic steps using velocity Verlet.\\n #\\n for step in range(nsteps):\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x+dt*v\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m+(x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Accept/reject step.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Enew\\\", \\\"ke + energy\\\")\\n self.addComputeGlobal(\\\"accept\\\", \\\"step(exp(-(Enew-Eold)/kT) - uniform)\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x*accept + xold*(1-accept)\\\")\\n\\n #\\n # Accumulate statistics.\\n #\\n self.addComputeGlobal(\\\"naccept\\\", \\\"naccept + accept\\\")\\n self.addComputeGlobal(\\\"ntrials\\\", \\\"ntrials + 1\\\")\",\n \"def generate_Lk_by_Ck(fptree, data_set, Ck,dim, min_support, support_data):\\n Lk = set()\\n item_count = {}\\n t_num = float(len(data_set))\\n if dim == 1:\\n for t in data_set:\\n for item in Ck:\\n if item.issubset(t):\\n if item not in item_count:\\n item_count[item] = 1\\n else:\\n item_count[item] += 1\\n t_num = float(len(data_set))\\n else:\\n for item in Ck:\\n array = list(item)\\n subData, support = fptree.getSubData(array[len(array) - 1], dim)\\n for i in range(0, len(subData)):\\n if item.issubset(subData[i]):\\n if item not in item_count:\\n item_count[item] = support[i]\\n else:\\n item_count[item] += support[i]\\n for item in item_count:\\n if (item_count[item] / t_num) >= min_support:\\n Lk.add(item)\\n support_data[item] = item_count[item] / t_num\\n\\n return Lk\",\n \"def kin_energy (self):\\n\\n for planet in self.planets:\\n planet.kenergy = 0.5*planet.mass*((np.linalg.norm(planet.velocity))**2) # every 'kenergy' depends by the body's mass and velocity\",\n \"def __call__(self, T_HTF_inlet, m_in, htf):\\n # Function maps inputs ( T [K], P [Pa] ) to outputs (C [J/kg-K])\\n # We apply it: inputs ( T [C], P [Pa] ) to outputs (C [J/kg-K])\\n T_min, T_max = T_HTF_inlet, self.T_exhaust_inlet\\n T_mean = 0.5 * (T_min + T_max)\\n C_p_exhaust = PropsSI('C',\\n 'T', T_mean + 273.15,\\n 'P', self.P_exhaust_inlet,\\n 'Air')\\n C_exhaust = C_p_exhaust * self.m_exhaust # [J/K]\\n C_HTF = htf.lookup('C',T_mean) * m_in\\n\\n # This should be true\\n C_min, C_max = C_exhaust, C_HTF\\n C_r = C_min / C_max\\n if C_r > 1:\\n raise ValueError(\\\"HTF stream should have greater capacity (C_r = {})\\\".format(C_r))\\n DeltaT_max = self.T_exhaust_inlet - T_HTF_inlet\\n Q_max = C_min * DeltaT_max\\n Q = self.effectiveness * Q_max\\n T_HTF_outlet = T_HTF_inlet + Q / C_HTF\\n T_exhaust_outlet = self.T_exhaust_inlet - Q / C_exhaust\\n\\n # TODO: adjust for (water) flow rate\\n DeltaP_HTF = -6e3 # [Pa]\\n DeltaP_exhaust = -300 # [Pa]\\n \\n return Q, T_HTF_outlet, T_exhaust_outlet, DeltaP_HTF, DeltaP_exhaust\",\n \"def zpkfreqz(z, p, k, worN=None):\\n if worN is None or isinstance(worN, int):\\n N = worN or 512\\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\\n else:\\n ws = worN\\n\\n h = []\\n for wk in ws:\\n zm1 = mp.exp(1j * wk)\\n numer = _prod([zm1 - t for t in z])\\n denom = _prod([zm1 - t for t in p])\\n hk = k * numer / denom\\n h.append(hk)\\n return ws, h\",\n \"def HKS(evals,evects, time_list,scaled=False):\\n evals_s = np.asarray(evals).flatten()\\n t_list = np.asarray(time_list).flatten()\\n\\n coefs = np.exp(-np.outer(t_list, evals_s)) # (num_T,K)\\n weighted_evects = evects[None,:,:] * coefs[:,None,:] # (num_T,N,K)\\n natural_HKS = np.einsum('tnk,nk->nt',weighted_evects,evects)\\n\\n if scaled:\\n inv_scaling = coefs.sum(1) # (num_T)\\n return (1/inv_scaling)[None,:] * natural_HKS\\n\\n else:\\n return natural_HKS\",\n \"def MCS(n,k):\\n\\tglobal dict_all\\n\\tdict_val=copy.deepcopy(dict_all)\\n\\t#start_time = time.time()\\n\\tfinal = {}\\t\\t\\t\\t\\t # Store all result with the count as key. For example final[1]=[[1,0,0],[0,1,1]]\\n\\tseq = []\\t\\t\\t\\t\\t\\t# Store the count with no duplication\\n\\tfor i in range(n):\\n\\t\\tleaf={}\\t\\t\\t\\t\\t\\t# leaf is the dictionary to store the random value of each leaf\\n\\t\\t#count=0\\n\\t\\tfor i in leaves:\\n\\t\\t\\tleaf[i] = choice([0,1])\\n\\t\\t\\tdict_val[i]=leaf[i]\\n\\t\\t\\t#count += leaf[i]\\n\\t\\tresult = Cal_FT(dict_val)\\t\\n\\t\\t'''\\n\\t\\tif result:\\n\\t\\t\\tcutset = []\\n\\t\\t\\tfor i in leaves:\\n\\t\\t\\t\\tcutset.append(str(leaf[i]))\\n\\t\\t\\tcutset=\\\"\\\".join(cutset)\\n\\t\\t\\tif cutset not in final:\\n\\t\\t\\t\\tfinal[cutset]=count\\n\\tfinal_sorted=sorted(zip(final.values(),final.keys())) \\t\\t\\t\\t#Order the cutset by its count\\n\\tfor i in range(k):\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t#Print the first k result\\n\\t\\tcutset=list(final_sorted[i][1])\\n\\t\\tresult=[]\\n\\t\\tfor index in range(len(cutset)):\\n\\t\\t\\tif cutset[index] is \\\"1\\\":\\n\\t\\t\\t\\tresult.append(leaves[index])\\n\\t\\tprint result\\n\\t#end_time=time.time()\\n\\t#print \\\"Running time is\\\", end_time-start_time\\n\\t'''\",\n \"def readenergy(self, filelist):\\r\\n \\r\\n energy=[]\\r\\n tmpenergy=[]\\r\\n for filename in filelist:\\r\\n if not(os.path.exists(filename)):\\r\\n if self._resultfile: self._resultfile.write('Output file: \\\"'+filename+'\\\" does not exist. Restart your calculation. \\\\n')\\r\\n else: print 'Output file: \\\"'+filename+'\\\" does not exist. Restart your calculation. \\\\n'\\r\\n sys.exit()\\r\\n else:\\r\\n tmpdat=[]\\r\\n for key in self._keydict:\\r\\n infile=open(filename)\\r\\n lenstart=len(key['start'])\\r\\n lenblock=len(key['startblock'])\\r\\n if lenblock:\\r\\n tmp=''\\r\\n readlist=[]\\r\\n readout=0\\r\\n startblock=0\\r\\n startcol=[]\\r\\n lcount=0\\r\\n count=0\\r\\n for tmpc in infile:\\r\\n if tmp>'':\\r\\n # We are in the area that we should read.\\r\\n if tmpc.count(key['stop']):\\r\\n tmp=''\\r\\n else:\\r\\n # We are currently in a data block.\\r\\n if readout:\\r\\n if (ischar and tmpc.count(key['stopblock'])) or (not(ischar) and len(tmpc)<=1):\\r\\n readout=readout-1\\r\\n else:\\r\\n # Read the columns.\\r\\n if lcount==0:\\r\\n for i in range(0, len(startcol)):\\r\\n tmpenergy.append([float(key['factor'])*float(tmpc[startcol[i][0]:startcol[i][0]+startcol[i][1]]),''])\\r\\n ilast=startlen\\r\\n count=0\\r\\n # Get the labeling information form the block.\\r\\n if key['type']=='label' or key['type']=='': \\r\\n # For type=label we read the symmetry of the orbitals. And put it at the end of the list containing the energy values.\\r\\n for i in range(ilast, len(tmpc)-1):\\r\\n if tmpc[i:i+1]==' ':\\r\\n if i-ilast>1:\\r\\n if int(tmpc[ilast:i]): \\r\\n if len(tmpenergy[ecount][1]): tmpenergy[ecount][1]=tmpenergy[ecount][1]+'<->'+readlist[lcount+count]\\r\\n else: tmpenergy[ecount][1]=readlist[lcount+count]\\r\\n count=count+1\\r\\n ilast=i\\r\\n ecount=ecount+1\\r\\n else:\\r\\n if self._resultfile: self._resultfile.write('ERROR: (parsedirac.dat). Type of data block is not implemented. '+key['type']+' key= '+key['key']+' \\\\n')\\r\\n else: print 'ERROR: (parsedirac.dat). Type of data block is not implemented. type=\\\"'+key['type']+'\\\" key= '+key['key']+' \\\\n'\\r\\n sys.exit()\\r\\n elif tmpc.count(key['startblock']):\\r\\n try:\\r\\n readout=float(key['stopblock'])\\r\\n ischar=0\\r\\n except:\\r\\n readout=1\\r\\n ischar=1\\r\\n # If readout=0 we only need to read to the end of this line.\\r\\n if readout==0:\\r\\n ilast=tmpc.index(key['startblock'])+len(key['startblock'])\\r\\n for i in range(ilast, len(tmpc)):\\r\\n if tmpc[i:i+1] in (' ', '\\\\n'):\\r\\n if (i-ilast)>1:\\r\\n try:\\r\\n tmpdat.append(key['factor']*float(tmpc[ilast+1:i]))\\r\\n except:\\r\\n if self._resultfile: self.resultfile.write('ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\\\n'+tmpc+'\\\\n')\\r\\n else: print 'ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\\\n'+tmpc+'\\\\n'\\r\\n ilast=i\\r\\n else:\\r\\n # Read the positions of the columns containing energy information.\\r\\n for col in key['columns']:\\r\\n if tmpc.count(col):\\r\\n startcol.append((tmpc.index(col),len(col))) \\r\\n startlen=tmpc.index(key['startblock'])+len(key['startblock'])\\r\\n ilast=startlen\\r\\n lcount=lcount+count\\r\\n count=0\\r\\n ecount=0\\r\\n # Read the labels after the block start commando.\\r\\n for i in range(ilast, len(tmpc)-1):\\r\\n if tmpc[i:i+1]==' ':\\r\\n if i-ilast>1:\\r\\n readlist.append(tmpc[ilast+1:i])\\r\\n count=count+1\\r\\n ilast=i\\r\\n elif tmpc.count(key['start']):\\r\\n tmp=key['start']\\r\\n tmpenergy=[]\\r\\n tmpdat.append(tmpenergy)\\r\\n else:\\r\\n # If we read only one line, find it and read all numbers on it.\\r\\n for tmpc in infile: \\r\\n tmpn=tmpc.count(key['start'])\\r\\n if tmpn:\\r\\n ilast=tmpc.index(key['start'])+len(key['start'])\\r\\n for i in range(ilast, len(tmpc)):\\r\\n if tmpc[i:i+1] in (' ', '\\\\n'):\\r\\n if (i-ilast)>1:\\r\\n try:\\r\\n tmpdat.append(key['factor']*float(tmpc[ilast+1:i]))\\r\\n except:\\r\\n if self._resultfile: self.resultfile.write('ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\\\n'+tmpc+'\\\\n')\\r\\n else: print 'ERROR (parsedirac.py): Numirical data expected. File= '+filename+'\\\\n'+tmpc+'\\\\n'\\r\\n ilast=i\\r\\n infile.close()\\r\\n energy.append(tmpdat)\\r\\n return energy\",\n \"def total_band_energy(vals, T, Ec):\\n vals = np.sort(np.concatenate(vals))\\n occup = occup_TK(vals, T=T, spin=2)\\n return np.dot(vals, occup)-Ec\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for low temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n S_low = (\\n -gbar\\n * np.sqrt(2)\\n / (6 * np.pi ** 2)\\n * tt_low ** (3 / 2)\\n * vv_low\\n * (\\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\\n )\\n )\\n # low temperatures - high numbers\\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((S_low, S_high)).reshape(y.shape)\",\n \"def heat(self, delta_temp):\\n return self.heat_capacity * self.mass * delta_temp\",\n \"def half_space_cooling_temperature(z, t, T1, T0, kappa):\\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]\",\n \"def C_T(self):\\n return self.generic_getter(\\n get_sound_speed_temperature, \\\"C_T\\\", \\\"convert_sound_speed\\\"\\n )\",\n \"def temperature_energy():\\n e = _si.e.value\\n k_B = _si.k_B.value\\n return Equivalency(\\n [(si.K, si.eV, lambda x: x / (e / k_B), lambda x: x * (e / k_B))],\\n \\\"temperature_energy\\\",\\n )\",\n \"def conductivity(self, T):\\n m = self.mass\\n mu = self.viscosity(T)\\n K = (15/4) * kB * mu / m\\n return K\",\n \"def HeatEqn_FT(D, L, x, t, u_0):\\n n = x.size\\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\\n u_0t = np.fft.fft(u_0)\\n\\n U = np.zeros((t.size, x.size))\\n for ti in range(t.size):\\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\\n\\n return U\",\n \"def effective_temperature(R,times):\\n T_eff = np.empty((len(R),times))\\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \\n for i in range (len(R)):\\n for t in range(times): \\n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\\n return T_eff\",\n \"def hz2mel(freq):\\n return 2595. * np.log10(1+freq/700.0)\",\n \"def get_freq_grid():\\n (bins_per_octave, n_octaves, _, _, f_min, _) = get_hcqt_params()\\n freq_grid = librosa.cqt_frequencies(\\n bins_per_octave*n_octaves, f_min, bins_per_octave=bins_per_octave\\n )\\n return freq_grid\",\n \"def k_Wa92(wind_second_moment, temp_C):\\n\\n U2 = wind_second_moment\\n\\n Sc = schmidt_number(temp_C)\\n k = (0.31 * U2) * (660 / Sc) ** 0.5\\n\\n return k\",\n \"def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\\n pi, ids = induced_distribution(hmsm, 0, level)\\n\\n discrete_free_energy = np.ndarray(pi.shape)\\n for i, id in enumerate(ids):\\n discrete_free_energy[i] = \\\\\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\\n boltzmann = np.exp(-discrete_free_energy/kT)\\n boltzmann *= (1/np.sum(boltzmann))\\n return D_KL(boltzmann, pi)\",\n \"def main():\\n # Reading the list of temps\\n the_list = read_list()\\n\\n # Getting a temp to count and running frequency function\\n count_temp = int(input(\\\"Enter a value you would like the frequency of: \\\"))\\n\\n # calling the frequency function\\n frequency(count_temp, the_list)\",\n \"def temperature(self):\\n value = float(self._parent.query('R{}'.format(self._idx))[1:])\\n return pq.Quantity(value, pq.Kelvin)\",\n \"def getHeatFlux(self, T):\\n\\t\\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\\n\\t\\treturn Q\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\n \"def zenith_gain(freq):\\n parfile = open(project_path\\n + \\\"DSS-28_technical/efficiency_vs_freq_pars.pkl\\\",\\\"r\\\")\\n pars = cPickle.load(parfile)\\n parfile.close()\\n effic = {}\\n avg_effic = 0\\n for key in list(pars.keys()):\\n effic[key] = pars[key](freq)/100.\\n avg_effic += effic[key]\\n # right now I don't know what Pol A and Pol B are\\n avg_effic /= len(list(pars.keys()))\\n return avg_effic\",\n \"def get_sound_speed_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n C_S = (\\n np.sqrt(5)\\n * np.sqrt(gbar)\\n * 2 ** (1 / 4)\\n / (3 * np.pi)\\n * tt ** (5 / 4)\\n * np.sqrt(vv * _1d_call(_fdk, y, k=3 / 2))\\n )\\n return C_S\",\n \"def Kgrid(struc, Kresol=0.10, dimension=3):\\n a, b, c, alpha, beta, gamma = struc.get_cell_lengths_and_angles()\\n vol = struc.get_volume()\\n dist = np.zeros(3);\\n dist[2] = np.abs(vol/(a*b*np.sin(np.radians(gamma))))\\n dist[1] = np.abs(vol/(a*c*np.sin(np.radians(beta))))\\n dist[0] = np.abs(vol/(b*c*np.sin(np.radians(alpha))))\\n Kpoints = np.ceil(1./(dist*Kresol))\\n if dimension == 2:\\n Kpoints[-1] = 1;\\n #print(a, b, c, alpha, beta, gamma)\\n #print(vol/(a*b*np.sin(gamma)), a*b, np.sin(gamma))\\n #print(vol/(a*c*np.sin(beta)), a*c, np.sin(beta))\\n #print(vol/(b*c*np.sin(alpha)), b*c, np.sin(alpha))\\n #print(Kpoints)\\n #import sys; sys.exit()\\n return Kpoints.astype(int)\",\n \"def getMolarFluxes(self,T):\\n\\t\\tsigma = 0.1 # Hertz-Knudsen condensation/evaporation coefficient\\n\\t\\t# see doi:10.1103/PhysRevE.59.429\\n\\t\\t# http://www.mie.utoronto.ca/labs/tkl/publications/WardFangExpress.pdf\\n\\t\\tvp = self.getVaporPressures(T)\\n\\t\\tmw = self.molar_masses*0.001 / 6.02E23 # mass of molecule in kg\\n\\t\\tkb = 1.38E-23 # m^2 kg s^-2 K^-1 !!\\n\\t\\tJe = vp / numpy.sqrt(2*numpy.pi * mw * kb * T) \\n\\t\\treturn Je/ 6.02E23\",\n \"def fahrenheit(T_in_celsius):\\n return (T_in_celsius * 9 / 5) + 32\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\\n\\n # Initialize constants.\\n kT = kB * temperature\\n gamma = collision_rate\\n\\n # Create a new custom integrator.\\n super(GHMCIntegrator, self).__init__(timestep)\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addGlobalVariable(\\\"b\\\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addGlobalVariable(\\\"ke\\\", 0) # kinetic energy\\n self.addPerDofVariable(\\\"vold\\\", 0) # old velocities\\n self.addPerDofVariable(\\\"xold\\\", 0) # old positions\\n self.addGlobalVariable(\\\"Eold\\\", 0) # old energy\\n self.addGlobalVariable(\\\"Enew\\\", 0) # new energy\\n self.addGlobalVariable(\\\"accept\\\", 0) # accept or reject\\n self.addGlobalVariable(\\\"naccept\\\", 0) # number accepted\\n self.addGlobalVariable(\\\"ntrials\\\", 0) # number of Metropolization trials\\n self.addPerDofVariable(\\\"x1\\\", 0) # position before application of constraints\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Allow context updating here.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Constrain positions.\\n #\\n self.addConstrainPositions()\\n\\n #\\n # Velocity perturbation.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Metropolized symplectic step.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Eold\\\", \\\"ke + energy\\\")\\n self.addComputePerDof(\\\"xold\\\", \\\"x\\\")\\n self.addComputePerDof(\\\"vold\\\", \\\"v\\\")\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x + v*dt\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m + (x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Enew\\\", \\\"ke + energy\\\")\\n self.addComputeGlobal(\\\"accept\\\", \\\"step(exp(-(Enew-Eold)/kT) - uniform)\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x*accept + xold*(1-accept)\\\")\\n self.addComputePerDof(\\\"v\\\", \\\"v*accept - vold*(1-accept)\\\")\\n\\n #\\n # Velocity randomization\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Accumulate statistics.\\n #\\n self.addComputeGlobal(\\\"naccept\\\", \\\"naccept + accept\\\")\\n self.addComputeGlobal(\\\"ntrials\\\", \\\"ntrials + 1\\\")\",\n \"def categoryFrequency(categoryList): #TODO delete units\\n n=len(categoryList)\\n freq = dict()\\n for i in categoryList:\\n if i in freq.keys():\\n freq[i]=freq[i]+1/float(n)\\n else:\\n freq[i]=1/float(n)\\n sortedFreq=sorted([(v,k) for (k,v) in freq.items()], reverse = True)[:10]\\n freq=dict([(k,v) for (v,k) in sortedFreq])\\n return freq\",\n \"def __init__(self):\\n \\n # list of all frequencies\\n self.freqs = []\\n \\n # list of frequencies with Z != 0\\n self.freqsToSolve = []\\n \\n # minimum Ck value to be kept\\n self.min_Ck = 1.0e-18\\n \\n # Ck spectrum (list of OneCk objects)\\n self.Ck = []\",\n \"def helmholtzenergy(temp,pres):\\n g = liq_g(0,0,temp,pres)\\n g_p = liq_g(0,1,temp,pres)\\n f = g - pres*g_p\\n return f\",\n \"def add_clump_forming_kmers(counts, clumpFormingKmers):\\n for kmer in counts:\\n if counts[kmer] >= t:\\n clumpFormingKmers.add(kmer)\\n\\n return clumpFormingKmers\",\n \"def tristimulus_weighting_factors_ASTME2022(cmfs, illuminant, shape, k=None):\\n\\n if cmfs.shape.interval != 1:\\n raise ValueError('\\\"{0}\\\" shape \\\"interval\\\" must be 1!'.format(cmfs))\\n\\n if illuminant.shape.interval != 1:\\n raise ValueError(\\n '\\\"{0}\\\" shape \\\"interval\\\" must be 1!'.format(illuminant))\\n\\n global _TRISTIMULUS_WEIGHTING_FACTORS_CACHE\\n if _TRISTIMULUS_WEIGHTING_FACTORS_CACHE is None:\\n _TRISTIMULUS_WEIGHTING_FACTORS_CACHE = CaseInsensitiveMapping()\\n\\n name_twf = ', '.join((cmfs.name, illuminant.name, str(shape), str(k)))\\n if name_twf in _TRISTIMULUS_WEIGHTING_FACTORS_CACHE:\\n return _TRISTIMULUS_WEIGHTING_FACTORS_CACHE[name_twf]\\n\\n Y = cmfs.values\\n S = illuminant.values\\n\\n interval_i = DEFAULT_INT_DTYPE(shape.interval)\\n W = S[::interval_i, np.newaxis] * Y[::interval_i, :]\\n\\n # First and last measurement intervals *Lagrange Coefficients*.\\n c_c = lagrange_coefficients_ASTME2022(interval_i, 'boundary')\\n # Intermediate measurement intervals *Lagrange Coefficients*.\\n c_b = lagrange_coefficients_ASTME2022(interval_i, 'inner')\\n\\n # Total wavelengths count.\\n w_c = len(Y)\\n # Measurement interval interpolated values count.\\n r_c = c_b.shape[0]\\n # Last interval first interpolated wavelength.\\n w_lif = w_c - (w_c - 1) % interval_i - 1 - r_c\\n\\n # Intervals count.\\n i_c = W.shape[0]\\n i_cm = i_c - 1\\n\\n # \\\"k\\\" is used as index in the nested loop.\\n k_n = k\\n\\n for i in range(3):\\n # First interval.\\n for j in range(r_c):\\n for k in range(3):\\n W[k, i] = W[k, i] + c_c[j, k] * S[j + 1] * Y[j + 1, i]\\n\\n # Last interval.\\n for j in range(r_c):\\n for k in range(i_cm, i_cm - 3, -1):\\n W[k, i] = (W[k, i] + c_c[r_c - j - 1, i_cm - k] * S[j + w_lif]\\n * Y[j + w_lif, i])\\n\\n # Intermediate intervals.\\n for j in range(i_c - 3):\\n for k in range(r_c):\\n w_i = (r_c + 1) * (j + 1) + 1 + k\\n W[j, i] = W[j, i] + c_b[k, 0] * S[w_i] * Y[w_i, i]\\n W[j + 1, i] = W[j + 1, i] + c_b[k, 1] * S[w_i] * Y[w_i, i]\\n W[j + 2, i] = W[j + 2, i] + c_b[k, 2] * S[w_i] * Y[w_i, i]\\n W[j + 3, i] = W[j + 3, i] + c_b[k, 3] * S[w_i] * Y[w_i, i]\\n\\n # Extrapolation of potential incomplete interval.\\n for j in range(\\n DEFAULT_INT_DTYPE(w_c - ((w_c - 1) % interval_i)), w_c, 1):\\n W[i_cm, i] = W[i_cm, i] + S[j] * Y[j, i]\\n\\n W *= 100 / np.sum(W, axis=0)[1] if k_n is None else k_n\\n\\n _TRISTIMULUS_WEIGHTING_FACTORS_CACHE[name_twf] = W\\n\\n return W\",\n \"def hertz_to_mel(freq):\\n return 2595.0 * np.log10(1 + (freq / 700.0))\",\n \"def F2K(T_F):\\n return 5./9.*(T_F+459.67)\",\n \"def _convert_frequency(self, frequency):\\n\\n # Assert frequency lies within allowed range\\n FTW_step = self.clock_freq/2**32\\n FTW = round(frequency/FTW_step)\\n Min_freq = 0\\n Max_freq = (2**32-1)*FTW_step\\n\\n assert FTW >= 0, 'Minimum frequency is %r' %Min_freq\\n assert FTW <= 2**32, 'Maximum frequency is %r' %Max_freq\\n\\n # Compute frequency tuning word for given frequency and clock frequency\\n # Write FTW in list of 4 bytes (CFTW0 is a 32-bit register)\\n return [FTW.to_bytes(4, 'big')[i] for i in range(4)]\",\n \"def better_clumps_finding(text, k, t, L):\\n frequent_patterns = []\\n clumps = [0 for i in range(0, 4**k)]\\n first_subtext = text[:L]\\n freq_array = compute_freq(first_subtext, k)\\n for index, freq in enumerate(freq_array):\\n if freq >= t:\\n clumps[index] = 1\\n for i in range(1, len(text) - L + 1):\\n old_kmer = text[i - 1:i - 1 + k]\\n old_kmer_number = pattern_to_number(old_kmer)\\n freq_array[old_kmer_number] -= 1\\n new_kmer = text[i + L:i + L + k]\\n new_kmer_number = pattern_to_number(new_kmer)\\n freq_array[new_kmer_number] += 1\\n if freq_array[new_kmer_number] >= t:\\n clumps[new_kmer_number] = 1\\n for index, clump in enumerate(clumps):\\n if clump == 1:\\n pattern = number_to_pattern(index, k)\\n frequent_patterns.append(pattern) \\n return frequent_patterns\",\n \"def k_Ni00(wind_ms, temp_C):\\n\\n U = wind_ms\\n\\n Sc = schmidt_number(temp_C)\\n k = (0.333 * U + 0.222 * U ** 2) * (600 / Sc) ** 0.5\\n\\n return k\",\n \"def rough_frequency_samples(m1, m2, flow, fmax, df_min):\\n kmin = int(flow / df_min)\\n kmax = int(fmax / df_min)\\n k = kmin\\n ksamples = []\\n while k < kmax:\\n ksamples.append(k)\\n k += int(1.0 / rough_time_estimate(m1, m2, k * df_min) / df_min)\\n ksamples.append(kmax)\\n return numpy.array(ksamples)\",\n \"def get_frequency(self, c):\\n yield self.wm.write(\\\":READ:POW?\\\\r\\\\n\\\")\\n yield self.wm.write(\\\":READ:FREQ?\\\\r\\\\n\\\")\\n freq = yield self.wm.read_very_eager()\\n if freq != '':\\n\\n temp = freq.split()\\n temp = map(float,temp)\\n temp.sort()\\n if temp[len(temp)-1] >40.0:\\n freq = temp[len(temp)-1]\\n self.freq_changed((freq))\\n self.freq = freq\\n if temp[0] < 40.0:\\n amp = temp[0]\\n self.amp_changed((amp))\\n self.amp = amp\\n returnValue(self.freq)\",\n \"def totalInfilHorton1time(f0, fc, k, t):\\n numerator = (f0 - fc)*(1 - np.exp(-k*t))\\n Ft = (fc*t) + (numerator/k)\\n return Ft\",\n \"def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\\n\\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\\n\\td = dist * 1e3 * pc\\n\\t# Radius (in unit of pc)\\n\\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\\n\\t# Mass\\n\\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\\n\\t# Number density\\n\\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\\n\\t# Sigmav of 2.33H\\n\\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\\n\\t# Virial\\n\\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\\n\\t# Virial parameter with B-field, assume 1 mG\\n\\tB = 1 * 1e-3 # G\\n\\trho = density * 2.8 * mp # g/cm3\\n\\talfven = B / np.sqrt(4*np.pi*rho)\\n\\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\\n\\n\\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B\",\n \"def main(l, k):\\n S = 0\\n T = product(xrange(2), repeat=k)\\n for ts in T:\\n tmp = []\\n\\n for t, c in zip(ts, cs):\\n tmp.append(((-1)*c)**t)\\n\\n S += (sum(tmp)**l)\\n val = (sum(tmp)**l)\\n print val\\n return S / float(2**(k))\",\n \"def main(l, k):\\n S = 0\\n T = product(xrange(2), repeat=k)\\n for ts in T:\\n tmp = []\\n\\n for t, c in zip(ts, cs):\\n tmp.append(((-1)*c)**t)\\n\\n S += (sum(tmp)**l)\\n val = (sum(tmp)**l)\\n print val\\n return S / float(2**(k))\",\n \"def zzx_mul_term(f, c, k):\\n if not c or not f:\\n return []\\n else:\\n return [ c * coeff for coeff in f ] + [INT_ZERO]*k\",\n \"def get_kf_kms(self):\\n kfkms = np.array([ self.kf / (ss.velfac * 3.085678e24/ss.units.UnitLength_in_cm) for ss in self.spectrae])\\n return kfkms\",\n \"def flux_sensitivity(freq_hz, t_acc=5, bw_hz=100e3, num_antennas=256, eta=1,\\n t_sys=None, a_eff=None):\\n t_sys = system_temp(freq_hz) if t_sys is None else t_sys\\n a_eff = (element_effective_area(freq_hz) * num_antennas) if a_eff is None \\\\\\n else a_eff\\n sefd = (2 * const.k_B.value * t_sys * eta) / a_eff\\n sigma_s = (sefd * 1e26) / sqrt(2 * bw_hz * t_acc)\\n return sigma_s\",\n \"def KE_ejected_electron(frequency=1,workFunction=1, units=eV):\\n\\n var = sy.var('h nu W')\\n par = units['h'], frequency, workFunction\\n\\n y = h*nu - W\\n\\n return dic_result(var,par,y)\",\n \"def cel_to_fahren(temp_list):\\n fahren_list = [round(temp*9/5+32) for temp in temp_list]\\n return fahren_list\",\n \"def chunkedClumpFinder(sequence, k, L, t):\\n\\n frequentPatterns = set([])\\n for i in range(len(sequence)):\\n window = sequence[i:i + L]\\n frequencies = {}\\n\\n for j in range(len(window)):\\n pattern = window[j:j + k]\\n if pattern not in frequencies:\\n frequencies[pattern] = 1\\n else:\\n frequencies[pattern] += 1\\n for p in frequencies:\\n if frequencies[p] >= t:\\n frequentPatterns.add(p)\\n return frequentPatterns\",\n \"def k_Sw07(wind_second_moment, temp_C):\\n\\n U2 = wind_second_moment\\n\\n Sc = schmidt_number(temp_C)\\n k = (0.27 * U2) * (660 / Sc) ** 0.5\\n\\n return k\",\n \"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr\",\n \"def __call__(self, T_HTF_inlet, m_in, htf):\\n T_min, T_max = T_HTF_inlet, self.T_exhaust_inlet\\n # Function maps inputs ( T [K], P [Pa] ) to outputs (H [J/kg])\\n # We apply it: inputs ( T [C], P [Pa] ) to outputs (H [J/kg])\\n H_exhaust = lambda(T): PropsSI('H',\\n 'T', T + 273.15,\\n 'P', self.P_exhaust_inlet,\\n 'Air')\\n H_exhaust_max = H_exhaust(T_max)\\n DeltaH_exhaust_max = H_exhaust_max - H_exhaust(T_min)\\n # Q_max = C_min * DeltaT_max\\n Q_max = self.m_exhaust * DeltaH_exhaust_max\\n Q = self.effectiveness * Q_max\\n # Now find the temperatures that give this value.\\n # For the exhaust stream we have an inverse.\\n H_exhaust_outlet = H_exhaust_max - DeltaH_exhaust_max * self.effectiveness\\n # Function maps inputs ( T [K], P [Pa] ) to outputs (H [J/kg])\\n # We apply it: inputs ( T [C], P [Pa] ) to outputs (H [J/kg])\\n T_exhaust_outlet = -273.15 + PropsSI('T',\\n 'H', H_exhaust_outlet,\\n 'P', self.P_exhaust_inlet,\\n 'Air')\\n DeltaH_HTF = Q / m_in\\n H_HTF_min = htf.h(T_HTF_inlet)\\n self.H_HTF_max = H_HTF_min + DeltaH_HTF\\n self.H_HTF_err = lambda(T): htf.h(T) - self.H_HTF_max\\n self.T_HTF_outlet = fsolve(self.H_HTF_err, T_HTF_inlet)\\n T_HTF_outlet = self.T_HTF_outlet[0]\\n\\n # TODO: adjust for (water) flow rate\\n DeltaP_HTF = -6e3 # [Pa]\\n DeltaP_exhaust = -300 # [kPa]\\n \\n return Q, T_HTF_outlet, T_exhaust_outlet, DeltaP_HTF, DeltaP_exhaust\",\n \"def distribution_planck_nu(frequency=1,temperature=1, units=SI,printA=False):\\n\\n var = sy.var('pi nu h c k t')\\n par = np.pi, frequency, units['h'], units['c'], units['k'], temperature\\n\\n y = ( 8 * pi * nu**2 * h * nu ) / ( c**3 * (sy.exp(h*nu/k/t) - 1) )\\n\\n return dic_result(var,par,y)\",\n \"def setTemp(self, T):\\n kb = 1.380658*10**-23\\n v = np.sqrt(2)*np.sqrt(kb)*np.sqrt(T) / np.sqrt(m)\\n for p in self.listOfParticles:\\n # Downscale the direction vector\\n p.V = p.V.scale(1)\\n # Scale the direction vector to fit the temperature\\n p.V = p.V.scale(v)\",\n \"def element_area_and_temperature(freq_hz):\\n # Element noise data.\\n noise_data = {\\n 'freqs': [0.05e9, 0.07e9, 0.11e9, 0.17e9, 0.25e9, 0.35e9,\\n 0.45e9, 0.55e9, 0.65e9],\\n 'a_eff': [1.8791, 1.8791, 1.8694, 1.3193, 0.6080, 0.2956,\\n 0.2046, 0.1384, 0.0792],\\n 't_sys': [4.0409e3, 1.5029e3, 0.6676e3, 0.2936e3, 0.1402e3, 0.0873e3,\\n 0.0689e3, 0.0607e3, 0.0613e3]\\n }\\n log_freq = numpy.log10(freq_hz)\\n freqs = numpy.array(noise_data['freqs'])\\n a_eff = numpy.array(noise_data['a_eff'])\\n t_sys = numpy.array(noise_data['t_sys'])\\n f_cut = 2\\n\\n # Interpolate to get effective area.\\n if freq_hz <= freqs[f_cut]:\\n f = scipy.interpolate.interp1d(numpy.log10(freqs[:f_cut+1]), \\n numpy.log10(a_eff[:f_cut+1]), kind='slinear')\\n a_eff = 10**f(log_freq)\\n else:\\n f = scipy.interpolate.interp1d(numpy.log10(freqs[f_cut:]), \\n numpy.log10(a_eff[f_cut:]), kind='cubic')\\n a_eff = 10**f(log_freq)\\n\\n # Interpolate to get system temperature.\\n f = scipy.interpolate.interp1d(numpy.log10(freqs), \\n numpy.log10(t_sys), kind='cubic')\\n t_sys = 10**f(log_freq)\\n return a_eff, t_sys\",\n \"def to_kwh(m):\\n cp = 4243.5 # specific heat of water [J/ kg K]\\n dT = 179 # change in steam temperature [deg C]\\n h_in = 196 # inlet enthalpy [BTU/lb]\\n h_out = 1368 # outlet enthalpy [BTU/lb]\\n\\n # times 0.29307107 to convert from BTU/hr to kilowatts\\n kwh = (m * (h_out - h_in)) * 0.29307107\\n return kwh\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7163064","0.71257627","0.68290627","0.6795192","0.6786145","0.6622097","0.64092433","0.62078923","0.6155763","0.60118943","0.5884279","0.5819744","0.5750861","0.57141733","0.56468594","0.5608937","0.5543009","0.5515287","0.5447956","0.53431475","0.5332353","0.52839166","0.5262165","0.5258992","0.5212717","0.5161336","0.51001203","0.50840443","0.50792253","0.5077702","0.50641507","0.50398344","0.50372773","0.50350255","0.49753535","0.49745855","0.4970117","0.49645388","0.4964017","0.49609756","0.49588248","0.49466926","0.49064624","0.49057165","0.48853815","0.4877512","0.4853128","0.48514524","0.48460424","0.4833737","0.48335868","0.48246658","0.48174983","0.4816938","0.48128003","0.48058406","0.48019314","0.480055","0.47890204","0.47755936","0.47749493","0.47654533","0.47652018","0.47640544","0.4763971","0.4750503","0.47398737","0.47366044","0.47354782","0.47330457","0.4727314","0.47263667","0.4715332","0.4709352","0.4696751","0.4690362","0.46842575","0.46835017","0.46777943","0.46767","0.46618694","0.46564153","0.46562603","0.4655583","0.46542493","0.46524224","0.46524224","0.46390066","0.46348807","0.46247858","0.46190178","0.46182147","0.4613812","0.45994583","0.4596048","0.45885125","0.45880818","0.45825112","0.45779738","0.45760936"],"string":"[\n \"0.7163064\",\n \"0.71257627\",\n \"0.68290627\",\n \"0.6795192\",\n \"0.6786145\",\n \"0.6622097\",\n \"0.64092433\",\n \"0.62078923\",\n \"0.6155763\",\n \"0.60118943\",\n \"0.5884279\",\n \"0.5819744\",\n \"0.5750861\",\n \"0.57141733\",\n \"0.56468594\",\n \"0.5608937\",\n \"0.5543009\",\n \"0.5515287\",\n \"0.5447956\",\n \"0.53431475\",\n \"0.5332353\",\n \"0.52839166\",\n \"0.5262165\",\n \"0.5258992\",\n \"0.5212717\",\n \"0.5161336\",\n \"0.51001203\",\n \"0.50840443\",\n \"0.50792253\",\n \"0.5077702\",\n \"0.50641507\",\n \"0.50398344\",\n \"0.50372773\",\n \"0.50350255\",\n \"0.49753535\",\n \"0.49745855\",\n \"0.4970117\",\n \"0.49645388\",\n \"0.4964017\",\n \"0.49609756\",\n \"0.49588248\",\n \"0.49466926\",\n \"0.49064624\",\n \"0.49057165\",\n \"0.48853815\",\n \"0.4877512\",\n \"0.4853128\",\n \"0.48514524\",\n \"0.48460424\",\n \"0.4833737\",\n \"0.48335868\",\n \"0.48246658\",\n \"0.48174983\",\n \"0.4816938\",\n \"0.48128003\",\n \"0.48058406\",\n \"0.48019314\",\n \"0.480055\",\n \"0.47890204\",\n \"0.47755936\",\n \"0.47749493\",\n \"0.47654533\",\n \"0.47652018\",\n \"0.47640544\",\n \"0.4763971\",\n \"0.4750503\",\n \"0.47398737\",\n \"0.47366044\",\n \"0.47354782\",\n \"0.47330457\",\n \"0.4727314\",\n \"0.47263667\",\n \"0.4715332\",\n \"0.4709352\",\n \"0.4696751\",\n \"0.4690362\",\n \"0.46842575\",\n \"0.46835017\",\n \"0.46777943\",\n \"0.46767\",\n \"0.46618694\",\n \"0.46564153\",\n \"0.46562603\",\n \"0.4655583\",\n \"0.46542493\",\n \"0.46524224\",\n \"0.46524224\",\n \"0.46390066\",\n \"0.46348807\",\n \"0.46247858\",\n \"0.46190178\",\n \"0.46182147\",\n \"0.4613812\",\n \"0.45994583\",\n \"0.4596048\",\n \"0.45885125\",\n \"0.45880818\",\n \"0.45825112\",\n \"0.45779738\",\n \"0.45760936\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7431342"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88353,"cells":{"query":{"kind":"string","value":"Return the first derivative of the heat capacity with respect to the harmonic oscillator frequency in J/molK/cm^1 at the given set of temperatures `Tlist` in K, evaluated at the frequency `freq` in cm^1."},"document":{"kind":"string","value":"def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq"},"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 harmonicOscillator_heatCapacity(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x","def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq","def thermal(isatom, freq, scalfac,linnonlin,T):\n if isatom != \"true\":\n nfreq = len(freq)\n\n vib_temp = []\n for ifreq in range(nfreq):\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\n vib_temp.append(vib_temp_new)\n\n dE_vib = 0\n for ifreq in range(nfreq):\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\n\n dE_ZPE = 0.5 * sum(freq) * cmi2au\n\n if linnonlin == \"L\":\n dE_rot = kB * T * j2au\n elif linnonlin == \"NL\":\n dE_rot = kB * T * j2au * (3.0/2.0)\n else:\n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"ERROR: unknown entry for linear/nonlinear\")\n else:\n dE_ZPE = 0\n dE_vib = 0\n dE_rot = 0\n\n dE_tra = kB * T * j2au * (3.0/2.0)\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\n\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)","def compute_energy_density(kT):\n h=u.planck\n c=u.speed_of_light\n pi=np.pi\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def DFTscargle(times, signal,f0,fn,df):\n f0 = 0.\n #fn *= 2*np.pi\n #df *= 2*np.pi\n #-- initialize\n nfreq = int((fn-f0)/(df))\n print \"Nfreq=\",nfreq\n tzero = times[0]\n si = 1.\n lfreq = 2*nfreq+1\n mm = 2*nfreq\n ftrx = np.zeros(mm)\n ftix = np.zeros(mm)\n om = np.zeros(mm)\n w = np.zeros(mm)\n wz = df #pi/(nn+dt)\n nn = len(times)\n \n #-- calculate DFT\n ftrx,ftix,om,w = pydft.ft(signal,times,wz,nfreq,si,lfreq,tzero,df,ftrx,ftix,om,w,nn,mm)\n \n if f0==0:\n ftrx[1:] *= np.sqrt(2)\n ftix[1:] *= np.sqrt(2)\n w[1:] *= np.sqrt(2)\n \n cut_off = len(w)\n for i in range(0,len(w))[::-1]:\n if w[i] != 0: cut_off = i+1;break\n \n om = om[:cut_off]\n ftrx = ftrx[:cut_off]\n ftix = ftix[:cut_off]\n w = w[:cut_off]\n \n # norm amplitudes for easy inversion\n T = times[-1]-times[0]\n N = len(times)\n \n w *= T/(2.*N)\n ftrx *= T/(2.*N)\n ftix *= T/(2.*N)\n \n return om*2*np.pi,w,ftrx,ftix","def thermodynamic_temperature(frequency, T_cmb=None):\n nu = frequency.to(si.GHz, spectral())\n\n if T_cmb is None:\n from astropy.cosmology import default_cosmology\n\n T_cmb = default_cosmology.get().Tcmb0\n\n def f(nu, T_cmb=T_cmb):\n x = _si.h * nu / _si.k_B / T_cmb\n return x**2 * np.exp(x) / np.expm1(x) ** 2\n\n def convert_Jy_to_K(x_jybm):\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\n astrophys.Jy\n )\n return x_jybm / factor\n\n def convert_K_to_Jy(x_K):\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\n si.K\n )\n return x_K / factor\n\n return Equivalency(\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\n \"thermodynamic_temperature\",\n {\"frequency\": frequency, \"T_cmb\": T_cmb},\n )","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def HeatEqn_FT(D, L, x, t, u_0):\n n = x.size\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\n u_0t = np.fft.fft(u_0)\n\n U = np.zeros((t.size, x.size))\n for ti in range(t.size):\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\n\n return U","def rangerate_from_freq(freq,Fc):\n # print(f'freq {freq} Fc {Fc}')\n dopp_at_IF = freq - Fc\n return dopp_at_IF*scipy.constants.speed_of_light/Fc","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def freq2den(freq):\n\n return freq * freq * k_2","def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\n kB = 1.380658e-16\n h = 6.6260755e-27\n c = 29979245800.\n nu = freqGHz*1.e9\n x = h*nu/(kB*T0)\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\n cNu *= 1e23\n return cNu","def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def get_quantum_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n f = 0\n for m in self.input.structure.get_masses():\n hbar_omega = (\n HBAR\n * np.sqrt(self.input.spring_constant / m)\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\n )\n f += (3.0 / 2) * hbar_omega + (\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\n )\n return f","def kld(Fk, freq, Fk_red, f_red):\n \n #pad the reduced input with zeros\n f_red = [float(val) for val in f_red]\n freq = [float(val) for val in freq]\n f_Fk_red = dict(zip(f_red,Fk_red))\n Fk_red_pad = []\n #for each frequency in the nonreduced signal\n for i,f in enumerate(freq):\n #if the frequency is shared with the reduced signal\n if f in f_red:\n #add the coefficient from the reduced signal\n Fk_red_pad.append(f_Fk_red[f])\n #otherwise, pad it with a zero\n else:\n Fk_red_pad.append(0.)\n Fk_red_pad = np.array(Fk_red_pad)\n \n Fk = np.abs(Fk)\n Fk /= sum(Fk)\n Fk_red_pad = np.abs(Fk_red_pad)\n Fk_red_pad /= sum(Fk_red_pad)\n \n return stats.entropy(Fk_red_pad, Fk)","def system_temp(freq_hz):\n freqs = np.array([0.05e9, 0.07e9, 0.11e9, 0.17e9, 0.25e9, 0.35e9, 0.45e9,\n 0.55e9, 0.65e9])\n t_sys = np.array([4.0409e3, 1.5029e3, 0.6676e3, 0.2936e3, 0.1402e3, 0.0873e3,\n 0.0689e3, 0.0607e3, 0.0613e3])\n f = interp1d(np.log10(freqs), np.log10(t_sys), kind='cubic')\n return 10**f(np.log10(freq_hz))","def D(T, xC):\n a = 4.53e5\n b = 8339.9/T\n c = 1./T - 2.221e-4\n d = 17767\n e = -26436\n\n yC = xC/(1. - xC)\n\n # D0 = 4.53e5*(1. + yC*(1.-yC)*8339.9/T) # Pre-exponential term\n # D = D0*np.exp(-(1./T - 2.221e-4)*(17767 - yC*26436)) # um^2/s\n # return D\n return a*(1 + b*yC*(1-yC))*np.exp(-c*(d + e*yC))","def calc_entropy(frequency_wn, temperature):\r\n\tentropy = 0\r\n\tfrequency = [entry * SPEED_OF_LIGHT for entry in frequency_wn]\r\n\tfor entry in frequency:\r\n\t\tfactor = ((PLANCK_CONSTANT*entry)/(BOLTZMANN_CONSTANT*temperature))\r\n\t\ttemp = factor*(1/(math.exp(factor)-1)) - math.log(1-math.exp(-factor))\r\n\t\ttemp = temp*GAS_CONSTANT/4.184\r\n\t\tentropy = entropy + temp \r\n\treturn entropy","def get_classical_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n\n return (\n -3\n * len(self.input.structure)\n * np.log(np.pi / (self.input.spring_constant * beta))\n / (2 * beta)\n )","def fuel_cond(T):\n\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\n \n return kc","def cu_lpf(stimulus, dt, freq):\n num = len(stimulus)\n num_fft = int(num / 2 + 1)\n idtype = stimulus.dtype\n odtype = np.complex128 if idtype == np.float64 else np.complex64\n\n if not isinstance(stimulus, gpuarray.GPUArray):\n d_stimulus = gpuarray.to_gpu(stimulus)\n else:\n d_stimulus = stimulus\n\n plan = Plan(stimulus.shape, idtype, odtype)\n d_fstimulus = gpuarray.empty(num_fft, odtype)\n fft(d_stimulus, d_fstimulus, plan)\n\n df = 1.0 / dt / num\n idx = int(freq // df)\n\n unit = int(d_fstimulus.dtype.itemsize / 4)\n offset = int(d_fstimulus.gpudata) + d_fstimulus.dtype.itemsize * idx\n\n cuda.memset_d32(offset, 0, unit * (num_fft - idx))\n\n plan = Plan(stimulus.shape, odtype, idtype)\n d_lpf_stimulus = gpuarray.empty(num, idtype)\n ifft(d_fstimulus, d_lpf_stimulus, plan, False)\n\n return d_lpf_stimulus.get()","def helmholtzenergy(temp,pres):\n g = liq_g(0,0,temp,pres)\n g_p = liq_g(0,1,temp,pres)\n f = g - pres*g_p\n return f","def get_frequency(self):\r\n # print '*********in get freq'\r\n self.cntr.run('FREQ 1')\r\n f_0_ = self.cntr.get_measurements(1)\r\n self.f_0 = f_0_[0]\r\n self.cntr.run('FREQ 2')\r\n f_rep_ = self.cntr.get_measurements(1)\r\n self.f_rep = f_rep_[0]","def get_frequency(self,):\n\n # TODO: Find way to appropriately reconvert the frequency to its initial\n # TODO: Value or alert that the value is APPROXIMATE\n FTW = int (0)\n freq = int(0)\n\n FTW_bytes = self._read('CFTW0')\n FTW = FTW.from_bytes(FTW_bytes,'big')\n freq = FTW*self.clock_freq/2**32\n\n print('Latest frequency set: ', \"{:.2e}\".format(freq), 'Hz')\n print(['%.2e' % elem for elem in self.frequencies])\n\n return self.frequencies","def dft(X): \n N = len(X)\n x = np.zeros(N, 'complex')\n K = np.arange(0, N, 1)\n for n in range(0, N, 1):\n x[n] = np.dot(X, np.exp(1j * 2 * np.pi * K * n / N))\n return x","def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n C_T = (\n 2 ** (1 / 4)\n * np.sqrt(gbar)\n / np.pi\n * np.sqrt(vv)\n * tt ** (5 / 4)\n * _1d_call(_fdk, y, k=1 / 2)\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\n )\n return C_T","def _get_a_freq(self, energy):\n left_index = bisect.bisect_left(self.energy_list, energy)\n if left_index+1 >= len(self.energy_list):\n left_index = len(self.energy_list)-2\n elif left_index > 0:\n left_index -= 1\n energy0 = self.energy_list[left_index]\n energy1 = self.energy_list[left_index+1]\n freq0 = 1./self.closed_orbits_t[energy0]\n freq1 = 1./self.closed_orbits_t[energy1]\n frequency = (freq1 - freq0)/(energy1-energy0)*(energy-energy0) + freq0\n #print \"\\nl:\", left_index, \"e0:\", energy0, \"e1:\", energy1, \\\n # \"f0:\", freq0, \"f1:\", freq1, \"DE:\", energy-e0, \"f\", frequency\n return frequency","def vib_energy(frequency, temp):\n\n # vibrational temperature\n\n vtemp = plank_const * speed_ol / boltz_const * frequency\n\n vtemp = np.matrix(vtemp)\n\n temp = 1 / np.matrix(temp)\n\n # need to convert to array, because the element wise exponential\n # cannot work with matrix\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\n\n # energy is a np.matrix, need to convert to array\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\n energy = np.array(energy)[0]\n\n return energy","def CMB_spec(eng, temp):\n if np.issubdtype(type(eng), float):\n eng = np.array([eng])\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\n\n if np.issubdtype(type(eng), float): \n return phot_spec_density[0] \n else: \n return phot_spec_density","def DFTpower(time, signal, f0=None, fn=None, df=None, full_output=False):\n\n freqs = np.arange(f0,fn,df)\n Ntime = len(time)\n Nfreq = int(np.ceil((fn-f0)/df))\n \n A = np.exp(1j*2.*pi*f0*time) * signal\n B = np.exp(1j*2.*pi*df*time)\n ft = np.zeros(Nfreq, complex) \n ft[0] = A.sum()\n for k in range(1,Nfreq):\n A *= B\n ft[k] = np.sum(A)\n \n if full_output:\n return freqs,ft**2*4.0/Ntime**2\n else:\n return freqs,(ft.real**2 + ft.imag**2) * 4.0 / Ntime**2","def calccfl(k, t, x):\n xstep = (max(x) - min(x)) / (len(x)-1)\n tstep = (max(t) - min(t)) / (len(t)-1)\n cfl = k*tstep/xstep**2\n return cfl","def __setSpectrum__(self):\n \n self.Ck = []\n TempCk = []\n TempOneCk = OneCk()\n \n # Process 1st frequency\n Tb = self.freqs[1].totalJ\n \n for b in range(-Tb, Tb, 1):\n TempOneCk.freq = b*self.freqs[1].Vph\n TempOneCk.Amp = self.freqs[1].Cjk(b)\n self.Ck.append(TempOneCk)\n \n # Process additional frequencies\n CkSize = len(self.Ck)\n Added = FALSE\n \n for f in range(2, len(self.freqs), 1):\n # Reset temporary variables\n Tb = self.freqs[f].totalJ\n TempCk = []\n \n # Calculate each Ck coefficient\n for b in range(-Tb, Tb, 1):\n for k in range(CkSize):\n TempOneCk.Amp = Ck[k].Amp * self.freq[f].Cjk(b)\n \n # Check to see if Amp is big enough to keep\n if( abs(TempOneCk.Amp) > self.min_Ck ):\n Added = FALSE\n TempOneCk.freq = self.Ck[k].freq + b*self.freqs.Vph\n \n # If freq is already in Ck, add new value to old,\n # if not, add new value and freq to spectrum\n for c in TempCk:\n if abs(c.freq-TempOneCk.freq < DOUBLE_PRECISION):\n c.Amp += TempOneCk.Amp\n Added = TRUE\n break\n \n if (not Added):\n TempCk.append(TempOneCk)\n \n self.Ck = TempCk\n CkSize = len(self.Ck)","def hz_to_mel(frequencies, htk=False):\n\n frequencies = np.asanyarray(frequencies)\n\n if htk:\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\n\n # Fill in the linear part\n f_min = 0.0\n f_sp = 200.0 / 3\n\n mels = (frequencies - f_min) / f_sp\n\n # Fill in the log-scale part\n\n min_log_hz = 1000.0 # beginning of log region (Hz)\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\n logstep = np.log(6.4) / 27.0 # step size for log region\n\n if frequencies.ndim:\n # If we have array data, vectorize\n log_t = frequencies >= min_log_hz\n mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep\n elif frequencies >= min_log_hz:\n # If we have scalar data, heck directly\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\n\n return mels","def getf(element, energy, conv_fwhm=0):\n try:\n Z = int(element)\n except: \n if element in elements.Z:\n Z = elements.Z[element]\n else:\n Z = None\n if Z is None or Z>93:\n raise ValueError(\"Invalid element / element number: %s. \"\n \"(Only elements from H to U allowed).\"%str(Z))\n energy = np.array(energy, ndmin=1)\n diffE = np.unique(np.diff(energy))\n if not len(diffE):\n return deltaf.clcalc(Z, energy)\n dE = abs(diffE.min())\n fwhm_chan = abs(float(conv_fwhm))/dE/2.\n # make equally spaced data:\n if diffE.std()/diffE.mean() > 1e-5 and fwhm_chan>1e-2:\n newenergy = np.arange(energy.min() - 10*dE, energy.max() + 10.*dE, dE)\n do_interpolate = True\n else:\n newenergy = energy\n do_interpolate = False\n \n f1, f2 = deltaf.clcalc(Z, newenergy)\n if fwhm_chan>1e-2:\n f1, f2 = deltaf.convl2(f1, f2, fwhm_chan)\n if do_interpolate:\n ffunc = interp1d(newenergy, (f1, f2))\n f1, f2 = ffunc(energy)\n return f1, f2","def main():\n # Reading the list of temps\n the_list = read_list()\n\n # Getting a temp to count and running frequency function\n count_temp = int(input(\"Enter a value you would like the frequency of: \"))\n\n # calling the frequency function\n frequency(count_temp, the_list)","def hz_to_mel(frequencies, htk=False):\n\n frequencies = np.asanyarray(frequencies)\n\n if htk:\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\n\n # Fill in the linear part\n f_min = 0.0\n f_sp = 200.0 / 3\n\n mels = (frequencies - f_min) / f_sp\n\n # Fill in the log-scale part\n\n min_log_hz = 1000.0 # beginning of log region (Hz)\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\n logstep = np.log(6.4) / 27.0 # step size for log region\n\n if frequencies.ndim:\n # If we have array data, vectorize\n log_t = (frequencies >= min_log_hz)\n mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep\n elif frequencies >= min_log_hz:\n # If we have scalar data, heck directly\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\n\n return mels","def k_HF(T, n, h=1e-3):\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\n return dn_dmu / n","def EGWD_fg(f):\n A = 4.2e-47\n res = np.zeros((len(f)))\n for i,freq in enumerate(f): \n if freq >=3e-3:\n # strain \n res[i] = A * freq**(-7/3) * np.exp(-2*(freq/5e-2)**2) \n else:\n res[i] = np.NaN\n return np.array(res)","def KE_ejected_electron(frequency=1,workFunction=1, units=eV):\n\n var = sy.var('h nu W')\n par = units['h'], frequency, workFunction\n\n y = h*nu - W\n\n return dic_result(var,par,y)","def cutoff_denominator(self, list_energy):\n\n tol = 1e-3\n\n z = list_energy/tol\n\n den = N.imag(SS.wofz(z))/tol*N.sqrt(N.pi)\n\n return den","def torch_mel_to_hertz(frequencies_mel):\r\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\r\n return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)","def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr","def get_f_jk(j_dist,degree_dist=None):\n if degree_dist is not None:\n for k,freq in zip(degree_dist.index, degree_dist.values):\n j_dist.loc[j_dist.k==k,'j_freq'] *= freq\n return j_dist","def half_space_cooling_temperature(z, t, T1, T0, kappa):\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]","def FSDs(X, Y, K, Intervals):\n\n # check input 'Intervals'\n if Intervals[0] != 1.:\n Intervals = np.hstack((1., Intervals))\n if Intervals[-1] != (K / 2):\n Intervals = np.hstack((Intervals, float(K)))\n # get length of intervals\n L = len(Intervals)\n # initialize F\n F = np.zeros((L-1, ))\n # interpolate boundaries\n iXY = InterpolateArcLength(X, Y, K)\n # check if iXY.iX is not empty\n if iXY.iX.size:\n # calculate curvature\n Curvature = np.arctan2(\n (iXY.iY[1:] - iXY.iY[:-1]),\n (iXY.iX[1:] - iXY.iX[:-1])\n )\n # make curvature cumulative\n Curvature = Curvature - Curvature[0]\n # calculate FFT\n fX = np.fft.fft(Curvature).T\n # spectral energy\n fX = fX * fX.conj()\n fX = fX / fX.sum()\n # calculate 'F' values\n for i in range(L-1):\n F[i] = np.round(\n fX[Intervals[i]-1:Intervals[i+1]].sum(), L\n ).real.astype(float)\n\n return F","def compute_ghost_series(self,terms):\n\t\tp=self.p\n\t\tcomp=self.comp\n\t\tf1=self.f1\n\t\tf2=self.f2\n\n\t\tghost_coefs = [[] for i in range(terms+1)]\n\n\n\t\tk=comp;\n\t\tif k==0 or k==1:\n\t\t\tk=k+p-1\n\n\t\t## Precompute the needed dimensions\n\t\tself.f1v = [f1(k)]\n\t\tself.f2v = [f2(k)]\n\t\tk = k + p-1\n\t\twhile self.f1v[len(self.f1v)-1] <= terms+1:\n\t\t\tself.f1v += [f1(k)]\n\t\t\tself.f2v += [f2(k)]\n\t\t\tk = k + p-1\n\t\t\n\t\t## Starting at weight 2, we run through weights in the component,\n\t\t## compute the associated indices, and then record the weights at those\n\t\t## indices with appropriate multiplicities\n\n\t\tk = comp;\n\t\tif k==0 or k==1:\n\t\t\tk=k+p-1\n\t\tn = 0\n\n\t\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\n\t\twhile (len(inds)==0 or inds[0]<=terms+1):\n\t\t\t## This loops adds the weights to the appropriate indices with the appropriate multiplicities\n\t\t\tfor m in range(floor((len(inds)+1)/2)):\n\t\t\t\tif m < floor(len(inds)/2):\n\t\t\t\t\tif inds[m]<=terms:\n\t\t\t\t\t\tghost_coefs[inds[m]] += [(k,m+1)]\n\t\t\t\t\tif (inds[len(inds)-1-m]<=terms):\n\t\t\t\t\t\tghost_coefs[inds[len(inds)-1-m]] += [(k,m+1)]\n\t\t\t\telse:\n\t\t\t\t\tif inds[m]<=terms:\n\t\t\t\t\t\tghost_coefs[inds[m]] += [(k,m+1)]\n\t\t\tk = k + p-1\n\t\t\tn = n + 1\n\t\t\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\n\t\tself.series=ghost_coefs","def _Kgradients(self):\r\n dL_dfhat, I_KW_i = self._shared_gradients_components()\r\n dlp = self.noise_model.dlogpdf_df(self.f_hat, self.data, extra_data=self.extra_data)\r\n\r\n #Explicit\r\n #expl_a = np.dot(self.Ki_f, self.Ki_f.T)\r\n #expl_b = self.Wi_K_i\r\n #expl = 0.5*expl_a - 0.5*expl_b\r\n #dL_dthetaK_exp = dK_dthetaK(expl, X)\r\n\r\n #Implicit\r\n impl = mdot(dlp, dL_dfhat, I_KW_i)\r\n\r\n #No longer required as we are computing these in the gp already\r\n #otherwise we would take them away and add them back\r\n #dL_dthetaK_imp = dK_dthetaK(impl, X)\r\n #dL_dthetaK = dL_dthetaK_exp + dL_dthetaK_imp\r\n #dL_dK = expl + impl\r\n\r\n #No need to compute explicit as we are computing dZ_dK to account\r\n #for the difference between the K gradients of a normal GP,\r\n #and the K gradients including the implicit part\r\n dL_dK = impl\r\n return dL_dK","def DFTdirect(x):\n \n N = len(x)\n X = []\n for k in range(N):\n X_k = Complex(0,0)\n for n in range(N):\n a = 2*math.pi*k*n/N\n X_k += x[n]*Complex(math.cos(a), -math.sin(a))\n X.append(X_k)\n return X","def getFourierPower(data, freq=None, ax=1, t=None):\n\n if t==None:\n t = numpy.linspace(0.0,1.0,64)\n Fs = 1.0/t[1] \n L = t.shape[0]\n ft = numpy.fft.fft(data,axis=ax)\n freqs = numpy.fft.fftfreq(64,1.0/64.0)\n ftAmp = abs(ft)/data.shape[1]*2\n ftPhase = numpy.arctan2(ft.real, ft.imag)\n if freq==None:\n ii = numpy.argmax(abs(ft[:,1:])**2.0,axis=1)\n ii += 1\n else:\n fr = numpy.asarray([freq])\n fr = fr.flatten()\n ii = numpy.ones(fr.shape)\n for kk in range(0,fr.shape[0]):\n ii[kk] = numpy.argmin(abs(freqs-fr[kk]))\n \n jj = numpy.arange(0,ftAmp.shape[0])\n amp = ftAmp[jj,ii.astype('int')]\n phase = ftPhase[jj,ii.astype('int')]\n else:\n Fs = 1.0/t[1]\n L = t.shape[0]\n ft = numpy.fft.fft(data,n=NFFT,axis=ax)[1:]/L#skip the DC\n ftAmp = abs(ft)/len(t)*2\n ftPhase = numpy.arctan2(ft.real, ft.imag)\n if freq==None:\n ii = argmax(abs(ft)**2.0,0)\n else: \n ii = freq-1\n \n amp = ftAmp[:,ii]\n phase = ftPhase[:,ii]\n return amp, phase, ii","def gradient_function(X, t, flow, species_list):\n vals = {\"t\": t}\n\n for i, species in enumerate(species_list):\n vals[species] = X[i]\n\n result = []\n\n for species in flow:\n result.append(flow[species].evalf(subs=vals))\n\n return result","def Heston_fft(self,alpha,n,B,K):\r\n bt = time.time()\r\n r = self.r\r\n T = self.T\r\n S0 = self.S0\r\n N = 2**n\r\n Eta = B / N\r\n Lambda_Eta = 2 * math.pi / N\r\n Lambda = Lambda_Eta / Eta\r\n \r\n J = np.arange(1,N+1,dtype = complex)\r\n vj = (J-1) * Eta\r\n m = np.arange(1,N+1,dtype = complex)\r\n Beta = np.log(S0) - Lambda * N / 2\r\n km = Beta + (m-1) * Lambda\r\n \r\n ii = complex(0,1)\r\n \r\n Psi_vj = np.zeros(len(J),dtype = complex)\r\n \r\n for zz in range(0,N):\r\n u = vj[zz] - (alpha + 1) * ii\r\n numer = self.Heston_cf(u)\r\n denom = (alpha + vj[zz] * ii) * (alpha + 1 + vj[zz] * ii)\r\n \r\n Psi_vj [zz] = numer / denom\r\n \r\n # Compute FTT\r\n xx = (Eta/2) * Psi_vj * np.exp(-ii * Beta * vj) * (2 - self.dirac(J-1))\r\n zz = np.fft.fft(xx)\r\n \r\n # Option price\r\n Mul = np.exp(-alpha * np.array(km)) / np.pi\r\n zz2 = Mul * np.array(zz).real\r\n k_List = list(Beta + (np.cumsum(np.ones((N, 1))) - 1) * Lambda)\r\n Kt = np.exp(np.array(k_List))\r\n \r\n Kz = []\r\n Z = []\r\n for i in range(len(Kt)):\r\n if( Kt[i]>1e-16 )&(Kt[i] < 1e16)& ( Kt[i] != float(\"inf\"))&( Kt[i] != float(\"-inf\")) &( zz2[i] != float(\"inf\"))&(zz2[i] != float(\"-inf\")) & (zz2[i] is not float(\"nan\")):\r\n Kz += [Kt[i]]\r\n Z += [zz2[i]]\r\n tck = interpolate.splrep(Kz , np.real(Z))\r\n price = np.exp(-r*T)*interpolate.splev(K, tck).real\r\n et = time.time()\r\n \r\n runt = et-bt\r\n\r\n return(price,runt)","def get_dft_train():\n\n single_dft = np.array(generate_doublet_train(ipi_to_frequency(155), num_pulses=6, pulse_duration=0.6))\n all_dft = []\n for i in range(150):\n dft = np.copy(single_dft)\n if all_dft:\n dft += all_dft[-1] + 500\n all_dft.extend(dft)\n\n return np.array(all_dft)","def calc_dtdc_star(tpbpc0, spec):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n # Create array of times per bandpass\n dtpb = np.hstack(tpbpc0)\n\n Nbs = len(dtpb)\n dcomp = np.zeros(Nbs) # completeness\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def create_fft_freq(dt, nfft, full):\n freqs = da.fft.fftfreq(nfft, d=dt) \n\n if (nfft % 2 == 0):\n freqs = da.hstack([freqs[0: nfft // 2], -freqs[nfft //2], freqs[nfft // 2:nfft]])\n if full:\n freqs = da.fft.fftshift(freqs)\n else:\n freqs = freqs[0:nfft // 2 + 1]\n\n return(freqs)","def get_dom_freq(Fk, freq, n_freq):\n\n #get the magnitude of the coefficients\n Fk_abs = np.abs(Fk)\n #sort the coefficients in descending order\n Fk_sort = sorted(Fk_abs, reverse=True)\n \n dom_Fk = []\n dom_f = []\n i = 0\n while i < n_freq:\n inds = np.where(Fk_abs == Fk_sort[i])\n for ind in inds:\n dom_f.append(freq[ind])\n dom_Fk.append(Fk[ind])\n i += 1\n \n #sort based on frequency from lo to hi\n #convert from numpy float to python float for mapping\n dom_f = [float(abs(f)) for f in dom_f]\n f_Fk = dict(zip(dom_f,dom_Fk))\n f_sorted = sorted(dom_f)\n # return(dom_f, f_Fk, f_sorted, dom_Fk)\n\n\n dom_Fk = []\n for f in f_sorted:\n dom_Fk.append(f_Fk[f][0])\n \n return np.array(dom_Fk), np.array(f_sorted)","def DFT_slow(x):\r\n x = np.asarray(x, dtype=complex)\r\n N = len(x)\r\n n = np.arange(N)\r\n k = n.reshape((N, 1))\r\n M = np.exp(-2j * np.pi * k * n / N)\r\n return np.dot(M, x)","def getPartitionFunction(self, Tlist):\n\t\treturn _modes.harmonicoscillator_partitionfunction(Tlist, self.frequency) ** self.degeneracy","def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq / 700.0))","def manual_calc_kfs(wbwc_list, dec_list, timelen, timesteps):\n global X0\n global wbwc_kfs\n global all_kfs\n ####\n t = np.linspace(0, timelen, timesteps)\n ##\n ## 1. set new wbwc rates\n wbwc_kfs[wbwc_list[0]]['hf'] = wbwc_list[1][0]\n wbwc_kfs[wbwc_list[0]]['hr'] = wbwc_list[1][1]\n wbwc_kfs = fill_wbwc_dict(wbwc_kfs, fill='rates')\n init() \n #####\n ## now, loop for each value of a rate const in dec_list\n for k in dec_list[1]:\n all_kfs[dec_list[0]] = k\n kname = dec_list[0] + str(k)\n ##\n #init() \n set_expdeg()\n ode(calc_model, X0, t, stype='manual', dname = kname)\n ###","def fourier_coefficient(t, freq, n=1, axis=-1):\n t, freq, n = map(np.asanyarray, (t, freq, n))\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)","def freqvals(t):\n N = len(t)\n T = t[-1] - t[0]\n dt = T/N\n nyquist = 1/(2.0*dt)\n lowfreq = 1/T\n return (N, T, dt, nyquist, lowfreq)","def get_tuning_freq(self, freq):\n if freq < self.freq_lo:\n return\n\n while freq < self.NOTES.min() or freq > self.NOTES.max():\n while freq > self.NOTES.max():\n self.NOTES *= 2\n while freq < self.NOTES.min():\n self.NOTES /= 2\n tuning_freq = min(self.NOTES, key=lambda x: abs(x-freq))\n return tuning_freq","def getHeatFlux(self, T):\n\t\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\n\t\treturn Q","def freq_defl_comp(fmax, p=75, p1=database['K+'], p2=database['pi+'],\r\n p3=database['p+'], L_t=79.6, l=2.74, E=1e6, plot=True,\r\n details=False, n=1000, delta_p=1.6e-2, fmin=0, just_pi=False):\r\n f_range = np.linspace(fmin, fmax, n)\r\n min_defl, d2, d3 = [], [], []\r\n for f in f_range:\r\n if just_pi == True:\r\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\r\n min_defl.append(d2[-1])\r\n if just_pi == False: \r\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\r\n d3.append(ang_deflection(p, f, p1, p3, L_t, l, E, delta_p))\r\n min_defl.append(np.min([d2[-1], d3[-1]]))\r\n if plot == True:\r\n fig = plt.figure(figsize=[9, 5])\r\n ax = fig.add_subplot(1, 1, 1)\r\n if details == True:\r\n ax.plot(f_range, d2, 'r', alpha=0.5, label=f'{p2.name} deflection')\r\n ax.plot(f_range, d3, 'b', alpha=0.5, label=f'{p3.name} deflection')\r\n else:\r\n ax.plot(f_range, min_defl, color=[1, 0, 1], alpha=0.5, label='min deflection')\r\n# ax.set_xlim(fmin, fmax)\r\n ax.set_ylim(0)\r\n ax.set_xlabel('Frequency / Hz', fontsize=20)\r\n text = r'$D_{'\r\n text += p2.name + '/' + p3.name\r\n text += '}$ / mrad'\r\n ax.set_ylabel(text, fontsize=20)\r\n ax.set_xscale('log')\r\n ax.legend(fontsize=20)\r\n plt.show()\r\n opt_freq = f_range[np.argmax(min_defl)]\r\n d_opt = (fmax-fmin)/1000\r\n d_opt_perc = (d_opt/opt_freq)*100\r\n if details == True:\r\n return 'optimum frequency = {0:.0f} +/- {1:.5f}%'.format(opt_freq, d_opt_perc)\r\n return opt_freq","def totalInfilHorton1time(f0, fc, k, t):\n numerator = (f0 - fc)*(1 - np.exp(-k*t))\n Ft = (fc*t) + (numerator/k)\n return Ft","def get_frequency(self, c):\n yield self.wm.write(\":READ:POW?\\r\\n\")\n yield self.wm.write(\":READ:FREQ?\\r\\n\")\n freq = yield self.wm.read_very_eager()\n if freq != '':\n\n temp = freq.split()\n temp = map(float,temp)\n temp.sort()\n if temp[len(temp)-1] >40.0:\n freq = temp[len(temp)-1]\n self.freq_changed((freq))\n self.freq = freq\n if temp[0] < 40.0:\n amp = temp[0]\n self.amp_changed((amp))\n self.amp = amp\n returnValue(self.freq)","def derivert(f, k):\r\n \r\n return(k*f)","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def get_frequency(self, detune=0) -> float:\n return np.power(2, (self._cents + detune)/1200) * 440","def getKlauder(f,t,T=5.0):\n assert len(f) == 2, 'Klauder wavelet needs 2 frequencies as input'\n\n k = np.diff(f)/T\n f0 = np.sum(f)/2.0\n wav = np.real(np.sin(pi*k*t*(T-t))/(pi*k*t)*np.exp(2*pi*1j*f0*t))\n return wav","def daily_temp(dft):\n\n tavg = (dft[\"T_Max\"] + dft[\"T_Min\"]) / 20 # tenths of degree C\n return tavg","def temperature_energy():\n e = _si.e.value\n k_B = _si.k_B.value\n return Equivalency(\n [(si.K, si.eV, lambda x: x / (e / k_B), lambda x: x * (e / k_B))],\n \"temperature_energy\",\n )","def DFTct(x):\n \n N = len(x)\n if N == 2:\n return [x[0] + x[1], x[0] - x[1]]\n \n Half_N = int(N/2)\n X = [0]*N\n \n Evens = DFTct([x[2*n] for n in range(Half_N)])\n Odds = DFTct([x[2*n+1] for n in range(Half_N)])\n \n for k in range(Half_N):\n a = 2*math.pi*k/N\n w = Complex(math.cos(a), -math.sin(a))\n E_k = Evens[k]\n O_k = w*Odds[k]\n X[k] = E_k + O_k\n X[k + Half_N] = E_k - O_k\n return X","def dK_dtheta(self,dL_dK,X,X2,target):\r\n if X2 is None: X2 = X\r\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\r\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\r\n\r\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)), self.a[1]*self.basis_omega, self.a[2]*self.basis_omega**2, self.a[3]*self.basis_omega**3))\r\n Lo = np.column_stack((self.basis_omega, self.basis_omega, self.basis_omega, self.basis_omega))\r\n Lp = np.column_stack((self.basis_phi, self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\r\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\r\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\r\n\r\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\r\n F1lower = np.array(self._cos(self.basis_alpha*self.basis_omega,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n F2lower = np.array(self._cos(self.basis_alpha*self.basis_omega**2,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\r\n\r\n #dK_dvar\r\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\r\n\r\n #dK_dlen\r\n da_dlen = [-3*self.a[0]/self.lengthscale, -2*self.a[1]/self.lengthscale, -self.a[2]/self.lengthscale, 0.]\r\n db_dlen = [0., 4*self.b[1]/self.lengthscale, 2*self.b[2]/self.lengthscale, 2*self.b[3]/self.lengthscale, 2*self.b[4]/self.lengthscale]\r\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)), da_dlen[1]*self.basis_omega, da_dlen[2]*self.basis_omega**2, da_dlen[3]*self.basis_omega**3))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\r\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\r\n dGint_dlen = dGint_dlen + dGint_dlen.T\r\n dlower_terms_dlen = db_dlen[0]*np.dot(Flower,Flower.T) + db_dlen[1]*np.dot(F2lower,F2lower.T) + db_dlen[2]*np.dot(F1lower,F1lower.T) + db_dlen[3]*np.dot(F2lower,Flower.T) + db_dlen[4]*np.dot(Flower,F2lower.T)\r\n dG_dlen = 15*self.lengthscale**4/(400*np.sqrt(5))*Gint + 3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dlen + dlower_terms_dlen\r\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\r\n\r\n #dK_dper\r\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\r\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\r\n\r\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period, -self.a[2]*self.basis_omega**3/self.period, -self.a[3]*self.basis_omega**4/self.period))\r\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi,self.basis_phi+np.pi*3/2,self.basis_phi))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\r\n\r\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\r\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\r\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\r\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\r\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\r\n\r\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\r\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\r\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\r\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\r\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\r\n\r\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period, -2*self.a[2]*self.basis_omega**2/self.period, -3*self.a[3]*self.basis_omega**3/self.period))\r\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\r\n r2,omega2,phi2 = self._cos_factorization(dLa_dper2,Lo[:,0:2],dLp_dper2)\r\n\r\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\r\n dGint_dper = dGint_dper + dGint_dper.T\r\n\r\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n dF1lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower)+self._cos(-self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n dF2lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**3/self.period,self.basis_omega,self.basis_phi+np.pi*3/2)(self.lower) + self._cos(-2*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\r\n\r\n dlower_terms_dper = self.b[0] * (np.dot(dFlower_dper,Flower.T) + np.dot(Flower.T,dFlower_dper))\r\n dlower_terms_dper += self.b[1] * (np.dot(dF2lower_dper,F2lower.T) + np.dot(F2lower,dF2lower_dper.T)) - 4*self.b[1]/self.period*np.dot(F2lower,F2lower.T)\r\n dlower_terms_dper += self.b[2] * (np.dot(dF1lower_dper,F1lower.T) + np.dot(F1lower,dF1lower_dper.T)) - 2*self.b[2]/self.period*np.dot(F1lower,F1lower.T)\r\n dlower_terms_dper += self.b[3] * (np.dot(dF2lower_dper,Flower.T) + np.dot(F2lower,dFlower_dper.T)) - 2*self.b[3]/self.period*np.dot(F2lower,Flower.T)\r\n dlower_terms_dper += self.b[4] * (np.dot(dFlower_dper,F2lower.T) + np.dot(Flower,dF2lower_dper.T)) - 2*self.b[4]/self.period*np.dot(Flower,F2lower.T)\r\n\r\n dG_dper = 1./self.variance*(3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dper + 0.5*dlower_terms_dper)\r\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\r\n\r\n # np.add(target[:,:,0],dK_dvar, target[:,:,0])\r\n target[0] += np.sum(dK_dvar*dL_dK)\r\n #np.add(target[:,:,1],dK_dlen, target[:,:,1])\r\n target[1] += np.sum(dK_dlen*dL_dK)\r\n #np.add(target[:,:,2],dK_dper, target[:,:,2])\r\n target[2] += np.sum(dK_dper*dL_dK)","def dK_dtheta(self,dL_dK,X,X2,target):\r\n if X2 is None: X2 = X\r\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\r\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\r\n\r\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega))\r\n Lo = np.column_stack((self.basis_omega,self.basis_omega))\r\n Lp = np.column_stack((self.basis_phi,self.basis_phi+np.pi/2))\r\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\r\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\r\n\r\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\r\n\r\n #dK_dvar\r\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\r\n\r\n #dK_dlen\r\n da_dlen = [-1./self.lengthscale**2,0.]\r\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)),da_dlen[1]*self.basis_omega))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\r\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\r\n dGint_dlen = dGint_dlen + dGint_dlen.T\r\n dG_dlen = 1./2*Gint + self.lengthscale/2*dGint_dlen\r\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\r\n\r\n #dK_dper\r\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\r\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\r\n\r\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period))\r\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\r\n\r\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\r\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\r\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\r\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\r\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\r\n\r\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\r\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\r\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\r\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\r\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\r\n\r\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period))\r\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2))\r\n r2,omega2,phi2 = dLa_dper2.T,Lo[:,0:1],dLp_dper2.T\r\n\r\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\r\n dGint_dper = dGint_dper + dGint_dper.T\r\n\r\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n\r\n dG_dper = 1./self.variance*(self.lengthscale/2*dGint_dper + self.b[0]*(np.dot(dFlower_dper,Flower.T)+np.dot(Flower,dFlower_dper.T)))\r\n\r\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\r\n\r\n target[0] += np.sum(dK_dvar*dL_dK)\r\n target[1] += np.sum(dK_dlen*dL_dK)\r\n target[2] += np.sum(dK_dper*dL_dK)","def input_f(t,decay=0.5,freq=1.5):\n u_t = 1*(t>0)\n return np.cos(freq*t)*np.exp(-decay*t) * u_t","def dK_dtheta(self,dL_dK,X,X2,target):\r\n if X2 is None: X2 = X\r\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\r\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\r\n\r\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega,self.a[2]*self.basis_omega**2))\r\n Lo = np.column_stack((self.basis_omega,self.basis_omega,self.basis_omega))\r\n Lp = np.column_stack((self.basis_phi,self.basis_phi+np.pi/2,self.basis_phi+np.pi))\r\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\r\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\r\n\r\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\r\n F1lower = np.array(self._cos(self.basis_alpha*self.basis_omega,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n\r\n #dK_dvar\r\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\r\n\r\n #dK_dlen\r\n da_dlen = [-6/self.lengthscale**3,-2*np.sqrt(3)/self.lengthscale**2,0.]\r\n db_dlen = [0.,2*self.lengthscale/3.]\r\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)),da_dlen[1]*self.basis_omega,da_dlen[2]*self.basis_omega**2))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\r\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\r\n dGint_dlen = dGint_dlen + dGint_dlen.T\r\n dG_dlen = self.lengthscale**2/(4*np.sqrt(3))*Gint + self.lengthscale**3/(12*np.sqrt(3))*dGint_dlen + db_dlen[0]*np.dot(Flower,Flower.T) + db_dlen[1]*np.dot(F1lower,F1lower.T)\r\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\r\n\r\n #dK_dper\r\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\r\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\r\n\r\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period, -self.a[2]*self.basis_omega**3/self.period))\r\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi,self.basis_phi+np.pi*3/2))\r\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\r\n\r\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\r\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\r\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\r\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\r\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\r\n\r\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\r\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\r\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\r\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\r\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\r\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\r\n\r\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period, -2*self.a[2]*self.basis_omega**2/self.period))\r\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi))\r\n r2,omega2,phi2 = self._cos_factorization(dLa_dper2,Lo[:,0:2],dLp_dper2)\r\n\r\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\r\n dGint_dper = dGint_dper + dGint_dper.T\r\n\r\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n dF1lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower)+self._cos(-self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\r\n\r\n dG_dper = 1./self.variance*(self.lengthscale**3/(12*np.sqrt(3))*dGint_dper + self.b[0]*(np.dot(dFlower_dper,Flower.T)+np.dot(Flower,dFlower_dper.T)) + self.b[1]*(np.dot(dF1lower_dper,F1lower.T)+np.dot(F1lower,dF1lower_dper.T)))\r\n\r\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\r\n\r\n # np.add(target[:,:,0],dK_dvar, target[:,:,0])\r\n target[0] += np.sum(dK_dvar*dL_dK)\r\n #np.add(target[:,:,1],dK_dlen, target[:,:,1])\r\n target[1] += np.sum(dK_dlen*dL_dK)\r\n #np.add(target[:,:,2],dK_dper, target[:,:,2])\r\n target[2] += np.sum(dK_dper*dL_dK)","def calc_dtdc(tpbpcs, specs):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n Nbs = len(np.hstack(tpbpcs[0]))\n Ndraw = len(tpbpcs)\n\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\n\n for i in range(Ndraw):\n\n # Create array of times per bandpass\n dtpb[i,:] = np.hstack(tpbpcs[i])\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def increaseFreq(self, desHz):\n from scipy.interpolate import interp1d\n import time\n from numpy import linspace, floor\n from decimal import getcontext, Decimal\n\n if desHz > 1000: # set max freq here \n raise ValueError('Max Frequency is 1000 (3 decimal places)')\n now = time.asctime(time.localtime(time.time())) \n stamp = ''.join(['%% The following created by alog_manip.MOOSalog.MOOSalog.increaseFreq\\n%% ', now])\n increase_msg = ''.join(['%% Resultant Frequency: ',str(desHz),' Hz'])\n # hiHz = {}\n self.outData = {} # erase pre-existing dict\n self.outData['header'] = [stamp,increase_msg,'%%%%'] + self.srcData['header']\n\n def create_msgs():\n \"\"\" Puts interpolated data into dict outData\n Primary interpolation function for increaseFreq\n Consider using uniaxial spline --> would have one function for all of dictionary dat\n \"\"\"\n getcontext().prec = 3 # will round to 3 decimal places\n orig_times = sorted(dat)\n for n in range(len(dat) - 1):\n linfun = interp1d([orig_times[n], orig_times[n+1]], \\\n [dat[orig_times[n]], dat[orig_times[n+1]]])\n dt = orig_times[n+1] - orig_times[n] # current\n freq = 1/dt # current\n if dt < (1/desHz):\n print('found instance where Freq already at/above desired Freq')\n else:\n new_dt = dt*freq/desHz\n new_times = linspace(orig_times[n],orig_times[n+1],floor(dt/new_dt))\n # print(new_times)\n new_values = linfun(new_times)\n # rounded_values = [float(Decimal(\"%.3f\" % e)) for e in new_values]\n rounded_times = [float(Decimal(\"%.3f\" % e)) for e in new_times]\n for m in range(len(rounded_times)):\n # this_time = int(new_times[m]*100000)/100000 # 5 decimal places in timstamp\n self.outData[sens][meas][rounded_times[m]] = new_values[m]\n\n ## go thru and pull out dictionaries {time: value} then send to interpolation func\n for sens in self.srcData:\n if sens is not 'header':\n self.outData[sens] = {}\n for meas in self.srcData[sens]:\n self.outData[sens][meas] = {}\n dat = self.srcData[sens][meas]\n if len(dat) == 1:\n self.outData[sens][meas] = dat # only 1 data point, no interp\n else:\n create_msgs()","def filter_list_freq(lst, min_freq):\r\n arr = np.array(lst)\r\n items, count = np.unique(np.array(arr), return_counts=True)\r\n rem_items = items[count < min_freq]\r\n return [i for i in arr[~np.in1d(np.array(arr), rem_items)]]","def DFT_slow(x):\n x = np.asarray(x, dtype=float)\n N = x.shape[0]\n n = np.arange(N)\n k = n.reshape((N, 1))\n M = np.exp(-2j * np.pi * k * n / N)\n return np.dot(M, x)","def energy_Photon(freq=1.0,energy=0.0):\n global r,c,h\n if freq ==0:\n print(\"enerji yok...\")\n return 0\n if energy != 0:\n energy =energy\n else:\n energy = h*freq\n getit =str(input(\"frekans bulmak istiyorsaniz f,yoksa bos gecin.\"))\n if getit ==\"f\":\n return ('%.2E' % Decimal(str(energy/h)))\n return float('%.2E' % Decimal(str(energy)))","def DFT(h, m, N=None):\n # Check input params\n assert np.all(np.array(m, dtype=int) == m), 'DFT: m should be an integer or an array of integers.'\n if N is None:\n warnings.warn('DFT: N not specified, assuming N is the length of h.')\n N = len(h)\n else:\n assert int(N)==N, 'DFT: N should be an integer number.'\n n = np.linspace(0, N-1, N)\n # Construct array of e^-jwn where each row corresponds to a w value and each column corresponds to a n value\n A = np.fromfunction(lambda i, j: np.exp(-1j*m[i.astype(int)]*2*np.pi*n[j.astype(int)]/N), shape=(len(m), N))\n # Calculate sum over all n (0 to N-1) for each m\n return np.dot(A, h[:N])","def compute_dewpoint(t,h):\n\n tempC = (t-32)*5/9 #convert from deg F to deg C\n rh = h/100\n\n b = 18.678\n c = 257.14 #deg C\n\n gamma = math.log(rh)+(b*tempC)/(c+tempC)\n tdp = c*gamma/(b-gamma)\n\n tdp_F = 9/5*tdp +32 #convert from deg C to deg F\n\n return tdp_F","def illuminationEff(freq,fD, FFBW, dB_at_bw, feed_type):\n theta0 = fD2angle(fD,units='degrees')\n dtt = 0.1\n theta = np.arange(0.0,theta0/2.0+dtt,dtt)\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\n theta = theta*math.pi/180.0\n kern = np.sqrt(g)*np.tan(theta/2.0)\n num = 32.0*(fD*integ.trapz(kern,dx=dtt*math.pi/180.0))**2\n kern = g*np.sin(theta)\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\n\n n_ill = num/den \n return n_ill","def _get_distance_by_least_frequency(get_freq, positions, forms):\n if len(set(forms[positions])) < 2:\n return 0\n if len(positions) == 2:\n return _get_trivial_distance(positions)\n sorted_positions = np.array(sorted(positions))\n freqs = [get_freq(f) for f in forms[sorted_positions]]\n freq_sort = np.argsort(freqs)\n idx = sorted_positions[freq_sort]\n if idx.shape[0] >= 2:\n not_first_pos = idx[idx != idx[0]]\n if not_first_pos.shape[0] > 0:\n end = not_first_pos[0]\n return np.abs(end - idx[0]) + 1\n return 0","def zpkfreqz(z, p, k, worN=None):\n if worN is None or isinstance(worN, int):\n N = worN or 512\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\n else:\n ws = worN\n\n h = []\n for wk in ws:\n zm1 = mp.exp(1j * wk)\n numer = _prod([zm1 - t for t in z])\n denom = _prod([zm1 - t for t in p])\n hk = k * numer / denom\n h.append(hk)\n return ws, h","def all_dhkl(self, crystal):\n #d_min = self.wavelength/self.max2theta*pi/2\n d_min = self.wavelength/sin(self.max2theta/2)/2\n \n # This block is to find the shortest d_hkl, \n # for all basic directions (1,0,0), (0,1,0), (1,1,0), (1,-1,0) and so on, 26 in total \n hkl_max = np.array([1,1,1])\n for h1 in [-1, 0, 1]:\n for k1 in [-1, 0, 1]:\n for l1 in [-1, 0, 1]:\n hkl_index = np.array([[h1,k1,l1]])\n d = float(np.linalg.norm( np.dot(hkl_index, crystal.rec_matrix), axis=1))\n if d>0:\n multiple = 1/d/d_min\n hkl_index *= round(multiple)\n for i in range(len(hkl_max)):\n if hkl_max[i] < hkl_index[0,i]:\n hkl_max[i] = hkl_index[0,i]\n #h1 = 2*ceil(np.linalg.norm(crystal.cell_para[0])/d_min)\n #k1 = 2*ceil(np.linalg.norm(crystal.cell_para[1])/d_min)\n #l1 = 2*ceil(np.linalg.norm(crystal.cell_para[2])/d_min)\n h1, k1, l1 = hkl_max\n h = np.arange(-h1,h1)\n k = np.arange(-k1,k1)\n l = np.arange(-l1,l1)\n \n hkl = np.array((np.meshgrid(h,k,l))).transpose()\n hkl_list = np.reshape(hkl, [len(h)*len(k)*len(l),3])\n hkl_list = hkl_list[np.where(hkl_list.any(axis=1))[0]]\n d_hkl = 1/np.linalg.norm( np.dot(hkl_list, crystal.rec_matrix), axis=1)\n #for ix, a in enumerate(hkl_list):\n # if np.array_equal(a, np.array([1,-1,3])) is True:\n # print(a)\n # break\n #\n #print(ix, hkl_list[ix], d_hkl[ix], d_min)\n\n shortlist = d_hkl > (d_min)\n d_hkl = d_hkl[shortlist]\n hkl_list = hkl_list[shortlist]\n sintheta = self.wavelength/2/d_hkl\n\n self.theta = np.arcsin(sintheta)\n self.hkl_list = hkl_list\n self.d_hkl = d_hkl\n \n #return hkl_list, d_hkl, sintheta","def _convert_frequency(self, frequency):\n\n # Assert frequency lies within allowed range\n FTW_step = self.clock_freq/2**32\n FTW = round(frequency/FTW_step)\n Min_freq = 0\n Max_freq = (2**32-1)*FTW_step\n\n assert FTW >= 0, 'Minimum frequency is %r' %Min_freq\n assert FTW <= 2**32, 'Maximum frequency is %r' %Max_freq\n\n # Compute frequency tuning word for given frequency and clock frequency\n # Write FTW in list of 4 bytes (CFTW0 is a 32-bit register)\n return [FTW.to_bytes(4, 'big')[i] for i in range(4)]","def energy_due_to_vibrations(self, T, cf):\n E = 0.0\n for key, value in self.eci_per_kbT:\n E += value * cf[key] * kB * T\n return E","def tconst_filter(freq, tau):\n\treturn 1/(2*np.pi*1j*freq*tau+1)","def getPartitionFunction(self, Tlist):\n\t\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\n\t\t# Active K-rotor\n\t\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\n\t\tif len(rotors) == 0:\n\t\t\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\n\t\t\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\t# Other modes\n\t\tfor mode in self.modes:\n\t\t\tQ0 = mode.getPartitionFunction(Tlist)\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\treturn Q","def print_key_freq(self,\r\n freq_list):\r\n\r\n for key, freq in freq_list:\r\n\r\n display.noteprint((EMPTYCHAR,key + alerts.APPEARS_BEG\\\r\n +len(self.get_indexes_for_key(key)\\\r\n +alerts.APPEARS_END+freq)))","def differentialFlux(energy,costheta):\n p1 = 0.102573\n p2 = -0.068287\n p3 = 0.958633\n p4 = 0.0407253\n p5 = 0.817285\n \n costhetastar = sqrt((costheta**2+p1**2+p2*(costheta**p3)+p4*(costheta**p5))/(1.+p1**2+p2+p4))\n twopointseven = energy*(1+3.64/(energy*(costhetastar**1.29)))\n f = .140*(twopointseven**(-2.7))*((1./(1.+1.1*energy*costhetastar/115.))+0.054/(1.+1.1*energy*costhetastar/850.))\n return f","def temperature() -> FlowFieldVal:\n return [\n self._t_s - self._delta_t * tf.math.tanh(z / self._height) for z in zz\n ]"],"string":"[\n \"def harmonicOscillator_heatCapacity(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x\",\n \"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def thermal(isatom, freq, scalfac,linnonlin,T):\\n if isatom != \\\"true\\\":\\n nfreq = len(freq)\\n\\n vib_temp = []\\n for ifreq in range(nfreq):\\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\\n vib_temp.append(vib_temp_new)\\n\\n dE_vib = 0\\n for ifreq in range(nfreq):\\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\\n\\n dE_ZPE = 0.5 * sum(freq) * cmi2au\\n\\n if linnonlin == \\\"L\\\":\\n dE_rot = kB * T * j2au\\n elif linnonlin == \\\"NL\\\":\\n dE_rot = kB * T * j2au * (3.0/2.0)\\n else:\\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"ERROR: unknown entry for linear/nonlinear\\\")\\n else:\\n dE_ZPE = 0\\n dE_vib = 0\\n dE_rot = 0\\n\\n dE_tra = kB * T * j2au * (3.0/2.0)\\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\\n\\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)\",\n \"def compute_energy_density(kT):\\n h=u.planck\\n c=u.speed_of_light\\n pi=np.pi\\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def DFTscargle(times, signal,f0,fn,df):\\n f0 = 0.\\n #fn *= 2*np.pi\\n #df *= 2*np.pi\\n #-- initialize\\n nfreq = int((fn-f0)/(df))\\n print \\\"Nfreq=\\\",nfreq\\n tzero = times[0]\\n si = 1.\\n lfreq = 2*nfreq+1\\n mm = 2*nfreq\\n ftrx = np.zeros(mm)\\n ftix = np.zeros(mm)\\n om = np.zeros(mm)\\n w = np.zeros(mm)\\n wz = df #pi/(nn+dt)\\n nn = len(times)\\n \\n #-- calculate DFT\\n ftrx,ftix,om,w = pydft.ft(signal,times,wz,nfreq,si,lfreq,tzero,df,ftrx,ftix,om,w,nn,mm)\\n \\n if f0==0:\\n ftrx[1:] *= np.sqrt(2)\\n ftix[1:] *= np.sqrt(2)\\n w[1:] *= np.sqrt(2)\\n \\n cut_off = len(w)\\n for i in range(0,len(w))[::-1]:\\n if w[i] != 0: cut_off = i+1;break\\n \\n om = om[:cut_off]\\n ftrx = ftrx[:cut_off]\\n ftix = ftix[:cut_off]\\n w = w[:cut_off]\\n \\n # norm amplitudes for easy inversion\\n T = times[-1]-times[0]\\n N = len(times)\\n \\n w *= T/(2.*N)\\n ftrx *= T/(2.*N)\\n ftix *= T/(2.*N)\\n \\n return om*2*np.pi,w,ftrx,ftix\",\n \"def thermodynamic_temperature(frequency, T_cmb=None):\\n nu = frequency.to(si.GHz, spectral())\\n\\n if T_cmb is None:\\n from astropy.cosmology import default_cosmology\\n\\n T_cmb = default_cosmology.get().Tcmb0\\n\\n def f(nu, T_cmb=T_cmb):\\n x = _si.h * nu / _si.k_B / T_cmb\\n return x**2 * np.exp(x) / np.expm1(x) ** 2\\n\\n def convert_Jy_to_K(x_jybm):\\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\\n astrophys.Jy\\n )\\n return x_jybm / factor\\n\\n def convert_K_to_Jy(x_K):\\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\\n si.K\\n )\\n return x_K / factor\\n\\n return Equivalency(\\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\\n \\\"thermodynamic_temperature\\\",\\n {\\\"frequency\\\": frequency, \\\"T_cmb\\\": T_cmb},\\n )\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def HeatEqn_FT(D, L, x, t, u_0):\\n n = x.size\\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\\n u_0t = np.fft.fft(u_0)\\n\\n U = np.zeros((t.size, x.size))\\n for ti in range(t.size):\\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\\n\\n return U\",\n \"def rangerate_from_freq(freq,Fc):\\n # print(f'freq {freq} Fc {Fc}')\\n dopp_at_IF = freq - Fc\\n return dopp_at_IF*scipy.constants.speed_of_light/Fc\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def freq2den(freq):\\n\\n return freq * freq * k_2\",\n \"def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\\n kB = 1.380658e-16\\n h = 6.6260755e-27\\n c = 29979245800.\\n nu = freqGHz*1.e9\\n x = h*nu/(kB*T0)\\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\\n cNu *= 1e23\\n return cNu\",\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def get_quantum_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n f = 0\\n for m in self.input.structure.get_masses():\\n hbar_omega = (\\n HBAR\\n * np.sqrt(self.input.spring_constant / m)\\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\\n )\\n f += (3.0 / 2) * hbar_omega + (\\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\\n )\\n return f\",\n \"def kld(Fk, freq, Fk_red, f_red):\\n \\n #pad the reduced input with zeros\\n f_red = [float(val) for val in f_red]\\n freq = [float(val) for val in freq]\\n f_Fk_red = dict(zip(f_red,Fk_red))\\n Fk_red_pad = []\\n #for each frequency in the nonreduced signal\\n for i,f in enumerate(freq):\\n #if the frequency is shared with the reduced signal\\n if f in f_red:\\n #add the coefficient from the reduced signal\\n Fk_red_pad.append(f_Fk_red[f])\\n #otherwise, pad it with a zero\\n else:\\n Fk_red_pad.append(0.)\\n Fk_red_pad = np.array(Fk_red_pad)\\n \\n Fk = np.abs(Fk)\\n Fk /= sum(Fk)\\n Fk_red_pad = np.abs(Fk_red_pad)\\n Fk_red_pad /= sum(Fk_red_pad)\\n \\n return stats.entropy(Fk_red_pad, Fk)\",\n \"def system_temp(freq_hz):\\n freqs = np.array([0.05e9, 0.07e9, 0.11e9, 0.17e9, 0.25e9, 0.35e9, 0.45e9,\\n 0.55e9, 0.65e9])\\n t_sys = np.array([4.0409e3, 1.5029e3, 0.6676e3, 0.2936e3, 0.1402e3, 0.0873e3,\\n 0.0689e3, 0.0607e3, 0.0613e3])\\n f = interp1d(np.log10(freqs), np.log10(t_sys), kind='cubic')\\n return 10**f(np.log10(freq_hz))\",\n \"def D(T, xC):\\n a = 4.53e5\\n b = 8339.9/T\\n c = 1./T - 2.221e-4\\n d = 17767\\n e = -26436\\n\\n yC = xC/(1. - xC)\\n\\n # D0 = 4.53e5*(1. + yC*(1.-yC)*8339.9/T) # Pre-exponential term\\n # D = D0*np.exp(-(1./T - 2.221e-4)*(17767 - yC*26436)) # um^2/s\\n # return D\\n return a*(1 + b*yC*(1-yC))*np.exp(-c*(d + e*yC))\",\n \"def calc_entropy(frequency_wn, temperature):\\r\\n\\tentropy = 0\\r\\n\\tfrequency = [entry * SPEED_OF_LIGHT for entry in frequency_wn]\\r\\n\\tfor entry in frequency:\\r\\n\\t\\tfactor = ((PLANCK_CONSTANT*entry)/(BOLTZMANN_CONSTANT*temperature))\\r\\n\\t\\ttemp = factor*(1/(math.exp(factor)-1)) - math.log(1-math.exp(-factor))\\r\\n\\t\\ttemp = temp*GAS_CONSTANT/4.184\\r\\n\\t\\tentropy = entropy + temp \\r\\n\\treturn entropy\",\n \"def get_classical_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n\\n return (\\n -3\\n * len(self.input.structure)\\n * np.log(np.pi / (self.input.spring_constant * beta))\\n / (2 * beta)\\n )\",\n \"def fuel_cond(T):\\n\\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\\n \\n return kc\",\n \"def cu_lpf(stimulus, dt, freq):\\n num = len(stimulus)\\n num_fft = int(num / 2 + 1)\\n idtype = stimulus.dtype\\n odtype = np.complex128 if idtype == np.float64 else np.complex64\\n\\n if not isinstance(stimulus, gpuarray.GPUArray):\\n d_stimulus = gpuarray.to_gpu(stimulus)\\n else:\\n d_stimulus = stimulus\\n\\n plan = Plan(stimulus.shape, idtype, odtype)\\n d_fstimulus = gpuarray.empty(num_fft, odtype)\\n fft(d_stimulus, d_fstimulus, plan)\\n\\n df = 1.0 / dt / num\\n idx = int(freq // df)\\n\\n unit = int(d_fstimulus.dtype.itemsize / 4)\\n offset = int(d_fstimulus.gpudata) + d_fstimulus.dtype.itemsize * idx\\n\\n cuda.memset_d32(offset, 0, unit * (num_fft - idx))\\n\\n plan = Plan(stimulus.shape, odtype, idtype)\\n d_lpf_stimulus = gpuarray.empty(num, idtype)\\n ifft(d_fstimulus, d_lpf_stimulus, plan, False)\\n\\n return d_lpf_stimulus.get()\",\n \"def helmholtzenergy(temp,pres):\\n g = liq_g(0,0,temp,pres)\\n g_p = liq_g(0,1,temp,pres)\\n f = g - pres*g_p\\n return f\",\n \"def get_frequency(self):\\r\\n # print '*********in get freq'\\r\\n self.cntr.run('FREQ 1')\\r\\n f_0_ = self.cntr.get_measurements(1)\\r\\n self.f_0 = f_0_[0]\\r\\n self.cntr.run('FREQ 2')\\r\\n f_rep_ = self.cntr.get_measurements(1)\\r\\n self.f_rep = f_rep_[0]\",\n \"def get_frequency(self,):\\n\\n # TODO: Find way to appropriately reconvert the frequency to its initial\\n # TODO: Value or alert that the value is APPROXIMATE\\n FTW = int (0)\\n freq = int(0)\\n\\n FTW_bytes = self._read('CFTW0')\\n FTW = FTW.from_bytes(FTW_bytes,'big')\\n freq = FTW*self.clock_freq/2**32\\n\\n print('Latest frequency set: ', \\\"{:.2e}\\\".format(freq), 'Hz')\\n print(['%.2e' % elem for elem in self.frequencies])\\n\\n return self.frequencies\",\n \"def dft(X): \\n N = len(X)\\n x = np.zeros(N, 'complex')\\n K = np.arange(0, N, 1)\\n for n in range(0, N, 1):\\n x[n] = np.dot(X, np.exp(1j * 2 * np.pi * K * n / N))\\n return x\",\n \"def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n C_T = (\\n 2 ** (1 / 4)\\n * np.sqrt(gbar)\\n / np.pi\\n * np.sqrt(vv)\\n * tt ** (5 / 4)\\n * _1d_call(_fdk, y, k=1 / 2)\\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\\n )\\n return C_T\",\n \"def _get_a_freq(self, energy):\\n left_index = bisect.bisect_left(self.energy_list, energy)\\n if left_index+1 >= len(self.energy_list):\\n left_index = len(self.energy_list)-2\\n elif left_index > 0:\\n left_index -= 1\\n energy0 = self.energy_list[left_index]\\n energy1 = self.energy_list[left_index+1]\\n freq0 = 1./self.closed_orbits_t[energy0]\\n freq1 = 1./self.closed_orbits_t[energy1]\\n frequency = (freq1 - freq0)/(energy1-energy0)*(energy-energy0) + freq0\\n #print \\\"\\\\nl:\\\", left_index, \\\"e0:\\\", energy0, \\\"e1:\\\", energy1, \\\\\\n # \\\"f0:\\\", freq0, \\\"f1:\\\", freq1, \\\"DE:\\\", energy-e0, \\\"f\\\", frequency\\n return frequency\",\n \"def vib_energy(frequency, temp):\\n\\n # vibrational temperature\\n\\n vtemp = plank_const * speed_ol / boltz_const * frequency\\n\\n vtemp = np.matrix(vtemp)\\n\\n temp = 1 / np.matrix(temp)\\n\\n # need to convert to array, because the element wise exponential\\n # cannot work with matrix\\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\\n\\n # energy is a np.matrix, need to convert to array\\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\\n energy = np.array(energy)[0]\\n\\n return energy\",\n \"def CMB_spec(eng, temp):\\n if np.issubdtype(type(eng), float):\\n eng = np.array([eng])\\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\\n\\n if np.issubdtype(type(eng), float): \\n return phot_spec_density[0] \\n else: \\n return phot_spec_density\",\n \"def DFTpower(time, signal, f0=None, fn=None, df=None, full_output=False):\\n\\n freqs = np.arange(f0,fn,df)\\n Ntime = len(time)\\n Nfreq = int(np.ceil((fn-f0)/df))\\n \\n A = np.exp(1j*2.*pi*f0*time) * signal\\n B = np.exp(1j*2.*pi*df*time)\\n ft = np.zeros(Nfreq, complex) \\n ft[0] = A.sum()\\n for k in range(1,Nfreq):\\n A *= B\\n ft[k] = np.sum(A)\\n \\n if full_output:\\n return freqs,ft**2*4.0/Ntime**2\\n else:\\n return freqs,(ft.real**2 + ft.imag**2) * 4.0 / Ntime**2\",\n \"def calccfl(k, t, x):\\n xstep = (max(x) - min(x)) / (len(x)-1)\\n tstep = (max(t) - min(t)) / (len(t)-1)\\n cfl = k*tstep/xstep**2\\n return cfl\",\n \"def __setSpectrum__(self):\\n \\n self.Ck = []\\n TempCk = []\\n TempOneCk = OneCk()\\n \\n # Process 1st frequency\\n Tb = self.freqs[1].totalJ\\n \\n for b in range(-Tb, Tb, 1):\\n TempOneCk.freq = b*self.freqs[1].Vph\\n TempOneCk.Amp = self.freqs[1].Cjk(b)\\n self.Ck.append(TempOneCk)\\n \\n # Process additional frequencies\\n CkSize = len(self.Ck)\\n Added = FALSE\\n \\n for f in range(2, len(self.freqs), 1):\\n # Reset temporary variables\\n Tb = self.freqs[f].totalJ\\n TempCk = []\\n \\n # Calculate each Ck coefficient\\n for b in range(-Tb, Tb, 1):\\n for k in range(CkSize):\\n TempOneCk.Amp = Ck[k].Amp * self.freq[f].Cjk(b)\\n \\n # Check to see if Amp is big enough to keep\\n if( abs(TempOneCk.Amp) > self.min_Ck ):\\n Added = FALSE\\n TempOneCk.freq = self.Ck[k].freq + b*self.freqs.Vph\\n \\n # If freq is already in Ck, add new value to old,\\n # if not, add new value and freq to spectrum\\n for c in TempCk:\\n if abs(c.freq-TempOneCk.freq < DOUBLE_PRECISION):\\n c.Amp += TempOneCk.Amp\\n Added = TRUE\\n break\\n \\n if (not Added):\\n TempCk.append(TempOneCk)\\n \\n self.Ck = TempCk\\n CkSize = len(self.Ck)\",\n \"def hz_to_mel(frequencies, htk=False):\\n\\n frequencies = np.asanyarray(frequencies)\\n\\n if htk:\\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\\n\\n # Fill in the linear part\\n f_min = 0.0\\n f_sp = 200.0 / 3\\n\\n mels = (frequencies - f_min) / f_sp\\n\\n # Fill in the log-scale part\\n\\n min_log_hz = 1000.0 # beginning of log region (Hz)\\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\\n logstep = np.log(6.4) / 27.0 # step size for log region\\n\\n if frequencies.ndim:\\n # If we have array data, vectorize\\n log_t = frequencies >= min_log_hz\\n mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep\\n elif frequencies >= min_log_hz:\\n # If we have scalar data, heck directly\\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\\n\\n return mels\",\n \"def getf(element, energy, conv_fwhm=0):\\n try:\\n Z = int(element)\\n except: \\n if element in elements.Z:\\n Z = elements.Z[element]\\n else:\\n Z = None\\n if Z is None or Z>93:\\n raise ValueError(\\\"Invalid element / element number: %s. \\\"\\n \\\"(Only elements from H to U allowed).\\\"%str(Z))\\n energy = np.array(energy, ndmin=1)\\n diffE = np.unique(np.diff(energy))\\n if not len(diffE):\\n return deltaf.clcalc(Z, energy)\\n dE = abs(diffE.min())\\n fwhm_chan = abs(float(conv_fwhm))/dE/2.\\n # make equally spaced data:\\n if diffE.std()/diffE.mean() > 1e-5 and fwhm_chan>1e-2:\\n newenergy = np.arange(energy.min() - 10*dE, energy.max() + 10.*dE, dE)\\n do_interpolate = True\\n else:\\n newenergy = energy\\n do_interpolate = False\\n \\n f1, f2 = deltaf.clcalc(Z, newenergy)\\n if fwhm_chan>1e-2:\\n f1, f2 = deltaf.convl2(f1, f2, fwhm_chan)\\n if do_interpolate:\\n ffunc = interp1d(newenergy, (f1, f2))\\n f1, f2 = ffunc(energy)\\n return f1, f2\",\n \"def main():\\n # Reading the list of temps\\n the_list = read_list()\\n\\n # Getting a temp to count and running frequency function\\n count_temp = int(input(\\\"Enter a value you would like the frequency of: \\\"))\\n\\n # calling the frequency function\\n frequency(count_temp, the_list)\",\n \"def hz_to_mel(frequencies, htk=False):\\n\\n frequencies = np.asanyarray(frequencies)\\n\\n if htk:\\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\\n\\n # Fill in the linear part\\n f_min = 0.0\\n f_sp = 200.0 / 3\\n\\n mels = (frequencies - f_min) / f_sp\\n\\n # Fill in the log-scale part\\n\\n min_log_hz = 1000.0 # beginning of log region (Hz)\\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\\n logstep = np.log(6.4) / 27.0 # step size for log region\\n\\n if frequencies.ndim:\\n # If we have array data, vectorize\\n log_t = (frequencies >= min_log_hz)\\n mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep\\n elif frequencies >= min_log_hz:\\n # If we have scalar data, heck directly\\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\\n\\n return mels\",\n \"def k_HF(T, n, h=1e-3):\\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\\n return dn_dmu / n\",\n \"def EGWD_fg(f):\\n A = 4.2e-47\\n res = np.zeros((len(f)))\\n for i,freq in enumerate(f): \\n if freq >=3e-3:\\n # strain \\n res[i] = A * freq**(-7/3) * np.exp(-2*(freq/5e-2)**2) \\n else:\\n res[i] = np.NaN\\n return np.array(res)\",\n \"def KE_ejected_electron(frequency=1,workFunction=1, units=eV):\\n\\n var = sy.var('h nu W')\\n par = units['h'], frequency, workFunction\\n\\n y = h*nu - W\\n\\n return dic_result(var,par,y)\",\n \"def cutoff_denominator(self, list_energy):\\n\\n tol = 1e-3\\n\\n z = list_energy/tol\\n\\n den = N.imag(SS.wofz(z))/tol*N.sqrt(N.pi)\\n\\n return den\",\n \"def torch_mel_to_hertz(frequencies_mel):\\r\\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\\r\\n return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\",\n \"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr\",\n \"def get_f_jk(j_dist,degree_dist=None):\\n if degree_dist is not None:\\n for k,freq in zip(degree_dist.index, degree_dist.values):\\n j_dist.loc[j_dist.k==k,'j_freq'] *= freq\\n return j_dist\",\n \"def half_space_cooling_temperature(z, t, T1, T0, kappa):\\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]\",\n \"def FSDs(X, Y, K, Intervals):\\n\\n # check input 'Intervals'\\n if Intervals[0] != 1.:\\n Intervals = np.hstack((1., Intervals))\\n if Intervals[-1] != (K / 2):\\n Intervals = np.hstack((Intervals, float(K)))\\n # get length of intervals\\n L = len(Intervals)\\n # initialize F\\n F = np.zeros((L-1, ))\\n # interpolate boundaries\\n iXY = InterpolateArcLength(X, Y, K)\\n # check if iXY.iX is not empty\\n if iXY.iX.size:\\n # calculate curvature\\n Curvature = np.arctan2(\\n (iXY.iY[1:] - iXY.iY[:-1]),\\n (iXY.iX[1:] - iXY.iX[:-1])\\n )\\n # make curvature cumulative\\n Curvature = Curvature - Curvature[0]\\n # calculate FFT\\n fX = np.fft.fft(Curvature).T\\n # spectral energy\\n fX = fX * fX.conj()\\n fX = fX / fX.sum()\\n # calculate 'F' values\\n for i in range(L-1):\\n F[i] = np.round(\\n fX[Intervals[i]-1:Intervals[i+1]].sum(), L\\n ).real.astype(float)\\n\\n return F\",\n \"def compute_ghost_series(self,terms):\\n\\t\\tp=self.p\\n\\t\\tcomp=self.comp\\n\\t\\tf1=self.f1\\n\\t\\tf2=self.f2\\n\\n\\t\\tghost_coefs = [[] for i in range(terms+1)]\\n\\n\\n\\t\\tk=comp;\\n\\t\\tif k==0 or k==1:\\n\\t\\t\\tk=k+p-1\\n\\n\\t\\t## Precompute the needed dimensions\\n\\t\\tself.f1v = [f1(k)]\\n\\t\\tself.f2v = [f2(k)]\\n\\t\\tk = k + p-1\\n\\t\\twhile self.f1v[len(self.f1v)-1] <= terms+1:\\n\\t\\t\\tself.f1v += [f1(k)]\\n\\t\\t\\tself.f2v += [f2(k)]\\n\\t\\t\\tk = k + p-1\\n\\t\\t\\n\\t\\t## Starting at weight 2, we run through weights in the component,\\n\\t\\t## compute the associated indices, and then record the weights at those\\n\\t\\t## indices with appropriate multiplicities\\n\\n\\t\\tk = comp;\\n\\t\\tif k==0 or k==1:\\n\\t\\t\\tk=k+p-1\\n\\t\\tn = 0\\n\\n\\t\\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\\n\\t\\twhile (len(inds)==0 or inds[0]<=terms+1):\\n\\t\\t\\t## This loops adds the weights to the appropriate indices with the appropriate multiplicities\\n\\t\\t\\tfor m in range(floor((len(inds)+1)/2)):\\n\\t\\t\\t\\tif m < floor(len(inds)/2):\\n\\t\\t\\t\\t\\tif inds[m]<=terms:\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[m]] += [(k,m+1)]\\n\\t\\t\\t\\t\\tif (inds[len(inds)-1-m]<=terms):\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[len(inds)-1-m]] += [(k,m+1)]\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif inds[m]<=terms:\\n\\t\\t\\t\\t\\t\\tghost_coefs[inds[m]] += [(k,m+1)]\\n\\t\\t\\tk = k + p-1\\n\\t\\t\\tn = n + 1\\n\\t\\t\\tinds = range(self.f1v[n]+1,self.f1v[n]+self.f2v[n])\\n\\t\\tself.series=ghost_coefs\",\n \"def _Kgradients(self):\\r\\n dL_dfhat, I_KW_i = self._shared_gradients_components()\\r\\n dlp = self.noise_model.dlogpdf_df(self.f_hat, self.data, extra_data=self.extra_data)\\r\\n\\r\\n #Explicit\\r\\n #expl_a = np.dot(self.Ki_f, self.Ki_f.T)\\r\\n #expl_b = self.Wi_K_i\\r\\n #expl = 0.5*expl_a - 0.5*expl_b\\r\\n #dL_dthetaK_exp = dK_dthetaK(expl, X)\\r\\n\\r\\n #Implicit\\r\\n impl = mdot(dlp, dL_dfhat, I_KW_i)\\r\\n\\r\\n #No longer required as we are computing these in the gp already\\r\\n #otherwise we would take them away and add them back\\r\\n #dL_dthetaK_imp = dK_dthetaK(impl, X)\\r\\n #dL_dthetaK = dL_dthetaK_exp + dL_dthetaK_imp\\r\\n #dL_dK = expl + impl\\r\\n\\r\\n #No need to compute explicit as we are computing dZ_dK to account\\r\\n #for the difference between the K gradients of a normal GP,\\r\\n #and the K gradients including the implicit part\\r\\n dL_dK = impl\\r\\n return dL_dK\",\n \"def DFTdirect(x):\\n \\n N = len(x)\\n X = []\\n for k in range(N):\\n X_k = Complex(0,0)\\n for n in range(N):\\n a = 2*math.pi*k*n/N\\n X_k += x[n]*Complex(math.cos(a), -math.sin(a))\\n X.append(X_k)\\n return X\",\n \"def getFourierPower(data, freq=None, ax=1, t=None):\\n\\n if t==None:\\n t = numpy.linspace(0.0,1.0,64)\\n Fs = 1.0/t[1] \\n L = t.shape[0]\\n ft = numpy.fft.fft(data,axis=ax)\\n freqs = numpy.fft.fftfreq(64,1.0/64.0)\\n ftAmp = abs(ft)/data.shape[1]*2\\n ftPhase = numpy.arctan2(ft.real, ft.imag)\\n if freq==None:\\n ii = numpy.argmax(abs(ft[:,1:])**2.0,axis=1)\\n ii += 1\\n else:\\n fr = numpy.asarray([freq])\\n fr = fr.flatten()\\n ii = numpy.ones(fr.shape)\\n for kk in range(0,fr.shape[0]):\\n ii[kk] = numpy.argmin(abs(freqs-fr[kk]))\\n \\n jj = numpy.arange(0,ftAmp.shape[0])\\n amp = ftAmp[jj,ii.astype('int')]\\n phase = ftPhase[jj,ii.astype('int')]\\n else:\\n Fs = 1.0/t[1]\\n L = t.shape[0]\\n ft = numpy.fft.fft(data,n=NFFT,axis=ax)[1:]/L#skip the DC\\n ftAmp = abs(ft)/len(t)*2\\n ftPhase = numpy.arctan2(ft.real, ft.imag)\\n if freq==None:\\n ii = argmax(abs(ft)**2.0,0)\\n else: \\n ii = freq-1\\n \\n amp = ftAmp[:,ii]\\n phase = ftPhase[:,ii]\\n return amp, phase, ii\",\n \"def gradient_function(X, t, flow, species_list):\\n vals = {\\\"t\\\": t}\\n\\n for i, species in enumerate(species_list):\\n vals[species] = X[i]\\n\\n result = []\\n\\n for species in flow:\\n result.append(flow[species].evalf(subs=vals))\\n\\n return result\",\n \"def Heston_fft(self,alpha,n,B,K):\\r\\n bt = time.time()\\r\\n r = self.r\\r\\n T = self.T\\r\\n S0 = self.S0\\r\\n N = 2**n\\r\\n Eta = B / N\\r\\n Lambda_Eta = 2 * math.pi / N\\r\\n Lambda = Lambda_Eta / Eta\\r\\n \\r\\n J = np.arange(1,N+1,dtype = complex)\\r\\n vj = (J-1) * Eta\\r\\n m = np.arange(1,N+1,dtype = complex)\\r\\n Beta = np.log(S0) - Lambda * N / 2\\r\\n km = Beta + (m-1) * Lambda\\r\\n \\r\\n ii = complex(0,1)\\r\\n \\r\\n Psi_vj = np.zeros(len(J),dtype = complex)\\r\\n \\r\\n for zz in range(0,N):\\r\\n u = vj[zz] - (alpha + 1) * ii\\r\\n numer = self.Heston_cf(u)\\r\\n denom = (alpha + vj[zz] * ii) * (alpha + 1 + vj[zz] * ii)\\r\\n \\r\\n Psi_vj [zz] = numer / denom\\r\\n \\r\\n # Compute FTT\\r\\n xx = (Eta/2) * Psi_vj * np.exp(-ii * Beta * vj) * (2 - self.dirac(J-1))\\r\\n zz = np.fft.fft(xx)\\r\\n \\r\\n # Option price\\r\\n Mul = np.exp(-alpha * np.array(km)) / np.pi\\r\\n zz2 = Mul * np.array(zz).real\\r\\n k_List = list(Beta + (np.cumsum(np.ones((N, 1))) - 1) * Lambda)\\r\\n Kt = np.exp(np.array(k_List))\\r\\n \\r\\n Kz = []\\r\\n Z = []\\r\\n for i in range(len(Kt)):\\r\\n if( Kt[i]>1e-16 )&(Kt[i] < 1e16)& ( Kt[i] != float(\\\"inf\\\"))&( Kt[i] != float(\\\"-inf\\\")) &( zz2[i] != float(\\\"inf\\\"))&(zz2[i] != float(\\\"-inf\\\")) & (zz2[i] is not float(\\\"nan\\\")):\\r\\n Kz += [Kt[i]]\\r\\n Z += [zz2[i]]\\r\\n tck = interpolate.splrep(Kz , np.real(Z))\\r\\n price = np.exp(-r*T)*interpolate.splev(K, tck).real\\r\\n et = time.time()\\r\\n \\r\\n runt = et-bt\\r\\n\\r\\n return(price,runt)\",\n \"def get_dft_train():\\n\\n single_dft = np.array(generate_doublet_train(ipi_to_frequency(155), num_pulses=6, pulse_duration=0.6))\\n all_dft = []\\n for i in range(150):\\n dft = np.copy(single_dft)\\n if all_dft:\\n dft += all_dft[-1] + 500\\n all_dft.extend(dft)\\n\\n return np.array(all_dft)\",\n \"def calc_dtdc_star(tpbpc0, spec):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n # Create array of times per bandpass\\n dtpb = np.hstack(tpbpc0)\\n\\n Nbs = len(dtpb)\\n dcomp = np.zeros(Nbs) # completeness\\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def create_fft_freq(dt, nfft, full):\\n freqs = da.fft.fftfreq(nfft, d=dt) \\n\\n if (nfft % 2 == 0):\\n freqs = da.hstack([freqs[0: nfft // 2], -freqs[nfft //2], freqs[nfft // 2:nfft]])\\n if full:\\n freqs = da.fft.fftshift(freqs)\\n else:\\n freqs = freqs[0:nfft // 2 + 1]\\n\\n return(freqs)\",\n \"def get_dom_freq(Fk, freq, n_freq):\\n\\n #get the magnitude of the coefficients\\n Fk_abs = np.abs(Fk)\\n #sort the coefficients in descending order\\n Fk_sort = sorted(Fk_abs, reverse=True)\\n \\n dom_Fk = []\\n dom_f = []\\n i = 0\\n while i < n_freq:\\n inds = np.where(Fk_abs == Fk_sort[i])\\n for ind in inds:\\n dom_f.append(freq[ind])\\n dom_Fk.append(Fk[ind])\\n i += 1\\n \\n #sort based on frequency from lo to hi\\n #convert from numpy float to python float for mapping\\n dom_f = [float(abs(f)) for f in dom_f]\\n f_Fk = dict(zip(dom_f,dom_Fk))\\n f_sorted = sorted(dom_f)\\n # return(dom_f, f_Fk, f_sorted, dom_Fk)\\n\\n\\n dom_Fk = []\\n for f in f_sorted:\\n dom_Fk.append(f_Fk[f][0])\\n \\n return np.array(dom_Fk), np.array(f_sorted)\",\n \"def DFT_slow(x):\\r\\n x = np.asarray(x, dtype=complex)\\r\\n N = len(x)\\r\\n n = np.arange(N)\\r\\n k = n.reshape((N, 1))\\r\\n M = np.exp(-2j * np.pi * k * n / N)\\r\\n return np.dot(M, x)\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_partitionfunction(Tlist, self.frequency) ** self.degeneracy\",\n \"def hertz_to_mel(freq):\\n return 2595.0 * np.log10(1 + (freq / 700.0))\",\n \"def manual_calc_kfs(wbwc_list, dec_list, timelen, timesteps):\\n global X0\\n global wbwc_kfs\\n global all_kfs\\n ####\\n t = np.linspace(0, timelen, timesteps)\\n ##\\n ## 1. set new wbwc rates\\n wbwc_kfs[wbwc_list[0]]['hf'] = wbwc_list[1][0]\\n wbwc_kfs[wbwc_list[0]]['hr'] = wbwc_list[1][1]\\n wbwc_kfs = fill_wbwc_dict(wbwc_kfs, fill='rates')\\n init() \\n #####\\n ## now, loop for each value of a rate const in dec_list\\n for k in dec_list[1]:\\n all_kfs[dec_list[0]] = k\\n kname = dec_list[0] + str(k)\\n ##\\n #init() \\n set_expdeg()\\n ode(calc_model, X0, t, stype='manual', dname = kname)\\n ###\",\n \"def fourier_coefficient(t, freq, n=1, axis=-1):\\n t, freq, n = map(np.asanyarray, (t, freq, n))\\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)\",\n \"def freqvals(t):\\n N = len(t)\\n T = t[-1] - t[0]\\n dt = T/N\\n nyquist = 1/(2.0*dt)\\n lowfreq = 1/T\\n return (N, T, dt, nyquist, lowfreq)\",\n \"def get_tuning_freq(self, freq):\\n if freq < self.freq_lo:\\n return\\n\\n while freq < self.NOTES.min() or freq > self.NOTES.max():\\n while freq > self.NOTES.max():\\n self.NOTES *= 2\\n while freq < self.NOTES.min():\\n self.NOTES /= 2\\n tuning_freq = min(self.NOTES, key=lambda x: abs(x-freq))\\n return tuning_freq\",\n \"def getHeatFlux(self, T):\\n\\t\\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\\n\\t\\treturn Q\",\n \"def freq_defl_comp(fmax, p=75, p1=database['K+'], p2=database['pi+'],\\r\\n p3=database['p+'], L_t=79.6, l=2.74, E=1e6, plot=True,\\r\\n details=False, n=1000, delta_p=1.6e-2, fmin=0, just_pi=False):\\r\\n f_range = np.linspace(fmin, fmax, n)\\r\\n min_defl, d2, d3 = [], [], []\\r\\n for f in f_range:\\r\\n if just_pi == True:\\r\\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\\r\\n min_defl.append(d2[-1])\\r\\n if just_pi == False: \\r\\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\\r\\n d3.append(ang_deflection(p, f, p1, p3, L_t, l, E, delta_p))\\r\\n min_defl.append(np.min([d2[-1], d3[-1]]))\\r\\n if plot == True:\\r\\n fig = plt.figure(figsize=[9, 5])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n if details == True:\\r\\n ax.plot(f_range, d2, 'r', alpha=0.5, label=f'{p2.name} deflection')\\r\\n ax.plot(f_range, d3, 'b', alpha=0.5, label=f'{p3.name} deflection')\\r\\n else:\\r\\n ax.plot(f_range, min_defl, color=[1, 0, 1], alpha=0.5, label='min deflection')\\r\\n# ax.set_xlim(fmin, fmax)\\r\\n ax.set_ylim(0)\\r\\n ax.set_xlabel('Frequency / Hz', fontsize=20)\\r\\n text = r'$D_{'\\r\\n text += p2.name + '/' + p3.name\\r\\n text += '}$ / mrad'\\r\\n ax.set_ylabel(text, fontsize=20)\\r\\n ax.set_xscale('log')\\r\\n ax.legend(fontsize=20)\\r\\n plt.show()\\r\\n opt_freq = f_range[np.argmax(min_defl)]\\r\\n d_opt = (fmax-fmin)/1000\\r\\n d_opt_perc = (d_opt/opt_freq)*100\\r\\n if details == True:\\r\\n return 'optimum frequency = {0:.0f} +/- {1:.5f}%'.format(opt_freq, d_opt_perc)\\r\\n return opt_freq\",\n \"def totalInfilHorton1time(f0, fc, k, t):\\n numerator = (f0 - fc)*(1 - np.exp(-k*t))\\n Ft = (fc*t) + (numerator/k)\\n return Ft\",\n \"def get_frequency(self, c):\\n yield self.wm.write(\\\":READ:POW?\\\\r\\\\n\\\")\\n yield self.wm.write(\\\":READ:FREQ?\\\\r\\\\n\\\")\\n freq = yield self.wm.read_very_eager()\\n if freq != '':\\n\\n temp = freq.split()\\n temp = map(float,temp)\\n temp.sort()\\n if temp[len(temp)-1] >40.0:\\n freq = temp[len(temp)-1]\\n self.freq_changed((freq))\\n self.freq = freq\\n if temp[0] < 40.0:\\n amp = temp[0]\\n self.amp_changed((amp))\\n self.amp = amp\\n returnValue(self.freq)\",\n \"def derivert(f, k):\\r\\n \\r\\n return(k*f)\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def get_frequency(self, detune=0) -> float:\\n return np.power(2, (self._cents + detune)/1200) * 440\",\n \"def getKlauder(f,t,T=5.0):\\n assert len(f) == 2, 'Klauder wavelet needs 2 frequencies as input'\\n\\n k = np.diff(f)/T\\n f0 = np.sum(f)/2.0\\n wav = np.real(np.sin(pi*k*t*(T-t))/(pi*k*t)*np.exp(2*pi*1j*f0*t))\\n return wav\",\n \"def daily_temp(dft):\\n\\n tavg = (dft[\\\"T_Max\\\"] + dft[\\\"T_Min\\\"]) / 20 # tenths of degree C\\n return tavg\",\n \"def temperature_energy():\\n e = _si.e.value\\n k_B = _si.k_B.value\\n return Equivalency(\\n [(si.K, si.eV, lambda x: x / (e / k_B), lambda x: x * (e / k_B))],\\n \\\"temperature_energy\\\",\\n )\",\n \"def DFTct(x):\\n \\n N = len(x)\\n if N == 2:\\n return [x[0] + x[1], x[0] - x[1]]\\n \\n Half_N = int(N/2)\\n X = [0]*N\\n \\n Evens = DFTct([x[2*n] for n in range(Half_N)])\\n Odds = DFTct([x[2*n+1] for n in range(Half_N)])\\n \\n for k in range(Half_N):\\n a = 2*math.pi*k/N\\n w = Complex(math.cos(a), -math.sin(a))\\n E_k = Evens[k]\\n O_k = w*Odds[k]\\n X[k] = E_k + O_k\\n X[k + Half_N] = E_k - O_k\\n return X\",\n \"def dK_dtheta(self,dL_dK,X,X2,target):\\r\\n if X2 is None: X2 = X\\r\\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\\r\\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\\r\\n\\r\\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)), self.a[1]*self.basis_omega, self.a[2]*self.basis_omega**2, self.a[3]*self.basis_omega**3))\\r\\n Lo = np.column_stack((self.basis_omega, self.basis_omega, self.basis_omega, self.basis_omega))\\r\\n Lp = np.column_stack((self.basis_phi, self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\\r\\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\\r\\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\\r\\n\\r\\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\\r\\n F1lower = np.array(self._cos(self.basis_alpha*self.basis_omega,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n F2lower = np.array(self._cos(self.basis_alpha*self.basis_omega**2,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\\r\\n\\r\\n #dK_dvar\\r\\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dlen\\r\\n da_dlen = [-3*self.a[0]/self.lengthscale, -2*self.a[1]/self.lengthscale, -self.a[2]/self.lengthscale, 0.]\\r\\n db_dlen = [0., 4*self.b[1]/self.lengthscale, 2*self.b[2]/self.lengthscale, 2*self.b[3]/self.lengthscale, 2*self.b[4]/self.lengthscale]\\r\\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)), da_dlen[1]*self.basis_omega, da_dlen[2]*self.basis_omega**2, da_dlen[3]*self.basis_omega**3))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\\r\\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\\r\\n dGint_dlen = dGint_dlen + dGint_dlen.T\\r\\n dlower_terms_dlen = db_dlen[0]*np.dot(Flower,Flower.T) + db_dlen[1]*np.dot(F2lower,F2lower.T) + db_dlen[2]*np.dot(F1lower,F1lower.T) + db_dlen[3]*np.dot(F2lower,Flower.T) + db_dlen[4]*np.dot(Flower,F2lower.T)\\r\\n dG_dlen = 15*self.lengthscale**4/(400*np.sqrt(5))*Gint + 3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dlen + dlower_terms_dlen\\r\\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dper\\r\\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\\r\\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\\r\\n\\r\\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period, -self.a[2]*self.basis_omega**3/self.period, -self.a[3]*self.basis_omega**4/self.period))\\r\\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi,self.basis_phi+np.pi*3/2,self.basis_phi))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\\r\\n\\r\\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\\r\\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\\r\\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\\r\\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\\r\\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\\r\\n\\r\\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\\r\\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\\r\\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\\r\\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\\r\\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\\r\\n\\r\\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period, -2*self.a[2]*self.basis_omega**2/self.period, -3*self.a[3]*self.basis_omega**3/self.period))\\r\\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2, self.basis_phi+np.pi, self.basis_phi+np.pi*3/2))\\r\\n r2,omega2,phi2 = self._cos_factorization(dLa_dper2,Lo[:,0:2],dLp_dper2)\\r\\n\\r\\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\\r\\n dGint_dper = dGint_dper + dGint_dper.T\\r\\n\\r\\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n dF1lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower)+self._cos(-self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n dF2lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**3/self.period,self.basis_omega,self.basis_phi+np.pi*3/2)(self.lower) + self._cos(-2*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower))[:,None]\\r\\n\\r\\n dlower_terms_dper = self.b[0] * (np.dot(dFlower_dper,Flower.T) + np.dot(Flower.T,dFlower_dper))\\r\\n dlower_terms_dper += self.b[1] * (np.dot(dF2lower_dper,F2lower.T) + np.dot(F2lower,dF2lower_dper.T)) - 4*self.b[1]/self.period*np.dot(F2lower,F2lower.T)\\r\\n dlower_terms_dper += self.b[2] * (np.dot(dF1lower_dper,F1lower.T) + np.dot(F1lower,dF1lower_dper.T)) - 2*self.b[2]/self.period*np.dot(F1lower,F1lower.T)\\r\\n dlower_terms_dper += self.b[3] * (np.dot(dF2lower_dper,Flower.T) + np.dot(F2lower,dFlower_dper.T)) - 2*self.b[3]/self.period*np.dot(F2lower,Flower.T)\\r\\n dlower_terms_dper += self.b[4] * (np.dot(dFlower_dper,F2lower.T) + np.dot(Flower,dF2lower_dper.T)) - 2*self.b[4]/self.period*np.dot(Flower,F2lower.T)\\r\\n\\r\\n dG_dper = 1./self.variance*(3*self.lengthscale**5/(400*np.sqrt(5))*dGint_dper + 0.5*dlower_terms_dper)\\r\\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\\r\\n\\r\\n # np.add(target[:,:,0],dK_dvar, target[:,:,0])\\r\\n target[0] += np.sum(dK_dvar*dL_dK)\\r\\n #np.add(target[:,:,1],dK_dlen, target[:,:,1])\\r\\n target[1] += np.sum(dK_dlen*dL_dK)\\r\\n #np.add(target[:,:,2],dK_dper, target[:,:,2])\\r\\n target[2] += np.sum(dK_dper*dL_dK)\",\n \"def dK_dtheta(self,dL_dK,X,X2,target):\\r\\n if X2 is None: X2 = X\\r\\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\\r\\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\\r\\n\\r\\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega))\\r\\n Lo = np.column_stack((self.basis_omega,self.basis_omega))\\r\\n Lp = np.column_stack((self.basis_phi,self.basis_phi+np.pi/2))\\r\\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\\r\\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\\r\\n\\r\\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\\r\\n\\r\\n #dK_dvar\\r\\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dlen\\r\\n da_dlen = [-1./self.lengthscale**2,0.]\\r\\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)),da_dlen[1]*self.basis_omega))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\\r\\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\\r\\n dGint_dlen = dGint_dlen + dGint_dlen.T\\r\\n dG_dlen = 1./2*Gint + self.lengthscale/2*dGint_dlen\\r\\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dper\\r\\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\\r\\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\\r\\n\\r\\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period))\\r\\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\\r\\n\\r\\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\\r\\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\\r\\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\\r\\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\\r\\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\\r\\n\\r\\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\\r\\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\\r\\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\\r\\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\\r\\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\\r\\n\\r\\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period))\\r\\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2))\\r\\n r2,omega2,phi2 = dLa_dper2.T,Lo[:,0:1],dLp_dper2.T\\r\\n\\r\\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\\r\\n dGint_dper = dGint_dper + dGint_dper.T\\r\\n\\r\\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n\\r\\n dG_dper = 1./self.variance*(self.lengthscale/2*dGint_dper + self.b[0]*(np.dot(dFlower_dper,Flower.T)+np.dot(Flower,dFlower_dper.T)))\\r\\n\\r\\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\\r\\n\\r\\n target[0] += np.sum(dK_dvar*dL_dK)\\r\\n target[1] += np.sum(dK_dlen*dL_dK)\\r\\n target[2] += np.sum(dK_dper*dL_dK)\",\n \"def input_f(t,decay=0.5,freq=1.5):\\n u_t = 1*(t>0)\\n return np.cos(freq*t)*np.exp(-decay*t) * u_t\",\n \"def dK_dtheta(self,dL_dK,X,X2,target):\\r\\n if X2 is None: X2 = X\\r\\n FX = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X)\\r\\n FX2 = self._cos(self.basis_alpha[None,:],self.basis_omega[None,:],self.basis_phi[None,:])(X2)\\r\\n\\r\\n La = np.column_stack((self.a[0]*np.ones((self.n_basis,1)),self.a[1]*self.basis_omega,self.a[2]*self.basis_omega**2))\\r\\n Lo = np.column_stack((self.basis_omega,self.basis_omega,self.basis_omega))\\r\\n Lp = np.column_stack((self.basis_phi,self.basis_phi+np.pi/2,self.basis_phi+np.pi))\\r\\n r,omega,phi = self._cos_factorization(La,Lo,Lp)\\r\\n Gint = self._int_computation( r,omega,phi, r,omega,phi)\\r\\n\\r\\n Flower = np.array(self._cos(self.basis_alpha,self.basis_omega,self.basis_phi)(self.lower))[:,None]\\r\\n F1lower = np.array(self._cos(self.basis_alpha*self.basis_omega,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n\\r\\n #dK_dvar\\r\\n dK_dvar = 1./self.variance*mdot(FX,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dlen\\r\\n da_dlen = [-6/self.lengthscale**3,-2*np.sqrt(3)/self.lengthscale**2,0.]\\r\\n db_dlen = [0.,2*self.lengthscale/3.]\\r\\n dLa_dlen = np.column_stack((da_dlen[0]*np.ones((self.n_basis,1)),da_dlen[1]*self.basis_omega,da_dlen[2]*self.basis_omega**2))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dlen,Lo,Lp)\\r\\n dGint_dlen = self._int_computation(r1,omega1,phi1, r,omega,phi)\\r\\n dGint_dlen = dGint_dlen + dGint_dlen.T\\r\\n dG_dlen = self.lengthscale**2/(4*np.sqrt(3))*Gint + self.lengthscale**3/(12*np.sqrt(3))*dGint_dlen + db_dlen[0]*np.dot(Flower,Flower.T) + db_dlen[1]*np.dot(F1lower,F1lower.T)\\r\\n dK_dlen = -mdot(FX,self.Gi,dG_dlen/self.variance,self.Gi,FX2.T)\\r\\n\\r\\n #dK_dper\\r\\n dFX_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X ,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X)\\r\\n dFX2_dper = self._cos(-self.basis_alpha[None,:]*self.basis_omega[None,:]/self.period*X2,self.basis_omega[None,:],self.basis_phi[None,:]+np.pi/2)(X2)\\r\\n\\r\\n dLa_dper = np.column_stack((-self.a[0]*self.basis_omega/self.period, -self.a[1]*self.basis_omega**2/self.period, -self.a[2]*self.basis_omega**3/self.period))\\r\\n dLp_dper = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi,self.basis_phi+np.pi*3/2))\\r\\n r1,omega1,phi1 = self._cos_factorization(dLa_dper,Lo,dLp_dper)\\r\\n\\r\\n IPPprim1 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi/2))\\r\\n IPPprim1 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + 1./(omega-omega1.T)*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi/2))\\r\\n IPPprim2 = self.upper*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi/2) + self.upper*np.cos(phi-phi1.T))\\r\\n IPPprim2 -= self.lower*(1./(omega+omega1.T)*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi/2) + self.lower*np.cos(phi-phi1.T))\\r\\n #IPPprim2[0,0] = 2*(self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPprim = np.where(np.isnan(IPPprim1),IPPprim2,IPPprim1)\\r\\n\\r\\n IPPint1 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.upper+phi-phi1.T-np.pi)\\r\\n IPPint1 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./(omega-omega1.T)**2*np.cos((omega-omega1.T)*self.lower+phi-phi1.T-np.pi)\\r\\n IPPint2 = 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.upper+phi+phi1.T-np.pi) + 1./2*self.upper**2*np.cos(phi-phi1.T)\\r\\n IPPint2 -= 1./(omega+omega1.T)**2*np.cos((omega+omega1.T)*self.lower+phi+phi1.T-np.pi) + 1./2*self.lower**2*np.cos(phi-phi1.T)\\r\\n #IPPint2[0,0] = (self.upper**2 - self.lower**2)*np.cos(phi[0,0])*np.cos(phi1[0,0])\\r\\n IPPint = np.where(np.isnan(IPPint1),IPPint2,IPPint1)\\r\\n\\r\\n dLa_dper2 = np.column_stack((-self.a[1]*self.basis_omega/self.period, -2*self.a[2]*self.basis_omega**2/self.period))\\r\\n dLp_dper2 = np.column_stack((self.basis_phi+np.pi/2,self.basis_phi+np.pi))\\r\\n r2,omega2,phi2 = self._cos_factorization(dLa_dper2,Lo[:,0:2],dLp_dper2)\\r\\n\\r\\n dGint_dper = np.dot(r,r1.T)/2 * (IPPprim - IPPint) + self._int_computation(r2,omega2,phi2, r,omega,phi)\\r\\n dGint_dper = dGint_dper + dGint_dper.T\\r\\n\\r\\n dFlower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n dF1lower_dper = np.array(self._cos(-self.lower*self.basis_alpha*self.basis_omega**2/self.period,self.basis_omega,self.basis_phi+np.pi)(self.lower)+self._cos(-self.basis_alpha*self.basis_omega/self.period,self.basis_omega,self.basis_phi+np.pi/2)(self.lower))[:,None]\\r\\n\\r\\n dG_dper = 1./self.variance*(self.lengthscale**3/(12*np.sqrt(3))*dGint_dper + self.b[0]*(np.dot(dFlower_dper,Flower.T)+np.dot(Flower,dFlower_dper.T)) + self.b[1]*(np.dot(dF1lower_dper,F1lower.T)+np.dot(F1lower,dF1lower_dper.T)))\\r\\n\\r\\n dK_dper = mdot(dFX_dper,self.Gi,FX2.T) - mdot(FX,self.Gi,dG_dper,self.Gi,FX2.T) + mdot(FX,self.Gi,dFX2_dper.T)\\r\\n\\r\\n # np.add(target[:,:,0],dK_dvar, target[:,:,0])\\r\\n target[0] += np.sum(dK_dvar*dL_dK)\\r\\n #np.add(target[:,:,1],dK_dlen, target[:,:,1])\\r\\n target[1] += np.sum(dK_dlen*dL_dK)\\r\\n #np.add(target[:,:,2],dK_dper, target[:,:,2])\\r\\n target[2] += np.sum(dK_dper*dL_dK)\",\n \"def calc_dtdc(tpbpcs, specs):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n Nbs = len(np.hstack(tpbpcs[0]))\\n Ndraw = len(tpbpcs)\\n\\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\\n\\n for i in range(Ndraw):\\n\\n # Create array of times per bandpass\\n dtpb[i,:] = np.hstack(tpbpcs[i])\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def increaseFreq(self, desHz):\\n from scipy.interpolate import interp1d\\n import time\\n from numpy import linspace, floor\\n from decimal import getcontext, Decimal\\n\\n if desHz > 1000: # set max freq here \\n raise ValueError('Max Frequency is 1000 (3 decimal places)')\\n now = time.asctime(time.localtime(time.time())) \\n stamp = ''.join(['%% The following created by alog_manip.MOOSalog.MOOSalog.increaseFreq\\\\n%% ', now])\\n increase_msg = ''.join(['%% Resultant Frequency: ',str(desHz),' Hz'])\\n # hiHz = {}\\n self.outData = {} # erase pre-existing dict\\n self.outData['header'] = [stamp,increase_msg,'%%%%'] + self.srcData['header']\\n\\n def create_msgs():\\n \\\"\\\"\\\" Puts interpolated data into dict outData\\n Primary interpolation function for increaseFreq\\n Consider using uniaxial spline --> would have one function for all of dictionary dat\\n \\\"\\\"\\\"\\n getcontext().prec = 3 # will round to 3 decimal places\\n orig_times = sorted(dat)\\n for n in range(len(dat) - 1):\\n linfun = interp1d([orig_times[n], orig_times[n+1]], \\\\\\n [dat[orig_times[n]], dat[orig_times[n+1]]])\\n dt = orig_times[n+1] - orig_times[n] # current\\n freq = 1/dt # current\\n if dt < (1/desHz):\\n print('found instance where Freq already at/above desired Freq')\\n else:\\n new_dt = dt*freq/desHz\\n new_times = linspace(orig_times[n],orig_times[n+1],floor(dt/new_dt))\\n # print(new_times)\\n new_values = linfun(new_times)\\n # rounded_values = [float(Decimal(\\\"%.3f\\\" % e)) for e in new_values]\\n rounded_times = [float(Decimal(\\\"%.3f\\\" % e)) for e in new_times]\\n for m in range(len(rounded_times)):\\n # this_time = int(new_times[m]*100000)/100000 # 5 decimal places in timstamp\\n self.outData[sens][meas][rounded_times[m]] = new_values[m]\\n\\n ## go thru and pull out dictionaries {time: value} then send to interpolation func\\n for sens in self.srcData:\\n if sens is not 'header':\\n self.outData[sens] = {}\\n for meas in self.srcData[sens]:\\n self.outData[sens][meas] = {}\\n dat = self.srcData[sens][meas]\\n if len(dat) == 1:\\n self.outData[sens][meas] = dat # only 1 data point, no interp\\n else:\\n create_msgs()\",\n \"def filter_list_freq(lst, min_freq):\\r\\n arr = np.array(lst)\\r\\n items, count = np.unique(np.array(arr), return_counts=True)\\r\\n rem_items = items[count < min_freq]\\r\\n return [i for i in arr[~np.in1d(np.array(arr), rem_items)]]\",\n \"def DFT_slow(x):\\n x = np.asarray(x, dtype=float)\\n N = x.shape[0]\\n n = np.arange(N)\\n k = n.reshape((N, 1))\\n M = np.exp(-2j * np.pi * k * n / N)\\n return np.dot(M, x)\",\n \"def energy_Photon(freq=1.0,energy=0.0):\\n global r,c,h\\n if freq ==0:\\n print(\\\"enerji yok...\\\")\\n return 0\\n if energy != 0:\\n energy =energy\\n else:\\n energy = h*freq\\n getit =str(input(\\\"frekans bulmak istiyorsaniz f,yoksa bos gecin.\\\"))\\n if getit ==\\\"f\\\":\\n return ('%.2E' % Decimal(str(energy/h)))\\n return float('%.2E' % Decimal(str(energy)))\",\n \"def DFT(h, m, N=None):\\n # Check input params\\n assert np.all(np.array(m, dtype=int) == m), 'DFT: m should be an integer or an array of integers.'\\n if N is None:\\n warnings.warn('DFT: N not specified, assuming N is the length of h.')\\n N = len(h)\\n else:\\n assert int(N)==N, 'DFT: N should be an integer number.'\\n n = np.linspace(0, N-1, N)\\n # Construct array of e^-jwn where each row corresponds to a w value and each column corresponds to a n value\\n A = np.fromfunction(lambda i, j: np.exp(-1j*m[i.astype(int)]*2*np.pi*n[j.astype(int)]/N), shape=(len(m), N))\\n # Calculate sum over all n (0 to N-1) for each m\\n return np.dot(A, h[:N])\",\n \"def compute_dewpoint(t,h):\\n\\n tempC = (t-32)*5/9 #convert from deg F to deg C\\n rh = h/100\\n\\n b = 18.678\\n c = 257.14 #deg C\\n\\n gamma = math.log(rh)+(b*tempC)/(c+tempC)\\n tdp = c*gamma/(b-gamma)\\n\\n tdp_F = 9/5*tdp +32 #convert from deg C to deg F\\n\\n return tdp_F\",\n \"def illuminationEff(freq,fD, FFBW, dB_at_bw, feed_type):\\n theta0 = fD2angle(fD,units='degrees')\\n dtt = 0.1\\n theta = np.arange(0.0,theta0/2.0+dtt,dtt)\\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\\n theta = theta*math.pi/180.0\\n kern = np.sqrt(g)*np.tan(theta/2.0)\\n num = 32.0*(fD*integ.trapz(kern,dx=dtt*math.pi/180.0))**2\\n kern = g*np.sin(theta)\\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n\\n n_ill = num/den \\n return n_ill\",\n \"def _get_distance_by_least_frequency(get_freq, positions, forms):\\n if len(set(forms[positions])) < 2:\\n return 0\\n if len(positions) == 2:\\n return _get_trivial_distance(positions)\\n sorted_positions = np.array(sorted(positions))\\n freqs = [get_freq(f) for f in forms[sorted_positions]]\\n freq_sort = np.argsort(freqs)\\n idx = sorted_positions[freq_sort]\\n if idx.shape[0] >= 2:\\n not_first_pos = idx[idx != idx[0]]\\n if not_first_pos.shape[0] > 0:\\n end = not_first_pos[0]\\n return np.abs(end - idx[0]) + 1\\n return 0\",\n \"def zpkfreqz(z, p, k, worN=None):\\n if worN is None or isinstance(worN, int):\\n N = worN or 512\\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\\n else:\\n ws = worN\\n\\n h = []\\n for wk in ws:\\n zm1 = mp.exp(1j * wk)\\n numer = _prod([zm1 - t for t in z])\\n denom = _prod([zm1 - t for t in p])\\n hk = k * numer / denom\\n h.append(hk)\\n return ws, h\",\n \"def all_dhkl(self, crystal):\\n #d_min = self.wavelength/self.max2theta*pi/2\\n d_min = self.wavelength/sin(self.max2theta/2)/2\\n \\n # This block is to find the shortest d_hkl, \\n # for all basic directions (1,0,0), (0,1,0), (1,1,0), (1,-1,0) and so on, 26 in total \\n hkl_max = np.array([1,1,1])\\n for h1 in [-1, 0, 1]:\\n for k1 in [-1, 0, 1]:\\n for l1 in [-1, 0, 1]:\\n hkl_index = np.array([[h1,k1,l1]])\\n d = float(np.linalg.norm( np.dot(hkl_index, crystal.rec_matrix), axis=1))\\n if d>0:\\n multiple = 1/d/d_min\\n hkl_index *= round(multiple)\\n for i in range(len(hkl_max)):\\n if hkl_max[i] < hkl_index[0,i]:\\n hkl_max[i] = hkl_index[0,i]\\n #h1 = 2*ceil(np.linalg.norm(crystal.cell_para[0])/d_min)\\n #k1 = 2*ceil(np.linalg.norm(crystal.cell_para[1])/d_min)\\n #l1 = 2*ceil(np.linalg.norm(crystal.cell_para[2])/d_min)\\n h1, k1, l1 = hkl_max\\n h = np.arange(-h1,h1)\\n k = np.arange(-k1,k1)\\n l = np.arange(-l1,l1)\\n \\n hkl = np.array((np.meshgrid(h,k,l))).transpose()\\n hkl_list = np.reshape(hkl, [len(h)*len(k)*len(l),3])\\n hkl_list = hkl_list[np.where(hkl_list.any(axis=1))[0]]\\n d_hkl = 1/np.linalg.norm( np.dot(hkl_list, crystal.rec_matrix), axis=1)\\n #for ix, a in enumerate(hkl_list):\\n # if np.array_equal(a, np.array([1,-1,3])) is True:\\n # print(a)\\n # break\\n #\\n #print(ix, hkl_list[ix], d_hkl[ix], d_min)\\n\\n shortlist = d_hkl > (d_min)\\n d_hkl = d_hkl[shortlist]\\n hkl_list = hkl_list[shortlist]\\n sintheta = self.wavelength/2/d_hkl\\n\\n self.theta = np.arcsin(sintheta)\\n self.hkl_list = hkl_list\\n self.d_hkl = d_hkl\\n \\n #return hkl_list, d_hkl, sintheta\",\n \"def _convert_frequency(self, frequency):\\n\\n # Assert frequency lies within allowed range\\n FTW_step = self.clock_freq/2**32\\n FTW = round(frequency/FTW_step)\\n Min_freq = 0\\n Max_freq = (2**32-1)*FTW_step\\n\\n assert FTW >= 0, 'Minimum frequency is %r' %Min_freq\\n assert FTW <= 2**32, 'Maximum frequency is %r' %Max_freq\\n\\n # Compute frequency tuning word for given frequency and clock frequency\\n # Write FTW in list of 4 bytes (CFTW0 is a 32-bit register)\\n return [FTW.to_bytes(4, 'big')[i] for i in range(4)]\",\n \"def energy_due_to_vibrations(self, T, cf):\\n E = 0.0\\n for key, value in self.eci_per_kbT:\\n E += value * cf[key] * kB * T\\n return E\",\n \"def tconst_filter(freq, tau):\\n\\treturn 1/(2*np.pi*1j*freq*tau+1)\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\\n\\t\\t# Active K-rotor\\n\\t\\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\\n\\t\\tif len(rotors) == 0:\\n\\t\\t\\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\\n\\t\\t\\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\t# Other modes\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tQ0 = mode.getPartitionFunction(Tlist)\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\treturn Q\",\n \"def print_key_freq(self,\\r\\n freq_list):\\r\\n\\r\\n for key, freq in freq_list:\\r\\n\\r\\n display.noteprint((EMPTYCHAR,key + alerts.APPEARS_BEG\\\\\\r\\n +len(self.get_indexes_for_key(key)\\\\\\r\\n +alerts.APPEARS_END+freq)))\",\n \"def differentialFlux(energy,costheta):\\n p1 = 0.102573\\n p2 = -0.068287\\n p3 = 0.958633\\n p4 = 0.0407253\\n p5 = 0.817285\\n \\n costhetastar = sqrt((costheta**2+p1**2+p2*(costheta**p3)+p4*(costheta**p5))/(1.+p1**2+p2+p4))\\n twopointseven = energy*(1+3.64/(energy*(costhetastar**1.29)))\\n f = .140*(twopointseven**(-2.7))*((1./(1.+1.1*energy*costhetastar/115.))+0.054/(1.+1.1*energy*costhetastar/850.))\\n return f\",\n \"def temperature() -> FlowFieldVal:\\n return [\\n self._t_s - self._delta_t * tf.math.tanh(z / self._height) for z in zz\\n ]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66852283","0.6590223","0.621406","0.61375594","0.58432394","0.5664569","0.5585242","0.55327094","0.5501561","0.5434934","0.5308666","0.5281351","0.5243485","0.52303797","0.5228673","0.51834196","0.5166179","0.51437104","0.51344746","0.5100388","0.50891364","0.50871795","0.50506","0.50266427","0.5025682","0.5007211","0.4970855","0.4947168","0.49283898","0.49270785","0.49096927","0.4909228","0.49013168","0.48987934","0.48828694","0.48572713","0.48266554","0.48232922","0.4820647","0.48158488","0.48127052","0.48112804","0.4806182","0.4797003","0.4796484","0.47871062","0.47858426","0.47858325","0.47823417","0.4779515","0.47753152","0.47709513","0.47585082","0.4753459","0.4748847","0.47450042","0.47440997","0.47399485","0.47388896","0.47382015","0.47364774","0.47352314","0.47301415","0.4728981","0.4725802","0.47130427","0.4711975","0.471088","0.47091234","0.47067305","0.47036314","0.4701483","0.47000957","0.46997526","0.46964216","0.46914324","0.4691087","0.46841866","0.46796998","0.46727166","0.46712217","0.46660724","0.46566918","0.46560523","0.46552816","0.4651418","0.4649243","0.4643306","0.4636173","0.46360725","0.4635624","0.46355098","0.46336263","0.46254689","0.46246746","0.46133652","0.461309","0.46110848","0.46014816","0.4596922"],"string":"[\n \"0.66852283\",\n \"0.6590223\",\n \"0.621406\",\n \"0.61375594\",\n \"0.58432394\",\n \"0.5664569\",\n \"0.5585242\",\n \"0.55327094\",\n \"0.5501561\",\n \"0.5434934\",\n \"0.5308666\",\n \"0.5281351\",\n \"0.5243485\",\n \"0.52303797\",\n \"0.5228673\",\n \"0.51834196\",\n \"0.5166179\",\n \"0.51437104\",\n \"0.51344746\",\n \"0.5100388\",\n \"0.50891364\",\n \"0.50871795\",\n \"0.50506\",\n \"0.50266427\",\n \"0.5025682\",\n \"0.5007211\",\n \"0.4970855\",\n \"0.4947168\",\n \"0.49283898\",\n \"0.49270785\",\n \"0.49096927\",\n \"0.4909228\",\n \"0.49013168\",\n \"0.48987934\",\n \"0.48828694\",\n \"0.48572713\",\n \"0.48266554\",\n \"0.48232922\",\n \"0.4820647\",\n \"0.48158488\",\n \"0.48127052\",\n \"0.48112804\",\n \"0.4806182\",\n \"0.4797003\",\n \"0.4796484\",\n \"0.47871062\",\n \"0.47858426\",\n \"0.47858325\",\n \"0.47823417\",\n \"0.4779515\",\n \"0.47753152\",\n \"0.47709513\",\n \"0.47585082\",\n \"0.4753459\",\n \"0.4748847\",\n \"0.47450042\",\n \"0.47440997\",\n \"0.47399485\",\n \"0.47388896\",\n \"0.47382015\",\n \"0.47364774\",\n \"0.47352314\",\n \"0.47301415\",\n \"0.4728981\",\n \"0.4725802\",\n \"0.47130427\",\n \"0.4711975\",\n \"0.471088\",\n \"0.47091234\",\n \"0.47067305\",\n \"0.47036314\",\n \"0.4701483\",\n \"0.47000957\",\n \"0.46997526\",\n \"0.46964216\",\n \"0.46914324\",\n \"0.4691087\",\n \"0.46841866\",\n \"0.46796998\",\n \"0.46727166\",\n \"0.46712217\",\n \"0.46660724\",\n \"0.46566918\",\n \"0.46560523\",\n \"0.46552816\",\n \"0.4651418\",\n \"0.4649243\",\n \"0.4643306\",\n \"0.4636173\",\n \"0.46360725\",\n \"0.4635624\",\n \"0.46355098\",\n \"0.46336263\",\n \"0.46254689\",\n \"0.46246746\",\n \"0.46133652\",\n \"0.461309\",\n \"0.46110848\",\n \"0.46014816\",\n \"0.4596922\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75777584"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88354,"cells":{"query":{"kind":"string","value":"Return the heat capacity in J/molK at the given set of temperatures `Tlist` in K for the 1D hindered rotor with a frequency `freq` in cm^1 and a barrier height `barr` in cm^1."},"document":{"kind":"string","value":"def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)"},"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 hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr","def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy","def heat_capacity(r, phi, q, kT):\n pot = q*(phi - phi[0])\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\n c = np.trapz(np.exp(-pot/kT) * r, r)\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)","def harmonicOscillator_heatCapacity(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\n # low temperatures - high numbers\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)","def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_P_low *= (\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n )\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\n # low temperatures - high numbers\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)","def fuel_cond(T):\n\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\n \n return kc","def heatCapacity(self, Tk=None, Tc=None):\n Tk = getTk(Tc, Tk)\n self.checkPropertyTempRange(\"heat capacity\", Tk)\n return (\n sum(\n [\n +1.38642e-13 * Tk**4,\n -6.47481e-10 * Tk**3,\n +1.02345e-06 * Tk**2,\n -4.32829e-04 * Tk,\n +1.06133e00,\n ]\n )\n * 1000.0\n ) # kJ / kg K to J / kg K","def thermal(isatom, freq, scalfac,linnonlin,T):\n if isatom != \"true\":\n nfreq = len(freq)\n\n vib_temp = []\n for ifreq in range(nfreq):\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\n vib_temp.append(vib_temp_new)\n\n dE_vib = 0\n for ifreq in range(nfreq):\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\n\n dE_ZPE = 0.5 * sum(freq) * cmi2au\n\n if linnonlin == \"L\":\n dE_rot = kB * T * j2au\n elif linnonlin == \"NL\":\n dE_rot = kB * T * j2au * (3.0/2.0)\n else:\n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"ERROR: unknown entry for linear/nonlinear\")\n else:\n dE_ZPE = 0\n dE_vib = 0\n dE_rot = 0\n\n dE_tra = kB * T * j2au * (3.0/2.0)\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\n\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)","def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\n kB = 1.380658e-16\n h = 6.6260755e-27\n c = 29979245800.\n nu = freqGHz*1.e9\n x = h*nu/(kB*T0)\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\n cNu *= 1e23\n return cNu","def CMB_spec(eng, temp):\n if np.issubdtype(type(eng), float):\n eng = np.array([eng])\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\n\n if np.issubdtype(type(eng), float): \n return phot_spec_density[0] \n else: \n return phot_spec_density","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def get_freq_grid():\n (bins_per_octave, n_octaves, _, _, f_min, _) = get_hcqt_params()\n freq_grid = librosa.cqt_frequencies(\n bins_per_octave*n_octaves, f_min, bins_per_octave=bins_per_octave\n )\n return freq_grid","def get_kt(temps, delta_gibbs_ts):\n # rate coefficient from Eyring equation\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular","def thermodynamic_temperature(frequency, T_cmb=None):\n nu = frequency.to(si.GHz, spectral())\n\n if T_cmb is None:\n from astropy.cosmology import default_cosmology\n\n T_cmb = default_cosmology.get().Tcmb0\n\n def f(nu, T_cmb=T_cmb):\n x = _si.h * nu / _si.k_B / T_cmb\n return x**2 * np.exp(x) / np.expm1(x) ** 2\n\n def convert_Jy_to_K(x_jybm):\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\n astrophys.Jy\n )\n return x_jybm / factor\n\n def convert_K_to_Jy(x_K):\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\n si.K\n )\n return x_K / factor\n\n return Equivalency(\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\n \"thermodynamic_temperature\",\n {\"frequency\": frequency, \"T_cmb\": T_cmb},\n )","def add_clump_forming_kmers(counts, clumpFormingKmers):\n for kmer in counts:\n if counts[kmer] >= t:\n clumpFormingKmers.add(kmer)\n\n return clumpFormingKmers","def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\n pi, ids = induced_distribution(hmsm, 0, level)\n\n discrete_free_energy = np.ndarray(pi.shape)\n for i, id in enumerate(ids):\n discrete_free_energy[i] = \\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\n boltzmann = np.exp(-discrete_free_energy/kT)\n boltzmann *= (1/np.sum(boltzmann))\n return D_KL(boltzmann, pi)","def get_granule_frequency(self,r=None,ids=None):\n # Simply divide the length of each spike vector by the simulation time\n # or window time.\n spikes=[] # The local copy of spikes to get the frequency on\n try:\n spikes=self.get_granule_spikes(r,ids)\n if len(spikes)==0:\n raise Exception('Unable to get mitral cell spikes')\n except Exception:\n raise\n freqg=numpy.zeros(self.num_gran)\n timems=self.sim_time\n if type(r) is tuple and len(r)==2:\n timems=float(r[1]-r[0])\n for i in range(len(spikes)):\n freqg[i]=float(len(spikes[i]))*1000./timems\n return freqg","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n C_T = (\n 2 ** (1 / 4)\n * np.sqrt(gbar)\n / np.pi\n * np.sqrt(vv)\n * tt ** (5 / 4)\n * _1d_call(_fdk, y, k=1 / 2)\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\n )\n return C_T","def effective_temperature(R,times):\n T_eff = np.empty((len(R),times))\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \n for i in range (len(R)):\n for t in range(times): \n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\n return T_eff","def fcut(r, rcut, trans_width):\n if (isinstance(r, list) or isinstance(r, np.ndarray)) and len(r) > 1:\n return np.array([fcut(ri, rcut, trans_width) for ri in r])\n else:\n if r > rcut:\n return 0.\n elif r > rcut-trans_width:\n return 0.5*(np.cos(np.pi*(r-rcut+trans_width)/trans_width) + 1)\n else:\n return 1.0","def rebin_power_to_kms(kfkms, kfmpc, flux_powers, zbins, omega_m, omega_l = None):\n if omega_l is None:\n omega_l = 1 - omega_m\n nz = np.size(zbins)\n nk = np.size(kfmpc)\n assert np.size(flux_powers) == nz * nk\n velfac = lambda zz: 1./(1+zz) * 100.0* np.sqrt(omega_m * (1 + zz)**3 + omega_l)\n rebinned=[scipy.interpolate.interpolate.interp1d(kfmpc,flux_powers[ii*nk:(ii+1)*nk]) for ii in range(nz)]\n okmsbins = [kfkms[np.where(kfkms >= np.min(kfmpc)/velfac(zz))] for zz in zbins]\n flux_rebinned = [rebinned[ii](okmsbins[ii]*velfac(zz)) for ii, zz in enumerate(zbins)]\n return okmsbins, flux_rebinned","def volumetric_heat_capacity(temperature):\n a = -2.4083\n b = 7.6006\n c = -8.2982\n d = 7.3301\n e = -4.2386\n f = 1.4294\n g = -0.24396\n h = 0.015236\n i = 0.0\n log_t = math.log10(temperature)\n f_exp = a + b*log_t + c*log_t**2.0 + d*log_t**3.0 + e*log_t**4.0 + f*log_t**5.0 + g*log_t**6.0 + \\\n h*log_t**7.0 + i*log_t**8.0\n g10_cp = 10.0**f_exp\n return g10_cp * G10NISTMaterialProperties.density","def getMolarFluxes(self,T):\n\t\tsigma = 0.1 # Hertz-Knudsen condensation/evaporation coefficient\n\t\t# see doi:10.1103/PhysRevE.59.429\n\t\t# http://www.mie.utoronto.ca/labs/tkl/publications/WardFangExpress.pdf\n\t\tvp = self.getVaporPressures(T)\n\t\tmw = self.molar_masses*0.001 / 6.02E23 # mass of molecule in kg\n\t\tkb = 1.38E-23 # m^2 kg s^-2 K^-1 !!\n\t\tJe = vp / numpy.sqrt(2*numpy.pi * mw * kb * T) \n\t\treturn Je/ 6.02E23","def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for low temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n S_low = (\n -gbar\n * np.sqrt(2)\n / (6 * np.pi ** 2)\n * tt_low ** (3 / 2)\n * vv_low\n * (\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\n )\n )\n # low temperatures - high numbers\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((S_low, S_high)).reshape(y.shape)","def chemical_potential(T, pressure):\n import numpy as np\n\n kb = 1.38064852e-23 # Boltzmann constant (J K^{-1})\n planck = 6.62607004e-34 # Planck constant\n mass = 2.0 * 1.00784 * 1.6737236e-27 # Mass of H2 in Kg\n beta = 1.0 / (kb * T) # Thermodynamic beta\n\n # Thermal wavelength\n thermal_wav = planck * planck * beta / (2 * np.pi * mass)\n thermal_wav = thermal_wav ** (1/2.)\n\n # Calculate chemical potential \n chemical_pot = np.log(pressure * thermal_wav ** 3 * beta) * T\n \n return chemical_pot","def frequentist_MC(bolo_name, exposure):\n\n\thdata, file_data = PyRPl.open_ROOT_object(\"../ROOT_files/Axion/Spec/\" + bolo_name + \"_spec_perkeV.root\", \"h_\" + bolo_name)\n\tfmodel, file_model = PyRPl.open_ROOT_object(\"../ROOT_files/Axion/Model/\" + bolo_name + \"_model_perkeV.root\", bolo_name + \"_FidGamma\")\n\tfflux, file_flux = PyRPl.open_ROOT_object(\"../ROOT_files/Axion/CBRD_convolved/\" + bolo_name + \"_flux.root\", bolo_name + \"_flux_mass_0\")\n\n\t#Histograms parameters\n\tbin_X, min_X, max_X = hdata.GetNbinsX(), hdata.GetBinCenter(1) - 0.5*hdata.GetBinWidth(0), hdata.GetBinCenter(hdata.GetNbinsX()) + 0.5 * hdata.GetBinWidth(0)\n\n\tclass Flux:\n\t\tdef __call__( self, x, par ):\n\t\t\treturn exposure*fflux.Eval(x[0]) + par[0]\n\tnorm_flux = TF1(\"flux\", Flux(), min_X, max_X, 1)\n\tnorm_flux.SetParameter(0,0)\n\n\t#Create bckg model histo in c/keV\n\thbckg = TH1F(\"hbckg\", \"hbckg\", bin_X, min_X, max_X)\n\tfor i in range(1,bin_X+1) :\n\t\thbckg.SetBinContent(i, fmodel.Eval(hbckg.GetBinCenter(i)))\n\n\tfor gAe in [14, 0.5] :\n\t\tlist_result = []\n\t\tfor nsimu in range(100) :\n\t\t\tprint gAe, nsimu\n\t\t\t#Simulate fake data \n\t\t\thdata_sim = TH1F(\"hdata_sim\"+str(nsimu)+str(gAe), \"hdata_sim\"+str(nsimu)+str(gAe), bin_X, min_X, max_X)\n\t\t\tfor i in range(1, bin_X+1): \n\t\t\t\thdata_sim.SetBinContent(i, hbckg.GetBinContent(i) + np.random.poisson(np.power(gAe*1E-12,4)*norm_flux.Eval(hbckg.GetBinCenter(i))))\n\n\t\t\thdata_sim.SetLineColor(kRed)\n\t\t\t# hsignal.SetLineColor(kGreen-3)\n\t\t\thbckg.Draw()\n\t\t\thdata_sim.Add(hbckg,-1)\n\t\t\thdata_sim.Draw(\"same\")\n\t\t\tprint hdata_sim.Integral()*hdata_sim.GetBinWidth(10)\n\t\t\t# hsignal.Draw(\"same\")\n\t\t\traw_input()\n\n\t\t\t#Build likelihood\n\t\t\tclass likelihood_hist:\n\t\t\t\tdef __call__( self, x, par ):\n\t\t\t\t\tlikelihood =0\n\t\t\t\t\tfor i in range(1,bin_X+1):\n\t\t\t\t\t\tN_expected =hbckg.GetBinContent(i)+np.power(x[0]*1E-12,4)*norm_flux.Eval(hbckg.GetBinCenter(i)) #hsignal.GetBinContent(i)\n\t\t\t\t\t\tN_obs = hdata_sim.GetBinContent(i)\n\t\t\t\t\t\tif N_expected>0:\n\t\t\t\t\t\t\tlikelihood +=-N_expected+N_obs*np.log(N_expected)-log_factorial(N_obs)\n\t\t\t\t\treturn -(likelihood + par[0])\n\n\t\t\tnll = TF1(\"nll\", likelihood_hist(), 1E-2,1E3, 1)\n\t\t\tnll.SetParameter(0,0)\n\t\t\tlist_result.append(nll.GetMinimumX())\n\t\tpl.hist(list_result, histtype = \"step\", bins = 30)\n\t\tpl.show()\n\t\traw_input()\n\n\t# #Create signal histo in c/keV, gAe set to 1\n\t# hsignal = TH1F(\"hsignal\", \"hsignal\", bin_X, min_X, max_X)\n\t# for i in range(1, 301) :\n\t# \thsignal.SetBinContent(i, np.power(1E-12,4)*norm_flux.Eval(hsignal.GetBinCenter(i)))\n\n\t# hbckg.SetLineColor(kRed)\n\t# hsignal.SetLineColor(kGreen-3)\n\t# hbckg.Draw()\n\t# hdata.Draw(\"same\")\n\t# hsignal.Draw(\"same\")\n\t# raw_input()\n\n\n\n\t\n\n\traw_input()","def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # Bounds for harmonic oscillator frequencies\n for i in range(Nvib):\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # Bounds for pseudo-hindered rotor frequency and barrier height\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\n\n # Construct the initial guess\n # Initial guesses within each mode type must be distinct or else the\n # optimization will fail\n x0 = numpy.zeros(Nvib + 2, numpy.float64)\n # Initial guess for harmonic oscillator frequencies\n if Nvib > 0:\n x0[0] = 200.0\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\n # Initial guess for hindered rotor frequencies and barrier heights\n x0[Nvib] = 100.0\n x0[Nvib+1] = 300.0\n\n # Execute the optimization\n fit = PseudoRotorFit(Tlist, Cvlist, Nvib, Nrot)\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\n x, igo = fit.solve(x0)\n\n # Check that the results of the optimization are valid\n if not numpy.isfinite(x).all():\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\n if igo == 8:\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\n\n # Postprocess optimization results\n vib = list(x[0:Nvib])\n hind = []\n for i in range(Nrot):\n hind.append((x[Nvib], x[Nvib+1]))\n\n return vib, hind","def zpkfreqz(z, p, k, worN=None):\n if worN is None or isinstance(worN, int):\n N = worN or 512\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\n else:\n ws = worN\n\n h = []\n for wk in ws:\n zm1 = mp.exp(1j * wk)\n numer = _prod([zm1 - t for t in z])\n denom = _prod([zm1 - t for t in p])\n hk = k * numer / denom\n h.append(hk)\n return ws, h","def getPartitionFunction(self, Tlist):\n\t\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\n\t\t# Active K-rotor\n\t\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\n\t\tif len(rotors) == 0:\n\t\t\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\n\t\t\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\t# Other modes\n\t\tfor mode in self.modes:\n\t\t\tQ0 = mode.getPartitionFunction(Tlist)\n\t\t\tfor i in range(len(Tlist)):\n\t\t\t\tQ[i] *= Q0[i]\n\t\treturn Q","def gibbs_(dict_, T):\n\tdST = dict_['S298'] + CpT(dict_, T)[0]\n\t\t\n\tdHT = dict_['dH298'] + CpT(dict_, T)[1]/1000\n\t\t\n\treturn (dHT - T*dST/1000)","def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\n\n # Initialize constants.\n kT = kB * temperature\n gamma = collision_rate\n\n # Create a new custom integrator.\n super(GHMCIntegrator, self).__init__(timestep)\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addGlobalVariable(\"b\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\n self.addPerDofVariable(\"sigma\", 0)\n self.addGlobalVariable(\"ke\", 0) # kinetic energy\n self.addPerDofVariable(\"vold\", 0) # old velocities\n self.addPerDofVariable(\"xold\", 0) # old positions\n self.addGlobalVariable(\"Eold\", 0) # old energy\n self.addGlobalVariable(\"Enew\", 0) # new energy\n self.addGlobalVariable(\"accept\", 0) # accept or reject\n self.addGlobalVariable(\"naccept\", 0) # number accepted\n self.addGlobalVariable(\"ntrials\", 0) # number of Metropolization trials\n self.addPerDofVariable(\"x1\", 0) # position before application of constraints\n\n #\n # Pre-computation.\n # This only needs to be done once, but it needs to be done for each degree of freedom.\n # Could move this to initialization?\n #\n self.addComputePerDof(\"sigma\", \"sqrt(kT/m)\")\n\n #\n # Allow context updating here.\n #\n self.addUpdateContextState()\n\n #\n # Constrain positions.\n #\n self.addConstrainPositions()\n\n #\n # Velocity perturbation.\n #\n self.addComputePerDof(\"v\", \"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Metropolized symplectic step.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Eold\", \"ke + energy\")\n self.addComputePerDof(\"xold\", \"x\")\n self.addComputePerDof(\"vold\", \"v\")\n self.addComputePerDof(\"v\", \"v + 0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x + v*dt\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v + 0.5*dt*f/m + (x-x1)/dt\")\n self.addConstrainVelocities()\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Enew\", \"ke + energy\")\n self.addComputeGlobal(\"accept\", \"step(exp(-(Enew-Eold)/kT) - uniform)\")\n self.addComputePerDof(\"x\", \"x*accept + xold*(1-accept)\")\n self.addComputePerDof(\"v\", \"v*accept - vold*(1-accept)\")\n\n #\n # Velocity randomization\n #\n self.addComputePerDof(\"v\", \"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Accumulate statistics.\n #\n self.addComputeGlobal(\"naccept\", \"naccept + accept\")\n self.addComputeGlobal(\"ntrials\", \"ntrials + 1\")","def total_band_energy(vals, T, Ec):\n vals = np.sort(np.concatenate(vals))\n occup = occup_TK(vals, T=T, spin=2)\n return np.dot(vals, occup)-Ec","def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \n N_res=30):\n x_eps = 0.3 # shift from Dirac point\n x_res = 20\n kx_int = 0 + x_eps # -np.pi\n kx_fin = 4*np.pi/3 + x_eps\n Dx = (kx_fin - kx_int)/x_res\n\n y_res = 20\n ky_int = 0 # -np.pi\n ky_fin = 2*np.pi/np.sqrt(3)\n Dy = (ky_fin - ky_int)/y_res\n\n Nd = self.Nd # dimension of the Hamiltonian\n Dk = np.array([Dx,Dy], float)\n\n LF = np.zeros((Nd), dtype=complex)\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\n sumN = np.zeros((Nd), dtype=complex)\n E_k = np.zeros((Nd), dtype=complex)\n chernN = np.zeros((Nd), dtype=complex)\n\n # Loop over kx\n for ix in range(x_res):\n kx = kx_int + ix*Dx\n\n # Loop over ky\n for iy in range(y_res):\n ky = ky_int + iy*Dy\n\n k_vec = np.array([kx,ky], float)\n\n LF, E_k = self.latF(k_vec, Dk, self.delta)\n\n sumN += LF\n\n # # save data for plotting\n LF_arr[:,ix,iy] = LF.imag\n\n E_arr[:,ix,iy] = np.sort(E_k.real)\n\n # End of ky Loop\n # End of kx Loop\n\n chernN = sumN.imag/(2*np.pi)\n print(\"Chern number bands are (%.3f, %.3f) \" \n %(chernN[0], chernN[1]))\n print(\"Sum of all bands Chern Number is %.2f \" %(sum(chernN)))\n return chernN, E_arr\n #################### ","def gyroHF(self, GYRO, PFC):\n print(\"Calculating gyro orbit heat loads\")\n log.info(\"Calculating gyro orbit heat loads\")\n #get divertor HF\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\n #Get fractional multipliers for each helical trace\n gyroFrac = 1.0/GYRO.N_gyroPhase\n vPhaseFrac = 1.0/GYRO.N_vPhase\n vSliceFrac = GYRO.energyFracs\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\n Pgyro = np.zeros((GYRO.Nt))\n PNaN = 0.0\n sum=0\n sum1=0\n #loop through intersect record and redistribute power using multipliers\n for gyroPhase in range(GYRO.N_gyroPhase):\n for vPhase in range(GYRO.N_vPhase):\n for vSlice in range(GYRO.N_vSlice):\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\n notNanTo = notNanTo.astype(int) #cast as integer\n isNanTo = idx[np.isnan(idx)] #indices we map power to\n isNanTo = isNanTo.astype(int) #cast as integer\n\n if len(notNanFrom)>0:\n #multiple Froms can light up the same To, so we loop\n for i in range(len(notNanFrom)):\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\n\n if len(isNanFrom)>0:\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\n\n #print(\"\\nTEST2\")\n #print(GYRO.intersectRecord[0,0,0,1711])\n #print(Pgyro[1711])\n\n GYRO.gyroPowMatrix += Pgyro\n GYRO.gyroNanPower += PNaN\n return","def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\n\n # def Q_gen(I, R):\n # w = I * I * R\n # return w\n\n # def Q_rad_in(I_sun, A_s, a_s):\n # w = I_sun * D * a_s\n # return w\n\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\n # w = htcoeff * A_s * (T_line - T_amb)\n # return w\n\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\n # return w\n\n def reynolds(V, D, v, Mair=1.103):\n r = V * D / v\n return r\n\n def nusselt(Re, Pr):\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\n c = (Re / 282000) ** (5.0/8.0)\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\n return n\n\n def air_prop(T_amb):\n # temp v k Pr\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\n [250, 11.44e-6, 22.3e-3, 0.720],\n [300, 15.89e-6, 26.3e-3, 0.707],\n [350, 20.92e-6, 30.0e-3, 0.700],\n [400, 26.41e-6, 33.8e-3, 0.690],\n [450, 32.39e-6, 37.3e-3, 0.686],\n [500, 38.79e-6, 40.7e-3, 0.684],\n [550, 45.57e-6, 43.9e-3, 0.683],\n [600, 52.69e-6, 46.9e-3, 0.685]])\n\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\n 0, air_prop[:,1:])\n return v, k, Pr\n\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\n if 273 <= T_line <= 323:\n R = ((R_lo + \n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\n *(T_line - T_range[0]))/N_cond)\n elif T_line > 323:\n R = ((R_mid + \n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\n *(T_line - T_range[1]))/N_cond)\n else:\n R = R_lo\n print('Out of bounds')\n return R\n\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\n temp_factor = 1\n wind_factor = 1\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\n\n T_amb = T_amb*temp_factor\n V = V*wind_factor\n\n v, k, Pr = air_prop(T_amb)\n Re = reynolds(V, D, v)\n htcoeff = nusselt(Re, Pr) * k / D\n\n def T_line(T_init):\n \n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\n print R\n\n C4 = e_s * sigma * D * math.pi\n C3 = 0.0\n C2 = 0.0\n C1 = htcoeff * D * math.pi\n C0 = - ( I ** 2 * R\n + I_sun * a_s * D\n + htcoeff * D * math.pi * T_amb\n + e_s * D * math.pi * sigma * (T_amb ** 4))\n\n return np.roots([C4, C3, C2, C1, C0])\n\n T_c = T_amb\n \n for i in range(n_iter):\n T_arr = T_line(T_c)\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\n print T_c\n\n return T_c","def compute_energy_density(kT):\n h=u.planck\n c=u.speed_of_light\n pi=np.pi\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)","def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\n\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\n\td = dist * 1e3 * pc\n\t# Radius (in unit of pc)\n\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\n\t# Mass\n\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\n\t# Number density\n\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\n\t# Sigmav of 2.33H\n\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\n\t# Virial\n\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\n\t# Virial parameter with B-field, assume 1 mG\n\tB = 1 * 1e-3 # G\n\trho = density * 2.8 * mp # g/cm3\n\talfven = B / np.sqrt(4*np.pi*rho)\n\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\n\n\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B","def clumps_finding(text, k, t, L):\n frequent_patterns = []\n clumps = [0 for i in range(0, 4**k)]\n for i in range(0, len(text) - L + 1):\n subtext = text[i:i + L]\n freq_array = compute_freq(subtext, k)\n for index, freq in enumerate(freq_array):\n if freq >= t:\n clumps[index] = 1\n for index, clump in enumerate(clumps):\n if clump == 1:\n pattern = number_to_pattern(index, k)\n frequent_patterns.append(pattern)\n return frequent_patterns","def makeRecombMapBooker(snplist, rholist, chrom):\n if chrom == \"X\":\n mapsize = 44.7\n elif chrom == \"3R\":\n mapsize = 90.9\n elif chrom == \"3L\":\n mapsize = 89.1\n elif chrom == \"2L\":\n mapsize = 63.2\n elif chrom == \"2R\":\n mapsize = 94.8\n elif chrom == \"2RL\":\n mapsize = 158\n elif chrom == \"3RL\":\n mapsize = 180\n poslist = []\n rhocum = []\n cMlist = []\n cMMblist = []\n for i, pos in enumerate(snplist):\n if i == 0:\n rhoTemp = (rholist[i] * (pos))\n else:\n rhoTemp = (rholist[i] * (pos - snplist[i-1]))\n if i == 0:\n rhocum.append(rhoTemp)\n else:\n rhocum.append(rhocum[-1] + rhoTemp)\n poslist.append(pos)\n for i, j in enumerate(rhocum):\n cMperSNP = (j / rhocum[-1])\n cMlist.append(cMperSNP)\n cMMblist.append(((cMlist[i] - cMlist[i-1])*mapsize) / ((snplist[i] - snplist[i-1])/1E6))\n return(poslist, cMMblist, cMlist)","def get_hbls_hbbl(self):\n [Ly,N] = self.b.shape\n z_u_w = self.grid_dict['z_u_w']\n z_u_r = self.grid_dict['z_u_r']\n u = self.u\n v = self.v\n \n v_upts = TTTW_func.v2u(v)\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\n\n\n\n # CALCULATE swr_frac\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\n\n\n # WHOLE THING HAPPENS IN j loop through y-indices\n \n # INITIALIZE ARRAYS\n self.kmo = np.zeros([Ly])\n self.Cr = np.zeros([Ly])\n self.kbl = np.empty([Ly],dtype='int')\n self.C_h_MO = np.zeros([Ly])\n self.Cr = np.zeros([Ly,N+1]) # sum term\n self.FC = np.zeros([Ly,N+1])\n self.swdk_r = np.zeros([Ly,N+1])\n \n self.zscale = np.zeros([Ly,N])\n self.Kern = np.zeros([Ly,N])\n\n \n # --> LOOP THROUGH Y-INDICES\n for j in range(Ly):\n if self.LIMIT_MO_DEPTH:\n self.kmo[j] = 0\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\n \n self.kbl[j] = 0\n self.Cr[j,-1] = 0 # set top Cr\n self.Cr[j,0] = 0 # set bottom Cr\n \n # SEARCH FOR MIXED LAYER DEPTH\n self.FC[j,-1] = 0.\n\n\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\n for k in range(N-1,0,-1):\n # INDEX MAP\n k_r = k-1\n k_w = k\n\n \n zscale = z_u_w[j,N] - z_u_r[j,k_r]\n self.zscale[j,k_w] = zscale\n if self.LMD_KPP:\n if self.LMD_BKPP:\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\n else:\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\n else:\n Kern = 1.\n \n\n\n self.Kern[j,k_w] = Kern\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\n\n\n #\t\tLOOP THAT FINDS BL DEPTH ##\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \n \n if self.LMD_KPP:\n #swdk_r only used in this function so don't need to be class attribute\n # but for testing make it an attribute to see what it is\n \n # fortran equivlanet ===> k=N,1,-1 \n for k in range(N,0,-1):\n # INDEX MAP\n k_r = k-1\n k_w = k\n\n ###################################################################### \n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\n \n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\n \n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\n \t\t\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\n \n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\n \n\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\n \n\n #######################################################################\n \n # SEARCH FOR hbls vertical level #\n '''\n kbl is specified at vertical w-level (via Cr which is at\n vertical w-levels)\n '''\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\n self.kbl[j] = k_w\n if self.LIMIT_MO_DEPTH:\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\n self.kmo[j] = k_w\n\n \n #--> still in j-loop\n #######################################################\n \n # \t\tGET SURFACE BOUNDARY LAYER DEPTH # \n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\n if self.kbl[j] > 0:\n k_w = self.kbl[j]\n k_r = k_w - 1 \n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\n \n else:\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\n \n if self.LIMIT_MO_DEPTH:\n if self.kmo[j] > 0:\n k_w = self.kmo[j]\n k_r = k_w-1\n if k_w == N:\n z_up = z_u_w[j,N]\n cff_up = np.max([0,Bo[j]])\n else:\n z_up = z_r[j,k_w+1]\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\n \n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\n + self.C_h_MO[j] * (cff_dn - cff_up)\n\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\n\n\n\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\n if self.LMD_BKPP:\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\n self.Cr[j,0] = 0.\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\n \n #---> LOOP BOTTOM TO TOP\n # FIND kbl for BBL\n for k in range(1,N+1):\n k_r = k-1\n k_w = k \n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\n \n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\n self.kbl[j] = k_w \n \n\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\n if self.kbl[j] > 0 :\n k_w = self.kbl[j] \n k_r = k_w -1\n if k_w == 1: # NO BBL CASE\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\n else:\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]","def specCoeffsInReaction(r):\n c = []\n for k in range(__data.nsp):\n nu = (__data.g.product_stoich_coeff(k,r) -\n __data.g.reactant_stoich_coeff(k,r))\n if (nu <> 0):\n c.append((__data.g.species_name(k),nu))\n return c","def mfccInitFilterBanks(fs, nfft):\n\n # filter bank params:\n lowfreq = 133.33\n linsc = 200/3.\n logsc = 1.0711703\n numLinFiltTotal = 13\n numLogFilt = 27\n\n if fs < 8000:\n nlogfil = 5\n\n # Total number of filters\n nFiltTotal = numLinFiltTotal + numLogFilt\n\n # Compute frequency points of the triangle:\n freqs = numpy.zeros(nFiltTotal+2)\n freqs[:numLinFiltTotal] = lowfreq + numpy.arange(numLinFiltTotal) * linsc\n freqs[numLinFiltTotal:] = freqs[numLinFiltTotal-1] * logsc ** numpy.arange(1, numLogFilt + 3)\n heights = 2./(freqs[2:] - freqs[0:-2])\n\n # Compute filterbank coeff (in fft domain, in bins)\n fbank = numpy.zeros((nFiltTotal, nfft))\n nfreqs = numpy.arange(nfft) / (1. * nfft) * fs\n\n for i in range(nFiltTotal):\n lowTrFreq = freqs[i]\n cenTrFreq = freqs[i+1]\n highTrFreq = freqs[i+2]\n\n lid = numpy.arange(numpy.floor(lowTrFreq * nfft / fs) + 1, numpy.floor(cenTrFreq * nfft / fs) + 1, dtype=numpy.int)\n lslope = heights[i] / (cenTrFreq - lowTrFreq)\n rid = numpy.arange(numpy.floor(cenTrFreq * nfft / fs) + 1, numpy.floor(highTrFreq * nfft / fs) + 1, dtype=numpy.int)\n rslope = heights[i] / (highTrFreq - cenTrFreq)\n fbank[i][lid] = lslope * (nfreqs[lid] - lowTrFreq)\n fbank[i][rid] = rslope * (highTrFreq - nfreqs[rid])\n\n return fbank, freqs","def rcfilter_C(freq, R):\n R = _normalizevalue(R)\n C = 1/(R*freq*2*math.pi)\n return _Cap(C)","def get_quantum_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n f = 0\n for m in self.input.structure.get_masses():\n hbar_omega = (\n HBAR\n * np.sqrt(self.input.spring_constant / m)\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\n )\n f += (3.0 / 2) * hbar_omega + (\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\n )\n return f","def calculate_bandwidth(self, complist):\n\n self.type = complist[0]\n self.spot = complist[2]\n self.value = complist[1]\n self.fail = False\n\n if self.spot == \"1\" or self.spot == \"2\":\n # print \"Calculation if Loop 1st filter\"\n if self.type == \"C\":\n if self.c1 == 0:\n self.c1 = self.value\n else:\n self.fail = True\n else:\n if self.r1 == 0:\n self.r1 = self.value\n else:\n self.fail = True\n\n if self.spot == \"3\" or self.spot == \"4\":\n # print \"Calculation if loop 2nd filter\"\n if self.type == \"C\":\n if self.c2 == 0:\n self.c2 = self.value\n else:\n self.fail = True\n else: #self.type == \"R\"\n if self.r2 == 0:\n self.r2 = self.value\n else:\n self.fail = True\n\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\n #print \"hello!\"\n cf_low = str(cf_low)\n self.cutoff_freql = cf_low\n self.cutoff_freql_text = cf_low + \"K\"\n print self.cutoff_freql_text\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\n cf_high = str(cf_high)\n self.cutoff_freqh = cf_high\n self.cutoff_freqh_text = cf_high + \"K\"\n print self.cutoff_freqh_text\n voltage_change = float((self.r2)/self.r1)\n voltage = 5 + voltage_change\n self.voltage = str(voltage)\n print self.voltage","def mfccInitFilterBanks(fs, nfft):\n # filter bank params:\n lowfreq = 133.33\n linsc = 200/3.\n logsc = 1.0711703\n numLinFiltTotal = 13\n numLogFilt = 27\n\n if fs < 8000:\n nlogfil = 5\n\n # Total number of filters\n nFiltTotal = numLinFiltTotal + numLogFilt\n\n # Compute frequency points of the triangle:\n freqs = np.zeros(nFiltTotal+2)\n freqs[:numLinFiltTotal] = lowfreq + np.arange(numLinFiltTotal) * linsc\n freqs[numLinFiltTotal:] = freqs[numLinFiltTotal-1] * logsc ** np.arange(1, numLogFilt + 3)\n heights = 2./(freqs[2:] - freqs[0:-2])\n\n # Compute filterbank coeff (in fft domain, in bins)\n fbank = np.zeros((nFiltTotal, nfft))\n nfreqs = np.arange(nfft) / (1. * nfft) * fs\n\n for i in range(nFiltTotal):\n lowTrFreq = freqs[i]\n cenTrFreq = freqs[i+1]\n highTrFreq = freqs[i+2]\n\n lid = np.arange(np.floor(lowTrFreq * nfft / fs) + 1,\n np.floor(cenTrFreq * nfft / fs) + 1,\n dtype=np.int)\n lslope = heights[i] / (cenTrFreq - lowTrFreq)\n rid = np.arange(np.floor(cenTrFreq * nfft / fs) + 1,\n np.floor(highTrFreq * nfft / fs) + 1,\n dtype=np.int)\n rslope = heights[i] / (highTrFreq - cenTrFreq)\n fbank[i][lid] = lslope * (nfreqs[lid] - lowTrFreq)\n fbank[i][rid] = rslope * (highTrFreq - nfreqs[rid])\n\n return fbank, freqs","def mce_filter(freq, f_raw, params):\n\tz = np.exp(-2j*np.pi*freq/f_raw)\n\tb11, b12, b21, b22 = np.array(params[:4])*0.5**14\n\tH = (1+z)**4 / (1-b11*z+b12*z**2) / (1-b21*z+b22*z**2)\n\tH /= 2**4 / (1-b11+b12) / (1-b21+b22)\n\treturn H","def coolingrate(tables, density, He_mass_frac=0.258, metallicity=0.25):\n # list of all elements in table\n elements = [\n x for x in tables.keys() if x not in [\n 'Header', 'Metal_free', 'Solar', 'Total_Metals']\n ]\n \n # Helium mass fraction bins of only hydrogen and helium\n metal_free_He_mass_frac = list(\n tables['Metal_free']['Helium_mass_fraction_bins']\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of /Metal_free/Hydrogen_density_bins, \n # /Metal_free/Temperature_bins, and helium abundance.\n metal_free_ne_nh = list(\n tables['Metal_free']['Electron_density_over_n_h']\n )\n \n # Find index of He mass frac, ssuming direct match in table.\n He_mass_frac_index = metal_free_He_mass_frac.index(np.float32(He_mass_frac))\n # Find index of density bin, ssuming direct match in table.\n abundance_index = list(\n tables[elements[0]]['Hydrogen_density_bins']).index(np.float32(density)\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of temperature at given denisty and helium mass fraction.\n metal_free_ne_nh = list(\n tables['Metal_free']\\\n ['Electron_density_over_n_h']\\\n [He_mass_frac_index, :,abundance_index]\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of temperature at given density for solar abundance.\n solar_ne_nh = tables['Solar']\\\n ['Electron_density_over_n_h']\\\n [:, abundance_index]\n\n # Normalized net cooling rate for only hydrogen and helium as a function of \n # /Metal_free/Hydrogen_density_bins, /Metal_free/Temperature_bins, \n # and helium abundance. \n lambda_metal_free = tables['Metal_free']\\\n ['Net_Cooling']\\\n [He_mass_frac_index, :, abundance_index]\n \n # Temperature bins (T [K])\n T = tables['Metal_free']['Temperature_bins']\n \n sum_metals = np.zeros(352)\n for e in elements:\n # Normalized, net cooling rate e as a function of temperature for \n # Hydrogen density 'density'.\n lambda_i_solar = tables[e]['Net_Cooling'][:,abundance_index]\n \n # Calulating the cooling contribution of element e and addind to total.\n sum_metals += lambda_i_solar*(metal_free_ne_nh/solar_ne_nh)*metallicity\n \n coolingrate = lambda_metal_free + sum_metals\n \n return T, coolingrate","def doCalculation(self, E1, E2, muL, muR, T, pot, C, TCalc, Density, E0, L):\n NEcut = len(E1) #we determine the number of single-particle states that we use\n VG=np.diag(pot)\n E= int(0.5*np.size(VG))\n V = VG[0:E] #since the potential of both barriers is symmetric and we only tunnel through one barrier. Therefore we only use one half of the potential.\n dx= L/(np.size(pot))\n\n #Following prints are for debugging purposes:\n #print(\"---------------------------------------------------------------------\")\n #print(\"---------------------------------------------------------------------\")\n #print(\"Hier beginnt die Ausgabe von Rates:\")\n #print(\"---------------------------------------------------------------------\")\n #print(\"V:\", V)\n #print(\"E1:\", E1)\n #print(\"E2:\", E2)\n #print(\"C:\", C)\n\n kB=0.08629 #Boltzmann constant in meV/K\n \n \n def fermi(E,mu,T):\n \"\"\"This fermi-function tells us with which likelyhood a state with an E is occupied on the lead.\n E(float): energy difference between the initial and the final state that the tunneling electron has to carry.\n mu(float): chemical potential of either drain(muR) or source(muL).\n T(float): temperature.\n \"\"\"\n if (E-mu)/T > 600:\n f=0\n\t\t\t\t\n else:\n f=1/(math.exp((E-mu)/(kB*T) )+1)\n return(f)\n \n\n\t#This function is called by the Gamma_ij-equations and includes the transmission-coefficient for each tunnelling-event\n #and the density of state function of the source and drain. \n def Gamma(Ea,Eb,V):\n \"\"\":math:`\\\\Gamma` includes the transmission coefficient and DOS: :math:`\\Gamma = | t |^2 * DOS`\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n V(np.array): barrier potential\n \"\"\"\n #print(Ea)\n #print(V)\n return (np.absolute(TCalc.calculate_transmission(Ea,V,dx))**2*Density.calculate_DensityofStates(np.absolute(Ea-Eb)))\n \n #These next four functions are used to calculate the transition rates.Each function for a different kind of transition:\n #We distinguish between transitions, in which the number of electrons on the dot changes from one to two(Gamma_12) and reverse(Gamma_21).\n #And between transitions in which the number of electrons on the dot change from zero to one(Gamma_01) and reverse(Gamma_10).\n\n def Gamma_12(Ea,Eb,mu,T):\n \"\"\"Calculates the rate of a transition from a one body state to a two body state.\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n summe=0\n j=0\n Cb=C[np.where(E2==Eb)[0][0]]\n while j< NEcut:\n summe=Cb[np.where(E1==Ea)[0][0]][j]+summe\n j=j+1\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*fermi((Eb-Ea),mu,T))\n\n\n def Gamma_01(Eb,mu,T):\n \"\"\"Calculates the transition rate from the vacuum state to a one-body state.\n\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n return(Gamma(E0,Eb,V)*fermi((Eb-E0),mu,T))\n\n def Gamma_21(Ea,Eb,mu,T):\n \"\"\"Calculates the rate of a transition from a two body state to a one body state.\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n summe=0\n nu=0\n Ca=C[np.where(E2==Ea)[0][0]]\n while nu < NEcut:\n summe=summe+Ca[np.where(E1==Eb)[0][0]][nu]\n nu=nu+1\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*(1-fermi((Ea-Eb),mu,T)))\n\n def Gamma_10(Ea,mu,T):\n \"\"\"Calculates the rate of a transition from a one body state to the vacuum state.\n\n Ea(float): energy of initial state \n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n return(Gamma(Ea,E0,V)*(1-fermi((Ea-E0),mu,T)))\n\n #creating the output matrices that later contain all the transition rates through either\n #the left or the right barrier\n Gamma_R=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\n Gamma_L=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\n\n #using a loop to fill the output matrices with transition rates.\n i_=0\n for i in E1:\n j_=0\n for j in E2:\n Gamma_L[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muL,T)\n Gamma_L[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muL,T)\n Gamma_R[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muR,T)\n Gamma_R[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muR,T)\n j_=j_+1\n Gamma_L[0][i_+1]=Gamma_10(i,muL,T)\n Gamma_R[0][i_+1]=Gamma_10(i,muR,T)\n Gamma_L[i_+1][0]=Gamma_01(i,muL,T)\n Gamma_R[i_+1][0]=Gamma_01(i,muR,T)\n i_=1+i_\n\n #print(\"Gamma_L und Gamma_R:\")\n #print(Gamma_L,Gamma_R)\n #print(\"-----------------------------------------------------------------------\")\n #print(\"---------------------------------------------------------------------\")\n return(Gamma_L,Gamma_R)","def GetGC(flanks):\n gc = 0\n total = 0\n for i in flanks:\n if i != \"N\":\n total += 1\n if i == \"C\" or i == \"G\": gc += 1\n return gc*1.0/total","def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq / 700.0))","def makedtimes(in_list,bucket,date,radar):\n s = pd.Series(in_list)\n split_s = s.str.split(bucket + date.strftime('/%Y/%m/%d/') + radar + '/' + radar+date.strftime('%Y%m%d_'),expand=True)\n split_s = split_s[1]\n counts = split_s.str.len()\n if date < np.datetime64('2007-12-31'):\n version = '.gz'\n min_count = 9.0\n elif date < np.datetime64('2015-12-31'):\n version = '_V06'\n min_count = 13\n else:\n min_count=10.0\n if radar[0]=='K':\n version = '_V06'\n elif radar[0] =='T':\n version = '_V08'\n split_s = split_s.str.split(version,expand=True)\n split_s = split_s[0]\n dtime = pd.to_datetime(date.strftime('%Y-%m-%d ')+ split_s).values\n df = pd.DataFrame(in_list,index=dtime)\n\n df['counts'] = pd.Series(counts.values,index=dtime)\n df = df.where(df.counts == min_count).dropna()\n df = df.drop('counts',axis=1)\n return df","def __init__(self, temperature=298.0 * simtk.unit.kelvin, nsteps=10, timestep=1 * simtk.unit.femtoseconds):\n\n super(HMCIntegrator, self).__init__(timestep)\n\n # Compute the thermal energy.\n kT = kB * temperature\n\n #\n # Integrator initialization.\n #\n self.addGlobalVariable(\"naccept\", 0) # number accepted\n self.addGlobalVariable(\"ntrials\", 0) # number of Metropolization trials\n\n self.addGlobalVariable(\"kT\", kT) # thermal energy\n self.addPerDofVariable(\"sigma\", 0)\n self.addGlobalVariable(\"ke\", 0) # kinetic energy\n self.addPerDofVariable(\"xold\", 0) # old positions\n self.addGlobalVariable(\"Eold\", 0) # old energy\n self.addGlobalVariable(\"Enew\", 0) # new energy\n self.addGlobalVariable(\"accept\", 0) # accept or reject\n self.addPerDofVariable(\"x1\", 0) # for constraints\n\n #\n # Pre-computation.\n # This only needs to be done once, but it needs to be done for each degree of freedom.\n # Could move this to initialization?\n #\n self.addComputePerDof(\"sigma\", \"sqrt(kT/m)\")\n\n #\n # Allow Context updating here, outside of inner loop only.\n #\n self.addUpdateContextState()\n\n #\n # Draw new velocity.\n #\n self.addComputePerDof(\"v\", \"sigma*gaussian\")\n self.addConstrainVelocities()\n\n #\n # Store old position and energy.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Eold\", \"ke + energy\")\n self.addComputePerDof(\"xold\", \"x\")\n\n #\n # Inner symplectic steps using velocity Verlet.\n #\n for step in range(nsteps):\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m\")\n self.addComputePerDof(\"x\", \"x+dt*v\")\n self.addComputePerDof(\"x1\", \"x\")\n self.addConstrainPositions()\n self.addComputePerDof(\"v\", \"v+0.5*dt*f/m+(x-x1)/dt\")\n self.addConstrainVelocities()\n\n #\n # Accept/reject step.\n #\n self.addComputeSum(\"ke\", \"0.5*m*v*v\")\n self.addComputeGlobal(\"Enew\", \"ke + energy\")\n self.addComputeGlobal(\"accept\", \"step(exp(-(Enew-Eold)/kT) - uniform)\")\n self.addComputePerDof(\"x\", \"x*accept + xold*(1-accept)\")\n\n #\n # Accumulate statistics.\n #\n self.addComputeGlobal(\"naccept\", \"naccept + accept\")\n self.addComputeGlobal(\"ntrials\", \"ntrials + 1\")","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def add_energy(self, T=0, beta=0, Mkep=0, mu=1, gamma=5/3., Tmin=0., AU=1):\n \n if self.npart == 0:\n self.u = array([])\n return\n\n print(' Adding temperature...')\n\n radii = norm(self.pos - self.center, axis=1)\n \n if T < 0:\n print(' Setting Temperature according to c_s(r)**2, with c_s(r) = h * v_kep(r),')\n if not hasattr(self, 'v_kep'): self.v_kep = sqrt(Mkep * G / radii)\n c_s = self.h * self.v_kep\n if gamma <= 0: gamma_cs = 1\n else: gamma_cs = gamma\n if mu <= 0:\n if gamma == 1.4: mu_cs = 2.01 # Adiabatic molecular\n else: mu_cs = 1.005 # Adiabatic/Isothermal atomic\n\n print(' using gamma = {:.3f}, and mu = {:.3f}...'.format(gamma_cs, mu_cs)) \n \n T = c_s**2 * mu_cs * mP / (gamma_cs * KB)\n\n else:\n T = full(self.npart, T * (radii / AU)**beta)\n\n\n T[T < Tmin] = Tmin \n \n # This following settings are still being tested if correct\n \n if mu <= 0:\n print(' Calculating mu used in code...')\n mu = full(self.npart, 0.5) # Ionized\n mu[T < 1.e4] = 1.005 # Atomic\n mu[T < 2.e3] = 2.01 # Molecular (Optional)\n\n if gamma <= 0:\n print(' Calculating gamma used in code...')\n gamma = full(self.npart, 5/3.) # Adiabatic monoatomic\n gamma[T < 2.e3] = 1.4\t # Adiabatic diatomic\n\n factor = KB / (mP * mu * (gamma - 1))\n \n if max(T) == min(T): print(\" Temperature: {} [K]\".format(T[0]))\n else:\n print(' Maximum temperature: {:.2f} [K]'.format(max(T)))\n print(' Minimum temperature: {:.2f} [K]'.format(min(T)))\n \n\n self.u = T * factor","def torch_mel_to_hertz(frequencies_mel):\r\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\r\n return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)","def __setSpectrum__(self):\n \n self.Ck = []\n TempCk = []\n TempOneCk = OneCk()\n \n # Process 1st frequency\n Tb = self.freqs[1].totalJ\n \n for b in range(-Tb, Tb, 1):\n TempOneCk.freq = b*self.freqs[1].Vph\n TempOneCk.Amp = self.freqs[1].Cjk(b)\n self.Ck.append(TempOneCk)\n \n # Process additional frequencies\n CkSize = len(self.Ck)\n Added = FALSE\n \n for f in range(2, len(self.freqs), 1):\n # Reset temporary variables\n Tb = self.freqs[f].totalJ\n TempCk = []\n \n # Calculate each Ck coefficient\n for b in range(-Tb, Tb, 1):\n for k in range(CkSize):\n TempOneCk.Amp = Ck[k].Amp * self.freq[f].Cjk(b)\n \n # Check to see if Amp is big enough to keep\n if( abs(TempOneCk.Amp) > self.min_Ck ):\n Added = FALSE\n TempOneCk.freq = self.Ck[k].freq + b*self.freqs.Vph\n \n # If freq is already in Ck, add new value to old,\n # if not, add new value and freq to spectrum\n for c in TempCk:\n if abs(c.freq-TempOneCk.freq < DOUBLE_PRECISION):\n c.Amp += TempOneCk.Amp\n Added = TRUE\n break\n \n if (not Added):\n TempCk.append(TempOneCk)\n \n self.Ck = TempCk\n CkSize = len(self.Ck)","def make_steer_frs(dims, numlevels, numorientations, bandwidth):\n \n result = []\n bands=[]\n p = numorientations-1\n const = math.sqrt(float(math.pow(2,(2*p))*math.pow(math.factorial(p),2)) / float(math.factorial(2*p)*(p+1)))\n f1 = freqspace(dims[0])\n f2 = freqspace(dims[1])\n wx, wy = np.meshgrid(f1, f2)\n size = wx.shape\n r = np.sqrt(wx**2 + wy**2)\n theta = np.arctan2(wy, wx) \n \n bands = np.full((numlevels, numorientations, dims[0], dims[1]), const*1j)\n for level in range(numlevels):\n for orientation in range(numorientations):\n theta_offset = orientation * np.pi / numorientations\n ctrfreq = pi / math.pow(2, (level+1)*bandwidth)\n band = np.cos(theta - theta_offset)**p * log_raised_cos(r, ctrfreq, bandwidth)\n bands[level,orientation,:,:] *= band\n \n hi = log_raised_coshi(r, pi / math.pow(2, bandwidth), bandwidth)\n\n lo = log_raised_coslo(r, pi / math.pow(2, bandwidth * numlevels), bandwidth)\n \n result.append(hi)\n result.append(bands)\n result.append(lo)\n return result","def Boltzchoice(LFnum, energylist, RNs):\n # transform list to energy values in kT according to experimental\n # affinities and the energy window allowed by the threshold\n energylist = cf.y0 + np.array(energylist) * cf.m\n # calculate norm of initial list\n Norm = sum([math.exp(-ener) for ener in energylist])\n # calculate initial probability vector\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\n # list to catch indices of selected cells\n selected = []\n # cells to be picked: determined by the lesser of #waiters and #LFs\n cellpick = min(len(energylist), LFnum)\n while len(selected) < cellpick:\n bins = np.cumsum(probs)\n ind = np.digitize(RNs.getR(), bins)\n selected.append(ind)\n # now, set the probability of the selected cell to 0 and renormalise\n # the remaining probability vector\n newNorm = Norm - math.exp(-energylist[ind])\n probs[ind] = 0\n probs = probs * Norm / newNorm\n Norm = newNorm\n\n return selected","def gyroHF2(self, GYRO, PFC):\n print(\"Calculating gyro orbit heat loads\")\n log.info(\"Calculating gyro orbit heat loads\")\n #get divertor HF\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\n #Get fractional multipliers for each helical trace\n gyroFrac = 1.0/GYRO.N_gyroPhase\n vPhaseFrac = 1.0/GYRO.N_vPhase\n vSliceFrac = GYRO.energyFracs\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\n Pgyro = np.zeros((GYRO.Nt))\n PNaN = 0.0\n sum=0\n sum1=0\n #loop through intersect record and redistribute power using multipliers\n for gyroPhase in range(GYRO.N_gyroPhase):\n for vPhase in range(GYRO.N_vPhase):\n for vSlice in range(GYRO.N_vSlice):\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\n hdotn = np.abs(GYRO.hdotn[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap])\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\n notNanTo = notNanTo.astype(int) #cast as integer\n isNanTo = idx[np.isnan(idx)] #indices we map power to\n isNanTo = isNanTo.astype(int) #cast as integer\n\n if len(notNanFrom)>0:\n #multiple sources can load the same target face, so we loop\n for i in range(len(notNanFrom)):\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\n\n if len(isNanFrom)>0:\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\n\n\n GYRO.gyroPowMatrix += Pgyro\n GYRO.gyroNanPower += PNaN\n return","def mass_fuel_system(\n fuel_volume: float,\n n_tanks: int,\n fraction_in_integral_tanks: float = 0.5,\n) -> float:\n\n fraction_in_protected_tanks = 1 - fraction_in_integral_tanks\n return (\n 2.405 *\n (fuel_volume / u.gallon) ** 0.606 *\n (1 + fraction_in_integral_tanks) ** -1 *\n (1 + fraction_in_protected_tanks) *\n n_tanks ** 0.5\n ) * u.lbm","def hz_to_mel(frequencies, htk=False):\n\n frequencies = np.asanyarray(frequencies)\n\n if htk:\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\n\n # Fill in the linear part\n f_min = 0.0\n f_sp = 200.0 / 3\n\n mels = (frequencies - f_min) / f_sp\n\n # Fill in the log-scale part\n\n min_log_hz = 1000.0 # beginning of log region (Hz)\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\n logstep = np.log(6.4) / 27.0 # step size for log region\n\n if frequencies.ndim:\n # If we have array data, vectorize\n log_t = frequencies >= min_log_hz\n mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep\n elif frequencies >= min_log_hz:\n # If we have scalar data, heck directly\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\n\n return mels","def haperfluxMany(inputlist, maplist, radius, rinner, router, galactic=True, decimal=True, noise_model=0):\n\n ## Names and frequencies of the sample maps included in this repo.\n\n freqlist = ['30','44','70','100','143','217','353','545','857','1249','1874','2141','2998','3331','4612','4997','11992','16655','24983','24983','24983','33310']\n freqval = [28.405889, 44.072241,70.421396,100.,143.,217.,353.,545.,857.,1249.,1874.,2141.,2141.,2998.,2998.,3331.,4612.,4997.,11992.,16655.,24983.,24983.,24983.,33310.]\n band_names = [\"akari9\", \"dirbe12\",\"iras12\",\"wise12\",\"akari18\",\"iras25\",\"iras60\",\"akari65\",\"akari90\",\"dirbe100\",\"iras100\",\"akari140\",\"dirbe140\",\"akari160\",\"dirbe240\",\"planck857\", \"planck545\"]\n\n k0 = 1.0\n k1 = rinner/radius\n k2 = router/radius\n apcor = ((1 - (0.5)**(4*k0**2))-((0.5)**(4*k1**2) - (0.5)**(4*k2**2)))**(-1)\n\n # 'galactic' overrules 'decimal'\n if (galactic==True):\n dt=[('sname',np.dtype('S13')),('glon',np.float32),('glat',np.float32)]\n targets = np.genfromtxt(inputlist, delimiter=\",\",dtype=dt)\n\n ns = len(targets['glat'])\n\n fd3 = -1\n fd_err3 = -1\n\n fn = np.genfromtxt(maplist, delimiter=\" \", dtype='str')\n nmaps = len(fn)\n ## Initialize the arrays which will hold the results\n fd_all = np.zeros((ns,nmaps))\n fd_err_all = np.zeros((ns,nmaps))\n fd_bg_all = np.zeros((ns,nmaps))\n\n # Start the actual processing: Read-in the maps.\n for ct2 in range(0,nmaps):\n xtmp_data, xtmp_head = hp.read_map(fn[ct2], h=True, verbose=False, nest=False)\n freq = dict(xtmp_head)['FREQ']\n units = dict(xtmp_head)['TUNIT1']\n freq_str = str(freq)\n idx = freqlist.index(str(freq))\n currfreq = int(freq)\n\n if (radius == None):\n radval = fwhmlist[idx]\n else:\n radval = radius\n\n\n for ct in range(0,ns):\n\n glon = targets['glon'][ct]\n glat = targets['glat'][ct]\n\n fd_all[ct,ct2], fd_err_all[ct,ct2], fd_bg_all[ct,ct2] = \\\n haperflux(inmap= xtmp_data, freq= currfreq, lon=glon, lat=glat, aper_inner_radius=radius, aper_outer_radius1=rinner, \\\n aper_outer_radius2=router,units=units, noise_model=noise_model)\n\n if (np.isfinite(fd_err_all[ct,ct2]) == False):\n fd_all[ct,ct2] = -1\n fd_err_all[ct,ct2] = -1\n else:\n if radius==None:\n fd_all[ct,ct2] = fd_all[ct,ct2]*apcor\n fd_err_all[ct,ct2] = fd_err_all[ct,ct2]*apcor\n\n return fd_all, fd_err_all, fd_bg_all","def torch_hertz_to_mel(frequencies_hertz):\r\n # return _MEL_HIGH_FREQUENCY_Q * tf.math.log(\r\n # 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\r\n return _MEL_HIGH_FREQUENCY_Q * np.log(\r\n 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))","def half_space_cooling_temperature(z, t, T1, T0, kappa):\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]","def better_clumps_finding(text, k, t, L):\n frequent_patterns = []\n clumps = [0 for i in range(0, 4**k)]\n first_subtext = text[:L]\n freq_array = compute_freq(first_subtext, k)\n for index, freq in enumerate(freq_array):\n if freq >= t:\n clumps[index] = 1\n for i in range(1, len(text) - L + 1):\n old_kmer = text[i - 1:i - 1 + k]\n old_kmer_number = pattern_to_number(old_kmer)\n freq_array[old_kmer_number] -= 1\n new_kmer = text[i + L:i + L + k]\n new_kmer_number = pattern_to_number(new_kmer)\n freq_array[new_kmer_number] += 1\n if freq_array[new_kmer_number] >= t:\n clumps[new_kmer_number] = 1\n for index, clump in enumerate(clumps):\n if clump == 1:\n pattern = number_to_pattern(index, k)\n frequent_patterns.append(pattern) \n return frequent_patterns","def metro_ising(L, T, h):\n\n lattice = transform_lattice(np.random.rand(N + 2, N + 2)) # +2 because of periodic bounds\n ising_chain = [lattice]\n m = 0\n\n for i in range(L):\n rand_row = np.random.choice(index)\n rand_col = np.random.choice(index)\n\n if H(ising_chain[i], rand_row, rand_col, h, T):\n new_lattice = ising_chain[i].copy()\n new_lattice[rand_row][rand_col] *= -1\n ising_chain.append(transform_lattice(new_lattice))\n else:\n ising_chain.append(ising_chain[i])\n\n m += np.sum(ising_chain[i][1:N + 1, 1:N + 1]) # magnetization\n\n return m","def bf_counter(file_name, k, n, capacity, error_rate, verbose=False):\n if verbose:\n start = time.time()\n print('BFCounter started.')\n\n heap = []\n for i in range(n):\n heap.append((0, ''))\n\n bf = BloomFilter(capacity, error_rate, 'kmer_bf')\n\n kmer_counter = defaultdict(lambda: 1)\n\n # Assign functions to local variables for performance improvement\n add_to_bf = bf.add\n heap_pushpop = heapq.heappushpop\n\n with open(file_name, 'r') as f:\n line_num = 0\n for line in f:\n if line_num % 4 == 1: # dna sequence\n kmer_count = len(line) - k\n for i in range(kmer_count):\n kmer = line[i:i + k]\n if kmer not in bf: # not in Bloom Filter\n add_to_bf(kmer)\n else: # in Bloom Filter\n kmer_counter[kmer] += 1\n line_num += 1\n if verbose:\n end_hash = time.time()\n hash_table_size = sys.getsizeof(kmer_counter) / (1024 ** 2)\n print('Hash table is created in {:.2f} seconds.'.format(\n end_hash - start))\n print('Hash table size: {:.2f} MB.'.format(hash_table_size))\n start_populate = time.time()\n print('Populating the heap...')\n\n for count, kmer in kmer_counter.items():\n # insert to the heap if count is bigger than minimum\n if count > heap[0][0]:\n heap_pushpop(heap, (count, kmer))\n\n if verbose:\n end_populate = time.time()\n print('Heap is populated in {:.2f} seconds.'.format(\n end_populate - start_populate\n ))\n\n os.remove('kmer_bf')\n if verbose:\n end = time.time()\n print('BFCounter is completed in {:.2f} seconds.'.format(end - start))\n\n return heap","def lrelfreq(inlist,numbins=10,defaultreallimits=None):\r\n h,l,b,e = histogram(inlist,numbins,defaultreallimits)\r\n for i in range(len(h)):\r\n h[i] = h[i]/float(len(inlist))\r\n return h,l,b,e","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def hz_to_mel(frequencies, htk=False):\n\n frequencies = np.asanyarray(frequencies)\n\n if htk:\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\n\n # Fill in the linear part\n f_min = 0.0\n f_sp = 200.0 / 3\n\n mels = (frequencies - f_min) / f_sp\n\n # Fill in the log-scale part\n\n min_log_hz = 1000.0 # beginning of log region (Hz)\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\n logstep = np.log(6.4) / 27.0 # step size for log region\n\n if frequencies.ndim:\n # If we have array data, vectorize\n log_t = (frequencies >= min_log_hz)\n mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep\n elif frequencies >= min_log_hz:\n # If we have scalar data, heck directly\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\n\n return mels","def get_rec_rate_H_caseB(T):\n Tinv = 1.0/T\n bb = 315614.0*Tinv\n cc = 115188.0*Tinv\n dd = 1.0 + np.power(cc, 0.407)\n return 2.753e-14*np.power(bb, 1.5)*np.power(dd, -2.242)","def generateFrequentPatterns(self, tidList):\n tidList1 = {}\n if len(tidList) == 0:\n print(\"There are no more candidate sets\")\n else:\n key = list(tidList.keys())\n for i in range(0, len(key)):\n nighbousItems=self.getNighboirItems(key[i])\n for j in range(i + 1, len(key)):\n if not key[j] in nighbousItems:\n \tcontinue\n intersectionList = list(set(tidList[key[i]]).intersection(set(tidList[key[j]])))\n itemList = []\n if len(intersectionList) >= self.minSup:\n itemList += key[i], key[j]\n itemList.sort()\n tidList1[tuple(itemList)] = intersectionList\n\n return tidList1","def Hertz_dipole_ff (r, p, R, phi, f, t=0, epsr=1.):\r\n nf = len(f)\r\n rprime = r-R # r'=r-R\r\n if ndim(p) < 2:\r\n magrprime = sqrt(sum((rprime)**2))\r\n magrprimep = tile(magrprime, (len(f),1)).T\r\n phip = tile(phi, (len(f),1))\r\n w = 2*pi*f # \\omega\r\n k = w/c # wave number\r\n krp = k*magrprimep # k|r'|\r\n rprime_cross_p = cross(rprime, p) # r'x p\r\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\r\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\r\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[0],(nf,1))).T\r\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[1],(nf,1))).T\r\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[2],(nf,1))).T\r\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[0],(nf,1)).T)\r\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[1],(nf,1)).T)\r\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[2],(nf,1)).T)\r\n E = vstack((Ex,Ey,Ez))\r\n B = vstack((Bx,By,Bz))\r\n else:\r\n magrprime = sqrt(sum((rprime)**2,axis=1)) # |r'|\r\n magrprimep = tile(magrprime, (len(f),1)).T\r\n phip = tile(phi, (len(f),1))\r\n fp = tile(f,(len(magrprime),1))\r\n w = 2*pi*fp # \\omega\r\n k = w/c # wave number\r\n krp = k*magrprimep # k|r'|\r\n rprime_cross_p = cross(rprime, p) # r'x p\r\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\r\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\r\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,0],(nf,1))).T\r\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,1],(nf,1))).T\r\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,2],(nf,1))).T\r\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,0],(nf,1)).T)\r\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,1],(nf,1)).T)\r\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,2],(nf,1)).T)\r\n E = vstack((sum(Ex,axis=0),sum(Ey,axis=0),sum(Ez,axis=0)))\r\n B = vstack((sum(Bx,axis=0),sum(By,axis=0),sum(Bz,axis=0)))\r\n return E,B","def init_buckets(len2freq):\n source = Counter(len2freq)\n\n if not len(source):\n raise ValueError('Empty length-to-frequency map')\n\n if not all(map(lambda x: isinstance(x, int), source.keys())):\n raise ValueError('Keys of length-to-frequency must be integers')\n\n if not all(map(lambda x: isinstance(x, int), source.values())):\n raise ValueError('Values of length-to-frequency must be integers')\n\n denominator = 8\n lengths = sorted(source.keys())\n\n buckets = []\n for lng in lengths:\n b = int(np.ceil(lng / denominator)) * denominator + 1\n if not len(buckets) or buckets[-1][0] != b:\n buckets.append((b, {}))\n buckets[-1][1][lng] = source[lng]\n\n return buckets","def calc_Cop_boiler(q_load_Wh, Q_nom_W, T_return_to_boiler_K):\n\n if (Q_nom_W > 0.0) and (q_load_Wh > 0.0):\n\n # calculate efficiency according to partload\n phi = float(q_load_Wh) / float(Q_nom_W)\n if phi >=1.0: # avoid rounding error\n phi = 0.98\n T_return_C = np.float(T_return_to_boiler_K - 273.15)\n eff_score = eff_of_phi(phi) / eff_of_phi(1)\n boiler_eff = (eff_score * eff_of_T_return([T_return_C]))[0] / 100.0\n else:\n boiler_eff = 0.0\n\n return boiler_eff","def calculate_NH_relaxation_from_Ct(bondtype, B_0, t, Ct):\n gamma_1H = 267.513e6 ; # rad s^-1 T^-1\n gamma_X = -27.116e6\n DeltaSigma_X=-160e-6\n r_XH=1.02e-10\n\n om, G = do_dft(t, Ct)\n J = G.real\n\n omega, iOmH, iOmX = obtain_HX_frequencies()\n\n Jw=np.zeros(5)\n for i in range(5):\n w = omega[i]\n Jw[i] = interpolate_point(w, om, J)\n\n # f_DD = 519627720.1974593 , if r_NH is at default values\n f_DD = 7.958699205571828e-67 * r_XH**-6.0 * gamma_X**2\n # f_CSA = 498637299.69233465, if B_0 = 600.13, and DeltaSigma=-160e-6\n f_CSA = 2.0/15.0 * DeltaSigma_X**2 * ( gamma_X * B_0 )**2\n\n R1 = f_DD*( J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] ) + f_CSA*J[iOmX]\n R2 = 0.5*f_DD*( 4*J[0] + J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] + 6*J[iOmH] ) + 1.0/6.0*f_CSA*(4*J[0] + 3*J[iOmX])\n NOE = 1.0 + gamma_1H/gamma_X/R1 * f_DD*(6*J[iOmH+iOmX] - J[iOmH-iOmX])\n\n return R1, R2, NOE","def __init__(self,kT=None,T=None):\n if kT is not None: kT = kT\n elif T is not None: kT = u.boltzmann*T\n else: raise Exception(\"kT or k must be passed to BlackBody\")\n\n energy_density=BlackBody.compute_energy_density(kT)\n super(BlackBody,self).__init__(energy_density=energy_density, kT=kT)","def frfplot(freq, H, freq_min=0, freq_max=None, type=1, legend=[]):\n FLAG = type # Plot type, should libe renamed throughout.\n freq = freq.reshape(1, -1)\n lenF = freq.shape[1]\n if len(H.shape) is 1:\n H = H.reshape(1, -1)\n\n if H.shape[0] > H.shape[1]:\n H = H.T\n\n if freq_max is None:\n freq_max = np.max(freq)\n\n if freq_min is None:\n freq_min = np.min(freq)\n\n if freq_min < np.min(freq):\n freq_min = np.min(freq)\n\n if freq_min > freq_max:\n raise ValueError('freq_min must be less than freq_max.')\n\n # print(str(np.amin(freq)))\n inlow = int(lenF * (freq_min - np.amin(freq)\n ) // (np.amax(freq) - np.amin(freq)))\n\n inhigh = int(lenF * (freq_max - np.amin(freq)\n ) // (np.amax(freq) - np.amin(freq)) - 1)\n # if inlow<1,inlow=1;end\n # if inhigh>lenF,inhigh=lenF;end\n \"\"\"print('freq shape: {}'.format(freq.shape))\n print('H shape: {}'.format(H.shape))\n print('Index of low frequency: {}'.format(inlow))\n print('Index of high frequency: {}'.format(inhigh))\"\"\"\n H = H[:, inlow:inhigh]\n # print(H.shape)\n freq = freq[:, inlow:inhigh]\n mag = 20 * np.log10(np.abs(H))\n # print(mag)\n # print(mag.shape)\n minmag = np.min(mag)\n maxmag = np.max(mag)\n phase = np.unwrap(np.angle(H)) * 180 / np.pi\n # phmin_max=[min(phase)//45)*45 ceil(max(max(phase))/45)*45];\n phmin = np.amin(phase) // 45 * 45.0\n phmax = (np.amax(phase) // 45 + 1) * 45\n \"\"\"minreal = np.amin(np.real(H))\n maxreal = np.amax(np.real(H))\n minimag = np.amin(np.imag(H))\n maximag = np.amax(np.imag(H))\"\"\"\n\n if FLAG is 1:\n fig, (ax1, ax2) = plt.subplots(2, 1)\n ax1.plot(freq.T, mag.T)\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Mag (dB)')\n ax1.grid()\n ax1.set_xlim(xmax=freq_max, xmin=freq_min)\n ax1.set_ylim(ymax=maxmag, ymin=minmag)\n\n ax2.plot(freq.T, phase.T)\n ax2.set_xlabel('Frequency (Hz)')\n ax2.set_ylabel('Phase (deg)')\n ax2.grid()\n ax2.set_xlim(xmax=freq_max, xmin=freq_min)\n ax2.set_ylim(ymax=phmax, ymin=phmin)\n ax2.set_yticks(np.arange(phmin, (phmax + 45), 45))\n fig.tight_layout()\n\n if len(legend) > 0:\n plt.legend(legend)\n ax = (ax1, ax2)\n else:\n print(\"Sorry, that option isn't supported yet\")\n return ax\n\n \"\"\"# elif FLAG==2:\n # subplot(2,1,1)\n # semilogx(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # % Fmin,Fmax,min(mag),max(mag)\n # axis([Fmin Fmax minmag maxmag])\n\n # subplot(2,1,2)\n # semilogx(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n\n # elif FLAG==3:\n # subplot(2,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F*2*pi,mag)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Wmin Wmax minmag maxmag])\n # zoom on\n # subplot(2,1,2)\n # semilogx(F*2*pi,phase)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n\n # elseif FLAG==4\n # subplot(2,1,1)\n # plot(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # subplot(2,1,2)\n # plot(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==5\n # subplot(1,1,1)\n # imax=round(length(F)*Fmax/max(F));\n # imin=round(length(F)*Fmin/max(F))+1;\n # plot(real(Xfer(imin:imax)),imag(Xfer(imin:imax)))\n # xlabel('Real')\n # ylabel('Imaginary')\n # grid on\n # zoom on\n # elseif FLAG==6\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # plot(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # elseif FLAG==7\n # subplot(1,1,1)\n # plot(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # elseif FLAG==8\n # subplot(1,1,1)\n # plot(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # elseif FLAG==9\n # subplot(1,1,1)\n # plot(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==10\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # elseif FLAG==11\n # subplot(1,1,1)\n # semilogx(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # elseif FLAG==12\n # subplot(1,1,1)\n # semilogx(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # elseif FLAG==13\n # subplot(1,1,1)\n # semilogx(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==14\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F*2*pi,mag)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Wmin Wmax minmag maxmag])\n # zoom on\n # elseif FLAG==15\n # subplot(1,1,1)\n # semilogx(F*2*pi,phase)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # else\n # subplot(2,1,1)\n # mag=20*log10(abs(Xfer));\n # plot(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # subplot(2,1,2)\n # plot(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n \"\"\"","def get_mitral_frequency(self,r=None,ids=None):\n # Simply divide the length of each spike vector by the simulation time\n # or window time.\n spikes=[] # The local copy of spikes to get the frequency on\n try:\n spikes=self.get_mitral_spikes(r,ids)\n if len(spikes)==0:\n raise Exception('Unable to get mitral cell spikes')\n except Exception:\n raise\n freqm=numpy.zeros(self.num_mit)\n timems=self.sim_time\n if type(r) is tuple and len(r)==2:\n timems=float(r[1]-r[0])\n for i in range(len(spikes)):\n freqm[i]=float(len(spikes[i]))*1000./timems\n return freqm","def get_effective_mass():\n\n H_BAR = 6.582119514e-16 # eV*s\n M_0 = 9.10938356e-31 # kg\n N_KPTS = 6 # Number of k-points included in the parabola.\n\n spin_up = Spin(1)\n\n band_structure = Vasprun('vasprun.xml').get_band_structure()\n\n # Locations of CBM and VBM in band_structure.bands\n cbm_band_index = band_structure.get_cbm()['band_index'][spin_up][0]\n cbm_kpoint_index = band_structure.get_cbm()['kpoint_index'][0]\n\n vbm_band_index = band_structure.get_vbm()['band_index'][spin_up][0]\n vbm_kpoint_index = band_structure.get_vbm()['kpoint_index'][0]\n\n k = {'electron': {'left': [], 'right': []},\n 'hole': {'left': [], 'right': []}}\n E = {'electron': {'left': [], 'right': []},\n 'hole': {'left': [], 'right': []}}\n\n e_ref_coords = band_structure.kpoints[cbm_kpoint_index]._ccoords\n h_ref_coords = band_structure.kpoints[vbm_kpoint_index]._ccoords\n\n for n in range(-N_KPTS, 1):\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\n\n k['electron']['left'].append(\n ((e_coords[0] - e_ref_coords[0])**2 +\n (e_coords[1] - e_ref_coords[1])**2 +\n (e_coords[2] - e_ref_coords[2])**2)**0.5\n )\n k['hole']['left'].append(\n ((h_coords[0] - h_ref_coords[0])**2 +\n (h_coords[1] - h_ref_coords[1])**2 +\n (h_coords[2] - h_ref_coords[2])**2)**0.5\n )\n\n e_energy = band_structure.bands[\n spin_up][cbm_band_index][cbm_kpoint_index + n]\n h_energy = band_structure.bands[\n spin_up][vbm_band_index][vbm_kpoint_index + n]\n\n E['electron']['left'].append(e_energy)\n E['hole']['left'].append(h_energy)\n\n for n in range(1, 1 + N_KPTS):\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\n\n k['electron']['right'].append(\n ((e_coords[0] - e_ref_coords[0])**2 +\n (e_coords[1] - e_ref_coords[1])**2 +\n (e_coords[2] - e_ref_coords[2])**2)**0.5\n )\n k['hole']['right'].append(\n ((h_coords[0] - h_ref_coords[0])**2 +\n (h_coords[1] - h_ref_coords[1])**2 +\n (h_coords[2] - h_ref_coords[2])**2)**0.5\n )\n\n e_energy = band_structure.bands[\n spin_up][cbm_band_index][cbm_kpoint_index + n]\n h_energy = band_structure.bands[\n spin_up][vbm_band_index][vbm_kpoint_index + n]\n\n E['electron']['right'].append(e_energy)\n E['hole']['right'].append(h_energy)\n\n # 2nd order fits\n e_l_fit = np.poly1d(\n np.polyfit(k['electron']['left'], E['electron']['left'], 2))\n e_r_fit = np.poly1d(\n np.polyfit(k['electron']['right'], E['electron']['right'], 2))\n h_l_fit = np.poly1d(\n np.polyfit(k['hole']['left'], E['hole']['left'], 2))\n h_r_fit = np.poly1d(\n np.polyfit(k['hole']['right'], E['hole']['right'], 2))\n\n # Curvatures\n e_l_curvature = e_l_fit.deriv().deriv()[0]\n e_r_curvature = e_r_fit.deriv().deriv()[0]\n h_l_curvature = h_l_fit.deriv().deriv()[0]\n h_r_curvature = h_r_fit.deriv().deriv()[0]\n\n # Unit conversion\n e_m_eff_l = 10 * ((H_BAR ** 2) / e_l_curvature) / M_0\n e_m_eff_r = 10 * ((H_BAR ** 2) / e_r_curvature) / M_0\n h_m_eff_l = -10 * ((H_BAR ** 2) / h_l_curvature) / M_0\n h_m_eff_r = -10 * ((H_BAR ** 2) / h_r_curvature) / M_0\n\n return {'electron': {'left': e_m_eff_l, 'right': e_m_eff_r},\n 'hole': {'left': h_m_eff_l, 'right': h_m_eff_r}}","def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\n \n # INPUTS FROM TTTW SYSTEM\n self.b = b #buoyancy field: [Ly,N]\n self.u = u # x-component of velocity [Ly,N]\n self.v = v # y-component of velocity [Ly+1,N]\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\n self.grid_dict = grid_dict #gridded data\n self.f = f #coriolis parameter\n # KPP-SPECIFIC VARIABLES \n self.hbls = np.zeros([self.b.shape[0]])\n self.hbbl = np.zeros([self.b.shape[0]])\n self.ustar = []\n self.bvf = [] \n self.kmo = []\n self.C_h_MO = []\n self.kbl = []\n self.Cr = [] \n self.Fc = []\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\n self.dt = dt","def vib_energy(frequency, temp):\n\n # vibrational temperature\n\n vtemp = plank_const * speed_ol / boltz_const * frequency\n\n vtemp = np.matrix(vtemp)\n\n temp = 1 / np.matrix(temp)\n\n # need to convert to array, because the element wise exponential\n # cannot work with matrix\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\n\n # energy is a np.matrix, need to convert to array\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\n energy = np.array(energy)[0]\n\n return energy","def cer(r: list, h: list):\n # initialisation\n import numpy\n d = numpy.zeros((len(r) + 1) * (len(h) + 1), dtype=numpy.uint16)\n d = d.reshape((len(r) + 1, len(h) + 1))\n for i in tqdm(range(len(r) + 1)):\n for j in range(len(h) + 1):\n if i == 0:\n d[0][j] = j\n elif j == 0:\n d[i][0] = i\n # computation\n for i in tqdm(range(1, len(r) + 1)):\n for j in range(1, len(h) + 1):\n if r[i - 1] == h[j - 1]:\n d[i][j] = d[i - 1][j - 1]\n else:\n substitution = d[i - 1][j - 1] + 1\n insertion = d[i][j - 1] + 1\n deletion = d[i - 1][j] + 1\n d[i][j] = min(substitution, insertion, deletion)\n return d[len(r)][len(h)] / float(len(r))","def buoyancy_frequency(self, z, h=0.01):\n # Check validity of the input z values\n if np.max(z) > self.z_max or np.min(z) < self.z_min:\n raise ValueError('Selected depths outside range of ' + \\\n 'CTD data: %g to %g m' % (self.z_min, \n self.z_max))\n if h > 1.0 or h < 0.0:\n raise ValueError('Input parameter h must be between 0.0 ' + \\\n 'and 1.0.')\n \n # Prepare space to store the solution\n if not isinstance(z, np.ndarray):\n N = np.zeros(1)\n z = np.array([z])\n elements = 0\n else:\n N = np.zeros(z.shape)\n elements = range(len(N))\n \n # Compute the length-scale for the finite difference method\n dz = (self.z_max - self.z_min) * h\n \n # Fill the solution matrix\n for i in range(len(z)):\n # Get the end-points of z for the finite difference formula\n if z[i] + dz > self.z_max:\n z1 = self.z_max\n z0 = z1 - 2 * dz\n elif z[i] - dz < self.z_min:\n z0 = self.z_min\n z1 = z0 + 2 * dz\n else:\n z0 = z[i] - dz\n z1 = z[i] + dz\n \n # Get the density at z0 and z1. Use atmospheric pressure to \n # compute the potential density and remove the effect of \n # compressibility\n T0, S0 = self.get_values(z0, self.ztsp[1:3])\n T1, S1 = self.get_values(z1, self.ztsp[1:3])\n Pa = 101325.\n rho_0 = seawater.density(T0, S0, Pa)\n rho_1 = seawater.density(T1, S1, Pa)\n N[i] = np.sqrt(9.81 / rho_0 * (rho_1 - rho_0) / (z1 - z0))\n \n return N[elements]","def get_F_potential(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n # y = chemical_potential/temperature\n y = chemical_potential / tt\n F = gbar / np.sqrt(2.0) / np.pi ** 2 * tt ** (2.5) * vv\n F *= y * _1d_call(_fdk, y, k=0.5) - 2.0 / 3.0 * _1d_call(_fdk, y, k=1.5)\n return F","def Kgrid(struc, Kresol=0.10, dimension=3):\n a, b, c, alpha, beta, gamma = struc.get_cell_lengths_and_angles()\n vol = struc.get_volume()\n dist = np.zeros(3);\n dist[2] = np.abs(vol/(a*b*np.sin(np.radians(gamma))))\n dist[1] = np.abs(vol/(a*c*np.sin(np.radians(beta))))\n dist[0] = np.abs(vol/(b*c*np.sin(np.radians(alpha))))\n Kpoints = np.ceil(1./(dist*Kresol))\n if dimension == 2:\n Kpoints[-1] = 1;\n #print(a, b, c, alpha, beta, gamma)\n #print(vol/(a*b*np.sin(gamma)), a*b, np.sin(gamma))\n #print(vol/(a*c*np.sin(beta)), a*c, np.sin(beta))\n #print(vol/(b*c*np.sin(alpha)), b*c, np.sin(alpha))\n #print(Kpoints)\n #import sys; sys.exit()\n return Kpoints.astype(int)","def conductivity(self, T):\n m = self.mass\n mu = self.viscosity(T)\n K = (15/4) * kB * mu / m\n return K","def calc_cop_CCGT(GT_size_W, T_sup_K, fuel_type):\n\n it_len = 50\n\n # create empty arrays\n range_el_output_CC_W = np.zeros(it_len)\n range_q_output_CC_W = np.zeros(it_len)\n range_eta_el_CC = np.zeros(it_len)\n range_eta_thermal_CC = np.zeros(it_len)\n range_q_input_CC_W = np.zeros(it_len)\n\n # create range of electricity output from the GT between the minimum and nominal load\n range_el_output_from_GT_W = np.linspace(GT_size_W * GT_MIN_PART_LOAD, GT_size_W, it_len)\n\n # calculate the operation data at different electricity load\n for i in range(len(range_el_output_from_GT_W)):\n el_output_from_GT_W = range_el_output_from_GT_W[i]\n\n # combine cycle operation\n CC_operation = calc_CC_operation(el_output_from_GT_W, GT_size_W, fuel_type, T_sup_K)\n range_el_output_CC_W[i] = CC_operation['el_output_W'] # Electricity output from the combined cycle\n range_q_output_CC_W[i] = CC_operation['q_output_ST_W'] # Thermal output from the combined cycle\n range_eta_el_CC[i] = CC_operation['eta_el'] # el. efficiency\n range_eta_thermal_CC[i] = CC_operation['eta_thermal'] # thermal efficiency\n\n range_q_input_CC_W[i] = range_q_output_CC_W[i] / range_eta_thermal_CC[i] # thermal energy input\n\n # create interpolation functions as a function of heat output\n el_output_interpol_with_q_output_W = interpolate.interp1d(range_q_output_CC_W, range_el_output_from_GT_W,\n kind=\"linear\")\n q_input_interpol_with_q_output_W = interpolate.interp1d(range_q_output_CC_W, range_q_input_CC_W, kind=\"linear\")\n\n # create interpolation functions as a function of thermal energy input\n eta_el_interpol_with_q_input = interpolate.interp1d(range_q_input_CC_W, range_eta_el_CC,\n kind=\"linear\")\n\n q_output_min_W = min(range_q_output_CC_W)\n q_output_max_W = max(range_q_output_CC_W)\n\n return {'el_output_fn_q_output_W': el_output_interpol_with_q_output_W,\n 'q_input_fn_q_output_W': q_input_interpol_with_q_output_W,\n 'q_output_min_W': q_output_min_W, 'q_output_max_W': q_output_max_W,\n 'eta_el_fn_q_input': eta_el_interpol_with_q_input}","def find_clumps(genome, k, L, t):\n assert (is_dna(genome))\n counts = collections.defaultdict(int)\n\n # compute counts of kmers in first L-length part of genome\n for k_start in range(L - k + 1):\n counts[genome[k_start:k_start + k]] += 1\n kmers = _get_keys(counts, t)\n\n # slide L-length window and update counts\n # remove previous leftmost kmer and add new kmer being rightmost in current window\n for L_start in range(1, len(genome) - L + 1):\n counts[genome[L_start - 1:L_start + k - 1]] -= 1\n new_kmer = genome[L_start + L - k:L_start + L]\n counts[new_kmer] += 1\n if counts[new_kmer] >= t:\n kmers.add(new_kmer)\n return kmers"],"string":"[\n \"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr\",\n \"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy\",\n \"def heat_capacity(r, phi, q, kT):\\n pot = q*(phi - phi[0])\\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\\n c = np.trapz(np.exp(-pot/kT) * r, r)\\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)\",\n \"def harmonicOscillator_heatCapacity(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\\n # low temperatures - high numbers\\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)\",\n \"def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_P_low *= (\\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n )\\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n # low temperatures - high numbers\\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)\",\n \"def fuel_cond(T):\\n\\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\\n \\n return kc\",\n \"def heatCapacity(self, Tk=None, Tc=None):\\n Tk = getTk(Tc, Tk)\\n self.checkPropertyTempRange(\\\"heat capacity\\\", Tk)\\n return (\\n sum(\\n [\\n +1.38642e-13 * Tk**4,\\n -6.47481e-10 * Tk**3,\\n +1.02345e-06 * Tk**2,\\n -4.32829e-04 * Tk,\\n +1.06133e00,\\n ]\\n )\\n * 1000.0\\n ) # kJ / kg K to J / kg K\",\n \"def thermal(isatom, freq, scalfac,linnonlin,T):\\n if isatom != \\\"true\\\":\\n nfreq = len(freq)\\n\\n vib_temp = []\\n for ifreq in range(nfreq):\\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\\n vib_temp.append(vib_temp_new)\\n\\n dE_vib = 0\\n for ifreq in range(nfreq):\\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\\n\\n dE_ZPE = 0.5 * sum(freq) * cmi2au\\n\\n if linnonlin == \\\"L\\\":\\n dE_rot = kB * T * j2au\\n elif linnonlin == \\\"NL\\\":\\n dE_rot = kB * T * j2au * (3.0/2.0)\\n else:\\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"ERROR: unknown entry for linear/nonlinear\\\")\\n else:\\n dE_ZPE = 0\\n dE_vib = 0\\n dE_rot = 0\\n\\n dE_tra = kB * T * j2au * (3.0/2.0)\\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\\n\\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)\",\n \"def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\\n kB = 1.380658e-16\\n h = 6.6260755e-27\\n c = 29979245800.\\n nu = freqGHz*1.e9\\n x = h*nu/(kB*T0)\\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\\n cNu *= 1e23\\n return cNu\",\n \"def CMB_spec(eng, temp):\\n if np.issubdtype(type(eng), float):\\n eng = np.array([eng])\\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\\n\\n if np.issubdtype(type(eng), float): \\n return phot_spec_density[0] \\n else: \\n return phot_spec_density\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def get_freq_grid():\\n (bins_per_octave, n_octaves, _, _, f_min, _) = get_hcqt_params()\\n freq_grid = librosa.cqt_frequencies(\\n bins_per_octave*n_octaves, f_min, bins_per_octave=bins_per_octave\\n )\\n return freq_grid\",\n \"def get_kt(temps, delta_gibbs_ts):\\n # rate coefficient from Eyring equation\\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular\",\n \"def thermodynamic_temperature(frequency, T_cmb=None):\\n nu = frequency.to(si.GHz, spectral())\\n\\n if T_cmb is None:\\n from astropy.cosmology import default_cosmology\\n\\n T_cmb = default_cosmology.get().Tcmb0\\n\\n def f(nu, T_cmb=T_cmb):\\n x = _si.h * nu / _si.k_B / T_cmb\\n return x**2 * np.exp(x) / np.expm1(x) ** 2\\n\\n def convert_Jy_to_K(x_jybm):\\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\\n astrophys.Jy\\n )\\n return x_jybm / factor\\n\\n def convert_K_to_Jy(x_K):\\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\\n si.K\\n )\\n return x_K / factor\\n\\n return Equivalency(\\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\\n \\\"thermodynamic_temperature\\\",\\n {\\\"frequency\\\": frequency, \\\"T_cmb\\\": T_cmb},\\n )\",\n \"def add_clump_forming_kmers(counts, clumpFormingKmers):\\n for kmer in counts:\\n if counts[kmer] >= t:\\n clumpFormingKmers.add(kmer)\\n\\n return clumpFormingKmers\",\n \"def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\\n pi, ids = induced_distribution(hmsm, 0, level)\\n\\n discrete_free_energy = np.ndarray(pi.shape)\\n for i, id in enumerate(ids):\\n discrete_free_energy[i] = \\\\\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\\n boltzmann = np.exp(-discrete_free_energy/kT)\\n boltzmann *= (1/np.sum(boltzmann))\\n return D_KL(boltzmann, pi)\",\n \"def get_granule_frequency(self,r=None,ids=None):\\n # Simply divide the length of each spike vector by the simulation time\\n # or window time.\\n spikes=[] # The local copy of spikes to get the frequency on\\n try:\\n spikes=self.get_granule_spikes(r,ids)\\n if len(spikes)==0:\\n raise Exception('Unable to get mitral cell spikes')\\n except Exception:\\n raise\\n freqg=numpy.zeros(self.num_gran)\\n timems=self.sim_time\\n if type(r) is tuple and len(r)==2:\\n timems=float(r[1]-r[0])\\n for i in range(len(spikes)):\\n freqg[i]=float(len(spikes[i]))*1000./timems\\n return freqg\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\n \"def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n C_T = (\\n 2 ** (1 / 4)\\n * np.sqrt(gbar)\\n / np.pi\\n * np.sqrt(vv)\\n * tt ** (5 / 4)\\n * _1d_call(_fdk, y, k=1 / 2)\\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\\n )\\n return C_T\",\n \"def effective_temperature(R,times):\\n T_eff = np.empty((len(R),times))\\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \\n for i in range (len(R)):\\n for t in range(times): \\n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\\n return T_eff\",\n \"def fcut(r, rcut, trans_width):\\n if (isinstance(r, list) or isinstance(r, np.ndarray)) and len(r) > 1:\\n return np.array([fcut(ri, rcut, trans_width) for ri in r])\\n else:\\n if r > rcut:\\n return 0.\\n elif r > rcut-trans_width:\\n return 0.5*(np.cos(np.pi*(r-rcut+trans_width)/trans_width) + 1)\\n else:\\n return 1.0\",\n \"def rebin_power_to_kms(kfkms, kfmpc, flux_powers, zbins, omega_m, omega_l = None):\\n if omega_l is None:\\n omega_l = 1 - omega_m\\n nz = np.size(zbins)\\n nk = np.size(kfmpc)\\n assert np.size(flux_powers) == nz * nk\\n velfac = lambda zz: 1./(1+zz) * 100.0* np.sqrt(omega_m * (1 + zz)**3 + omega_l)\\n rebinned=[scipy.interpolate.interpolate.interp1d(kfmpc,flux_powers[ii*nk:(ii+1)*nk]) for ii in range(nz)]\\n okmsbins = [kfkms[np.where(kfkms >= np.min(kfmpc)/velfac(zz))] for zz in zbins]\\n flux_rebinned = [rebinned[ii](okmsbins[ii]*velfac(zz)) for ii, zz in enumerate(zbins)]\\n return okmsbins, flux_rebinned\",\n \"def volumetric_heat_capacity(temperature):\\n a = -2.4083\\n b = 7.6006\\n c = -8.2982\\n d = 7.3301\\n e = -4.2386\\n f = 1.4294\\n g = -0.24396\\n h = 0.015236\\n i = 0.0\\n log_t = math.log10(temperature)\\n f_exp = a + b*log_t + c*log_t**2.0 + d*log_t**3.0 + e*log_t**4.0 + f*log_t**5.0 + g*log_t**6.0 + \\\\\\n h*log_t**7.0 + i*log_t**8.0\\n g10_cp = 10.0**f_exp\\n return g10_cp * G10NISTMaterialProperties.density\",\n \"def getMolarFluxes(self,T):\\n\\t\\tsigma = 0.1 # Hertz-Knudsen condensation/evaporation coefficient\\n\\t\\t# see doi:10.1103/PhysRevE.59.429\\n\\t\\t# http://www.mie.utoronto.ca/labs/tkl/publications/WardFangExpress.pdf\\n\\t\\tvp = self.getVaporPressures(T)\\n\\t\\tmw = self.molar_masses*0.001 / 6.02E23 # mass of molecule in kg\\n\\t\\tkb = 1.38E-23 # m^2 kg s^-2 K^-1 !!\\n\\t\\tJe = vp / numpy.sqrt(2*numpy.pi * mw * kb * T) \\n\\t\\treturn Je/ 6.02E23\",\n \"def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for low temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n S_low = (\\n -gbar\\n * np.sqrt(2)\\n / (6 * np.pi ** 2)\\n * tt_low ** (3 / 2)\\n * vv_low\\n * (\\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\\n )\\n )\\n # low temperatures - high numbers\\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((S_low, S_high)).reshape(y.shape)\",\n \"def chemical_potential(T, pressure):\\n import numpy as np\\n\\n kb = 1.38064852e-23 # Boltzmann constant (J K^{-1})\\n planck = 6.62607004e-34 # Planck constant\\n mass = 2.0 * 1.00784 * 1.6737236e-27 # Mass of H2 in Kg\\n beta = 1.0 / (kb * T) # Thermodynamic beta\\n\\n # Thermal wavelength\\n thermal_wav = planck * planck * beta / (2 * np.pi * mass)\\n thermal_wav = thermal_wav ** (1/2.)\\n\\n # Calculate chemical potential \\n chemical_pot = np.log(pressure * thermal_wav ** 3 * beta) * T\\n \\n return chemical_pot\",\n \"def frequentist_MC(bolo_name, exposure):\\n\\n\\thdata, file_data = PyRPl.open_ROOT_object(\\\"../ROOT_files/Axion/Spec/\\\" + bolo_name + \\\"_spec_perkeV.root\\\", \\\"h_\\\" + bolo_name)\\n\\tfmodel, file_model = PyRPl.open_ROOT_object(\\\"../ROOT_files/Axion/Model/\\\" + bolo_name + \\\"_model_perkeV.root\\\", bolo_name + \\\"_FidGamma\\\")\\n\\tfflux, file_flux = PyRPl.open_ROOT_object(\\\"../ROOT_files/Axion/CBRD_convolved/\\\" + bolo_name + \\\"_flux.root\\\", bolo_name + \\\"_flux_mass_0\\\")\\n\\n\\t#Histograms parameters\\n\\tbin_X, min_X, max_X = hdata.GetNbinsX(), hdata.GetBinCenter(1) - 0.5*hdata.GetBinWidth(0), hdata.GetBinCenter(hdata.GetNbinsX()) + 0.5 * hdata.GetBinWidth(0)\\n\\n\\tclass Flux:\\n\\t\\tdef __call__( self, x, par ):\\n\\t\\t\\treturn exposure*fflux.Eval(x[0]) + par[0]\\n\\tnorm_flux = TF1(\\\"flux\\\", Flux(), min_X, max_X, 1)\\n\\tnorm_flux.SetParameter(0,0)\\n\\n\\t#Create bckg model histo in c/keV\\n\\thbckg = TH1F(\\\"hbckg\\\", \\\"hbckg\\\", bin_X, min_X, max_X)\\n\\tfor i in range(1,bin_X+1) :\\n\\t\\thbckg.SetBinContent(i, fmodel.Eval(hbckg.GetBinCenter(i)))\\n\\n\\tfor gAe in [14, 0.5] :\\n\\t\\tlist_result = []\\n\\t\\tfor nsimu in range(100) :\\n\\t\\t\\tprint gAe, nsimu\\n\\t\\t\\t#Simulate fake data \\n\\t\\t\\thdata_sim = TH1F(\\\"hdata_sim\\\"+str(nsimu)+str(gAe), \\\"hdata_sim\\\"+str(nsimu)+str(gAe), bin_X, min_X, max_X)\\n\\t\\t\\tfor i in range(1, bin_X+1): \\n\\t\\t\\t\\thdata_sim.SetBinContent(i, hbckg.GetBinContent(i) + np.random.poisson(np.power(gAe*1E-12,4)*norm_flux.Eval(hbckg.GetBinCenter(i))))\\n\\n\\t\\t\\thdata_sim.SetLineColor(kRed)\\n\\t\\t\\t# hsignal.SetLineColor(kGreen-3)\\n\\t\\t\\thbckg.Draw()\\n\\t\\t\\thdata_sim.Add(hbckg,-1)\\n\\t\\t\\thdata_sim.Draw(\\\"same\\\")\\n\\t\\t\\tprint hdata_sim.Integral()*hdata_sim.GetBinWidth(10)\\n\\t\\t\\t# hsignal.Draw(\\\"same\\\")\\n\\t\\t\\traw_input()\\n\\n\\t\\t\\t#Build likelihood\\n\\t\\t\\tclass likelihood_hist:\\n\\t\\t\\t\\tdef __call__( self, x, par ):\\n\\t\\t\\t\\t\\tlikelihood =0\\n\\t\\t\\t\\t\\tfor i in range(1,bin_X+1):\\n\\t\\t\\t\\t\\t\\tN_expected =hbckg.GetBinContent(i)+np.power(x[0]*1E-12,4)*norm_flux.Eval(hbckg.GetBinCenter(i)) #hsignal.GetBinContent(i)\\n\\t\\t\\t\\t\\t\\tN_obs = hdata_sim.GetBinContent(i)\\n\\t\\t\\t\\t\\t\\tif N_expected>0:\\n\\t\\t\\t\\t\\t\\t\\tlikelihood +=-N_expected+N_obs*np.log(N_expected)-log_factorial(N_obs)\\n\\t\\t\\t\\t\\treturn -(likelihood + par[0])\\n\\n\\t\\t\\tnll = TF1(\\\"nll\\\", likelihood_hist(), 1E-2,1E3, 1)\\n\\t\\t\\tnll.SetParameter(0,0)\\n\\t\\t\\tlist_result.append(nll.GetMinimumX())\\n\\t\\tpl.hist(list_result, histtype = \\\"step\\\", bins = 30)\\n\\t\\tpl.show()\\n\\t\\traw_input()\\n\\n\\t# #Create signal histo in c/keV, gAe set to 1\\n\\t# hsignal = TH1F(\\\"hsignal\\\", \\\"hsignal\\\", bin_X, min_X, max_X)\\n\\t# for i in range(1, 301) :\\n\\t# \\thsignal.SetBinContent(i, np.power(1E-12,4)*norm_flux.Eval(hsignal.GetBinCenter(i)))\\n\\n\\t# hbckg.SetLineColor(kRed)\\n\\t# hsignal.SetLineColor(kGreen-3)\\n\\t# hbckg.Draw()\\n\\t# hdata.Draw(\\\"same\\\")\\n\\t# hsignal.Draw(\\\"same\\\")\\n\\t# raw_input()\\n\\n\\n\\n\\t\\n\\n\\traw_input()\",\n \"def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # Construct the lower and upper bounds for each variable\\n bounds = []\\n # Bounds for harmonic oscillator frequencies\\n for i in range(Nvib):\\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\\n # Bounds for pseudo-hindered rotor frequency and barrier height\\n bounds.append((hrFreqLowerBound, hrFreqUpperBound))\\n bounds.append((hrBarrLowerBound, hrBarrUpperBound))\\n\\n # Construct the initial guess\\n # Initial guesses within each mode type must be distinct or else the\\n # optimization will fail\\n x0 = numpy.zeros(Nvib + 2, numpy.float64)\\n # Initial guess for harmonic oscillator frequencies\\n if Nvib > 0:\\n x0[0] = 200.0\\n x0[1:Nvib] = numpy.linspace(800.0, 1600.0, Nvib-1)\\n # Initial guess for hindered rotor frequencies and barrier heights\\n x0[Nvib] = 100.0\\n x0[Nvib+1] = 300.0\\n\\n # Execute the optimization\\n fit = PseudoRotorFit(Tlist, Cvlist, Nvib, Nrot)\\n fit.initialize(Neq=len(Tlist), Nvars=len(x0), Ncons=0, bounds=bounds, maxIter=maxIter)\\n x, igo = fit.solve(x0)\\n\\n # Check that the results of the optimization are valid\\n if not numpy.isfinite(x).all():\\n raise StatmechFitError('Returned solution vector is nonsensical: x = {0}.'.format(x))\\n if igo == 8:\\n logging.warning('Maximum number of iterations reached when fitting spectral data for {0}.'.format(molecule))\\n\\n # Postprocess optimization results\\n vib = list(x[0:Nvib])\\n hind = []\\n for i in range(Nrot):\\n hind.append((x[Nvib], x[Nvib+1]))\\n\\n return vib, hind\",\n \"def zpkfreqz(z, p, k, worN=None):\\n if worN is None or isinstance(worN, int):\\n N = worN or 512\\n ws = [mp.pi * mp.mpf(j) / N for j in range(N)]\\n else:\\n ws = worN\\n\\n h = []\\n for wk in ws:\\n zm1 = mp.exp(1j * wk)\\n numer = _prod([zm1 - t for t in z])\\n denom = _prod([zm1 - t for t in p])\\n hk = k * numer / denom\\n h.append(hk)\\n return ws, h\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\tQ = np.ones((len(Tlist)), np.float64) / self.symmetry\\n\\t\\t# Active K-rotor\\n\\t\\trotors = [mode for mode in self.modes if isinstance(mode, RigidRotor)]\\n\\t\\tif len(rotors) == 0:\\n\\t\\t\\tTrot = constants.h * constants.c * 100.0 * 1.0 / constants.kB\\n\\t\\t\\tQ0 = [math.sqrt(T / Trot) for T in Tlist]\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\t# Other modes\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tQ0 = mode.getPartitionFunction(Tlist)\\n\\t\\t\\tfor i in range(len(Tlist)):\\n\\t\\t\\t\\tQ[i] *= Q0[i]\\n\\t\\treturn Q\",\n \"def gibbs_(dict_, T):\\n\\tdST = dict_['S298'] + CpT(dict_, T)[0]\\n\\t\\t\\n\\tdHT = dict_['dH298'] + CpT(dict_, T)[1]/1000\\n\\t\\t\\n\\treturn (dHT - T*dST/1000)\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, collision_rate=91.0 / simtk.unit.picoseconds, timestep=1.0 * simtk.unit.femtoseconds):\\n\\n # Initialize constants.\\n kT = kB * temperature\\n gamma = collision_rate\\n\\n # Create a new custom integrator.\\n super(GHMCIntegrator, self).__init__(timestep)\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addGlobalVariable(\\\"b\\\", numpy.exp(-gamma * timestep)) # velocity mixing parameter\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addGlobalVariable(\\\"ke\\\", 0) # kinetic energy\\n self.addPerDofVariable(\\\"vold\\\", 0) # old velocities\\n self.addPerDofVariable(\\\"xold\\\", 0) # old positions\\n self.addGlobalVariable(\\\"Eold\\\", 0) # old energy\\n self.addGlobalVariable(\\\"Enew\\\", 0) # new energy\\n self.addGlobalVariable(\\\"accept\\\", 0) # accept or reject\\n self.addGlobalVariable(\\\"naccept\\\", 0) # number accepted\\n self.addGlobalVariable(\\\"ntrials\\\", 0) # number of Metropolization trials\\n self.addPerDofVariable(\\\"x1\\\", 0) # position before application of constraints\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Allow context updating here.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Constrain positions.\\n #\\n self.addConstrainPositions()\\n\\n #\\n # Velocity perturbation.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Metropolized symplectic step.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Eold\\\", \\\"ke + energy\\\")\\n self.addComputePerDof(\\\"xold\\\", \\\"x\\\")\\n self.addComputePerDof(\\\"vold\\\", \\\"v\\\")\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x + v*dt\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v + 0.5*dt*f/m + (x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Enew\\\", \\\"ke + energy\\\")\\n self.addComputeGlobal(\\\"accept\\\", \\\"step(exp(-(Enew-Eold)/kT) - uniform)\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x*accept + xold*(1-accept)\\\")\\n self.addComputePerDof(\\\"v\\\", \\\"v*accept - vold*(1-accept)\\\")\\n\\n #\\n # Velocity randomization\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sqrt(b)*v + sqrt(1-b)*sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Accumulate statistics.\\n #\\n self.addComputeGlobal(\\\"naccept\\\", \\\"naccept + accept\\\")\\n self.addComputeGlobal(\\\"ntrials\\\", \\\"ntrials + 1\\\")\",\n \"def total_band_energy(vals, T, Ec):\\n vals = np.sort(np.concatenate(vals))\\n occup = occup_TK(vals, T=T, spin=2)\\n return np.dot(vals, occup)-Ec\",\n \"def chernNum(self, kx_Bz=np.array([0,4*np.pi/3]), \\n ky_Bz=np.array([0,2*np.pi/np.sqrt(3)]), \\n N_res=30):\\n x_eps = 0.3 # shift from Dirac point\\n x_res = 20\\n kx_int = 0 + x_eps # -np.pi\\n kx_fin = 4*np.pi/3 + x_eps\\n Dx = (kx_fin - kx_int)/x_res\\n\\n y_res = 20\\n ky_int = 0 # -np.pi\\n ky_fin = 2*np.pi/np.sqrt(3)\\n Dy = (ky_fin - ky_int)/y_res\\n\\n Nd = self.Nd # dimension of the Hamiltonian\\n Dk = np.array([Dx,Dy], float)\\n\\n LF = np.zeros((Nd), dtype=complex)\\n LF_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n E_arr = np.zeros((Nd,x_res, y_res), dtype=float)\\n sumN = np.zeros((Nd), dtype=complex)\\n E_k = np.zeros((Nd), dtype=complex)\\n chernN = np.zeros((Nd), dtype=complex)\\n\\n # Loop over kx\\n for ix in range(x_res):\\n kx = kx_int + ix*Dx\\n\\n # Loop over ky\\n for iy in range(y_res):\\n ky = ky_int + iy*Dy\\n\\n k_vec = np.array([kx,ky], float)\\n\\n LF, E_k = self.latF(k_vec, Dk, self.delta)\\n\\n sumN += LF\\n\\n # # save data for plotting\\n LF_arr[:,ix,iy] = LF.imag\\n\\n E_arr[:,ix,iy] = np.sort(E_k.real)\\n\\n # End of ky Loop\\n # End of kx Loop\\n\\n chernN = sumN.imag/(2*np.pi)\\n print(\\\"Chern number bands are (%.3f, %.3f) \\\" \\n %(chernN[0], chernN[1]))\\n print(\\\"Sum of all bands Chern Number is %.2f \\\" %(sum(chernN)))\\n return chernN, E_arr\\n #################### \",\n \"def gyroHF(self, GYRO, PFC):\\n print(\\\"Calculating gyro orbit heat loads\\\")\\n log.info(\\\"Calculating gyro orbit heat loads\\\")\\n #get divertor HF\\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\\n #Get fractional multipliers for each helical trace\\n gyroFrac = 1.0/GYRO.N_gyroPhase\\n vPhaseFrac = 1.0/GYRO.N_vPhase\\n vSliceFrac = GYRO.energyFracs\\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\\n Pgyro = np.zeros((GYRO.Nt))\\n PNaN = 0.0\\n sum=0\\n sum1=0\\n #loop through intersect record and redistribute power using multipliers\\n for gyroPhase in range(GYRO.N_gyroPhase):\\n for vPhase in range(GYRO.N_vPhase):\\n for vSlice in range(GYRO.N_vSlice):\\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\\n notNanTo = notNanTo.astype(int) #cast as integer\\n isNanTo = idx[np.isnan(idx)] #indices we map power to\\n isNanTo = isNanTo.astype(int) #cast as integer\\n\\n if len(notNanFrom)>0:\\n #multiple Froms can light up the same To, so we loop\\n for i in range(len(notNanFrom)):\\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\\n\\n if len(isNanFrom)>0:\\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\\n\\n #print(\\\"\\\\nTEST2\\\")\\n #print(GYRO.intersectRecord[0,0,0,1711])\\n #print(Pgyro[1711])\\n\\n GYRO.gyroPowMatrix += Pgyro\\n GYRO.gyroNanPower += PNaN\\n return\",\n \"def T_c(I, T_amb, V, D, R_list, N_cond=1, T_range=[298,323,348], a_s=0.9, e_s=0.9, I_sun=900.0, temp_factor=1, wind_factor=1, n_iter=10):\\n\\n # def Q_gen(I, R):\\n # w = I * I * R\\n # return w\\n\\n # def Q_rad_in(I_sun, A_s, a_s):\\n # w = I_sun * D * a_s\\n # return w\\n\\n # def Q_conv(htcoeff, A_s, T_lin, T_amb):\\n # w = htcoeff * A_s * (T_line - T_amb)\\n # return w\\n\\n # def Q_rad_out(e_s, A_s, sigma, T_line, T_amb):\\n # w = e_s * D * sigma * (T_line**4 - T_amb**4)\\n # return w\\n\\n def reynolds(V, D, v, Mair=1.103):\\n r = V * D / v\\n return r\\n\\n def nusselt(Re, Pr):\\n a = 0.62 * ( (Re) ** (1.0/2.0) ) * ( Pr ** (1.0/3.0) )\\n b = (1 + (0.4/(Pr**(2.0/3.0) ) ) ) ** (1.0/4.0)\\n c = (Re / 282000) ** (5.0/8.0)\\n n = 0.3 + (a/b) * ( (1 + c) ** (4.0/5.0) )\\n return n\\n\\n def air_prop(T_amb):\\n # temp v k Pr\\n air_prop = np.array([[200, 7.59e-6, 18.1e-3, 0.737],\\n [250, 11.44e-6, 22.3e-3, 0.720],\\n [300, 15.89e-6, 26.3e-3, 0.707],\\n [350, 20.92e-6, 30.0e-3, 0.700],\\n [400, 26.41e-6, 33.8e-3, 0.690],\\n [450, 32.39e-6, 37.3e-3, 0.686],\\n [500, 38.79e-6, 40.7e-3, 0.684],\\n [550, 45.57e-6, 43.9e-3, 0.683],\\n [600, 52.69e-6, 46.9e-3, 0.685]])\\n\\n v, k, Pr = np.apply_along_axis(lambda x: np.interp(T_amb, air_prop[:,0], x),\\n 0, air_prop[:,1:])\\n return v, k, Pr\\n\\n def R_T(R_lo, R_mid, R_hi, T_line, N_cond, T_range=T_range):\\n if 273 <= T_line <= 323:\\n R = ((R_lo + \\n ((R_lo - R_mid)/(T_range[0] - T_range[1]))\\n *(T_line - T_range[0]))/N_cond)\\n elif T_line > 323:\\n R = ((R_mid + \\n ((R_mid - R_hi)/(T_range[1] - T_range[2]))\\n *(T_line - T_range[1]))/N_cond)\\n else:\\n R = R_lo\\n print('Out of bounds')\\n return R\\n\\n R_lo, R_mid, R_hi = R_list[0], R_list[1], R_list[2]\\n temp_factor = 1\\n wind_factor = 1\\n sigma = 5.6703e-8 # Stefan-Boltzmann constant\\n\\n T_amb = T_amb*temp_factor\\n V = V*wind_factor\\n\\n v, k, Pr = air_prop(T_amb)\\n Re = reynolds(V, D, v)\\n htcoeff = nusselt(Re, Pr) * k / D\\n\\n def T_line(T_init):\\n \\n R = R_T(R_lo, R_mid, R_hi, T_init, N_cond)\\n print R\\n\\n C4 = e_s * sigma * D * math.pi\\n C3 = 0.0\\n C2 = 0.0\\n C1 = htcoeff * D * math.pi\\n C0 = - ( I ** 2 * R\\n + I_sun * a_s * D\\n + htcoeff * D * math.pi * T_amb\\n + e_s * D * math.pi * sigma * (T_amb ** 4))\\n\\n return np.roots([C4, C3, C2, C1, C0])\\n\\n T_c = T_amb\\n \\n for i in range(n_iter):\\n T_arr = T_line(T_c)\\n T_c = np.real(T_arr[np.where((np.real(T_arr) > 0) & ~(np.iscomplex(T_arr)))]).mean()\\n print T_c\\n\\n return T_c\",\n \"def compute_energy_density(kT):\\n h=u.planck\\n c=u.speed_of_light\\n pi=np.pi\\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)\",\n \"def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\\n\\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\\n\\td = dist * 1e3 * pc\\n\\t# Radius (in unit of pc)\\n\\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\\n\\t# Mass\\n\\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\\n\\t# Number density\\n\\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\\n\\t# Sigmav of 2.33H\\n\\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\\n\\t# Virial\\n\\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\\n\\t# Virial parameter with B-field, assume 1 mG\\n\\tB = 1 * 1e-3 # G\\n\\trho = density * 2.8 * mp # g/cm3\\n\\talfven = B / np.sqrt(4*np.pi*rho)\\n\\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\\n\\n\\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B\",\n \"def clumps_finding(text, k, t, L):\\n frequent_patterns = []\\n clumps = [0 for i in range(0, 4**k)]\\n for i in range(0, len(text) - L + 1):\\n subtext = text[i:i + L]\\n freq_array = compute_freq(subtext, k)\\n for index, freq in enumerate(freq_array):\\n if freq >= t:\\n clumps[index] = 1\\n for index, clump in enumerate(clumps):\\n if clump == 1:\\n pattern = number_to_pattern(index, k)\\n frequent_patterns.append(pattern)\\n return frequent_patterns\",\n \"def makeRecombMapBooker(snplist, rholist, chrom):\\n if chrom == \\\"X\\\":\\n mapsize = 44.7\\n elif chrom == \\\"3R\\\":\\n mapsize = 90.9\\n elif chrom == \\\"3L\\\":\\n mapsize = 89.1\\n elif chrom == \\\"2L\\\":\\n mapsize = 63.2\\n elif chrom == \\\"2R\\\":\\n mapsize = 94.8\\n elif chrom == \\\"2RL\\\":\\n mapsize = 158\\n elif chrom == \\\"3RL\\\":\\n mapsize = 180\\n poslist = []\\n rhocum = []\\n cMlist = []\\n cMMblist = []\\n for i, pos in enumerate(snplist):\\n if i == 0:\\n rhoTemp = (rholist[i] * (pos))\\n else:\\n rhoTemp = (rholist[i] * (pos - snplist[i-1]))\\n if i == 0:\\n rhocum.append(rhoTemp)\\n else:\\n rhocum.append(rhocum[-1] + rhoTemp)\\n poslist.append(pos)\\n for i, j in enumerate(rhocum):\\n cMperSNP = (j / rhocum[-1])\\n cMlist.append(cMperSNP)\\n cMMblist.append(((cMlist[i] - cMlist[i-1])*mapsize) / ((snplist[i] - snplist[i-1])/1E6))\\n return(poslist, cMMblist, cMlist)\",\n \"def get_hbls_hbbl(self):\\n [Ly,N] = self.b.shape\\n z_u_w = self.grid_dict['z_u_w']\\n z_u_r = self.grid_dict['z_u_r']\\n u = self.u\\n v = self.v\\n \\n v_upts = TTTW_func.v2u(v)\\n Hz = z_u_w[:,1:] - z_u_w[:,:-1]\\n\\n\\n\\n # CALCULATE swr_frac\\n self.swr_frac = TTTW_func.lmd_swr_frac(self.grid_dict)\\n\\n\\n # WHOLE THING HAPPENS IN j loop through y-indices\\n \\n # INITIALIZE ARRAYS\\n self.kmo = np.zeros([Ly])\\n self.Cr = np.zeros([Ly])\\n self.kbl = np.empty([Ly],dtype='int')\\n self.C_h_MO = np.zeros([Ly])\\n self.Cr = np.zeros([Ly,N+1]) # sum term\\n self.FC = np.zeros([Ly,N+1])\\n self.swdk_r = np.zeros([Ly,N+1])\\n \\n self.zscale = np.zeros([Ly,N])\\n self.Kern = np.zeros([Ly,N])\\n\\n \\n # --> LOOP THROUGH Y-INDICES\\n for j in range(Ly):\\n if self.LIMIT_MO_DEPTH:\\n self.kmo[j] = 0\\n self.C_h_MO[j] = self.C_MO *self.ustar[j]**3/self.vonKar\\n \\n self.kbl[j] = 0\\n self.Cr[j,-1] = 0 # set top Cr\\n self.Cr[j,0] = 0 # set bottom Cr\\n \\n # SEARCH FOR MIXED LAYER DEPTH\\n self.FC[j,-1] = 0.\\n\\n\\n # ---> LOOP TOP TO BOTTOM (FORTRAN ==> k=N-1,1,-1)\\n for k in range(N-1,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n \\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n self.zscale[j,k_w] = zscale\\n if self.LMD_KPP:\\n if self.LMD_BKPP:\\n zscaleb = z_u_r[j,k_r] - z_u_w[j,0]\\n Kern = zscale * zscaleb**2 / ( (zscale + self.epssfcs*self.hbls_old[j]) * (zscaleb**2+(self.epssfcb**2*self.hbbl_old[j]**2)))\\n else:\\n Kern = zscale / (zscale + (self.epssfcs*self.hbls_old[j]))\\n else:\\n Kern = 1.\\n \\n\\n\\n self.Kern[j,k_w] = Kern\\n self.FC[j,k_w] = self.FC[j,k_w+1] + Kern * (\\\\\\n ( ( u[j,k_r+1] - u[j,k_r] )**2 + ( v_upts[j,k_r+1] - v_upts[j,k_r])**2 ) \\\\\\n / (Hz[j,k_r] + Hz[j,k_r+1]) \\\\\\n - 0.5 * ( Hz[j,k_r] + Hz[j,k_r+1]) * (self.Ri_inv * self.bvf[j,k_w] + self.C_Ek*self.f[j]*self.f[j]))\\n\\n\\n #\\t\\tLOOP THAT FINDS BL DEPTH ##\\n #----> LOOP TOP TO BOTTOM (start at free surface, w-level surface) \\n \\n if self.LMD_KPP:\\n #swdk_r only used in this function so don't need to be class attribute\\n # but for testing make it an attribute to see what it is\\n \\n # fortran equivlanet ===> k=N,1,-1 \\n for k in range(N,0,-1):\\n # INDEX MAP\\n k_r = k-1\\n k_w = k\\n\\n ###################################################################### \\n self.swdk_r[j,k_w] = np.sqrt( self.swr_frac[j,k_w] * self.swr_frac[j,k_w-1])\\n zscale = z_u_w[j,N] - z_u_r[j,k_r]\\n Bfsfc = self.Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])\\n \\n self.bvf_max = np.sqrt(np.max([0,self.bvf[j,k_w-1]]))\\n \\n # CALCULATE TURBULENT VELOCITY SCALE FOR TRACERS\\n \\t\\t\\t self.ws = self.lmd_wscale_ws_only(Bfsfc, zscale,self.hbls_old[j],self.ustar[j])\\n \\n self.Vtsq = self.Vtc * self.ws* self.bvf_max + self.V0\\n \\n\\n self.Cr[j,k_w] = self.FC[j,k_w] + self.Vtsq\\n \\n\\n #######################################################################\\n \\n # SEARCH FOR hbls vertical level #\\n '''\\n kbl is specified at vertical w-level (via Cr which is at\\n vertical w-levels)\\n '''\\n if self.kbl[j] == 0 and self.Cr[j,k_w] < 0:\\n self.kbl[j] = k_w\\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] == 0 and Bfsfc*(z_u_w[j,N] - z_u_r[j,k_r]) > self.C_h_MO[j]:\\n self.kmo[j] = k_w\\n\\n \\n #--> still in j-loop\\n #######################################################\\n \\n # \\t\\tGET SURFACE BOUNDARY LAYER DEPTH # \\n self.hbls[j] = z_u_w[j,N] - z_u_w[j,0] + self.eps # set hbls as depth of entire water column\\n if self.kbl[j] > 0:\\n k_w = self.kbl[j]\\n k_r = k_w - 1 \\n if k_w == N: # set hbls at the surface btwn w- and rho-levels at surface\\n self.hbls[j] = z_u_w[j,N] - z_u_r[j,N-1]\\n \\n else:\\n self.hbls[j] = z_u_w[j,N] - ( z_u_r[j,k_r] * self.Cr[j,k_w+1] - z_u_r[j,k_r+1] * self.Cr[j,k_w]) / \\\\\\n (self.Cr[j,k_w+1] - self.Cr[j,k_w])\\n \\n if self.LIMIT_MO_DEPTH:\\n if self.kmo[j] > 0:\\n k_w = self.kmo[j]\\n k_r = k_w-1\\n if k_w == N:\\n z_up = z_u_w[j,N]\\n cff_up = np.max([0,Bo[j]])\\n else:\\n z_up = z_r[j,k_w+1]\\n cff_up = np.max([0, Bo[j] + self.Bosol[j]*(1-self.swdk_r[j,(k_w-1)+1])])\\n \\n cff_dn = np.max([0,Bo[j] + self.Bosol[j] * (1-self.swdk_r[j,k_w])]) \\n h_MO = z_u_w[j,N] + self.C_h_MO[j] * ( cff_up*z_up - cff_dn * z_u_r[j,k_r] ) \\\\\\n / ( cff_up * cff_dn * (z_up - z_u_r[j,k_r]) ) \\\\\\n + self.C_h_MO[j] * (cff_dn - cff_up)\\n\\n self.hbls[j] = np.min([self.hbls[j],np.max([h_MO,0])])\\n\\n\\n\\n #### GET BOTTOM BOUNDARY LAYER DEPTH #######\\n if self.LMD_BKPP:\\n self.kbl[j] = 0 # reset Cr at bottom and kbl for BKPP\\n self.Cr[j,0] = 0.\\n self.FC[j,0] = 1.5 * self.FC[j,1] - 0.5 * self.FC[j,2] # linear extrapolation\\n \\n #---> LOOP BOTTOM TO TOP\\n # FIND kbl for BBL\\n for k in range(1,N+1):\\n k_r = k-1\\n k_w = k \\n self.Cr[j,k_w] = self.FC[j,k_w] - self.FC[j,0]\\n \\n # LOOK FOR FIRST ZERO CROSSING FROM BOTTOM UP\\n if self.kbl[j] == 0 and self.Cr[j,k_w] > 0:\\n self.kbl[j] = k_w \\n \\n\\n self.hbbl[j] = z_u_w[j,N] - z_u_w[j,0] # total depth\\n if self.kbl[j] > 0 :\\n k_w = self.kbl[j] \\n k_r = k_w -1\\n if k_w == 1: # NO BBL CASE\\n self.hbbl[j] = z_u_r[j,0] - z_u_w[j,0] #in between bottom rho and w-level\\n else:\\n self.hbbl[j] = ( z_u_r[j,k_r-1] * self.Cr[j,k_w] - z_u_r[j,k_r] * self.Cr[j,k_w-1]) / \\\\\\n (self.Cr[j,k_w] - self.Cr[j,k_w-1]) - z_u_w[j,0]\",\n \"def specCoeffsInReaction(r):\\n c = []\\n for k in range(__data.nsp):\\n nu = (__data.g.product_stoich_coeff(k,r) -\\n __data.g.reactant_stoich_coeff(k,r))\\n if (nu <> 0):\\n c.append((__data.g.species_name(k),nu))\\n return c\",\n \"def mfccInitFilterBanks(fs, nfft):\\n\\n # filter bank params:\\n lowfreq = 133.33\\n linsc = 200/3.\\n logsc = 1.0711703\\n numLinFiltTotal = 13\\n numLogFilt = 27\\n\\n if fs < 8000:\\n nlogfil = 5\\n\\n # Total number of filters\\n nFiltTotal = numLinFiltTotal + numLogFilt\\n\\n # Compute frequency points of the triangle:\\n freqs = numpy.zeros(nFiltTotal+2)\\n freqs[:numLinFiltTotal] = lowfreq + numpy.arange(numLinFiltTotal) * linsc\\n freqs[numLinFiltTotal:] = freqs[numLinFiltTotal-1] * logsc ** numpy.arange(1, numLogFilt + 3)\\n heights = 2./(freqs[2:] - freqs[0:-2])\\n\\n # Compute filterbank coeff (in fft domain, in bins)\\n fbank = numpy.zeros((nFiltTotal, nfft))\\n nfreqs = numpy.arange(nfft) / (1. * nfft) * fs\\n\\n for i in range(nFiltTotal):\\n lowTrFreq = freqs[i]\\n cenTrFreq = freqs[i+1]\\n highTrFreq = freqs[i+2]\\n\\n lid = numpy.arange(numpy.floor(lowTrFreq * nfft / fs) + 1, numpy.floor(cenTrFreq * nfft / fs) + 1, dtype=numpy.int)\\n lslope = heights[i] / (cenTrFreq - lowTrFreq)\\n rid = numpy.arange(numpy.floor(cenTrFreq * nfft / fs) + 1, numpy.floor(highTrFreq * nfft / fs) + 1, dtype=numpy.int)\\n rslope = heights[i] / (highTrFreq - cenTrFreq)\\n fbank[i][lid] = lslope * (nfreqs[lid] - lowTrFreq)\\n fbank[i][rid] = rslope * (highTrFreq - nfreqs[rid])\\n\\n return fbank, freqs\",\n \"def rcfilter_C(freq, R):\\n R = _normalizevalue(R)\\n C = 1/(R*freq*2*math.pi)\\n return _Cap(C)\",\n \"def get_quantum_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n f = 0\\n for m in self.input.structure.get_masses():\\n hbar_omega = (\\n HBAR\\n * np.sqrt(self.input.spring_constant / m)\\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\\n )\\n f += (3.0 / 2) * hbar_omega + (\\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\\n )\\n return f\",\n \"def calculate_bandwidth(self, complist):\\n\\n self.type = complist[0]\\n self.spot = complist[2]\\n self.value = complist[1]\\n self.fail = False\\n\\n if self.spot == \\\"1\\\" or self.spot == \\\"2\\\":\\n # print \\\"Calculation if Loop 1st filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c1 == 0:\\n self.c1 = self.value\\n else:\\n self.fail = True\\n else:\\n if self.r1 == 0:\\n self.r1 = self.value\\n else:\\n self.fail = True\\n\\n if self.spot == \\\"3\\\" or self.spot == \\\"4\\\":\\n # print \\\"Calculation if loop 2nd filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c2 == 0:\\n self.c2 = self.value\\n else:\\n self.fail = True\\n else: #self.type == \\\"R\\\"\\n if self.r2 == 0:\\n self.r2 = self.value\\n else:\\n self.fail = True\\n\\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\\n #print \\\"hello!\\\"\\n cf_low = str(cf_low)\\n self.cutoff_freql = cf_low\\n self.cutoff_freql_text = cf_low + \\\"K\\\"\\n print self.cutoff_freql_text\\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\\n cf_high = str(cf_high)\\n self.cutoff_freqh = cf_high\\n self.cutoff_freqh_text = cf_high + \\\"K\\\"\\n print self.cutoff_freqh_text\\n voltage_change = float((self.r2)/self.r1)\\n voltage = 5 + voltage_change\\n self.voltage = str(voltage)\\n print self.voltage\",\n \"def mfccInitFilterBanks(fs, nfft):\\n # filter bank params:\\n lowfreq = 133.33\\n linsc = 200/3.\\n logsc = 1.0711703\\n numLinFiltTotal = 13\\n numLogFilt = 27\\n\\n if fs < 8000:\\n nlogfil = 5\\n\\n # Total number of filters\\n nFiltTotal = numLinFiltTotal + numLogFilt\\n\\n # Compute frequency points of the triangle:\\n freqs = np.zeros(nFiltTotal+2)\\n freqs[:numLinFiltTotal] = lowfreq + np.arange(numLinFiltTotal) * linsc\\n freqs[numLinFiltTotal:] = freqs[numLinFiltTotal-1] * logsc ** np.arange(1, numLogFilt + 3)\\n heights = 2./(freqs[2:] - freqs[0:-2])\\n\\n # Compute filterbank coeff (in fft domain, in bins)\\n fbank = np.zeros((nFiltTotal, nfft))\\n nfreqs = np.arange(nfft) / (1. * nfft) * fs\\n\\n for i in range(nFiltTotal):\\n lowTrFreq = freqs[i]\\n cenTrFreq = freqs[i+1]\\n highTrFreq = freqs[i+2]\\n\\n lid = np.arange(np.floor(lowTrFreq * nfft / fs) + 1,\\n np.floor(cenTrFreq * nfft / fs) + 1,\\n dtype=np.int)\\n lslope = heights[i] / (cenTrFreq - lowTrFreq)\\n rid = np.arange(np.floor(cenTrFreq * nfft / fs) + 1,\\n np.floor(highTrFreq * nfft / fs) + 1,\\n dtype=np.int)\\n rslope = heights[i] / (highTrFreq - cenTrFreq)\\n fbank[i][lid] = lslope * (nfreqs[lid] - lowTrFreq)\\n fbank[i][rid] = rslope * (highTrFreq - nfreqs[rid])\\n\\n return fbank, freqs\",\n \"def mce_filter(freq, f_raw, params):\\n\\tz = np.exp(-2j*np.pi*freq/f_raw)\\n\\tb11, b12, b21, b22 = np.array(params[:4])*0.5**14\\n\\tH = (1+z)**4 / (1-b11*z+b12*z**2) / (1-b21*z+b22*z**2)\\n\\tH /= 2**4 / (1-b11+b12) / (1-b21+b22)\\n\\treturn H\",\n \"def coolingrate(tables, density, He_mass_frac=0.258, metallicity=0.25):\\n # list of all elements in table\\n elements = [\\n x for x in tables.keys() if x not in [\\n 'Header', 'Metal_free', 'Solar', 'Total_Metals']\\n ]\\n \\n # Helium mass fraction bins of only hydrogen and helium\\n metal_free_He_mass_frac = list(\\n tables['Metal_free']['Helium_mass_fraction_bins']\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of /Metal_free/Hydrogen_density_bins, \\n # /Metal_free/Temperature_bins, and helium abundance.\\n metal_free_ne_nh = list(\\n tables['Metal_free']['Electron_density_over_n_h']\\n )\\n \\n # Find index of He mass frac, ssuming direct match in table.\\n He_mass_frac_index = metal_free_He_mass_frac.index(np.float32(He_mass_frac))\\n # Find index of density bin, ssuming direct match in table.\\n abundance_index = list(\\n tables[elements[0]]['Hydrogen_density_bins']).index(np.float32(density)\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of temperature at given denisty and helium mass fraction.\\n metal_free_ne_nh = list(\\n tables['Metal_free']\\\\\\n ['Electron_density_over_n_h']\\\\\\n [He_mass_frac_index, :,abundance_index]\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of temperature at given density for solar abundance.\\n solar_ne_nh = tables['Solar']\\\\\\n ['Electron_density_over_n_h']\\\\\\n [:, abundance_index]\\n\\n # Normalized net cooling rate for only hydrogen and helium as a function of \\n # /Metal_free/Hydrogen_density_bins, /Metal_free/Temperature_bins, \\n # and helium abundance. \\n lambda_metal_free = tables['Metal_free']\\\\\\n ['Net_Cooling']\\\\\\n [He_mass_frac_index, :, abundance_index]\\n \\n # Temperature bins (T [K])\\n T = tables['Metal_free']['Temperature_bins']\\n \\n sum_metals = np.zeros(352)\\n for e in elements:\\n # Normalized, net cooling rate e as a function of temperature for \\n # Hydrogen density 'density'.\\n lambda_i_solar = tables[e]['Net_Cooling'][:,abundance_index]\\n \\n # Calulating the cooling contribution of element e and addind to total.\\n sum_metals += lambda_i_solar*(metal_free_ne_nh/solar_ne_nh)*metallicity\\n \\n coolingrate = lambda_metal_free + sum_metals\\n \\n return T, coolingrate\",\n \"def doCalculation(self, E1, E2, muL, muR, T, pot, C, TCalc, Density, E0, L):\\n NEcut = len(E1) #we determine the number of single-particle states that we use\\n VG=np.diag(pot)\\n E= int(0.5*np.size(VG))\\n V = VG[0:E] #since the potential of both barriers is symmetric and we only tunnel through one barrier. Therefore we only use one half of the potential.\\n dx= L/(np.size(pot))\\n\\n #Following prints are for debugging purposes:\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"Hier beginnt die Ausgabe von Rates:\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"V:\\\", V)\\n #print(\\\"E1:\\\", E1)\\n #print(\\\"E2:\\\", E2)\\n #print(\\\"C:\\\", C)\\n\\n kB=0.08629 #Boltzmann constant in meV/K\\n \\n \\n def fermi(E,mu,T):\\n \\\"\\\"\\\"This fermi-function tells us with which likelyhood a state with an E is occupied on the lead.\\n E(float): energy difference between the initial and the final state that the tunneling electron has to carry.\\n mu(float): chemical potential of either drain(muR) or source(muL).\\n T(float): temperature.\\n \\\"\\\"\\\"\\n if (E-mu)/T > 600:\\n f=0\\n\\t\\t\\t\\t\\n else:\\n f=1/(math.exp((E-mu)/(kB*T) )+1)\\n return(f)\\n \\n\\n\\t#This function is called by the Gamma_ij-equations and includes the transmission-coefficient for each tunnelling-event\\n #and the density of state function of the source and drain. \\n def Gamma(Ea,Eb,V):\\n \\\"\\\"\\\":math:`\\\\\\\\Gamma` includes the transmission coefficient and DOS: :math:`\\\\Gamma = | t |^2 * DOS`\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n V(np.array): barrier potential\\n \\\"\\\"\\\"\\n #print(Ea)\\n #print(V)\\n return (np.absolute(TCalc.calculate_transmission(Ea,V,dx))**2*Density.calculate_DensityofStates(np.absolute(Ea-Eb)))\\n \\n #These next four functions are used to calculate the transition rates.Each function for a different kind of transition:\\n #We distinguish between transitions, in which the number of electrons on the dot changes from one to two(Gamma_12) and reverse(Gamma_21).\\n #And between transitions in which the number of electrons on the dot change from zero to one(Gamma_01) and reverse(Gamma_10).\\n\\n def Gamma_12(Ea,Eb,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a one body state to a two body state.\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n summe=0\\n j=0\\n Cb=C[np.where(E2==Eb)[0][0]]\\n while j< NEcut:\\n summe=Cb[np.where(E1==Ea)[0][0]][j]+summe\\n j=j+1\\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*fermi((Eb-Ea),mu,T))\\n\\n\\n def Gamma_01(Eb,mu,T):\\n \\\"\\\"\\\"Calculates the transition rate from the vacuum state to a one-body state.\\n\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n return(Gamma(E0,Eb,V)*fermi((Eb-E0),mu,T))\\n\\n def Gamma_21(Ea,Eb,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a two body state to a one body state.\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n summe=0\\n nu=0\\n Ca=C[np.where(E2==Ea)[0][0]]\\n while nu < NEcut:\\n summe=summe+Ca[np.where(E1==Eb)[0][0]][nu]\\n nu=nu+1\\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*(1-fermi((Ea-Eb),mu,T)))\\n\\n def Gamma_10(Ea,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a one body state to the vacuum state.\\n\\n Ea(float): energy of initial state \\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n return(Gamma(Ea,E0,V)*(1-fermi((Ea-E0),mu,T)))\\n\\n #creating the output matrices that later contain all the transition rates through either\\n #the left or the right barrier\\n Gamma_R=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\\n Gamma_L=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\\n\\n #using a loop to fill the output matrices with transition rates.\\n i_=0\\n for i in E1:\\n j_=0\\n for j in E2:\\n Gamma_L[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muL,T)\\n Gamma_L[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muL,T)\\n Gamma_R[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muR,T)\\n Gamma_R[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muR,T)\\n j_=j_+1\\n Gamma_L[0][i_+1]=Gamma_10(i,muL,T)\\n Gamma_R[0][i_+1]=Gamma_10(i,muR,T)\\n Gamma_L[i_+1][0]=Gamma_01(i,muL,T)\\n Gamma_R[i_+1][0]=Gamma_01(i,muR,T)\\n i_=1+i_\\n\\n #print(\\\"Gamma_L und Gamma_R:\\\")\\n #print(Gamma_L,Gamma_R)\\n #print(\\\"-----------------------------------------------------------------------\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n return(Gamma_L,Gamma_R)\",\n \"def GetGC(flanks):\\n gc = 0\\n total = 0\\n for i in flanks:\\n if i != \\\"N\\\":\\n total += 1\\n if i == \\\"C\\\" or i == \\\"G\\\": gc += 1\\n return gc*1.0/total\",\n \"def hertz_to_mel(freq):\\n return 2595.0 * np.log10(1 + (freq / 700.0))\",\n \"def makedtimes(in_list,bucket,date,radar):\\n s = pd.Series(in_list)\\n split_s = s.str.split(bucket + date.strftime('/%Y/%m/%d/') + radar + '/' + radar+date.strftime('%Y%m%d_'),expand=True)\\n split_s = split_s[1]\\n counts = split_s.str.len()\\n if date < np.datetime64('2007-12-31'):\\n version = '.gz'\\n min_count = 9.0\\n elif date < np.datetime64('2015-12-31'):\\n version = '_V06'\\n min_count = 13\\n else:\\n min_count=10.0\\n if radar[0]=='K':\\n version = '_V06'\\n elif radar[0] =='T':\\n version = '_V08'\\n split_s = split_s.str.split(version,expand=True)\\n split_s = split_s[0]\\n dtime = pd.to_datetime(date.strftime('%Y-%m-%d ')+ split_s).values\\n df = pd.DataFrame(in_list,index=dtime)\\n\\n df['counts'] = pd.Series(counts.values,index=dtime)\\n df = df.where(df.counts == min_count).dropna()\\n df = df.drop('counts',axis=1)\\n return df\",\n \"def __init__(self, temperature=298.0 * simtk.unit.kelvin, nsteps=10, timestep=1 * simtk.unit.femtoseconds):\\n\\n super(HMCIntegrator, self).__init__(timestep)\\n\\n # Compute the thermal energy.\\n kT = kB * temperature\\n\\n #\\n # Integrator initialization.\\n #\\n self.addGlobalVariable(\\\"naccept\\\", 0) # number accepted\\n self.addGlobalVariable(\\\"ntrials\\\", 0) # number of Metropolization trials\\n\\n self.addGlobalVariable(\\\"kT\\\", kT) # thermal energy\\n self.addPerDofVariable(\\\"sigma\\\", 0)\\n self.addGlobalVariable(\\\"ke\\\", 0) # kinetic energy\\n self.addPerDofVariable(\\\"xold\\\", 0) # old positions\\n self.addGlobalVariable(\\\"Eold\\\", 0) # old energy\\n self.addGlobalVariable(\\\"Enew\\\", 0) # new energy\\n self.addGlobalVariable(\\\"accept\\\", 0) # accept or reject\\n self.addPerDofVariable(\\\"x1\\\", 0) # for constraints\\n\\n #\\n # Pre-computation.\\n # This only needs to be done once, but it needs to be done for each degree of freedom.\\n # Could move this to initialization?\\n #\\n self.addComputePerDof(\\\"sigma\\\", \\\"sqrt(kT/m)\\\")\\n\\n #\\n # Allow Context updating here, outside of inner loop only.\\n #\\n self.addUpdateContextState()\\n\\n #\\n # Draw new velocity.\\n #\\n self.addComputePerDof(\\\"v\\\", \\\"sigma*gaussian\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Store old position and energy.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Eold\\\", \\\"ke + energy\\\")\\n self.addComputePerDof(\\\"xold\\\", \\\"x\\\")\\n\\n #\\n # Inner symplectic steps using velocity Verlet.\\n #\\n for step in range(nsteps):\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x+dt*v\\\")\\n self.addComputePerDof(\\\"x1\\\", \\\"x\\\")\\n self.addConstrainPositions()\\n self.addComputePerDof(\\\"v\\\", \\\"v+0.5*dt*f/m+(x-x1)/dt\\\")\\n self.addConstrainVelocities()\\n\\n #\\n # Accept/reject step.\\n #\\n self.addComputeSum(\\\"ke\\\", \\\"0.5*m*v*v\\\")\\n self.addComputeGlobal(\\\"Enew\\\", \\\"ke + energy\\\")\\n self.addComputeGlobal(\\\"accept\\\", \\\"step(exp(-(Enew-Eold)/kT) - uniform)\\\")\\n self.addComputePerDof(\\\"x\\\", \\\"x*accept + xold*(1-accept)\\\")\\n\\n #\\n # Accumulate statistics.\\n #\\n self.addComputeGlobal(\\\"naccept\\\", \\\"naccept + accept\\\")\\n self.addComputeGlobal(\\\"ntrials\\\", \\\"ntrials + 1\\\")\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def add_energy(self, T=0, beta=0, Mkep=0, mu=1, gamma=5/3., Tmin=0., AU=1):\\n \\n if self.npart == 0:\\n self.u = array([])\\n return\\n\\n print(' Adding temperature...')\\n\\n radii = norm(self.pos - self.center, axis=1)\\n \\n if T < 0:\\n print(' Setting Temperature according to c_s(r)**2, with c_s(r) = h * v_kep(r),')\\n if not hasattr(self, 'v_kep'): self.v_kep = sqrt(Mkep * G / radii)\\n c_s = self.h * self.v_kep\\n if gamma <= 0: gamma_cs = 1\\n else: gamma_cs = gamma\\n if mu <= 0:\\n if gamma == 1.4: mu_cs = 2.01 # Adiabatic molecular\\n else: mu_cs = 1.005 # Adiabatic/Isothermal atomic\\n\\n print(' using gamma = {:.3f}, and mu = {:.3f}...'.format(gamma_cs, mu_cs)) \\n \\n T = c_s**2 * mu_cs * mP / (gamma_cs * KB)\\n\\n else:\\n T = full(self.npart, T * (radii / AU)**beta)\\n\\n\\n T[T < Tmin] = Tmin \\n \\n # This following settings are still being tested if correct\\n \\n if mu <= 0:\\n print(' Calculating mu used in code...')\\n mu = full(self.npart, 0.5) # Ionized\\n mu[T < 1.e4] = 1.005 # Atomic\\n mu[T < 2.e3] = 2.01 # Molecular (Optional)\\n\\n if gamma <= 0:\\n print(' Calculating gamma used in code...')\\n gamma = full(self.npart, 5/3.) # Adiabatic monoatomic\\n gamma[T < 2.e3] = 1.4\\t # Adiabatic diatomic\\n\\n factor = KB / (mP * mu * (gamma - 1))\\n \\n if max(T) == min(T): print(\\\" Temperature: {} [K]\\\".format(T[0]))\\n else:\\n print(' Maximum temperature: {:.2f} [K]'.format(max(T)))\\n print(' Minimum temperature: {:.2f} [K]'.format(min(T)))\\n \\n\\n self.u = T * factor\",\n \"def torch_mel_to_hertz(frequencies_mel):\\r\\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\\r\\n return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\",\n \"def __setSpectrum__(self):\\n \\n self.Ck = []\\n TempCk = []\\n TempOneCk = OneCk()\\n \\n # Process 1st frequency\\n Tb = self.freqs[1].totalJ\\n \\n for b in range(-Tb, Tb, 1):\\n TempOneCk.freq = b*self.freqs[1].Vph\\n TempOneCk.Amp = self.freqs[1].Cjk(b)\\n self.Ck.append(TempOneCk)\\n \\n # Process additional frequencies\\n CkSize = len(self.Ck)\\n Added = FALSE\\n \\n for f in range(2, len(self.freqs), 1):\\n # Reset temporary variables\\n Tb = self.freqs[f].totalJ\\n TempCk = []\\n \\n # Calculate each Ck coefficient\\n for b in range(-Tb, Tb, 1):\\n for k in range(CkSize):\\n TempOneCk.Amp = Ck[k].Amp * self.freq[f].Cjk(b)\\n \\n # Check to see if Amp is big enough to keep\\n if( abs(TempOneCk.Amp) > self.min_Ck ):\\n Added = FALSE\\n TempOneCk.freq = self.Ck[k].freq + b*self.freqs.Vph\\n \\n # If freq is already in Ck, add new value to old,\\n # if not, add new value and freq to spectrum\\n for c in TempCk:\\n if abs(c.freq-TempOneCk.freq < DOUBLE_PRECISION):\\n c.Amp += TempOneCk.Amp\\n Added = TRUE\\n break\\n \\n if (not Added):\\n TempCk.append(TempOneCk)\\n \\n self.Ck = TempCk\\n CkSize = len(self.Ck)\",\n \"def make_steer_frs(dims, numlevels, numorientations, bandwidth):\\n \\n result = []\\n bands=[]\\n p = numorientations-1\\n const = math.sqrt(float(math.pow(2,(2*p))*math.pow(math.factorial(p),2)) / float(math.factorial(2*p)*(p+1)))\\n f1 = freqspace(dims[0])\\n f2 = freqspace(dims[1])\\n wx, wy = np.meshgrid(f1, f2)\\n size = wx.shape\\n r = np.sqrt(wx**2 + wy**2)\\n theta = np.arctan2(wy, wx) \\n \\n bands = np.full((numlevels, numorientations, dims[0], dims[1]), const*1j)\\n for level in range(numlevels):\\n for orientation in range(numorientations):\\n theta_offset = orientation * np.pi / numorientations\\n ctrfreq = pi / math.pow(2, (level+1)*bandwidth)\\n band = np.cos(theta - theta_offset)**p * log_raised_cos(r, ctrfreq, bandwidth)\\n bands[level,orientation,:,:] *= band\\n \\n hi = log_raised_coshi(r, pi / math.pow(2, bandwidth), bandwidth)\\n\\n lo = log_raised_coslo(r, pi / math.pow(2, bandwidth * numlevels), bandwidth)\\n \\n result.append(hi)\\n result.append(bands)\\n result.append(lo)\\n return result\",\n \"def Boltzchoice(LFnum, energylist, RNs):\\n # transform list to energy values in kT according to experimental\\n # affinities and the energy window allowed by the threshold\\n energylist = cf.y0 + np.array(energylist) * cf.m\\n # calculate norm of initial list\\n Norm = sum([math.exp(-ener) for ener in energylist])\\n # calculate initial probability vector\\n probs = np.array([math.exp(-ener) / Norm for ener in energylist])\\n # list to catch indices of selected cells\\n selected = []\\n # cells to be picked: determined by the lesser of #waiters and #LFs\\n cellpick = min(len(energylist), LFnum)\\n while len(selected) < cellpick:\\n bins = np.cumsum(probs)\\n ind = np.digitize(RNs.getR(), bins)\\n selected.append(ind)\\n # now, set the probability of the selected cell to 0 and renormalise\\n # the remaining probability vector\\n newNorm = Norm - math.exp(-energylist[ind])\\n probs[ind] = 0\\n probs = probs * Norm / newNorm\\n Norm = newNorm\\n\\n return selected\",\n \"def gyroHF2(self, GYRO, PFC):\\n print(\\\"Calculating gyro orbit heat loads\\\")\\n log.info(\\\"Calculating gyro orbit heat loads\\\")\\n #get divertor HF\\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\\n #Get fractional multipliers for each helical trace\\n gyroFrac = 1.0/GYRO.N_gyroPhase\\n vPhaseFrac = 1.0/GYRO.N_vPhase\\n vSliceFrac = GYRO.energyFracs\\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\\n Pgyro = np.zeros((GYRO.Nt))\\n PNaN = 0.0\\n sum=0\\n sum1=0\\n #loop through intersect record and redistribute power using multipliers\\n for gyroPhase in range(GYRO.N_gyroPhase):\\n for vPhase in range(GYRO.N_vPhase):\\n for vSlice in range(GYRO.N_vSlice):\\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\\n hdotn = np.abs(GYRO.hdotn[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap])\\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\\n notNanTo = notNanTo.astype(int) #cast as integer\\n isNanTo = idx[np.isnan(idx)] #indices we map power to\\n isNanTo = isNanTo.astype(int) #cast as integer\\n\\n if len(notNanFrom)>0:\\n #multiple sources can load the same target face, so we loop\\n for i in range(len(notNanFrom)):\\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\\n\\n if len(isNanFrom)>0:\\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\\n\\n\\n GYRO.gyroPowMatrix += Pgyro\\n GYRO.gyroNanPower += PNaN\\n return\",\n \"def mass_fuel_system(\\n fuel_volume: float,\\n n_tanks: int,\\n fraction_in_integral_tanks: float = 0.5,\\n) -> float:\\n\\n fraction_in_protected_tanks = 1 - fraction_in_integral_tanks\\n return (\\n 2.405 *\\n (fuel_volume / u.gallon) ** 0.606 *\\n (1 + fraction_in_integral_tanks) ** -1 *\\n (1 + fraction_in_protected_tanks) *\\n n_tanks ** 0.5\\n ) * u.lbm\",\n \"def hz_to_mel(frequencies, htk=False):\\n\\n frequencies = np.asanyarray(frequencies)\\n\\n if htk:\\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\\n\\n # Fill in the linear part\\n f_min = 0.0\\n f_sp = 200.0 / 3\\n\\n mels = (frequencies - f_min) / f_sp\\n\\n # Fill in the log-scale part\\n\\n min_log_hz = 1000.0 # beginning of log region (Hz)\\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\\n logstep = np.log(6.4) / 27.0 # step size for log region\\n\\n if frequencies.ndim:\\n # If we have array data, vectorize\\n log_t = frequencies >= min_log_hz\\n mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep\\n elif frequencies >= min_log_hz:\\n # If we have scalar data, heck directly\\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\\n\\n return mels\",\n \"def haperfluxMany(inputlist, maplist, radius, rinner, router, galactic=True, decimal=True, noise_model=0):\\n\\n ## Names and frequencies of the sample maps included in this repo.\\n\\n freqlist = ['30','44','70','100','143','217','353','545','857','1249','1874','2141','2998','3331','4612','4997','11992','16655','24983','24983','24983','33310']\\n freqval = [28.405889, 44.072241,70.421396,100.,143.,217.,353.,545.,857.,1249.,1874.,2141.,2141.,2998.,2998.,3331.,4612.,4997.,11992.,16655.,24983.,24983.,24983.,33310.]\\n band_names = [\\\"akari9\\\", \\\"dirbe12\\\",\\\"iras12\\\",\\\"wise12\\\",\\\"akari18\\\",\\\"iras25\\\",\\\"iras60\\\",\\\"akari65\\\",\\\"akari90\\\",\\\"dirbe100\\\",\\\"iras100\\\",\\\"akari140\\\",\\\"dirbe140\\\",\\\"akari160\\\",\\\"dirbe240\\\",\\\"planck857\\\", \\\"planck545\\\"]\\n\\n k0 = 1.0\\n k1 = rinner/radius\\n k2 = router/radius\\n apcor = ((1 - (0.5)**(4*k0**2))-((0.5)**(4*k1**2) - (0.5)**(4*k2**2)))**(-1)\\n\\n # 'galactic' overrules 'decimal'\\n if (galactic==True):\\n dt=[('sname',np.dtype('S13')),('glon',np.float32),('glat',np.float32)]\\n targets = np.genfromtxt(inputlist, delimiter=\\\",\\\",dtype=dt)\\n\\n ns = len(targets['glat'])\\n\\n fd3 = -1\\n fd_err3 = -1\\n\\n fn = np.genfromtxt(maplist, delimiter=\\\" \\\", dtype='str')\\n nmaps = len(fn)\\n ## Initialize the arrays which will hold the results\\n fd_all = np.zeros((ns,nmaps))\\n fd_err_all = np.zeros((ns,nmaps))\\n fd_bg_all = np.zeros((ns,nmaps))\\n\\n # Start the actual processing: Read-in the maps.\\n for ct2 in range(0,nmaps):\\n xtmp_data, xtmp_head = hp.read_map(fn[ct2], h=True, verbose=False, nest=False)\\n freq = dict(xtmp_head)['FREQ']\\n units = dict(xtmp_head)['TUNIT1']\\n freq_str = str(freq)\\n idx = freqlist.index(str(freq))\\n currfreq = int(freq)\\n\\n if (radius == None):\\n radval = fwhmlist[idx]\\n else:\\n radval = radius\\n\\n\\n for ct in range(0,ns):\\n\\n glon = targets['glon'][ct]\\n glat = targets['glat'][ct]\\n\\n fd_all[ct,ct2], fd_err_all[ct,ct2], fd_bg_all[ct,ct2] = \\\\\\n haperflux(inmap= xtmp_data, freq= currfreq, lon=glon, lat=glat, aper_inner_radius=radius, aper_outer_radius1=rinner, \\\\\\n aper_outer_radius2=router,units=units, noise_model=noise_model)\\n\\n if (np.isfinite(fd_err_all[ct,ct2]) == False):\\n fd_all[ct,ct2] = -1\\n fd_err_all[ct,ct2] = -1\\n else:\\n if radius==None:\\n fd_all[ct,ct2] = fd_all[ct,ct2]*apcor\\n fd_err_all[ct,ct2] = fd_err_all[ct,ct2]*apcor\\n\\n return fd_all, fd_err_all, fd_bg_all\",\n \"def torch_hertz_to_mel(frequencies_hertz):\\r\\n # return _MEL_HIGH_FREQUENCY_Q * tf.math.log(\\r\\n # 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\\r\\n return _MEL_HIGH_FREQUENCY_Q * np.log(\\r\\n 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\",\n \"def half_space_cooling_temperature(z, t, T1, T0, kappa):\\n return [math.erfc(z1 / (2 * numpy.sqrt(kappa * t))) * (T0 - T1) + T1 for z1 in z]\",\n \"def better_clumps_finding(text, k, t, L):\\n frequent_patterns = []\\n clumps = [0 for i in range(0, 4**k)]\\n first_subtext = text[:L]\\n freq_array = compute_freq(first_subtext, k)\\n for index, freq in enumerate(freq_array):\\n if freq >= t:\\n clumps[index] = 1\\n for i in range(1, len(text) - L + 1):\\n old_kmer = text[i - 1:i - 1 + k]\\n old_kmer_number = pattern_to_number(old_kmer)\\n freq_array[old_kmer_number] -= 1\\n new_kmer = text[i + L:i + L + k]\\n new_kmer_number = pattern_to_number(new_kmer)\\n freq_array[new_kmer_number] += 1\\n if freq_array[new_kmer_number] >= t:\\n clumps[new_kmer_number] = 1\\n for index, clump in enumerate(clumps):\\n if clump == 1:\\n pattern = number_to_pattern(index, k)\\n frequent_patterns.append(pattern) \\n return frequent_patterns\",\n \"def metro_ising(L, T, h):\\n\\n lattice = transform_lattice(np.random.rand(N + 2, N + 2)) # +2 because of periodic bounds\\n ising_chain = [lattice]\\n m = 0\\n\\n for i in range(L):\\n rand_row = np.random.choice(index)\\n rand_col = np.random.choice(index)\\n\\n if H(ising_chain[i], rand_row, rand_col, h, T):\\n new_lattice = ising_chain[i].copy()\\n new_lattice[rand_row][rand_col] *= -1\\n ising_chain.append(transform_lattice(new_lattice))\\n else:\\n ising_chain.append(ising_chain[i])\\n\\n m += np.sum(ising_chain[i][1:N + 1, 1:N + 1]) # magnetization\\n\\n return m\",\n \"def bf_counter(file_name, k, n, capacity, error_rate, verbose=False):\\n if verbose:\\n start = time.time()\\n print('BFCounter started.')\\n\\n heap = []\\n for i in range(n):\\n heap.append((0, ''))\\n\\n bf = BloomFilter(capacity, error_rate, 'kmer_bf')\\n\\n kmer_counter = defaultdict(lambda: 1)\\n\\n # Assign functions to local variables for performance improvement\\n add_to_bf = bf.add\\n heap_pushpop = heapq.heappushpop\\n\\n with open(file_name, 'r') as f:\\n line_num = 0\\n for line in f:\\n if line_num % 4 == 1: # dna sequence\\n kmer_count = len(line) - k\\n for i in range(kmer_count):\\n kmer = line[i:i + k]\\n if kmer not in bf: # not in Bloom Filter\\n add_to_bf(kmer)\\n else: # in Bloom Filter\\n kmer_counter[kmer] += 1\\n line_num += 1\\n if verbose:\\n end_hash = time.time()\\n hash_table_size = sys.getsizeof(kmer_counter) / (1024 ** 2)\\n print('Hash table is created in {:.2f} seconds.'.format(\\n end_hash - start))\\n print('Hash table size: {:.2f} MB.'.format(hash_table_size))\\n start_populate = time.time()\\n print('Populating the heap...')\\n\\n for count, kmer in kmer_counter.items():\\n # insert to the heap if count is bigger than minimum\\n if count > heap[0][0]:\\n heap_pushpop(heap, (count, kmer))\\n\\n if verbose:\\n end_populate = time.time()\\n print('Heap is populated in {:.2f} seconds.'.format(\\n end_populate - start_populate\\n ))\\n\\n os.remove('kmer_bf')\\n if verbose:\\n end = time.time()\\n print('BFCounter is completed in {:.2f} seconds.'.format(end - start))\\n\\n return heap\",\n \"def lrelfreq(inlist,numbins=10,defaultreallimits=None):\\r\\n h,l,b,e = histogram(inlist,numbins,defaultreallimits)\\r\\n for i in range(len(h)):\\r\\n h[i] = h[i]/float(len(inlist))\\r\\n return h,l,b,e\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def hz_to_mel(frequencies, htk=False):\\n\\n frequencies = np.asanyarray(frequencies)\\n\\n if htk:\\n return 2595.0 * np.log10(1.0 + frequencies / 700.0)\\n\\n # Fill in the linear part\\n f_min = 0.0\\n f_sp = 200.0 / 3\\n\\n mels = (frequencies - f_min) / f_sp\\n\\n # Fill in the log-scale part\\n\\n min_log_hz = 1000.0 # beginning of log region (Hz)\\n min_log_mel = (min_log_hz - f_min) / f_sp # same (Mels)\\n logstep = np.log(6.4) / 27.0 # step size for log region\\n\\n if frequencies.ndim:\\n # If we have array data, vectorize\\n log_t = (frequencies >= min_log_hz)\\n mels[log_t] = min_log_mel + np.log(frequencies[log_t]/min_log_hz) / logstep\\n elif frequencies >= min_log_hz:\\n # If we have scalar data, heck directly\\n mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep\\n\\n return mels\",\n \"def get_rec_rate_H_caseB(T):\\n Tinv = 1.0/T\\n bb = 315614.0*Tinv\\n cc = 115188.0*Tinv\\n dd = 1.0 + np.power(cc, 0.407)\\n return 2.753e-14*np.power(bb, 1.5)*np.power(dd, -2.242)\",\n \"def generateFrequentPatterns(self, tidList):\\n tidList1 = {}\\n if len(tidList) == 0:\\n print(\\\"There are no more candidate sets\\\")\\n else:\\n key = list(tidList.keys())\\n for i in range(0, len(key)):\\n nighbousItems=self.getNighboirItems(key[i])\\n for j in range(i + 1, len(key)):\\n if not key[j] in nighbousItems:\\n \\tcontinue\\n intersectionList = list(set(tidList[key[i]]).intersection(set(tidList[key[j]])))\\n itemList = []\\n if len(intersectionList) >= self.minSup:\\n itemList += key[i], key[j]\\n itemList.sort()\\n tidList1[tuple(itemList)] = intersectionList\\n\\n return tidList1\",\n \"def Hertz_dipole_ff (r, p, R, phi, f, t=0, epsr=1.):\\r\\n nf = len(f)\\r\\n rprime = r-R # r'=r-R\\r\\n if ndim(p) < 2:\\r\\n magrprime = sqrt(sum((rprime)**2))\\r\\n magrprimep = tile(magrprime, (len(f),1)).T\\r\\n phip = tile(phi, (len(f),1))\\r\\n w = 2*pi*f # \\\\omega\\r\\n k = w/c # wave number\\r\\n krp = k*magrprimep # k|r'|\\r\\n rprime_cross_p = cross(rprime, p) # r'x p\\r\\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\\r\\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\\r\\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[0],(nf,1))).T\\r\\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[1],(nf,1))).T\\r\\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[2],(nf,1))).T\\r\\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[0],(nf,1)).T)\\r\\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[1],(nf,1)).T)\\r\\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[2],(nf,1)).T)\\r\\n E = vstack((Ex,Ey,Ez))\\r\\n B = vstack((Bx,By,Bz))\\r\\n else:\\r\\n magrprime = sqrt(sum((rprime)**2,axis=1)) # |r'|\\r\\n magrprimep = tile(magrprime, (len(f),1)).T\\r\\n phip = tile(phi, (len(f),1))\\r\\n fp = tile(f,(len(magrprime),1))\\r\\n w = 2*pi*fp # \\\\omega\\r\\n k = w/c # wave number\\r\\n krp = k*magrprimep # k|r'|\\r\\n rprime_cross_p = cross(rprime, p) # r'x p\\r\\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\\r\\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\\r\\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,0],(nf,1))).T\\r\\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,1],(nf,1))).T\\r\\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,2],(nf,1))).T\\r\\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,0],(nf,1)).T)\\r\\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,1],(nf,1)).T)\\r\\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,2],(nf,1)).T)\\r\\n E = vstack((sum(Ex,axis=0),sum(Ey,axis=0),sum(Ez,axis=0)))\\r\\n B = vstack((sum(Bx,axis=0),sum(By,axis=0),sum(Bz,axis=0)))\\r\\n return E,B\",\n \"def init_buckets(len2freq):\\n source = Counter(len2freq)\\n\\n if not len(source):\\n raise ValueError('Empty length-to-frequency map')\\n\\n if not all(map(lambda x: isinstance(x, int), source.keys())):\\n raise ValueError('Keys of length-to-frequency must be integers')\\n\\n if not all(map(lambda x: isinstance(x, int), source.values())):\\n raise ValueError('Values of length-to-frequency must be integers')\\n\\n denominator = 8\\n lengths = sorted(source.keys())\\n\\n buckets = []\\n for lng in lengths:\\n b = int(np.ceil(lng / denominator)) * denominator + 1\\n if not len(buckets) or buckets[-1][0] != b:\\n buckets.append((b, {}))\\n buckets[-1][1][lng] = source[lng]\\n\\n return buckets\",\n \"def calc_Cop_boiler(q_load_Wh, Q_nom_W, T_return_to_boiler_K):\\n\\n if (Q_nom_W > 0.0) and (q_load_Wh > 0.0):\\n\\n # calculate efficiency according to partload\\n phi = float(q_load_Wh) / float(Q_nom_W)\\n if phi >=1.0: # avoid rounding error\\n phi = 0.98\\n T_return_C = np.float(T_return_to_boiler_K - 273.15)\\n eff_score = eff_of_phi(phi) / eff_of_phi(1)\\n boiler_eff = (eff_score * eff_of_T_return([T_return_C]))[0] / 100.0\\n else:\\n boiler_eff = 0.0\\n\\n return boiler_eff\",\n \"def calculate_NH_relaxation_from_Ct(bondtype, B_0, t, Ct):\\n gamma_1H = 267.513e6 ; # rad s^-1 T^-1\\n gamma_X = -27.116e6\\n DeltaSigma_X=-160e-6\\n r_XH=1.02e-10\\n\\n om, G = do_dft(t, Ct)\\n J = G.real\\n\\n omega, iOmH, iOmX = obtain_HX_frequencies()\\n\\n Jw=np.zeros(5)\\n for i in range(5):\\n w = omega[i]\\n Jw[i] = interpolate_point(w, om, J)\\n\\n # f_DD = 519627720.1974593 , if r_NH is at default values\\n f_DD = 7.958699205571828e-67 * r_XH**-6.0 * gamma_X**2\\n # f_CSA = 498637299.69233465, if B_0 = 600.13, and DeltaSigma=-160e-6\\n f_CSA = 2.0/15.0 * DeltaSigma_X**2 * ( gamma_X * B_0 )**2\\n\\n R1 = f_DD*( J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] ) + f_CSA*J[iOmX]\\n R2 = 0.5*f_DD*( 4*J[0] + J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] + 6*J[iOmH] ) + 1.0/6.0*f_CSA*(4*J[0] + 3*J[iOmX])\\n NOE = 1.0 + gamma_1H/gamma_X/R1 * f_DD*(6*J[iOmH+iOmX] - J[iOmH-iOmX])\\n\\n return R1, R2, NOE\",\n \"def __init__(self,kT=None,T=None):\\n if kT is not None: kT = kT\\n elif T is not None: kT = u.boltzmann*T\\n else: raise Exception(\\\"kT or k must be passed to BlackBody\\\")\\n\\n energy_density=BlackBody.compute_energy_density(kT)\\n super(BlackBody,self).__init__(energy_density=energy_density, kT=kT)\",\n \"def frfplot(freq, H, freq_min=0, freq_max=None, type=1, legend=[]):\\n FLAG = type # Plot type, should libe renamed throughout.\\n freq = freq.reshape(1, -1)\\n lenF = freq.shape[1]\\n if len(H.shape) is 1:\\n H = H.reshape(1, -1)\\n\\n if H.shape[0] > H.shape[1]:\\n H = H.T\\n\\n if freq_max is None:\\n freq_max = np.max(freq)\\n\\n if freq_min is None:\\n freq_min = np.min(freq)\\n\\n if freq_min < np.min(freq):\\n freq_min = np.min(freq)\\n\\n if freq_min > freq_max:\\n raise ValueError('freq_min must be less than freq_max.')\\n\\n # print(str(np.amin(freq)))\\n inlow = int(lenF * (freq_min - np.amin(freq)\\n ) // (np.amax(freq) - np.amin(freq)))\\n\\n inhigh = int(lenF * (freq_max - np.amin(freq)\\n ) // (np.amax(freq) - np.amin(freq)) - 1)\\n # if inlow<1,inlow=1;end\\n # if inhigh>lenF,inhigh=lenF;end\\n \\\"\\\"\\\"print('freq shape: {}'.format(freq.shape))\\n print('H shape: {}'.format(H.shape))\\n print('Index of low frequency: {}'.format(inlow))\\n print('Index of high frequency: {}'.format(inhigh))\\\"\\\"\\\"\\n H = H[:, inlow:inhigh]\\n # print(H.shape)\\n freq = freq[:, inlow:inhigh]\\n mag = 20 * np.log10(np.abs(H))\\n # print(mag)\\n # print(mag.shape)\\n minmag = np.min(mag)\\n maxmag = np.max(mag)\\n phase = np.unwrap(np.angle(H)) * 180 / np.pi\\n # phmin_max=[min(phase)//45)*45 ceil(max(max(phase))/45)*45];\\n phmin = np.amin(phase) // 45 * 45.0\\n phmax = (np.amax(phase) // 45 + 1) * 45\\n \\\"\\\"\\\"minreal = np.amin(np.real(H))\\n maxreal = np.amax(np.real(H))\\n minimag = np.amin(np.imag(H))\\n maximag = np.amax(np.imag(H))\\\"\\\"\\\"\\n\\n if FLAG is 1:\\n fig, (ax1, ax2) = plt.subplots(2, 1)\\n ax1.plot(freq.T, mag.T)\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Mag (dB)')\\n ax1.grid()\\n ax1.set_xlim(xmax=freq_max, xmin=freq_min)\\n ax1.set_ylim(ymax=maxmag, ymin=minmag)\\n\\n ax2.plot(freq.T, phase.T)\\n ax2.set_xlabel('Frequency (Hz)')\\n ax2.set_ylabel('Phase (deg)')\\n ax2.grid()\\n ax2.set_xlim(xmax=freq_max, xmin=freq_min)\\n ax2.set_ylim(ymax=phmax, ymin=phmin)\\n ax2.set_yticks(np.arange(phmin, (phmax + 45), 45))\\n fig.tight_layout()\\n\\n if len(legend) > 0:\\n plt.legend(legend)\\n ax = (ax1, ax2)\\n else:\\n print(\\\"Sorry, that option isn't supported yet\\\")\\n return ax\\n\\n \\\"\\\"\\\"# elif FLAG==2:\\n # subplot(2,1,1)\\n # semilogx(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # % Fmin,Fmax,min(mag),max(mag)\\n # axis([Fmin Fmax minmag maxmag])\\n\\n # subplot(2,1,2)\\n # semilogx(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n\\n # elif FLAG==3:\\n # subplot(2,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F*2*pi,mag)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Wmin Wmax minmag maxmag])\\n # zoom on\\n # subplot(2,1,2)\\n # semilogx(F*2*pi,phase)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n\\n # elseif FLAG==4\\n # subplot(2,1,1)\\n # plot(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # subplot(2,1,2)\\n # plot(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==5\\n # subplot(1,1,1)\\n # imax=round(length(F)*Fmax/max(F));\\n # imin=round(length(F)*Fmin/max(F))+1;\\n # plot(real(Xfer(imin:imax)),imag(Xfer(imin:imax)))\\n # xlabel('Real')\\n # ylabel('Imaginary')\\n # grid on\\n # zoom on\\n # elseif FLAG==6\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # plot(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==7\\n # subplot(1,1,1)\\n # plot(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # elseif FLAG==8\\n # subplot(1,1,1)\\n # plot(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # elseif FLAG==9\\n # subplot(1,1,1)\\n # plot(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==10\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==11\\n # subplot(1,1,1)\\n # semilogx(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # elseif FLAG==12\\n # subplot(1,1,1)\\n # semilogx(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # elseif FLAG==13\\n # subplot(1,1,1)\\n # semilogx(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==14\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F*2*pi,mag)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Wmin Wmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==15\\n # subplot(1,1,1)\\n # semilogx(F*2*pi,phase)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # else\\n # subplot(2,1,1)\\n # mag=20*log10(abs(Xfer));\\n # plot(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # subplot(2,1,2)\\n # plot(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n \\\"\\\"\\\"\",\n \"def get_mitral_frequency(self,r=None,ids=None):\\n # Simply divide the length of each spike vector by the simulation time\\n # or window time.\\n spikes=[] # The local copy of spikes to get the frequency on\\n try:\\n spikes=self.get_mitral_spikes(r,ids)\\n if len(spikes)==0:\\n raise Exception('Unable to get mitral cell spikes')\\n except Exception:\\n raise\\n freqm=numpy.zeros(self.num_mit)\\n timems=self.sim_time\\n if type(r) is tuple and len(r)==2:\\n timems=float(r[1]-r[0])\\n for i in range(len(spikes)):\\n freqm[i]=float(len(spikes[i]))*1000./timems\\n return freqm\",\n \"def get_effective_mass():\\n\\n H_BAR = 6.582119514e-16 # eV*s\\n M_0 = 9.10938356e-31 # kg\\n N_KPTS = 6 # Number of k-points included in the parabola.\\n\\n spin_up = Spin(1)\\n\\n band_structure = Vasprun('vasprun.xml').get_band_structure()\\n\\n # Locations of CBM and VBM in band_structure.bands\\n cbm_band_index = band_structure.get_cbm()['band_index'][spin_up][0]\\n cbm_kpoint_index = band_structure.get_cbm()['kpoint_index'][0]\\n\\n vbm_band_index = band_structure.get_vbm()['band_index'][spin_up][0]\\n vbm_kpoint_index = band_structure.get_vbm()['kpoint_index'][0]\\n\\n k = {'electron': {'left': [], 'right': []},\\n 'hole': {'left': [], 'right': []}}\\n E = {'electron': {'left': [], 'right': []},\\n 'hole': {'left': [], 'right': []}}\\n\\n e_ref_coords = band_structure.kpoints[cbm_kpoint_index]._ccoords\\n h_ref_coords = band_structure.kpoints[vbm_kpoint_index]._ccoords\\n\\n for n in range(-N_KPTS, 1):\\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\\n\\n k['electron']['left'].append(\\n ((e_coords[0] - e_ref_coords[0])**2 +\\n (e_coords[1] - e_ref_coords[1])**2 +\\n (e_coords[2] - e_ref_coords[2])**2)**0.5\\n )\\n k['hole']['left'].append(\\n ((h_coords[0] - h_ref_coords[0])**2 +\\n (h_coords[1] - h_ref_coords[1])**2 +\\n (h_coords[2] - h_ref_coords[2])**2)**0.5\\n )\\n\\n e_energy = band_structure.bands[\\n spin_up][cbm_band_index][cbm_kpoint_index + n]\\n h_energy = band_structure.bands[\\n spin_up][vbm_band_index][vbm_kpoint_index + n]\\n\\n E['electron']['left'].append(e_energy)\\n E['hole']['left'].append(h_energy)\\n\\n for n in range(1, 1 + N_KPTS):\\n e_coords = band_structure.kpoints[cbm_kpoint_index + n]._ccoords\\n h_coords = band_structure.kpoints[vbm_kpoint_index + n]._ccoords\\n\\n k['electron']['right'].append(\\n ((e_coords[0] - e_ref_coords[0])**2 +\\n (e_coords[1] - e_ref_coords[1])**2 +\\n (e_coords[2] - e_ref_coords[2])**2)**0.5\\n )\\n k['hole']['right'].append(\\n ((h_coords[0] - h_ref_coords[0])**2 +\\n (h_coords[1] - h_ref_coords[1])**2 +\\n (h_coords[2] - h_ref_coords[2])**2)**0.5\\n )\\n\\n e_energy = band_structure.bands[\\n spin_up][cbm_band_index][cbm_kpoint_index + n]\\n h_energy = band_structure.bands[\\n spin_up][vbm_band_index][vbm_kpoint_index + n]\\n\\n E['electron']['right'].append(e_energy)\\n E['hole']['right'].append(h_energy)\\n\\n # 2nd order fits\\n e_l_fit = np.poly1d(\\n np.polyfit(k['electron']['left'], E['electron']['left'], 2))\\n e_r_fit = np.poly1d(\\n np.polyfit(k['electron']['right'], E['electron']['right'], 2))\\n h_l_fit = np.poly1d(\\n np.polyfit(k['hole']['left'], E['hole']['left'], 2))\\n h_r_fit = np.poly1d(\\n np.polyfit(k['hole']['right'], E['hole']['right'], 2))\\n\\n # Curvatures\\n e_l_curvature = e_l_fit.deriv().deriv()[0]\\n e_r_curvature = e_r_fit.deriv().deriv()[0]\\n h_l_curvature = h_l_fit.deriv().deriv()[0]\\n h_r_curvature = h_r_fit.deriv().deriv()[0]\\n\\n # Unit conversion\\n e_m_eff_l = 10 * ((H_BAR ** 2) / e_l_curvature) / M_0\\n e_m_eff_r = 10 * ((H_BAR ** 2) / e_r_curvature) / M_0\\n h_m_eff_l = -10 * ((H_BAR ** 2) / h_l_curvature) / M_0\\n h_m_eff_r = -10 * ((H_BAR ** 2) / h_r_curvature) / M_0\\n\\n return {'electron': {'left': e_m_eff_l, 'right': e_m_eff_r},\\n 'hole': {'left': h_m_eff_l, 'right': h_m_eff_r}}\",\n \"def __init__(self,b,u,v,hbls_old,hbbl_old,Kv_old,Kt_old,srflx,sustr,svstr,f,grid_dict,tstep_mode,dt):\\n \\n # INPUTS FROM TTTW SYSTEM\\n self.b = b #buoyancy field: [Ly,N]\\n self.u = u # x-component of velocity [Ly,N]\\n self.v = v # y-component of velocity [Ly+1,N]\\n self.hbls_old = hbls_old #boundary layer depth from previous time step [Ly]\\n self.hbbl_old = hbbl_old # bottom boundary layer depth from previous time step [Ly]\\n self.Kv_old = Kv_old # momentum mixing coefficeint from previous time step [Ly,N+1]\\n self.Kt_old = Kt_old # tracer mixing coefficient from previous time step [Ly,N+1]\\n self.srflx = srflx #solar heat flux [Ly] (degC * (m/s))\\n self.sustr = sustr # x-component surface wind stress [Ly] (N/m^2) \\n self.svstr = svstr # y-component surface wind stress [Ly+1] (N/m^2)\\n self.grid_dict = grid_dict #gridded data\\n self.f = f #coriolis parameter\\n # KPP-SPECIFIC VARIABLES \\n self.hbls = np.zeros([self.b.shape[0]])\\n self.hbbl = np.zeros([self.b.shape[0]])\\n self.ustar = []\\n self.bvf = [] \\n self.kmo = []\\n self.C_h_MO = []\\n self.kbl = []\\n self.Cr = [] \\n self.Fc = []\\n self.ghat = [] #NONLOCAL TERM: TO BE USED IN TIME STEPPING\\n self.tstep_mode = tstep_mode# if in time steppign mode, turn on HBL_RATE_LIMIT\\n self.dt = dt\",\n \"def vib_energy(frequency, temp):\\n\\n # vibrational temperature\\n\\n vtemp = plank_const * speed_ol / boltz_const * frequency\\n\\n vtemp = np.matrix(vtemp)\\n\\n temp = 1 / np.matrix(temp)\\n\\n # need to convert to array, because the element wise exponential\\n # cannot work with matrix\\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\\n\\n # energy is a np.matrix, need to convert to array\\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\\n energy = np.array(energy)[0]\\n\\n return energy\",\n \"def cer(r: list, h: list):\\n # initialisation\\n import numpy\\n d = numpy.zeros((len(r) + 1) * (len(h) + 1), dtype=numpy.uint16)\\n d = d.reshape((len(r) + 1, len(h) + 1))\\n for i in tqdm(range(len(r) + 1)):\\n for j in range(len(h) + 1):\\n if i == 0:\\n d[0][j] = j\\n elif j == 0:\\n d[i][0] = i\\n # computation\\n for i in tqdm(range(1, len(r) + 1)):\\n for j in range(1, len(h) + 1):\\n if r[i - 1] == h[j - 1]:\\n d[i][j] = d[i - 1][j - 1]\\n else:\\n substitution = d[i - 1][j - 1] + 1\\n insertion = d[i][j - 1] + 1\\n deletion = d[i - 1][j] + 1\\n d[i][j] = min(substitution, insertion, deletion)\\n return d[len(r)][len(h)] / float(len(r))\",\n \"def buoyancy_frequency(self, z, h=0.01):\\n # Check validity of the input z values\\n if np.max(z) > self.z_max or np.min(z) < self.z_min:\\n raise ValueError('Selected depths outside range of ' + \\\\\\n 'CTD data: %g to %g m' % (self.z_min, \\n self.z_max))\\n if h > 1.0 or h < 0.0:\\n raise ValueError('Input parameter h must be between 0.0 ' + \\\\\\n 'and 1.0.')\\n \\n # Prepare space to store the solution\\n if not isinstance(z, np.ndarray):\\n N = np.zeros(1)\\n z = np.array([z])\\n elements = 0\\n else:\\n N = np.zeros(z.shape)\\n elements = range(len(N))\\n \\n # Compute the length-scale for the finite difference method\\n dz = (self.z_max - self.z_min) * h\\n \\n # Fill the solution matrix\\n for i in range(len(z)):\\n # Get the end-points of z for the finite difference formula\\n if z[i] + dz > self.z_max:\\n z1 = self.z_max\\n z0 = z1 - 2 * dz\\n elif z[i] - dz < self.z_min:\\n z0 = self.z_min\\n z1 = z0 + 2 * dz\\n else:\\n z0 = z[i] - dz\\n z1 = z[i] + dz\\n \\n # Get the density at z0 and z1. Use atmospheric pressure to \\n # compute the potential density and remove the effect of \\n # compressibility\\n T0, S0 = self.get_values(z0, self.ztsp[1:3])\\n T1, S1 = self.get_values(z1, self.ztsp[1:3])\\n Pa = 101325.\\n rho_0 = seawater.density(T0, S0, Pa)\\n rho_1 = seawater.density(T1, S1, Pa)\\n N[i] = np.sqrt(9.81 / rho_0 * (rho_1 - rho_0) / (z1 - z0))\\n \\n return N[elements]\",\n \"def get_F_potential(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n # y = chemical_potential/temperature\\n y = chemical_potential / tt\\n F = gbar / np.sqrt(2.0) / np.pi ** 2 * tt ** (2.5) * vv\\n F *= y * _1d_call(_fdk, y, k=0.5) - 2.0 / 3.0 * _1d_call(_fdk, y, k=1.5)\\n return F\",\n \"def Kgrid(struc, Kresol=0.10, dimension=3):\\n a, b, c, alpha, beta, gamma = struc.get_cell_lengths_and_angles()\\n vol = struc.get_volume()\\n dist = np.zeros(3);\\n dist[2] = np.abs(vol/(a*b*np.sin(np.radians(gamma))))\\n dist[1] = np.abs(vol/(a*c*np.sin(np.radians(beta))))\\n dist[0] = np.abs(vol/(b*c*np.sin(np.radians(alpha))))\\n Kpoints = np.ceil(1./(dist*Kresol))\\n if dimension == 2:\\n Kpoints[-1] = 1;\\n #print(a, b, c, alpha, beta, gamma)\\n #print(vol/(a*b*np.sin(gamma)), a*b, np.sin(gamma))\\n #print(vol/(a*c*np.sin(beta)), a*c, np.sin(beta))\\n #print(vol/(b*c*np.sin(alpha)), b*c, np.sin(alpha))\\n #print(Kpoints)\\n #import sys; sys.exit()\\n return Kpoints.astype(int)\",\n \"def conductivity(self, T):\\n m = self.mass\\n mu = self.viscosity(T)\\n K = (15/4) * kB * mu / m\\n return K\",\n \"def calc_cop_CCGT(GT_size_W, T_sup_K, fuel_type):\\n\\n it_len = 50\\n\\n # create empty arrays\\n range_el_output_CC_W = np.zeros(it_len)\\n range_q_output_CC_W = np.zeros(it_len)\\n range_eta_el_CC = np.zeros(it_len)\\n range_eta_thermal_CC = np.zeros(it_len)\\n range_q_input_CC_W = np.zeros(it_len)\\n\\n # create range of electricity output from the GT between the minimum and nominal load\\n range_el_output_from_GT_W = np.linspace(GT_size_W * GT_MIN_PART_LOAD, GT_size_W, it_len)\\n\\n # calculate the operation data at different electricity load\\n for i in range(len(range_el_output_from_GT_W)):\\n el_output_from_GT_W = range_el_output_from_GT_W[i]\\n\\n # combine cycle operation\\n CC_operation = calc_CC_operation(el_output_from_GT_W, GT_size_W, fuel_type, T_sup_K)\\n range_el_output_CC_W[i] = CC_operation['el_output_W'] # Electricity output from the combined cycle\\n range_q_output_CC_W[i] = CC_operation['q_output_ST_W'] # Thermal output from the combined cycle\\n range_eta_el_CC[i] = CC_operation['eta_el'] # el. efficiency\\n range_eta_thermal_CC[i] = CC_operation['eta_thermal'] # thermal efficiency\\n\\n range_q_input_CC_W[i] = range_q_output_CC_W[i] / range_eta_thermal_CC[i] # thermal energy input\\n\\n # create interpolation functions as a function of heat output\\n el_output_interpol_with_q_output_W = interpolate.interp1d(range_q_output_CC_W, range_el_output_from_GT_W,\\n kind=\\\"linear\\\")\\n q_input_interpol_with_q_output_W = interpolate.interp1d(range_q_output_CC_W, range_q_input_CC_W, kind=\\\"linear\\\")\\n\\n # create interpolation functions as a function of thermal energy input\\n eta_el_interpol_with_q_input = interpolate.interp1d(range_q_input_CC_W, range_eta_el_CC,\\n kind=\\\"linear\\\")\\n\\n q_output_min_W = min(range_q_output_CC_W)\\n q_output_max_W = max(range_q_output_CC_W)\\n\\n return {'el_output_fn_q_output_W': el_output_interpol_with_q_output_W,\\n 'q_input_fn_q_output_W': q_input_interpol_with_q_output_W,\\n 'q_output_min_W': q_output_min_W, 'q_output_max_W': q_output_max_W,\\n 'eta_el_fn_q_input': eta_el_interpol_with_q_input}\",\n \"def find_clumps(genome, k, L, t):\\n assert (is_dna(genome))\\n counts = collections.defaultdict(int)\\n\\n # compute counts of kmers in first L-length part of genome\\n for k_start in range(L - k + 1):\\n counts[genome[k_start:k_start + k]] += 1\\n kmers = _get_keys(counts, t)\\n\\n # slide L-length window and update counts\\n # remove previous leftmost kmer and add new kmer being rightmost in current window\\n for L_start in range(1, len(genome) - L + 1):\\n counts[genome[L_start - 1:L_start + k - 1]] -= 1\\n new_kmer = genome[L_start + L - k:L_start + L]\\n counts[new_kmer] += 1\\n if counts[new_kmer] >= t:\\n kmers.add(new_kmer)\\n return kmers\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6776927","0.6629585","0.6302823","0.6265761","0.6249234","0.6213433","0.61068034","0.59889144","0.5958544","0.59443885","0.58387303","0.5672785","0.5489304","0.535626","0.5331149","0.5270583","0.5189233","0.5121388","0.49093267","0.48052287","0.47886142","0.4778658","0.476383","0.47558084","0.47556755","0.47451013","0.47265995","0.47099164","0.47064683","0.46983644","0.46969643","0.46584567","0.46534234","0.4649549","0.46369043","0.46358517","0.4619042","0.46152508","0.46083072","0.4598931","0.4597642","0.45950678","0.45928597","0.4589616","0.45732665","0.45458907","0.454016","0.45342347","0.45334542","0.45331618","0.45228738","0.4507495","0.45064136","0.44941983","0.4491272","0.44907492","0.44691834","0.44536623","0.44391817","0.4438457","0.44339922","0.443107","0.4430632","0.4419569","0.44181934","0.44134766","0.4401929","0.4400588","0.43989918","0.43944058","0.43942565","0.43854436","0.4376688","0.43756378","0.4374677","0.43744344","0.43694872","0.4368641","0.4361919","0.43597743","0.43580976","0.43568483","0.43530217","0.43524742","0.43504694","0.43499926","0.43477172","0.43457162","0.4342763","0.4336874","0.43335092","0.43320587","0.4328416","0.4316183","0.43085456","0.4306377","0.43045256","0.4303509","0.4301254","0.43005356"],"string":"[\n \"0.6776927\",\n \"0.6629585\",\n \"0.6302823\",\n \"0.6265761\",\n \"0.6249234\",\n \"0.6213433\",\n \"0.61068034\",\n \"0.59889144\",\n \"0.5958544\",\n \"0.59443885\",\n \"0.58387303\",\n \"0.5672785\",\n \"0.5489304\",\n \"0.535626\",\n \"0.5331149\",\n \"0.5270583\",\n \"0.5189233\",\n \"0.5121388\",\n \"0.49093267\",\n \"0.48052287\",\n \"0.47886142\",\n \"0.4778658\",\n \"0.476383\",\n \"0.47558084\",\n \"0.47556755\",\n \"0.47451013\",\n \"0.47265995\",\n \"0.47099164\",\n \"0.47064683\",\n \"0.46983644\",\n \"0.46969643\",\n \"0.46584567\",\n \"0.46534234\",\n \"0.4649549\",\n \"0.46369043\",\n \"0.46358517\",\n \"0.4619042\",\n \"0.46152508\",\n \"0.46083072\",\n \"0.4598931\",\n \"0.4597642\",\n \"0.45950678\",\n \"0.45928597\",\n \"0.4589616\",\n \"0.45732665\",\n \"0.45458907\",\n \"0.454016\",\n \"0.45342347\",\n \"0.45334542\",\n \"0.45331618\",\n \"0.45228738\",\n \"0.4507495\",\n \"0.45064136\",\n \"0.44941983\",\n \"0.4491272\",\n \"0.44907492\",\n \"0.44691834\",\n \"0.44536623\",\n \"0.44391817\",\n \"0.4438457\",\n \"0.44339922\",\n \"0.443107\",\n \"0.4430632\",\n \"0.4419569\",\n \"0.44181934\",\n \"0.44134766\",\n \"0.4401929\",\n \"0.4400588\",\n \"0.43989918\",\n \"0.43944058\",\n \"0.43942565\",\n \"0.43854436\",\n \"0.4376688\",\n \"0.43756378\",\n \"0.4374677\",\n \"0.43744344\",\n \"0.43694872\",\n \"0.4368641\",\n \"0.4361919\",\n \"0.43597743\",\n \"0.43580976\",\n \"0.43568483\",\n \"0.43530217\",\n \"0.43524742\",\n \"0.43504694\",\n \"0.43499926\",\n \"0.43477172\",\n \"0.43457162\",\n \"0.4342763\",\n \"0.4336874\",\n \"0.43335092\",\n \"0.43320587\",\n \"0.4328416\",\n \"0.4316183\",\n \"0.43085456\",\n \"0.4306377\",\n \"0.43045256\",\n \"0.4303509\",\n \"0.4301254\",\n \"0.43005356\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.68888056"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88355,"cells":{"query":{"kind":"string","value":"Return the first derivative of the heat capacity with respect to the hindered rotor frequency in J/molK/cm^1 at the given set of temperatures `Tlist` in K, evaluated at the frequency `freq` in cm^1 and a barrier height `barr` in cm^1."},"document":{"kind":"string","value":"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq"},"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 hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def harmonicOscillator_heatCapacity(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x","def thermal(isatom, freq, scalfac,linnonlin,T):\n if isatom != \"true\":\n nfreq = len(freq)\n\n vib_temp = []\n for ifreq in range(nfreq):\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\n vib_temp.append(vib_temp_new)\n\n dE_vib = 0\n for ifreq in range(nfreq):\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\n\n dE_ZPE = 0.5 * sum(freq) * cmi2au\n\n if linnonlin == \"L\":\n dE_rot = kB * T * j2au\n elif linnonlin == \"NL\":\n dE_rot = kB * T * j2au * (3.0/2.0)\n else:\n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"ERROR: unknown entry for linear/nonlinear\")\n else:\n dE_ZPE = 0\n dE_vib = 0\n dE_rot = 0\n\n dE_tra = kB * T * j2au * (3.0/2.0)\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\n\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def heat_capacity(r, phi, q, kT):\n pot = q*(phi - phi[0])\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\n c = np.trapz(np.exp(-pot/kT) * r, r)\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy","def rangerate_from_freq(freq,Fc):\n # print(f'freq {freq} Fc {Fc}')\n dopp_at_IF = freq - Fc\n return dopp_at_IF*scipy.constants.speed_of_light/Fc","def Hertz_dipole_ff (r, p, R, phi, f, t=0, epsr=1.):\r\n nf = len(f)\r\n rprime = r-R # r'=r-R\r\n if ndim(p) < 2:\r\n magrprime = sqrt(sum((rprime)**2))\r\n magrprimep = tile(magrprime, (len(f),1)).T\r\n phip = tile(phi, (len(f),1))\r\n w = 2*pi*f # \\omega\r\n k = w/c # wave number\r\n krp = k*magrprimep # k|r'|\r\n rprime_cross_p = cross(rprime, p) # r'x p\r\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\r\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\r\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[0],(nf,1))).T\r\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[1],(nf,1))).T\r\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[2],(nf,1))).T\r\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[0],(nf,1)).T)\r\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[1],(nf,1)).T)\r\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[2],(nf,1)).T)\r\n E = vstack((Ex,Ey,Ez))\r\n B = vstack((Bx,By,Bz))\r\n else:\r\n magrprime = sqrt(sum((rprime)**2,axis=1)) # |r'|\r\n magrprimep = tile(magrprime, (len(f),1)).T\r\n phip = tile(phi, (len(f),1))\r\n fp = tile(f,(len(magrprime),1))\r\n w = 2*pi*fp # \\omega\r\n k = w/c # wave number\r\n krp = k*magrprimep # k|r'|\r\n rprime_cross_p = cross(rprime, p) # r'x p\r\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\r\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\r\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,0],(nf,1))).T\r\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,1],(nf,1))).T\r\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,2],(nf,1))).T\r\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,0],(nf,1)).T)\r\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,1],(nf,1)).T)\r\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,2],(nf,1)).T)\r\n E = vstack((sum(Ex,axis=0),sum(Ey,axis=0),sum(Ez,axis=0)))\r\n B = vstack((sum(Bx,axis=0),sum(By,axis=0),sum(Bz,axis=0)))\r\n return E,B","def compute_energy_density(kT):\n h=u.planck\n c=u.speed_of_light\n pi=np.pi\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)","def fuel_cond(T):\n\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\n \n return kc","def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\n kB = 1.380658e-16\n h = 6.6260755e-27\n c = 29979245800.\n nu = freqGHz*1.e9\n x = h*nu/(kB*T0)\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\n cNu *= 1e23\n return cNu","def gyroHF(self, GYRO, PFC):\n print(\"Calculating gyro orbit heat loads\")\n log.info(\"Calculating gyro orbit heat loads\")\n #get divertor HF\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\n #Get fractional multipliers for each helical trace\n gyroFrac = 1.0/GYRO.N_gyroPhase\n vPhaseFrac = 1.0/GYRO.N_vPhase\n vSliceFrac = GYRO.energyFracs\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\n Pgyro = np.zeros((GYRO.Nt))\n PNaN = 0.0\n sum=0\n sum1=0\n #loop through intersect record and redistribute power using multipliers\n for gyroPhase in range(GYRO.N_gyroPhase):\n for vPhase in range(GYRO.N_vPhase):\n for vSlice in range(GYRO.N_vSlice):\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\n notNanTo = notNanTo.astype(int) #cast as integer\n isNanTo = idx[np.isnan(idx)] #indices we map power to\n isNanTo = isNanTo.astype(int) #cast as integer\n\n if len(notNanFrom)>0:\n #multiple Froms can light up the same To, so we loop\n for i in range(len(notNanFrom)):\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\n\n if len(isNanFrom)>0:\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\n\n #print(\"\\nTEST2\")\n #print(GYRO.intersectRecord[0,0,0,1711])\n #print(Pgyro[1711])\n\n GYRO.gyroPowMatrix += Pgyro\n GYRO.gyroNanPower += PNaN\n return","def calc_dtdc(tpbpcs, specs):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n Nbs = len(np.hstack(tpbpcs[0]))\n Ndraw = len(tpbpcs)\n\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\n\n for i in range(Ndraw):\n\n # Create array of times per bandpass\n dtpb[i,:] = np.hstack(tpbpcs[i])\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def get_granule_frequency(self,r=None,ids=None):\n # Simply divide the length of each spike vector by the simulation time\n # or window time.\n spikes=[] # The local copy of spikes to get the frequency on\n try:\n spikes=self.get_granule_spikes(r,ids)\n if len(spikes)==0:\n raise Exception('Unable to get mitral cell spikes')\n except Exception:\n raise\n freqg=numpy.zeros(self.num_gran)\n timems=self.sim_time\n if type(r) is tuple and len(r)==2:\n timems=float(r[1]-r[0])\n for i in range(len(spikes)):\n freqg[i]=float(len(spikes[i]))*1000./timems\n return freqg","def calc_dtdc_star(tpbpc0, spec):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n # Create array of times per bandpass\n dtpb = np.hstack(tpbpc0)\n\n Nbs = len(dtpb)\n dcomp = np.zeros(Nbs) # completeness\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def CMB_spec(eng, temp):\n if np.issubdtype(type(eng), float):\n eng = np.array([eng])\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\n\n if np.issubdtype(type(eng), float): \n return phot_spec_density[0] \n else: \n return phot_spec_density","def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def DFTscargle(times, signal,f0,fn,df):\n f0 = 0.\n #fn *= 2*np.pi\n #df *= 2*np.pi\n #-- initialize\n nfreq = int((fn-f0)/(df))\n print \"Nfreq=\",nfreq\n tzero = times[0]\n si = 1.\n lfreq = 2*nfreq+1\n mm = 2*nfreq\n ftrx = np.zeros(mm)\n ftix = np.zeros(mm)\n om = np.zeros(mm)\n w = np.zeros(mm)\n wz = df #pi/(nn+dt)\n nn = len(times)\n \n #-- calculate DFT\n ftrx,ftix,om,w = pydft.ft(signal,times,wz,nfreq,si,lfreq,tzero,df,ftrx,ftix,om,w,nn,mm)\n \n if f0==0:\n ftrx[1:] *= np.sqrt(2)\n ftix[1:] *= np.sqrt(2)\n w[1:] *= np.sqrt(2)\n \n cut_off = len(w)\n for i in range(0,len(w))[::-1]:\n if w[i] != 0: cut_off = i+1;break\n \n om = om[:cut_off]\n ftrx = ftrx[:cut_off]\n ftix = ftix[:cut_off]\n w = w[:cut_off]\n \n # norm amplitudes for easy inversion\n T = times[-1]-times[0]\n N = len(times)\n \n w *= T/(2.*N)\n ftrx *= T/(2.*N)\n ftix *= T/(2.*N)\n \n return om*2*np.pi,w,ftrx,ftix","def get_F_potential(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n # y = chemical_potential/temperature\n y = chemical_potential / tt\n F = gbar / np.sqrt(2.0) / np.pi ** 2 * tt ** (2.5) * vv\n F *= y * _1d_call(_fdk, y, k=0.5) - 2.0 / 3.0 * _1d_call(_fdk, y, k=1.5)\n return F","def frfplot(freq, H, freq_min=0, freq_max=None, type=1, legend=[]):\n FLAG = type # Plot type, should libe renamed throughout.\n freq = freq.reshape(1, -1)\n lenF = freq.shape[1]\n if len(H.shape) is 1:\n H = H.reshape(1, -1)\n\n if H.shape[0] > H.shape[1]:\n H = H.T\n\n if freq_max is None:\n freq_max = np.max(freq)\n\n if freq_min is None:\n freq_min = np.min(freq)\n\n if freq_min < np.min(freq):\n freq_min = np.min(freq)\n\n if freq_min > freq_max:\n raise ValueError('freq_min must be less than freq_max.')\n\n # print(str(np.amin(freq)))\n inlow = int(lenF * (freq_min - np.amin(freq)\n ) // (np.amax(freq) - np.amin(freq)))\n\n inhigh = int(lenF * (freq_max - np.amin(freq)\n ) // (np.amax(freq) - np.amin(freq)) - 1)\n # if inlow<1,inlow=1;end\n # if inhigh>lenF,inhigh=lenF;end\n \"\"\"print('freq shape: {}'.format(freq.shape))\n print('H shape: {}'.format(H.shape))\n print('Index of low frequency: {}'.format(inlow))\n print('Index of high frequency: {}'.format(inhigh))\"\"\"\n H = H[:, inlow:inhigh]\n # print(H.shape)\n freq = freq[:, inlow:inhigh]\n mag = 20 * np.log10(np.abs(H))\n # print(mag)\n # print(mag.shape)\n minmag = np.min(mag)\n maxmag = np.max(mag)\n phase = np.unwrap(np.angle(H)) * 180 / np.pi\n # phmin_max=[min(phase)//45)*45 ceil(max(max(phase))/45)*45];\n phmin = np.amin(phase) // 45 * 45.0\n phmax = (np.amax(phase) // 45 + 1) * 45\n \"\"\"minreal = np.amin(np.real(H))\n maxreal = np.amax(np.real(H))\n minimag = np.amin(np.imag(H))\n maximag = np.amax(np.imag(H))\"\"\"\n\n if FLAG is 1:\n fig, (ax1, ax2) = plt.subplots(2, 1)\n ax1.plot(freq.T, mag.T)\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Mag (dB)')\n ax1.grid()\n ax1.set_xlim(xmax=freq_max, xmin=freq_min)\n ax1.set_ylim(ymax=maxmag, ymin=minmag)\n\n ax2.plot(freq.T, phase.T)\n ax2.set_xlabel('Frequency (Hz)')\n ax2.set_ylabel('Phase (deg)')\n ax2.grid()\n ax2.set_xlim(xmax=freq_max, xmin=freq_min)\n ax2.set_ylim(ymax=phmax, ymin=phmin)\n ax2.set_yticks(np.arange(phmin, (phmax + 45), 45))\n fig.tight_layout()\n\n if len(legend) > 0:\n plt.legend(legend)\n ax = (ax1, ax2)\n else:\n print(\"Sorry, that option isn't supported yet\")\n return ax\n\n \"\"\"# elif FLAG==2:\n # subplot(2,1,1)\n # semilogx(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # % Fmin,Fmax,min(mag),max(mag)\n # axis([Fmin Fmax minmag maxmag])\n\n # subplot(2,1,2)\n # semilogx(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n\n # elif FLAG==3:\n # subplot(2,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F*2*pi,mag)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Wmin Wmax minmag maxmag])\n # zoom on\n # subplot(2,1,2)\n # semilogx(F*2*pi,phase)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n\n # elseif FLAG==4\n # subplot(2,1,1)\n # plot(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # subplot(2,1,2)\n # plot(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==5\n # subplot(1,1,1)\n # imax=round(length(F)*Fmax/max(F));\n # imin=round(length(F)*Fmin/max(F))+1;\n # plot(real(Xfer(imin:imax)),imag(Xfer(imin:imax)))\n # xlabel('Real')\n # ylabel('Imaginary')\n # grid on\n # zoom on\n # elseif FLAG==6\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # plot(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # elseif FLAG==7\n # subplot(1,1,1)\n # plot(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # elseif FLAG==8\n # subplot(1,1,1)\n # plot(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # elseif FLAG==9\n # subplot(1,1,1)\n # plot(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==10\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # elseif FLAG==11\n # subplot(1,1,1)\n # semilogx(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # elseif FLAG==12\n # subplot(1,1,1)\n # semilogx(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # elseif FLAG==13\n # subplot(1,1,1)\n # semilogx(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==14\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F*2*pi,mag)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Wmin Wmax minmag maxmag])\n # zoom on\n # elseif FLAG==15\n # subplot(1,1,1)\n # semilogx(F*2*pi,phase)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # else\n # subplot(2,1,1)\n # mag=20*log10(abs(Xfer));\n # plot(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # subplot(2,1,2)\n # plot(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n \"\"\"","def fcut(r, rcut, trans_width):\n if (isinstance(r, list) or isinstance(r, np.ndarray)) and len(r) > 1:\n return np.array([fcut(ri, rcut, trans_width) for ri in r])\n else:\n if r > rcut:\n return 0.\n elif r > rcut-trans_width:\n return 0.5*(np.cos(np.pi*(r-rcut+trans_width)/trans_width) + 1)\n else:\n return 1.0","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def gyroHF2(self, GYRO, PFC):\n print(\"Calculating gyro orbit heat loads\")\n log.info(\"Calculating gyro orbit heat loads\")\n #get divertor HF\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\n #Get fractional multipliers for each helical trace\n gyroFrac = 1.0/GYRO.N_gyroPhase\n vPhaseFrac = 1.0/GYRO.N_vPhase\n vSliceFrac = GYRO.energyFracs\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\n Pgyro = np.zeros((GYRO.Nt))\n PNaN = 0.0\n sum=0\n sum1=0\n #loop through intersect record and redistribute power using multipliers\n for gyroPhase in range(GYRO.N_gyroPhase):\n for vPhase in range(GYRO.N_vPhase):\n for vSlice in range(GYRO.N_vSlice):\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\n hdotn = np.abs(GYRO.hdotn[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap])\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\n notNanTo = notNanTo.astype(int) #cast as integer\n isNanTo = idx[np.isnan(idx)] #indices we map power to\n isNanTo = isNanTo.astype(int) #cast as integer\n\n if len(notNanFrom)>0:\n #multiple sources can load the same target face, so we loop\n for i in range(len(notNanFrom)):\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\n\n if len(isNanFrom)>0:\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\n\n\n GYRO.gyroPowMatrix += Pgyro\n GYRO.gyroNanPower += PNaN\n return","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n pad=np.random.rand(nspad)/100\n trc_norm=trc/np.amax(np.abs(trc))\n trc_norm_padded=np.hstack((pad,trc_norm))\n trc_entropy=self.entropy(trc_norm_padded,50)\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\n for i,j in enumerate(trc):\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def stepfall(double[:] v, redshifts, in_terms, double H0):\n\n cdef double t = v[0]\n cdef double a = v[1]\n # ombar_i = rho_i(t) / rho_crit(t0)\n cdef double ombar_m = v[2]\n cdef double ombar_r = v[3]\n cdef double ombar_a = v[4]\n cdef double ombar_de = v[5]\n cdef double z = v[6]\n cdef double dl = v[7]\n\n cdef double in_v = in_terms[0]\n cdef double in_w = in_terms[1]\n cdef double in_x = in_terms[2]\n\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_a +ombar_de)**(0.5)\n\n# if ombar_m < 0 or ombar_de < 0 or ombar_r < 0 or ombar_a < 0:\n# print('stepfall')\n# print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\n# print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\n# 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\n\n if math.isnan(Hz):\n print('stepfall')\n print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\n print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\n 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\n\n cdef double dtdz = -1.0/((1.0+z) * Hz)\n cdef double dadz = -(1.0+z)**(-2.0)\n # d(ombar_i)/dz\n cdef double domdz = (3.0*ombar_m +in_v*ombar_m*ombar_r/Hz)/(1.0+z) # w = 0\n cdef double dordz = (4.0*ombar_r -in_v*ombar_m*ombar_r/Hz +in_w*ombar_r*ombar_a/Hz)/(1.0+z) # w = 1/3\n cdef double doadz = (2.7*ombar_a -in_w*ombar_r*ombar_a/Hz +in_x*ombar_a*ombar_de/Hz)/(1.0+z) # w = -0.1\n cdef double dodedz = -in_x*ombar_a*ombar_de/(1.0+z)/Hz # w = -1\n cdef double ddldz = 1.0/Hz\n\n # first derivatives of functions I want to find:\n f = [dtdz, # time\n dadz, # scale factor\n domdz, # w = 0\n dordz, # w = 1/3\n doadz, # w = -0.1\n dodedz,# w = -1\n 1.0, # redshift\n ddldz] # luminosty distance\n\n return f","def fourierBeam(self, centres, u_bl, v_bl, frequency, min_attenuation = 1e-10, N = 20):\n \n a = 1/ (2 * self._instr_core.sigma(frequency)**2)\n \n indx_u = np.digitize(u_bl, centres)\n indx_v = np.digitize(v_bl, centres)\n \n beam = []\n \n for jj in range(len(u_bl)):\n x, y = np.meshgrid(centres[indx_u[jj]-int(N/2):indx_u[jj]+int(N/2)], centres[indx_v[jj]-int(N/2):indx_v[jj]+int(N/2)],copy=False)\n B = (np.exp(- ((x - u_bl[jj])**2 + (y - v_bl[jj])**2 )/ a)).T\n B[B<min_attenuation] = 0\n beam.append(B)\n \n indx_u+= -int(N/2)\n indx_v+= -int(N/2)\n \n indx_u[indx_u<0] = 0\n indx_v[indx_v<0] = 0 \n \n return beam, indx_u, indx_v","def doCalculation(self, E1, E2, muL, muR, T, pot, C, TCalc, Density, E0, L):\n NEcut = len(E1) #we determine the number of single-particle states that we use\n VG=np.diag(pot)\n E= int(0.5*np.size(VG))\n V = VG[0:E] #since the potential of both barriers is symmetric and we only tunnel through one barrier. Therefore we only use one half of the potential.\n dx= L/(np.size(pot))\n\n #Following prints are for debugging purposes:\n #print(\"---------------------------------------------------------------------\")\n #print(\"---------------------------------------------------------------------\")\n #print(\"Hier beginnt die Ausgabe von Rates:\")\n #print(\"---------------------------------------------------------------------\")\n #print(\"V:\", V)\n #print(\"E1:\", E1)\n #print(\"E2:\", E2)\n #print(\"C:\", C)\n\n kB=0.08629 #Boltzmann constant in meV/K\n \n \n def fermi(E,mu,T):\n \"\"\"This fermi-function tells us with which likelyhood a state with an E is occupied on the lead.\n E(float): energy difference between the initial and the final state that the tunneling electron has to carry.\n mu(float): chemical potential of either drain(muR) or source(muL).\n T(float): temperature.\n \"\"\"\n if (E-mu)/T > 600:\n f=0\n\t\t\t\t\n else:\n f=1/(math.exp((E-mu)/(kB*T) )+1)\n return(f)\n \n\n\t#This function is called by the Gamma_ij-equations and includes the transmission-coefficient for each tunnelling-event\n #and the density of state function of the source and drain. \n def Gamma(Ea,Eb,V):\n \"\"\":math:`\\\\Gamma` includes the transmission coefficient and DOS: :math:`\\Gamma = | t |^2 * DOS`\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n V(np.array): barrier potential\n \"\"\"\n #print(Ea)\n #print(V)\n return (np.absolute(TCalc.calculate_transmission(Ea,V,dx))**2*Density.calculate_DensityofStates(np.absolute(Ea-Eb)))\n \n #These next four functions are used to calculate the transition rates.Each function for a different kind of transition:\n #We distinguish between transitions, in which the number of electrons on the dot changes from one to two(Gamma_12) and reverse(Gamma_21).\n #And between transitions in which the number of electrons on the dot change from zero to one(Gamma_01) and reverse(Gamma_10).\n\n def Gamma_12(Ea,Eb,mu,T):\n \"\"\"Calculates the rate of a transition from a one body state to a two body state.\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n summe=0\n j=0\n Cb=C[np.where(E2==Eb)[0][0]]\n while j< NEcut:\n summe=Cb[np.where(E1==Ea)[0][0]][j]+summe\n j=j+1\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*fermi((Eb-Ea),mu,T))\n\n\n def Gamma_01(Eb,mu,T):\n \"\"\"Calculates the transition rate from the vacuum state to a one-body state.\n\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n return(Gamma(E0,Eb,V)*fermi((Eb-E0),mu,T))\n\n def Gamma_21(Ea,Eb,mu,T):\n \"\"\"Calculates the rate of a transition from a two body state to a one body state.\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n summe=0\n nu=0\n Ca=C[np.where(E2==Ea)[0][0]]\n while nu < NEcut:\n summe=summe+Ca[np.where(E1==Eb)[0][0]][nu]\n nu=nu+1\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*(1-fermi((Ea-Eb),mu,T)))\n\n def Gamma_10(Ea,mu,T):\n \"\"\"Calculates the rate of a transition from a one body state to the vacuum state.\n\n Ea(float): energy of initial state \n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n return(Gamma(Ea,E0,V)*(1-fermi((Ea-E0),mu,T)))\n\n #creating the output matrices that later contain all the transition rates through either\n #the left or the right barrier\n Gamma_R=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\n Gamma_L=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\n\n #using a loop to fill the output matrices with transition rates.\n i_=0\n for i in E1:\n j_=0\n for j in E2:\n Gamma_L[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muL,T)\n Gamma_L[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muL,T)\n Gamma_R[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muR,T)\n Gamma_R[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muR,T)\n j_=j_+1\n Gamma_L[0][i_+1]=Gamma_10(i,muL,T)\n Gamma_R[0][i_+1]=Gamma_10(i,muR,T)\n Gamma_L[i_+1][0]=Gamma_01(i,muL,T)\n Gamma_R[i_+1][0]=Gamma_01(i,muR,T)\n i_=1+i_\n\n #print(\"Gamma_L und Gamma_R:\")\n #print(Gamma_L,Gamma_R)\n #print(\"-----------------------------------------------------------------------\")\n #print(\"---------------------------------------------------------------------\")\n return(Gamma_L,Gamma_R)","def thermodynamic_temperature(frequency, T_cmb=None):\n nu = frequency.to(si.GHz, spectral())\n\n if T_cmb is None:\n from astropy.cosmology import default_cosmology\n\n T_cmb = default_cosmology.get().Tcmb0\n\n def f(nu, T_cmb=T_cmb):\n x = _si.h * nu / _si.k_B / T_cmb\n return x**2 * np.exp(x) / np.expm1(x) ** 2\n\n def convert_Jy_to_K(x_jybm):\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\n astrophys.Jy\n )\n return x_jybm / factor\n\n def convert_K_to_Jy(x_K):\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\n si.K\n )\n return x_K / factor\n\n return Equivalency(\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\n \"thermodynamic_temperature\",\n {\"frequency\": frequency, \"T_cmb\": T_cmb},\n )","def mce_filter(freq, f_raw, params):\n\tz = np.exp(-2j*np.pi*freq/f_raw)\n\tb11, b12, b21, b22 = np.array(params[:4])*0.5**14\n\tH = (1+z)**4 / (1-b11*z+b12*z**2) / (1-b21*z+b22*z**2)\n\tH /= 2**4 / (1-b11+b12) / (1-b21+b22)\n\treturn H","def torch_mel_to_hertz(frequencies_mel):\r\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\r\n return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)","def exotic(double[:] v, redshifts, in_terms, double H0):\n\n cdef double t = v[0]\n cdef double a = v[1]\n cdef double ombar_m = v[2]\n cdef double ombar_r = v[3]\n cdef double ombar_de = v[4]\n cdef double z = v[5]\n cdef double dl = v[6]\n cdef double gamma = in_terms[0]\n cdef double zeta = in_terms[1]\n\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_de)**(0.5)\n\n# if ombar_m < 0 or ombar_de < 0:\n# print('exotic')\n# print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\n# print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\n# % (ombar_m, ombar_r, ombar_de))\n\n if math.isnan(Hz):\n print('exotic')\n print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\n print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\n % (ombar_m, ombar_r, ombar_de))\n\n cdef double dtdz = -1.0/((1.0+z) * Hz)\n cdef double dadz = -(1.0+z)**(-2.0)\n cdef double domdz = (3.0*ombar_m +gamma*ombar_m*ombar_r /Hz) /(1.0+z)\n cdef double dordz = (4.0*ombar_r -(gamma*ombar_m*ombar_r -zeta*ombar_r*ombar_de) /Hz ) /(1.0+z)\n cdef double dodedz = -zeta*ombar_r*ombar_de/(1.0+z) /Hz\n cdef double ddldz = 1.0/Hz\n\n # first derivatives of functions I want to find:\n f = [dtdz,# dt/dz (= f.d wrt z of time)\n dadz,# d(a)/dz (= f.d wrt z of scale factor)\n domdz,# dw = 0, (ombar_m)/dz (= f.d wrt z of density_m(t) / crit density(t0))\n dordz,# w = 1/3, d(ombar_r)/dz (= f.d wrt z of density_r(t) / crit density(t0))\n dodedz,# w = -1, d(ombar_de)/dz (= f.d wrt z of density_de(t) / crit density(t0))\n 1.0,# d(z)/dz (= f.d wrt z of redshift)\n ddldz]# d(dl)/dz (= f.d wrt z of luminosty distance) # H + Hdz*(1+z)\n\n return f","def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\n # low temperatures - high numbers\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)","def get_rec_rate_H_caseB_Dr11(T):\n T4 = T*1e-4\n return 2.54e-13*T4**(-0.8163 - 0.0208*np.log(T4))","def lrelfreq(inlist,numbins=10,defaultreallimits=None):\r\n h,l,b,e = histogram(inlist,numbins,defaultreallimits)\r\n for i in range(len(h)):\r\n h[i] = h[i]/float(len(inlist))\r\n return h,l,b,e","def __init__(self, N=1024, fc=50., tmax=1., delay=None):\n fc = float(fc)\n tmax = float(tmax)\n dt = tmax / (N-1)\n df = 1. / tmax\n istart = -N//2 + 1\n nroll = -istart\n t = np.arange(istart, N // 2 + 1) * dt\n f = np.arange(istart, N // 2 + 1) * df\n # arrange f as positve, negative freqs\n f = np.roll(f, -nroll)\n\n # freq domain ricker\n ricker_f = 2 * f**2 / (np.sqrt(np.pi) * fc**3) * np.exp(-(f/fc)**2)\n\n if delay is None:\n delay = 1.5 / fc\n ricker_f = ricker_f * np.exp(-1j * 2 * np.pi * f * delay)\n\n # time domain ricker\n ricker_t = N * np.real(np.fft.ifft(ricker_f))\n\n\n amp = np.absolute(ricker_f)\n phase = np.unwrap(np.angle(ricker_f, False))\n\n # ricker_f[0] contains the zero frequency term,\n # ricker_f[1:N//2] contains the positive-frequency terms,\n # ricker_f[N//2 + 1:] contains the negative-frequency terms,\n # in increasing order starting from the most negative frequency\n self.delay = delay\n self.fc = fc\n self.dt = dt\n # arange t and ricker_t in the order of increasing time; the zero phase case contains negative time\n\n self.ricker_t = np.roll(ricker_t, nroll)\n self.f = f\n self.t = t\n self.df = df\n self.ricker_f = ricker_f\n self.amp = amp\n self.phase = phase\n self.nroll = nroll","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def cutoff_denominator(self, list_energy):\n\n tol = 1e-3\n\n z = list_energy/tol\n\n den = N.imag(SS.wofz(z))/tol*N.sqrt(N.pi)\n\n return den","def get_fractional_degradation(bt):\n\n\n\n NomIch = 0.125 # Nominal charge current\n NomId = 0.25 # Nominal discharge current\n NomSoC = 0.5 # Nominal state of charge_mode\n NomDoD = 1.0 # Nominal depth of discharge\n B = 5 #Battery capacity\n qt = 5 * 0.5 # Amount of energy in the battery at the start\n # Determin charge of discharge\n if bt > 0:\n Id = bt/(B*1) # time interval differnece is 1\n Ich = NomIch\n else:\n Ich = bt/(B*1)\n Id = NomId\n\n #Calculate average State of Charge\n SoC = 100 * (qt - 0.5*bt)/B\n\n #Calculate Depth of Discharge\n DoD = 100 * bt /B\n\n # Functions\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\n nCL = nCL1 * nCL2 * nCL3\n Fractional_D = (0.5/3650)/ nCL\n return Fractional_D","def _solve_freq_unc(self, d, v, a, force, freq, incrb):\n # convert frequency in Hz to radian/sec:\n freqw = 2 * np.pi * freq\n freqw2 = freqw**2\n\n # solve rigid-body and elastic parts separately\n # - residual-flexibility part was already solved in _init_dva\n\n # solve rigid-body part:\n self._solve_freq_rb(d, v, a, force, freqw, freqw2, incrb, True)\n\n # solve elastic part:\n if self.elsize:\n el = self.el\n _el = self._el\n fw = freqw[None, :]\n fw2 = freqw2[None, :]\n if self.m is None:\n d[el] = force[el] / (\n 1j * (self.b[_el][:, None] @ fw) + self.k[_el][:, None] - fw2\n )\n else:\n d[el] = force[el] / (\n 1j * (self.b[_el][:, None] @ fw)\n + self.k[_el][:, None]\n - self.m[_el][:, None] @ fw2\n )\n a[el] = d[el] * -(freqw2)\n v[el] = d[el] * (1j * freqw)","def calculate_bandwidth(self, complist):\n\n self.type = complist[0]\n self.spot = complist[2]\n self.value = complist[1]\n self.fail = False\n\n if self.spot == \"1\" or self.spot == \"2\":\n # print \"Calculation if Loop 1st filter\"\n if self.type == \"C\":\n if self.c1 == 0:\n self.c1 = self.value\n else:\n self.fail = True\n else:\n if self.r1 == 0:\n self.r1 = self.value\n else:\n self.fail = True\n\n if self.spot == \"3\" or self.spot == \"4\":\n # print \"Calculation if loop 2nd filter\"\n if self.type == \"C\":\n if self.c2 == 0:\n self.c2 = self.value\n else:\n self.fail = True\n else: #self.type == \"R\"\n if self.r2 == 0:\n self.r2 = self.value\n else:\n self.fail = True\n\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\n #print \"hello!\"\n cf_low = str(cf_low)\n self.cutoff_freql = cf_low\n self.cutoff_freql_text = cf_low + \"K\"\n print self.cutoff_freql_text\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\n cf_high = str(cf_high)\n self.cutoff_freqh = cf_high\n self.cutoff_freqh_text = cf_high + \"K\"\n print self.cutoff_freqh_text\n voltage_change = float((self.r2)/self.r1)\n voltage = 5 + voltage_change\n self.voltage = str(voltage)\n print self.voltage","def div(\n coeff_rho,\n momentum_x,\n momentum_y,\n momentum_z,\n ):\n # Compute the fourth order derivative of the pressure for the face\n # velocity correction.\n p_corr = (\n states['p']\n if self._params.enable_rhie_chow_correction else states['dp'])\n d4p_dx4 = self._kernel_op.apply_kernel_op_x(p_corr, 'k4d2x')\n d4p_dy4 = self._kernel_op.apply_kernel_op_y(p_corr, 'k4d2y')\n d4p_dz4 = self._kernel_op.apply_kernel_op_z(p_corr, 'k4d2z',\n 'k4d2zsh')\n\n # Compute velocity gradient based on interpolated values on cell faces.\n coeff_x = dt / (4. * coeff_rho * dx**2)\n du = self._kernel_op.apply_kernel_op_x(momentum_x, 'kDx')\n du_dx = [\n du_i / (2. * dx) + coeff_x * d4p_dx4_i\n for du_i, d4p_dx4_i in zip(du, d4p_dx4)\n ]\n\n coeff_y = dt / (4. * coeff_rho * dy**2)\n dv = self._kernel_op.apply_kernel_op_y(momentum_y, 'kDy')\n dv_dy = [\n dv_i / (2. * dy) + coeff_y * d4p_dy4_i\n for dv_i, d4p_dy4_i in zip(dv, d4p_dy4)\n ]\n\n coeff_z = dt / (4. * coeff_rho * dz**2)\n dw = self._kernel_op.apply_kernel_op_z(momentum_z, 'kDz', 'kDzsh')\n dw_dz = [\n dw_i / (2. * dz) + coeff_z * d4p_dz4_i\n for dw_i, d4p_dz4_i in zip(dw, d4p_dz4)\n ]\n\n return [\n du_dx_i + dv_dy_i + dw_dz_i\n for du_dx_i, dv_dy_i, dw_dz_i in zip(du_dx, dv_dy, dw_dz)\n ]","def torch_hertz_to_mel(frequencies_hertz):\r\n # return _MEL_HIGH_FREQUENCY_Q * tf.math.log(\r\n # 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\r\n return _MEL_HIGH_FREQUENCY_Q * np.log(\r\n 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))","def effective_temperature(R,times):\n T_eff = np.empty((len(R),times))\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \n for i in range (len(R)):\n for t in range(times): \n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\n return T_eff","def apply_band_pass(ftd, freq, omega, bp_wid=1):\n # Find number of frequencies\n nf = len(freq)\n # Find index for band pass, only consider indices of positive freqs\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\n # Filter out frequencies left of band pass\n ftd[:,0:idx_om-1-bp_wid] = 0.0\n # Filter out frequencies left of omega\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\n # Correct for lost amplitude\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\n return ftd","def HeatEqn_FT(D, L, x, t, u_0):\n n = x.size\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\n u_0t = np.fft.fft(u_0)\n\n U = np.zeros((t.size, x.size))\n for ti in range(t.size):\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\n\n return U","def integrate_rd(D=2e-3, t0=1., tend=13., x0=1e-10, xend=1.0, N=256,\n nt=42, logt=False, logy=False, logx=False,\n random=False, k=1.0, nstencil=3, linterpol=False,\n rinterpol=False, num_jacobian=False, method='bdf',\n integrator='scipy', iter_type='undecided',\n linear_solver='default', atol=1e-8, rtol=1e-10, factor=1e5,\n random_seed=42, plot=False, savefig='None', verbose=False,\n scaling=1.0, ilu_limit=1000.0, first_step=0.0, n_jac_diags=0, use_log2=False):\n if t0 == 0.0:\n raise ValueError(\"t0==0 => Dirac delta function C0 profile.\")\n if random_seed:\n np.random.seed(random_seed)\n tout = np.linspace(t0, tend, nt)\n\n units = defaultdict(lambda: 1)\n units['amount'] = 1.0/scaling\n\n # Setup the grid\n x = generate_grid(x0, xend, N, logx, random=random)\n modulation = [1 if (i == 0) else 0 for i in range(N)]\n\n rd = ReactionDiffusion.nondimensionalisation(\n 2,\n [[0], [1]],\n [[1], [0]],\n [k, factor*k],\n N=N,\n D=[0, D],\n x=x,\n logy=logy,\n logt=logt,\n logx=logx,\n nstencil=nstencil,\n lrefl=not linterpol,\n rrefl=not rinterpol,\n modulated_rxns=[0, 1],\n modulation=[modulation, modulation],\n unit_registry=units,\n ilu_limit=ilu_limit,\n n_jac_diags=n_jac_diags,\n faraday_const=1,\n vacuum_permittivity=1,\n use_log2=use_log2\n )\n\n # Calc initial conditions / analytic reference values\n Cref = analytic(rd.xcenters, tout, D, x0, xend, logx, use_log2=use_log2).reshape(\n nt, N, 1)\n source = np.zeros_like(Cref[0, ...])\n source[0, 0] = factor\n y0 = np.concatenate((source, Cref[0, ...]), axis=1)\n\n # Run the integration\n integr = Integration(\n rd, y0, tout, integrator=integrator, atol=atol, rtol=rtol,\n with_jacobian=(not num_jacobian), method=method,\n iter_type=iter_type,\n linear_solver=linear_solver, first_step=first_step)\n Cout = integr.with_units('Cout')\n if verbose:\n import pprint\n pprint.pprint(integr.info)\n spat_ave_rmsd_over_atol = spat_ave_rmsd_vs_time(\n Cout[:, :, 1], Cref[:, :, 0]) / atol\n tot_ave_rmsd_over_atol = np.average(spat_ave_rmsd_over_atol)\n\n if plot:\n # Plot results\n import matplotlib.pyplot as plt\n plt.figure(figsize=(6, 10))\n\n def _plot(C, c, ttl=None, vlines=False,\n smooth=True):\n if vlines:\n plt.vlines(rd.x, 0, np.ones_like(rd.x)*max(C),\n linewidth=1, colors='gray')\n if smooth:\n plt.plot(rd.xcenters, C, c=c)\n else:\n for i, _C in enumerate(C):\n plt.plot([rd.x[i], rd.x[i+1]], [_C, _C], c=c)\n\n plt.xlabel('x / m')\n plt.ylabel('C / M')\n if ttl:\n plt.title(ttl)\n\n for i in range(nt):\n kwargs = dict(smooth=(N >= 20),\n vlines=(i == 0 and N < 20))\n\n c = 1-tout[i]/tend\n c = (1.0-c, .5-c/2, .5-c/2)\n plt.subplot(4, 1, 1)\n _plot(Cout[i, :, 1], c, 'Simulation (N={})'.format(rd.N),\n **kwargs)\n\n plt.subplot(4, 1, 2)\n _plot(Cref[i, :, 0], c, 'Analytic', **kwargs)\n\n plt.subplot(4, 1, 3)\n _plot((Cout[i, :, 1]-Cref[i, :, 0]), c,\n \"Error\",\n **kwargs)\n\n plt.subplot(4, 1, 4)\n plt.plot(integr.tout, spat_ave_rmsd_over_atol)\n plt.plot([integr.tout[0], integr.tout[-1]],\n [tot_ave_rmsd_over_atol]*2, '--')\n plt.title(\"RMSD / atol\")\n\n plt.tight_layout()\n save_and_or_show_plot(savefig=savefig)\n\n return tout, Cout, integr.info, rd, tot_ave_rmsd_over_atol","def freq2den(freq):\n\n return freq * freq * k_2","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","def freq_defl_comp(fmax, p=75, p1=database['K+'], p2=database['pi+'],\r\n p3=database['p+'], L_t=79.6, l=2.74, E=1e6, plot=True,\r\n details=False, n=1000, delta_p=1.6e-2, fmin=0, just_pi=False):\r\n f_range = np.linspace(fmin, fmax, n)\r\n min_defl, d2, d3 = [], [], []\r\n for f in f_range:\r\n if just_pi == True:\r\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\r\n min_defl.append(d2[-1])\r\n if just_pi == False: \r\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\r\n d3.append(ang_deflection(p, f, p1, p3, L_t, l, E, delta_p))\r\n min_defl.append(np.min([d2[-1], d3[-1]]))\r\n if plot == True:\r\n fig = plt.figure(figsize=[9, 5])\r\n ax = fig.add_subplot(1, 1, 1)\r\n if details == True:\r\n ax.plot(f_range, d2, 'r', alpha=0.5, label=f'{p2.name} deflection')\r\n ax.plot(f_range, d3, 'b', alpha=0.5, label=f'{p3.name} deflection')\r\n else:\r\n ax.plot(f_range, min_defl, color=[1, 0, 1], alpha=0.5, label='min deflection')\r\n# ax.set_xlim(fmin, fmax)\r\n ax.set_ylim(0)\r\n ax.set_xlabel('Frequency / Hz', fontsize=20)\r\n text = r'$D_{'\r\n text += p2.name + '/' + p3.name\r\n text += '}$ / mrad'\r\n ax.set_ylabel(text, fontsize=20)\r\n ax.set_xscale('log')\r\n ax.legend(fontsize=20)\r\n plt.show()\r\n opt_freq = f_range[np.argmax(min_defl)]\r\n d_opt = (fmax-fmin)/1000\r\n d_opt_perc = (d_opt/opt_freq)*100\r\n if details == True:\r\n return 'optimum frequency = {0:.0f} +/- {1:.5f}%'.format(opt_freq, d_opt_perc)\r\n return opt_freq","def F_rxth(mx, rhoc, Temp):\n return 64. * m.pow(Temp/1.e+5,0.5) * m.pow(1.e+14/rhoc,0.5) * m.pow(100./mx,0.5) # cm","def calc(self,index,counter_values):\n gr = self.grSign * self.grPitch['Value'].value\n m = self.mSign * self.mPitch['Value'].value\n \n offsetG,offsetM = self.checkOffset()\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\n alpha = (2.0*theta) + beta\n numerator = (math.sin(alpha) + math.sin(beta))\n denominator = (self.DiffrOrder * self.look_at_grx())\n wavelength = numerator / denominator\n \n if wavelength == 0.0:\n energy_physicalmot = 0.0\n else:\n energy_physicalmot = self.hc / wavelength\n #if self.FixedM2Pit: \n Cff = math.cos(beta)/math.cos(alpha)\n if energy_physicalmot < 0 :\n #warning: wavelength se vuelve negativo ... ??????\n energy_physicalmot = energy_physicalmot *(-1) \n \n # Real Energy is equal to the energy calculated by the encoders\n # minus an offset that depends on the same energy calculated by the \n # encoders:\n # E_physicalmot = Ereal + offset\n # with offset = a*Ereal + b\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \n a_coeff = self.EnergyDP.a_offset_coeff\n b_coeff = self.EnergyDP.b_offset_coeff\n numerator = energy_physicalmot - b_coeff\n denominator = 1 + a_coeff\n energy = numerator / denominator\n \n if index == 1:\n return energy\n elif index == 2:\n return Cff","def getPartitionFunction(self, Tlist):\n\t\treturn _modes.hinderedrotor_partitionfunction(Tlist, self.frequency, self.barrier) ** self.degeneracy","def butter_lpf(fc, fs, order):\n nyq = 0.5 * fs\n high = fc / nyq\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def get_quantum_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n f = 0\n for m in self.input.structure.get_masses():\n hbar_omega = (\n HBAR\n * np.sqrt(self.input.spring_constant / m)\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\n )\n f += (3.0 / 2) * hbar_omega + (\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\n )\n return f","def refraction(el, temp, press, hum, freq=150.0):\n\n fvec = np.vectorize(qp.qp_refraction, [np.double])\n delta = fvec(el, temp, press, hum, freq)\n if delta.shape == ():\n return delta[()]\n return delta","def zMCEff1D(ZReco, ZAcc, bins, obs, region='inclusive', sel=''):\n print(\">>> make differential efficiencies for \"+obs+\" in \"+region+\" region\")\n\n if sel != '':\n ZReco = ZReco.query(sel)\n ZAcc = ZAcc.query(sel)\n\n ZEff = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\n ZEff_sel = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\n ZEff_glo = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\n\n MuEff_HLT_Sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Sel_Glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Glo_StaOrTrk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Trk_Sta = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Sta_Trk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n\n ZMuMuEff = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n ZMuMuEff_sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n ZMuMuEff_glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n\n for i in range(0, len(bins)-1):\n bin_low = bins[i]\n bin_high = bins[i+1]\n sel = '{0}>{1} & {0}<{2}'.format(obs, bin_low, bin_high)\n\n ZReco_i = ZReco.query(sel)\n\n qHLT = 'muon_Category==5 & antiMuon_Category==5'\n qSel = '(muon_Category==5 & antiMuon_Category==4) | (muon_Category==4 & antiMuon_Category==5)'\n qGlo = '(muon_Category==5 & antiMuon_Category==3) | (muon_Category==3 & antiMuon_Category==5)'\n qSta = '(muon_Category==5 & antiMuon_Category==2) | (muon_Category==2 & antiMuon_Category==5)'\n qTrk = '(muon_Category==5 & antiMuon_Category==1) | (muon_Category==1 & antiMuon_Category==5)'\n\n nHLT = len(ZReco_i.query(qHLT))\n nSel = len(ZReco_i.query(qSel))\n nGlo = len(ZReco_i.query(qGlo))\n nSta = len(ZReco_i.query(qSta))\n nTrk = len(ZReco_i.query(qTrk))\n\n MuEff_HLT_Sel[0][i], MuEff_HLT_Sel[1][i] = muTagAndProbeEff(nHLT, 0, nSel)\n MuEff_Sel_Glo[0][i], MuEff_Sel_Glo[1][i] = muTagAndProbeEff(nHLT, nSel, nGlo)\n MuEff_Glo_StaOrTrk[0][i], MuEff_Glo_StaOrTrk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo, nSta + nTrk)\n MuEff_Trk_Sta[0][i], MuEff_Trk_Sta[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nTrk, nSta)\n MuEff_Sta_Trk[0][i], MuEff_Sta_Trk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nSta, nTrk)\n\n ZMuMuEff[0][i], ZMuMuEff[1][i] = eff_ztomumu_old(nHLT, nSel, nGlo, nSta, nTrk)\n ZMuMuEff_sel[0][i], ZMuMuEff_sel[1][i] = eff_ztomumu_sel(nHLT, nSel, nGlo, nSta, nTrk)\n ZMuMuEff_glo[0][i], ZMuMuEff_glo[1][i] = eff_ztomumu_glo(nHLT, nSel, nGlo, nSta, nTrk)\n\n # full true Z efficiency\n ZAcc_i = ZAcc.query(sel)\n ZReco_i = ZReco.query(sel + '& (muon_Category==5 | antiMuon_Category==5) & muon_Category>=4 & antiMuon_Category>=4')\n\n nReco_i = len(ZReco_i)\n nAcc_i = len(ZAcc_i)\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\n\n ZEff[0][i], ZEff[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\n\n # true Z efficiency at selection level (without requiring trigger)\n ZAcc_i = ZAcc.query(sel)\n ZReco_i = ZReco.query(sel + ' & muon_Category>=4 & antiMuon_Category>=4')\n\n nReco_i = len(ZReco_i)\n nAcc_i = len(ZAcc_i)\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\n\n ZEff_sel[0][i], ZEff_sel[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\n\n # true Z efficiency at gobal muon level (requiring two global muons)\n ZAcc_i = ZAcc.query(sel)\n ZReco_i = ZReco.query(sel + '& muon_Category>=3 & antiMuon_Category>=3 ')\n\n nReco_i = len(ZReco_i)\n nAcc_i = len(ZAcc_i)\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\n\n ZEff_glo[0][i], ZEff_glo[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\n\n x = bins[:-1] + (bins[1:] - bins[:-1])/2\n\n def plot_zeff(eff_true, eff_tnp, name):\n plt.clf()\n fig, ax = plt.subplots(2, 1, sharex=True, gridspec_kw={'height_ratios': [2, 1]})\n fig.subplots_adjust(hspace=0)\n\n ax[0].errorbar(x, eff_true[0], xerr=np.zeros(len(x)), yerr=eff_true[1], fmt='bo', label='true')\n ax[0].errorbar(x, eff_tnp[0], xerr=np.zeros(len(x)), yerr=eff_tnp[1], fmt='ro', label='tnp')\n ax[0].set(xlim=(bins[0], bins[-1]), ylim=(0.75, 1.1))\n ax[0].legend()\n ax[0].text(0.05, 0.9, r'$66\\ \\mathrm{GeV} < \\mathrm{M}_{\\mu\\mu} < 116\\ \\mathrm{GeV}$', transform=ax[0].transAxes)\n ax[0].text(0.05, 0.82, r'$p_\\mathrm{t}(\\mu) > 27\\ \\mathrm{GeV} \\qquad |\\eta(\\mu)| < 2.4$', transform=ax[0].transAxes)\n ax[0].text(0.05, 0.74, region, transform=ax[0].transAxes)\n ax[0].set_ylabel(r'$\\epsilon_\\mathrm{Z}$')\n ax[0].set_xlabel(obs)\n ax[0].set_yticks([0.8, 0.85, 0.9, 0.95, 1.0, 1.05])\n ax[0].set_title(\"Z efficiency at {0} muon level\".format(name))\n\n pulls = eff_tnp[0] - eff_true[0]\n pulls_sig = np.sqrt(eff_tnp[1]**2 + eff_true[1]**2)\n\n ax[1].errorbar(x, pulls, xerr=np.zeros(len(x)), yerr=pulls_sig, fmt='ko')# , label='factorized - true')\n ax[1].plot(x, np.zeros(len(x)), color='gray', linestyle='dashed')\n ax[1].set_ylim(-0.02, 0.04)\n ax[1].set_ylabel(r'$\\epsilon^\\mathrm{tnp}_\\mathrm{Z} - \\epsilon^\\mathrm{true}_\\mathrm{Z}$')\n ax[1].set_xlabel(obs)\n ax[1].set_yticks([-0.01, 0., 0.01, 0.02, 0.03])\n plt.savefig(output+'/ZMuMu_{0}_{1}_{2}_level.png'.format(obs, region, name))\n plt.close()\n\n plot_zeff(ZEff, ZMuMuEff, \"hlt\")\n plot_zeff(ZEff_sel, ZMuMuEff_sel, \"selection\")\n plot_zeff(ZEff_glo, ZMuMuEff_glo, \"global\")","def far_fields(horn_width, horn_height, eplane_effective_length, hplane_effective_length, frequency, r, theta, phi):\n # Calculate the wavenumber\n k = 2.0 * pi * frequency / c\n\n # Calculate the wave impedance\n eta = sqrt(mu_0 / epsilon_0)\n\n # Define the radial-component of the electric field\n e_r = 0.0\n\n # Define the theta-component of the electric field\n e_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Define the phi-component of the electric field\n e_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * cos(phi) * (1.0 + cos(theta)) * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Define the radial-component of the magnetic field\n h_r = 0.0\n\n # Define the theta-component of the magnetic field\n h_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * -cos(phi) * (1.0 + cos(theta)) / eta * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Define the phi-component of the magnetic field\n h_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) / eta * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Return all six components of the far field\n return e_r, e_theta, e_phi, h_r, h_theta, h_phi","def freqz_resp_list(b,a=np.array([1]),mode = 'dB',fs=1.0,Npts = 1024,fsize=(6,4)):\r\n if type(b) == list:\r\n # We have a list of filters\r\n N_filt = len(b)\r\n f = np.arange(0,Npts)/(2.0*Npts)\r\n for n in range(N_filt):\r\n w,H = signal.freqz(b[n],a[n],2*np.pi*f)\r\n if n == 0:\r\n plt.figure(figsize=fsize)\r\n if mode.lower() == 'db':\r\n plt.plot(f*fs,20*np.log10(np.abs(H)))\r\n if n == N_filt-1:\r\n plt.xlabel('Frequency (Hz)')\r\n plt.ylabel('Gain (dB)')\r\n plt.title('Frequency Response - Magnitude')\r\n\r\n elif mode.lower() == 'phase':\r\n plt.plot(f*fs,np.angle(H))\r\n if n == N_filt-1:\r\n plt.xlabel('Frequency (Hz)')\r\n plt.ylabel('Phase (rad)')\r\n plt.title('Frequency Response - Phase')\r\n\r\n elif (mode.lower() == 'groupdelay_s') or (mode.lower() == 'groupdelay_t'):\r\n \"\"\"\r\n Notes\r\n -----\r\n\r\n Since this calculation involves finding the derivative of the\r\n phase response, care must be taken at phase wrapping points \r\n and when the phase jumps by +/-pi, which occurs when the \r\n amplitude response changes sign. Since the amplitude response\r\n is zero when the sign changes, the jumps do not alter the group \r\n delay results.\r\n \"\"\"\r\n theta = np.unwrap(np.angle(H))\r\n # Since theta for an FIR filter is likely to have many pi phase\r\n # jumps too, we unwrap a second time 2*theta and divide by 2\r\n theta2 = np.unwrap(2*theta)/2.\r\n theta_dif = np.diff(theta2)\r\n f_diff = np.diff(f)\r\n Tg = -np.diff(theta2)/np.diff(w)\r\n # For gain almost zero set groupdelay = 0\r\n idx = pylab.find(20*np.log10(H[:-1]) < -400)\r\n Tg[idx] = np.zeros(len(idx))\r\n max_Tg = np.max(Tg)\r\n #print(max_Tg)\r\n if mode.lower() == 'groupdelay_t':\r\n max_Tg /= fs\r\n plt.plot(f[:-1]*fs,Tg/fs)\r\n plt.ylim([0,1.2*max_Tg])\r\n else:\r\n plt.plot(f[:-1]*fs,Tg)\r\n plt.ylim([0,1.2*max_Tg])\r\n if n == N_filt-1:\r\n plt.xlabel('Frequency (Hz)')\r\n if mode.lower() == 'groupdelay_t':\r\n plt.ylabel('Group Delay (s)')\r\n else:\r\n plt.ylabel('Group Delay (samples)')\r\n plt.title('Frequency Response - Group Delay')\r\n else:\r\n s1 = 'Error, mode must be \"dB\", \"phase, '\r\n s2 = '\"groupdelay_s\", or \"groupdelay_t\"'\r\n print(s1 + s2)","def trc_fgen_postfb(self,trc,dt,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n trc_norm=trc/np.amax(np.abs(trc))\n trc_entropy=self.entropy(trc_norm,50)\n trc_fdm=self.fdm(trc_norm,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm,hwin2)\n for i,j in enumerate(trc):\n if i<len(trc)-vlen-1:\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm)))[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(fb/dt):np.int(fb/dt)+vlen]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(fb/dt):np.int(fb/dt)+vlen]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\n\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\n\td = dist * 1e3 * pc\n\t# Radius (in unit of pc)\n\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\n\t# Mass\n\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\n\t# Number density\n\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\n\t# Sigmav of 2.33H\n\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\n\t# Virial\n\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\n\t# Virial parameter with B-field, assume 1 mG\n\tB = 1 * 1e-3 # G\n\trho = density * 2.8 * mp # g/cm3\n\talfven = B / np.sqrt(4*np.pi*rho)\n\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\n\n\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B","def buoyancy_frequency(self, z, h=0.01):\n # Check validity of the input z values\n if np.max(z) > self.z_max or np.min(z) < self.z_min:\n raise ValueError('Selected depths outside range of ' + \\\n 'CTD data: %g to %g m' % (self.z_min, \n self.z_max))\n if h > 1.0 or h < 0.0:\n raise ValueError('Input parameter h must be between 0.0 ' + \\\n 'and 1.0.')\n \n # Prepare space to store the solution\n if not isinstance(z, np.ndarray):\n N = np.zeros(1)\n z = np.array([z])\n elements = 0\n else:\n N = np.zeros(z.shape)\n elements = range(len(N))\n \n # Compute the length-scale for the finite difference method\n dz = (self.z_max - self.z_min) * h\n \n # Fill the solution matrix\n for i in range(len(z)):\n # Get the end-points of z for the finite difference formula\n if z[i] + dz > self.z_max:\n z1 = self.z_max\n z0 = z1 - 2 * dz\n elif z[i] - dz < self.z_min:\n z0 = self.z_min\n z1 = z0 + 2 * dz\n else:\n z0 = z[i] - dz\n z1 = z[i] + dz\n \n # Get the density at z0 and z1. Use atmospheric pressure to \n # compute the potential density and remove the effect of \n # compressibility\n T0, S0 = self.get_values(z0, self.ztsp[1:3])\n T1, S1 = self.get_values(z1, self.ztsp[1:3])\n Pa = 101325.\n rho_0 = seawater.density(T0, S0, Pa)\n rho_1 = seawater.density(T1, S1, Pa)\n N[i] = np.sqrt(9.81 / rho_0 * (rho_1 - rho_0) / (z1 - z0))\n \n return N[elements]","def calculate_NH_relaxation_from_Ct(bondtype, B_0, t, Ct):\n gamma_1H = 267.513e6 ; # rad s^-1 T^-1\n gamma_X = -27.116e6\n DeltaSigma_X=-160e-6\n r_XH=1.02e-10\n\n om, G = do_dft(t, Ct)\n J = G.real\n\n omega, iOmH, iOmX = obtain_HX_frequencies()\n\n Jw=np.zeros(5)\n for i in range(5):\n w = omega[i]\n Jw[i] = interpolate_point(w, om, J)\n\n # f_DD = 519627720.1974593 , if r_NH is at default values\n f_DD = 7.958699205571828e-67 * r_XH**-6.0 * gamma_X**2\n # f_CSA = 498637299.69233465, if B_0 = 600.13, and DeltaSigma=-160e-6\n f_CSA = 2.0/15.0 * DeltaSigma_X**2 * ( gamma_X * B_0 )**2\n\n R1 = f_DD*( J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] ) + f_CSA*J[iOmX]\n R2 = 0.5*f_DD*( 4*J[0] + J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] + 6*J[iOmH] ) + 1.0/6.0*f_CSA*(4*J[0] + 3*J[iOmX])\n NOE = 1.0 + gamma_1H/gamma_X/R1 * f_DD*(6*J[iOmH+iOmX] - J[iOmH-iOmX])\n\n return R1, R2, NOE","def get_kt(temps, delta_gibbs_ts):\n # rate coefficient from Eyring equation\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular","def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\n D=dmax*x[0]**n/(x[0]**n+K**n)\n #defune the degradation effect\n deg=0\n #define ODEs\n y=np.zeros([np.size(x)])\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\n \n return y","def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n C_T = (\n 2 ** (1 / 4)\n * np.sqrt(gbar)\n / np.pi\n * np.sqrt(vv)\n * tt ** (5 / 4)\n * _1d_call(_fdk, y, k=1 / 2)\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\n )\n return C_T","def bd(y, t_r, lbda=1.0, theta_0=None, z_0=None, hrf_dur=20.0, # noqa\n bounds=None, nb_iter=100, nb_sub_iter=1000, nb_last_iter=10000,\n print_period=50, early_stopping=False, wind=4, tol=1.0e-12, verbose=0):\n # force cast for Numba\n y = y.astype(np.float64)\n\n # initialization\n theta = MAX_DELTA if theta_0 is None else theta_0\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\n\n if z_0 is None:\n diff_z = np.zeros_like(y)\n z = np.zeros_like(y)\n x = np.zeros_like(y)\n else:\n diff_z = np.append(0, z_0[1:] - z_0[:-1])\n z = z_0\n x = spectral_convolve(h, z)\n\n if bounds is None:\n bounds = [(MIN_DELTA + 1.0e-1, MAX_DELTA - 1.0e-1)]\n\n d = {}\n r_0 = np.sum(np.square(x - y))\n d['r'] = [1.0]\n g_0 = np.sum(np.abs(diff_z))\n d['g'] = [g_0]\n j_0 = r_0 + lbda * g_0\n d['J'] = [1.0]\n d['l_alpha'] = []\n\n if (verbose > 0):\n print(\"normalized global cost-function \"\n \"(init): {0:.6f}\".format(d['J'][-1]))\n\n # main loop\n for idx in range(nb_iter):\n\n # deconvolution\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping,\n wind, tol)\n z = np.cumsum(diff_z)\n\n # hrf estimation\n args = (z, y, t_r, hrf_dur)\n theta, _, _ = fmin_l_bfgs_b(\n func=hrf_fit_err, x0=theta, args=args,\n bounds=bounds, approx_grad=True, maxiter=999,\n pgtol=1.0e-12)\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\n x = spectral_convolve(h, z)\n\n # cost function\n r = np.sum(np.square(x - y))\n g = np.sum(np.abs(diff_z))\n d['J'].append((r + lbda * g) / j_0 + 1.0e-30)\n d['r'].append(r / r_0 + 1.0e-30)\n d['g'].append(g)\n\n if (verbose > 0) and ((idx+1) % print_period == 0):\n print(\"normalized global cost-function \"\n \"({0:03d}/{1:03d}): {2:.6f}\".format(idx+1, nb_iter,\n d['J'][-1]))\n\n # early stopping\n if early_stopping:\n if idx > wind:\n sub_wind_len = int(wind/2)\n old_j = np.mean(d['J'][:-sub_wind_len])\n new_j = np.mean(d['J'][-sub_wind_len:])\n diff = (new_j - old_j) / new_j\n if diff < tol:\n if verbose > 0:\n print(\"\\n-----> early-stopping done at \"\n \"{0:03d}/{1:03d}, global\"\n \" normalized cost-function = \"\n \"{2:.6f}\".format(idx, nb_iter, d['J'][idx]))\n break\n\n # last (long) deconvolution\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping, wind,\n tol)\n z = np.cumsum(diff_z)\n x = spectral_convolve(h, z)\n\n # cost function\n r = np.sum(np.square(x - y))\n g = np.sum(np.abs(diff_z))\n d['J'].append((r + lbda * g) / j_0)\n d['r'].append(r / r_0)\n d['g'].append(g)\n\n d['J'] = np.array(d['J'])\n d['r'] = np.array(d['r'])\n d['g'] = np.array(d['g'])\n\n return x, z, diff_z, h, d","def rcfilter_C(freq, R):\n R = _normalizevalue(R)\n C = 1/(R*freq*2*math.pi)\n return _Cap(C)","def get_tuning_freq(self, freq):\n if freq < self.freq_lo:\n return\n\n while freq < self.NOTES.min() or freq > self.NOTES.max():\n while freq > self.NOTES.max():\n self.NOTES *= 2\n while freq < self.NOTES.min():\n self.NOTES /= 2\n tuning_freq = min(self.NOTES, key=lambda x: abs(x-freq))\n return tuning_freq","def getFWHM(antenna, freq):\n diameter = getDiameter(antenna)\n lam = 299792458.0 / (freq * 1e9)\n fwhmo = lam / math.pi * 180.0 * 60.0\n fwhm = 1.22 * fwhmo / diameter\n return fwhm","def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_P_low *= (\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n )\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\n # low temperatures - high numbers\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)","def get_frequency(self):\r\n # print '*********in get freq'\r\n self.cntr.run('FREQ 1')\r\n f_0_ = self.cntr.get_measurements(1)\r\n self.f_0 = f_0_[0]\r\n self.cntr.run('FREQ 2')\r\n f_rep_ = self.cntr.get_measurements(1)\r\n self.f_rep = f_rep_[0]","def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for low temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n S_low = (\n -gbar\n * np.sqrt(2)\n / (6 * np.pi ** 2)\n * tt_low ** (3 / 2)\n * vv_low\n * (\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\n )\n )\n # low temperatures - high numbers\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((S_low, S_high)).reshape(y.shape)","def k_HF(T, n, h=1e-3):\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\n return dn_dmu / n","def _get_a_freq(self, energy):\n left_index = bisect.bisect_left(self.energy_list, energy)\n if left_index+1 >= len(self.energy_list):\n left_index = len(self.energy_list)-2\n elif left_index > 0:\n left_index -= 1\n energy0 = self.energy_list[left_index]\n energy1 = self.energy_list[left_index+1]\n freq0 = 1./self.closed_orbits_t[energy0]\n freq1 = 1./self.closed_orbits_t[energy1]\n frequency = (freq1 - freq0)/(energy1-energy0)*(energy-energy0) + freq0\n #print \"\\nl:\", left_index, \"e0:\", energy0, \"e1:\", energy1, \\\n # \"f0:\", freq0, \"f1:\", freq1, \"DE:\", energy-e0, \"f\", frequency\n return frequency","def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq / 700.0))","def all_dhkl(self, crystal):\n #d_min = self.wavelength/self.max2theta*pi/2\n d_min = self.wavelength/sin(self.max2theta/2)/2\n \n # This block is to find the shortest d_hkl, \n # for all basic directions (1,0,0), (0,1,0), (1,1,0), (1,-1,0) and so on, 26 in total \n hkl_max = np.array([1,1,1])\n for h1 in [-1, 0, 1]:\n for k1 in [-1, 0, 1]:\n for l1 in [-1, 0, 1]:\n hkl_index = np.array([[h1,k1,l1]])\n d = float(np.linalg.norm( np.dot(hkl_index, crystal.rec_matrix), axis=1))\n if d>0:\n multiple = 1/d/d_min\n hkl_index *= round(multiple)\n for i in range(len(hkl_max)):\n if hkl_max[i] < hkl_index[0,i]:\n hkl_max[i] = hkl_index[0,i]\n #h1 = 2*ceil(np.linalg.norm(crystal.cell_para[0])/d_min)\n #k1 = 2*ceil(np.linalg.norm(crystal.cell_para[1])/d_min)\n #l1 = 2*ceil(np.linalg.norm(crystal.cell_para[2])/d_min)\n h1, k1, l1 = hkl_max\n h = np.arange(-h1,h1)\n k = np.arange(-k1,k1)\n l = np.arange(-l1,l1)\n \n hkl = np.array((np.meshgrid(h,k,l))).transpose()\n hkl_list = np.reshape(hkl, [len(h)*len(k)*len(l),3])\n hkl_list = hkl_list[np.where(hkl_list.any(axis=1))[0]]\n d_hkl = 1/np.linalg.norm( np.dot(hkl_list, crystal.rec_matrix), axis=1)\n #for ix, a in enumerate(hkl_list):\n # if np.array_equal(a, np.array([1,-1,3])) is True:\n # print(a)\n # break\n #\n #print(ix, hkl_list[ix], d_hkl[ix], d_min)\n\n shortlist = d_hkl > (d_min)\n d_hkl = d_hkl[shortlist]\n hkl_list = hkl_list[shortlist]\n sintheta = self.wavelength/2/d_hkl\n\n self.theta = np.arcsin(sintheta)\n self.hkl_list = hkl_list\n self.d_hkl = d_hkl\n \n #return hkl_list, d_hkl, sintheta","def total_band_energy(vals, T, Ec):\n vals = np.sort(np.concatenate(vals))\n occup = occup_TK(vals, T=T, spin=2)\n return np.dot(vals, occup)-Ec","def compute_f_BARR(self, R, e, D):\n upper_LHS_RHS = 5.02 * log(R / (4.518 * log((R / 7), 10)), 10)\n lower_LHS_RHS = R * (1 + (R**0.52) / (29 * (D/e)**0.7))\n\n upper_RHS_RHS = 1\n lower_RHS_RHS = 3.7*(D/e)\n bracket = (upper_LHS_RHS / lower_LHS_RHS) + (upper_RHS_RHS / lower_RHS_RHS)\n \n RHS = (-2)*log(bracket, 10)\n f = (1/RHS)**2\n \n return f","def drillSpeed(matID, W, FWHM_mm):\n vaporH = { # kJ/mol\n # spec heat from room temperature to melting + latent heat of fusion + spec heat from melting to boiling + latent heat of vaporization\n # refer https://webbook.nist.gov/chemistry/ for heat capacity, this tool also has some data in specificHeatParams\n 'Cu': 29.7 + 13.1 + 48.8 + 300,\n 'Fe': 49.5 + 13.8 + 60.9 + 340,\n 'W' : 118.4 + 46.9 + 82.5 + 824,\n 'Mo': 89.9 + 37.5 + 71.9 + 598,\n 'Al': 17.98 + 10.7 + 0.03175*1857 + 294\n }\n if matID not in vaporH.keys():\n raise ValueError(f'No vaporization data for {matID}: available in {vaporH.keys()}')\n \n mol_mmD = 2 * np.pi * (FWHM_mm/2.355)**2 / 1000 * defaultDensity(matID) / molarMass(matID)\n return W / (mol_mmD * vaporH[matID] * 1000)","def density_by_ideal_gas_law(\n p: tf.Tensor,\n r: tf.Tensor,\n t: tf.Tensor,\n ) -> tf.Tensor:\n return p / r / t","def vib_energy(frequency, temp):\n\n # vibrational temperature\n\n vtemp = plank_const * speed_ol / boltz_const * frequency\n\n vtemp = np.matrix(vtemp)\n\n temp = 1 / np.matrix(temp)\n\n # need to convert to array, because the element wise exponential\n # cannot work with matrix\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\n\n # energy is a np.matrix, need to convert to array\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\n energy = np.array(energy)[0]\n\n return energy","def fourier_coefficient(t, freq, n=1, axis=-1):\n t, freq, n = map(np.asanyarray, (t, freq, n))\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)","def kld(Fk, freq, Fk_red, f_red):\n \n #pad the reduced input with zeros\n f_red = [float(val) for val in f_red]\n freq = [float(val) for val in freq]\n f_Fk_red = dict(zip(f_red,Fk_red))\n Fk_red_pad = []\n #for each frequency in the nonreduced signal\n for i,f in enumerate(freq):\n #if the frequency is shared with the reduced signal\n if f in f_red:\n #add the coefficient from the reduced signal\n Fk_red_pad.append(f_Fk_red[f])\n #otherwise, pad it with a zero\n else:\n Fk_red_pad.append(0.)\n Fk_red_pad = np.array(Fk_red_pad)\n \n Fk = np.abs(Fk)\n Fk /= sum(Fk)\n Fk_red_pad = np.abs(Fk_red_pad)\n Fk_red_pad /= sum(Fk_red_pad)\n \n return stats.entropy(Fk_red_pad, Fk)","def getf(element, energy, conv_fwhm=0):\n try:\n Z = int(element)\n except: \n if element in elements.Z:\n Z = elements.Z[element]\n else:\n Z = None\n if Z is None or Z>93:\n raise ValueError(\"Invalid element / element number: %s. \"\n \"(Only elements from H to U allowed).\"%str(Z))\n energy = np.array(energy, ndmin=1)\n diffE = np.unique(np.diff(energy))\n if not len(diffE):\n return deltaf.clcalc(Z, energy)\n dE = abs(diffE.min())\n fwhm_chan = abs(float(conv_fwhm))/dE/2.\n # make equally spaced data:\n if diffE.std()/diffE.mean() > 1e-5 and fwhm_chan>1e-2:\n newenergy = np.arange(energy.min() - 10*dE, energy.max() + 10.*dE, dE)\n do_interpolate = True\n else:\n newenergy = energy\n do_interpolate = False\n \n f1, f2 = deltaf.clcalc(Z, newenergy)\n if fwhm_chan>1e-2:\n f1, f2 = deltaf.convl2(f1, f2, fwhm_chan)\n if do_interpolate:\n ffunc = interp1d(newenergy, (f1, f2))\n f1, f2 = ffunc(energy)\n return f1, f2","def bethe_gf_omega(z, t=1.0):\n half_bandwidth = 2 * t\n z_rel = z / half_bandwidth\n return 2. / half_bandwidth * z_rel * (1 - np.sqrt(1 - 1 / (z_rel * z_rel)))","def full_freq_time(freqs, time_arr, Ref_param, dv):\n Ref_all = pp.Reflectometer_Output(Ref_param.file_path, freqs, time_arr, \n Ref_param.n_cross_section, \n Ref_param.FWR_dimension, False, \n Ref_param.receiver_file_name)\n Ref_all.E_out = np.zeros((Ref_all.NF, Ref_all.NT, Ref_all.n_cross_section),\n dtype='complex')\n \n parallel_param_list = [(f,t,Ref_param) for f in freqs for t in time_arr]\n parallel_result = dv.map_async(single_freq_time, parallel_param_list)\n print('Parallel runs started.')\n parallel_result.wait_interactive()\n print('All signals computed!')\n E_out_scattered = parallel_result.get()\n print('signals collected.')\n for i in range(Ref_all.NF):\n for j in range(Ref_all.NT):\n Ref_all.E_out[i, j, :] = E_out_scattered[i*len(time_arr)+j][0, 0,:]\n print(('freq {0},time {1} stored.'.format(freqs[i], time_arr[j])))\n \n return Ref_all","def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\n pi, ids = induced_distribution(hmsm, 0, level)\n\n discrete_free_energy = np.ndarray(pi.shape)\n for i, id in enumerate(ids):\n discrete_free_energy[i] = \\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\n boltzmann = np.exp(-discrete_free_energy/kT)\n boltzmann *= (1/np.sum(boltzmann))\n return D_KL(boltzmann, pi)","def temperature_diff_wrapped(q: float,\n delta_tc: np.ndarray,\n T_r:np.ndarray,\n order = 1) -> callable:\n \n def objective_function(T_cr: np.ndarray) -> np.ndarray:\n\n \"\"\"\n the function to minimize in order to get the non-linear\n relationship for the geometrically extrapolated cooled surface temperatures\n \"\"\"\n \n Tm = (T_r + T_cr)/2.0\n ks = thermal_conductivity(Tm)\n T_cr_update = cooled_surface_temp_actual(T_r,q,delta_tc,ks)\n \n return np.linalg.norm(T_cr_update - T_cr,ord = 1)\n \n return objective_function","def illuminationEff(freq,fD, FFBW, dB_at_bw, feed_type):\n theta0 = fD2angle(fD,units='degrees')\n dtt = 0.1\n theta = np.arange(0.0,theta0/2.0+dtt,dtt)\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\n theta = theta*math.pi/180.0\n kern = np.sqrt(g)*np.tan(theta/2.0)\n num = 32.0*(fD*integ.trapz(kern,dx=dtt*math.pi/180.0))**2\n kern = g*np.sin(theta)\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\n\n n_ill = num/den \n return n_ill","def getHeatFlux(self, T):\n\t\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\n\t\treturn Q","def manual_calc_kfs(wbwc_list, dec_list, timelen, timesteps):\n global X0\n global wbwc_kfs\n global all_kfs\n ####\n t = np.linspace(0, timelen, timesteps)\n ##\n ## 1. set new wbwc rates\n wbwc_kfs[wbwc_list[0]]['hf'] = wbwc_list[1][0]\n wbwc_kfs[wbwc_list[0]]['hr'] = wbwc_list[1][1]\n wbwc_kfs = fill_wbwc_dict(wbwc_kfs, fill='rates')\n init() \n #####\n ## now, loop for each value of a rate const in dec_list\n for k in dec_list[1]:\n all_kfs[dec_list[0]] = k\n kname = dec_list[0] + str(k)\n ##\n #init() \n set_expdeg()\n ode(calc_model, X0, t, stype='manual', dname = kname)\n ###","def coolingrate(tables, density, He_mass_frac=0.258, metallicity=0.25):\n # list of all elements in table\n elements = [\n x for x in tables.keys() if x not in [\n 'Header', 'Metal_free', 'Solar', 'Total_Metals']\n ]\n \n # Helium mass fraction bins of only hydrogen and helium\n metal_free_He_mass_frac = list(\n tables['Metal_free']['Helium_mass_fraction_bins']\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of /Metal_free/Hydrogen_density_bins, \n # /Metal_free/Temperature_bins, and helium abundance.\n metal_free_ne_nh = list(\n tables['Metal_free']['Electron_density_over_n_h']\n )\n \n # Find index of He mass frac, ssuming direct match in table.\n He_mass_frac_index = metal_free_He_mass_frac.index(np.float32(He_mass_frac))\n # Find index of density bin, ssuming direct match in table.\n abundance_index = list(\n tables[elements[0]]['Hydrogen_density_bins']).index(np.float32(density)\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of temperature at given denisty and helium mass fraction.\n metal_free_ne_nh = list(\n tables['Metal_free']\\\n ['Electron_density_over_n_h']\\\n [He_mass_frac_index, :,abundance_index]\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of temperature at given density for solar abundance.\n solar_ne_nh = tables['Solar']\\\n ['Electron_density_over_n_h']\\\n [:, abundance_index]\n\n # Normalized net cooling rate for only hydrogen and helium as a function of \n # /Metal_free/Hydrogen_density_bins, /Metal_free/Temperature_bins, \n # and helium abundance. \n lambda_metal_free = tables['Metal_free']\\\n ['Net_Cooling']\\\n [He_mass_frac_index, :, abundance_index]\n \n # Temperature bins (T [K])\n T = tables['Metal_free']['Temperature_bins']\n \n sum_metals = np.zeros(352)\n for e in elements:\n # Normalized, net cooling rate e as a function of temperature for \n # Hydrogen density 'density'.\n lambda_i_solar = tables[e]['Net_Cooling'][:,abundance_index]\n \n # Calulating the cooling contribution of element e and addind to total.\n sum_metals += lambda_i_solar*(metal_free_ne_nh/solar_ne_nh)*metallicity\n \n coolingrate = lambda_metal_free + sum_metals\n \n return T, coolingrate","def get_dom_freq(Fk, freq, n_freq):\n\n #get the magnitude of the coefficients\n Fk_abs = np.abs(Fk)\n #sort the coefficients in descending order\n Fk_sort = sorted(Fk_abs, reverse=True)\n \n dom_Fk = []\n dom_f = []\n i = 0\n while i < n_freq:\n inds = np.where(Fk_abs == Fk_sort[i])\n for ind in inds:\n dom_f.append(freq[ind])\n dom_Fk.append(Fk[ind])\n i += 1\n \n #sort based on frequency from lo to hi\n #convert from numpy float to python float for mapping\n dom_f = [float(abs(f)) for f in dom_f]\n f_Fk = dict(zip(dom_f,dom_Fk))\n f_sorted = sorted(dom_f)\n # return(dom_f, f_Fk, f_sorted, dom_Fk)\n\n\n dom_Fk = []\n for f in f_sorted:\n dom_Fk.append(f_Fk[f][0])\n \n return np.array(dom_Fk), np.array(f_sorted)"],"string":"[\n \"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def harmonicOscillator_heatCapacity(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x\",\n \"def thermal(isatom, freq, scalfac,linnonlin,T):\\n if isatom != \\\"true\\\":\\n nfreq = len(freq)\\n\\n vib_temp = []\\n for ifreq in range(nfreq):\\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\\n vib_temp.append(vib_temp_new)\\n\\n dE_vib = 0\\n for ifreq in range(nfreq):\\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\\n\\n dE_ZPE = 0.5 * sum(freq) * cmi2au\\n\\n if linnonlin == \\\"L\\\":\\n dE_rot = kB * T * j2au\\n elif linnonlin == \\\"NL\\\":\\n dE_rot = kB * T * j2au * (3.0/2.0)\\n else:\\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"ERROR: unknown entry for linear/nonlinear\\\")\\n else:\\n dE_ZPE = 0\\n dE_vib = 0\\n dE_rot = 0\\n\\n dE_tra = kB * T * j2au * (3.0/2.0)\\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\\n\\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def heat_capacity(r, phi, q, kT):\\n pot = q*(phi - phi[0])\\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\\n c = np.trapz(np.exp(-pot/kT) * r, r)\\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy\",\n \"def rangerate_from_freq(freq,Fc):\\n # print(f'freq {freq} Fc {Fc}')\\n dopp_at_IF = freq - Fc\\n return dopp_at_IF*scipy.constants.speed_of_light/Fc\",\n \"def Hertz_dipole_ff (r, p, R, phi, f, t=0, epsr=1.):\\r\\n nf = len(f)\\r\\n rprime = r-R # r'=r-R\\r\\n if ndim(p) < 2:\\r\\n magrprime = sqrt(sum((rprime)**2))\\r\\n magrprimep = tile(magrprime, (len(f),1)).T\\r\\n phip = tile(phi, (len(f),1))\\r\\n w = 2*pi*f # \\\\omega\\r\\n k = w/c # wave number\\r\\n krp = k*magrprimep # k|r'|\\r\\n rprime_cross_p = cross(rprime, p) # r'x p\\r\\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\\r\\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\\r\\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[0],(nf,1))).T\\r\\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[1],(nf,1))).T\\r\\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[2],(nf,1))).T\\r\\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[0],(nf,1)).T)\\r\\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[1],(nf,1)).T)\\r\\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[2],(nf,1)).T)\\r\\n E = vstack((Ex,Ey,Ez))\\r\\n B = vstack((Bx,By,Bz))\\r\\n else:\\r\\n magrprime = sqrt(sum((rprime)**2,axis=1)) # |r'|\\r\\n magrprimep = tile(magrprime, (len(f),1)).T\\r\\n phip = tile(phi, (len(f),1))\\r\\n fp = tile(f,(len(magrprime),1))\\r\\n w = 2*pi*fp # \\\\omega\\r\\n k = w/c # wave number\\r\\n krp = k*magrprimep # k|r'|\\r\\n rprime_cross_p = cross(rprime, p) # r'x p\\r\\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\\r\\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\\r\\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,0],(nf,1))).T\\r\\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,1],(nf,1))).T\\r\\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,2],(nf,1))).T\\r\\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,0],(nf,1)).T)\\r\\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,1],(nf,1)).T)\\r\\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,2],(nf,1)).T)\\r\\n E = vstack((sum(Ex,axis=0),sum(Ey,axis=0),sum(Ez,axis=0)))\\r\\n B = vstack((sum(Bx,axis=0),sum(By,axis=0),sum(Bz,axis=0)))\\r\\n return E,B\",\n \"def compute_energy_density(kT):\\n h=u.planck\\n c=u.speed_of_light\\n pi=np.pi\\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)\",\n \"def fuel_cond(T):\\n\\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\\n \\n return kc\",\n \"def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\\n kB = 1.380658e-16\\n h = 6.6260755e-27\\n c = 29979245800.\\n nu = freqGHz*1.e9\\n x = h*nu/(kB*T0)\\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\\n cNu *= 1e23\\n return cNu\",\n \"def gyroHF(self, GYRO, PFC):\\n print(\\\"Calculating gyro orbit heat loads\\\")\\n log.info(\\\"Calculating gyro orbit heat loads\\\")\\n #get divertor HF\\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\\n #Get fractional multipliers for each helical trace\\n gyroFrac = 1.0/GYRO.N_gyroPhase\\n vPhaseFrac = 1.0/GYRO.N_vPhase\\n vSliceFrac = GYRO.energyFracs\\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\\n Pgyro = np.zeros((GYRO.Nt))\\n PNaN = 0.0\\n sum=0\\n sum1=0\\n #loop through intersect record and redistribute power using multipliers\\n for gyroPhase in range(GYRO.N_gyroPhase):\\n for vPhase in range(GYRO.N_vPhase):\\n for vSlice in range(GYRO.N_vSlice):\\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\\n notNanTo = notNanTo.astype(int) #cast as integer\\n isNanTo = idx[np.isnan(idx)] #indices we map power to\\n isNanTo = isNanTo.astype(int) #cast as integer\\n\\n if len(notNanFrom)>0:\\n #multiple Froms can light up the same To, so we loop\\n for i in range(len(notNanFrom)):\\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\\n\\n if len(isNanFrom)>0:\\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\\n\\n #print(\\\"\\\\nTEST2\\\")\\n #print(GYRO.intersectRecord[0,0,0,1711])\\n #print(Pgyro[1711])\\n\\n GYRO.gyroPowMatrix += Pgyro\\n GYRO.gyroNanPower += PNaN\\n return\",\n \"def calc_dtdc(tpbpcs, specs):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n Nbs = len(np.hstack(tpbpcs[0]))\\n Ndraw = len(tpbpcs)\\n\\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\\n\\n for i in range(Ndraw):\\n\\n # Create array of times per bandpass\\n dtpb[i,:] = np.hstack(tpbpcs[i])\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def get_granule_frequency(self,r=None,ids=None):\\n # Simply divide the length of each spike vector by the simulation time\\n # or window time.\\n spikes=[] # The local copy of spikes to get the frequency on\\n try:\\n spikes=self.get_granule_spikes(r,ids)\\n if len(spikes)==0:\\n raise Exception('Unable to get mitral cell spikes')\\n except Exception:\\n raise\\n freqg=numpy.zeros(self.num_gran)\\n timems=self.sim_time\\n if type(r) is tuple and len(r)==2:\\n timems=float(r[1]-r[0])\\n for i in range(len(spikes)):\\n freqg[i]=float(len(spikes[i]))*1000./timems\\n return freqg\",\n \"def calc_dtdc_star(tpbpc0, spec):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n # Create array of times per bandpass\\n dtpb = np.hstack(tpbpc0)\\n\\n Nbs = len(dtpb)\\n dcomp = np.zeros(Nbs) # completeness\\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def CMB_spec(eng, temp):\\n if np.issubdtype(type(eng), float):\\n eng = np.array([eng])\\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\\n\\n if np.issubdtype(type(eng), float): \\n return phot_spec_density[0] \\n else: \\n return phot_spec_density\",\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def DFTscargle(times, signal,f0,fn,df):\\n f0 = 0.\\n #fn *= 2*np.pi\\n #df *= 2*np.pi\\n #-- initialize\\n nfreq = int((fn-f0)/(df))\\n print \\\"Nfreq=\\\",nfreq\\n tzero = times[0]\\n si = 1.\\n lfreq = 2*nfreq+1\\n mm = 2*nfreq\\n ftrx = np.zeros(mm)\\n ftix = np.zeros(mm)\\n om = np.zeros(mm)\\n w = np.zeros(mm)\\n wz = df #pi/(nn+dt)\\n nn = len(times)\\n \\n #-- calculate DFT\\n ftrx,ftix,om,w = pydft.ft(signal,times,wz,nfreq,si,lfreq,tzero,df,ftrx,ftix,om,w,nn,mm)\\n \\n if f0==0:\\n ftrx[1:] *= np.sqrt(2)\\n ftix[1:] *= np.sqrt(2)\\n w[1:] *= np.sqrt(2)\\n \\n cut_off = len(w)\\n for i in range(0,len(w))[::-1]:\\n if w[i] != 0: cut_off = i+1;break\\n \\n om = om[:cut_off]\\n ftrx = ftrx[:cut_off]\\n ftix = ftix[:cut_off]\\n w = w[:cut_off]\\n \\n # norm amplitudes for easy inversion\\n T = times[-1]-times[0]\\n N = len(times)\\n \\n w *= T/(2.*N)\\n ftrx *= T/(2.*N)\\n ftix *= T/(2.*N)\\n \\n return om*2*np.pi,w,ftrx,ftix\",\n \"def get_F_potential(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n # y = chemical_potential/temperature\\n y = chemical_potential / tt\\n F = gbar / np.sqrt(2.0) / np.pi ** 2 * tt ** (2.5) * vv\\n F *= y * _1d_call(_fdk, y, k=0.5) - 2.0 / 3.0 * _1d_call(_fdk, y, k=1.5)\\n return F\",\n \"def frfplot(freq, H, freq_min=0, freq_max=None, type=1, legend=[]):\\n FLAG = type # Plot type, should libe renamed throughout.\\n freq = freq.reshape(1, -1)\\n lenF = freq.shape[1]\\n if len(H.shape) is 1:\\n H = H.reshape(1, -1)\\n\\n if H.shape[0] > H.shape[1]:\\n H = H.T\\n\\n if freq_max is None:\\n freq_max = np.max(freq)\\n\\n if freq_min is None:\\n freq_min = np.min(freq)\\n\\n if freq_min < np.min(freq):\\n freq_min = np.min(freq)\\n\\n if freq_min > freq_max:\\n raise ValueError('freq_min must be less than freq_max.')\\n\\n # print(str(np.amin(freq)))\\n inlow = int(lenF * (freq_min - np.amin(freq)\\n ) // (np.amax(freq) - np.amin(freq)))\\n\\n inhigh = int(lenF * (freq_max - np.amin(freq)\\n ) // (np.amax(freq) - np.amin(freq)) - 1)\\n # if inlow<1,inlow=1;end\\n # if inhigh>lenF,inhigh=lenF;end\\n \\\"\\\"\\\"print('freq shape: {}'.format(freq.shape))\\n print('H shape: {}'.format(H.shape))\\n print('Index of low frequency: {}'.format(inlow))\\n print('Index of high frequency: {}'.format(inhigh))\\\"\\\"\\\"\\n H = H[:, inlow:inhigh]\\n # print(H.shape)\\n freq = freq[:, inlow:inhigh]\\n mag = 20 * np.log10(np.abs(H))\\n # print(mag)\\n # print(mag.shape)\\n minmag = np.min(mag)\\n maxmag = np.max(mag)\\n phase = np.unwrap(np.angle(H)) * 180 / np.pi\\n # phmin_max=[min(phase)//45)*45 ceil(max(max(phase))/45)*45];\\n phmin = np.amin(phase) // 45 * 45.0\\n phmax = (np.amax(phase) // 45 + 1) * 45\\n \\\"\\\"\\\"minreal = np.amin(np.real(H))\\n maxreal = np.amax(np.real(H))\\n minimag = np.amin(np.imag(H))\\n maximag = np.amax(np.imag(H))\\\"\\\"\\\"\\n\\n if FLAG is 1:\\n fig, (ax1, ax2) = plt.subplots(2, 1)\\n ax1.plot(freq.T, mag.T)\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Mag (dB)')\\n ax1.grid()\\n ax1.set_xlim(xmax=freq_max, xmin=freq_min)\\n ax1.set_ylim(ymax=maxmag, ymin=minmag)\\n\\n ax2.plot(freq.T, phase.T)\\n ax2.set_xlabel('Frequency (Hz)')\\n ax2.set_ylabel('Phase (deg)')\\n ax2.grid()\\n ax2.set_xlim(xmax=freq_max, xmin=freq_min)\\n ax2.set_ylim(ymax=phmax, ymin=phmin)\\n ax2.set_yticks(np.arange(phmin, (phmax + 45), 45))\\n fig.tight_layout()\\n\\n if len(legend) > 0:\\n plt.legend(legend)\\n ax = (ax1, ax2)\\n else:\\n print(\\\"Sorry, that option isn't supported yet\\\")\\n return ax\\n\\n \\\"\\\"\\\"# elif FLAG==2:\\n # subplot(2,1,1)\\n # semilogx(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # % Fmin,Fmax,min(mag),max(mag)\\n # axis([Fmin Fmax minmag maxmag])\\n\\n # subplot(2,1,2)\\n # semilogx(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n\\n # elif FLAG==3:\\n # subplot(2,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F*2*pi,mag)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Wmin Wmax minmag maxmag])\\n # zoom on\\n # subplot(2,1,2)\\n # semilogx(F*2*pi,phase)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n\\n # elseif FLAG==4\\n # subplot(2,1,1)\\n # plot(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # subplot(2,1,2)\\n # plot(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==5\\n # subplot(1,1,1)\\n # imax=round(length(F)*Fmax/max(F));\\n # imin=round(length(F)*Fmin/max(F))+1;\\n # plot(real(Xfer(imin:imax)),imag(Xfer(imin:imax)))\\n # xlabel('Real')\\n # ylabel('Imaginary')\\n # grid on\\n # zoom on\\n # elseif FLAG==6\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # plot(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==7\\n # subplot(1,1,1)\\n # plot(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # elseif FLAG==8\\n # subplot(1,1,1)\\n # plot(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # elseif FLAG==9\\n # subplot(1,1,1)\\n # plot(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==10\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==11\\n # subplot(1,1,1)\\n # semilogx(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # elseif FLAG==12\\n # subplot(1,1,1)\\n # semilogx(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # elseif FLAG==13\\n # subplot(1,1,1)\\n # semilogx(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==14\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F*2*pi,mag)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Wmin Wmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==15\\n # subplot(1,1,1)\\n # semilogx(F*2*pi,phase)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # else\\n # subplot(2,1,1)\\n # mag=20*log10(abs(Xfer));\\n # plot(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # subplot(2,1,2)\\n # plot(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n \\\"\\\"\\\"\",\n \"def fcut(r, rcut, trans_width):\\n if (isinstance(r, list) or isinstance(r, np.ndarray)) and len(r) > 1:\\n return np.array([fcut(ri, rcut, trans_width) for ri in r])\\n else:\\n if r > rcut:\\n return 0.\\n elif r > rcut-trans_width:\\n return 0.5*(np.cos(np.pi*(r-rcut+trans_width)/trans_width) + 1)\\n else:\\n return 1.0\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def gyroHF2(self, GYRO, PFC):\\n print(\\\"Calculating gyro orbit heat loads\\\")\\n log.info(\\\"Calculating gyro orbit heat loads\\\")\\n #get divertor HF\\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\\n #Get fractional multipliers for each helical trace\\n gyroFrac = 1.0/GYRO.N_gyroPhase\\n vPhaseFrac = 1.0/GYRO.N_vPhase\\n vSliceFrac = GYRO.energyFracs\\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\\n Pgyro = np.zeros((GYRO.Nt))\\n PNaN = 0.0\\n sum=0\\n sum1=0\\n #loop through intersect record and redistribute power using multipliers\\n for gyroPhase in range(GYRO.N_gyroPhase):\\n for vPhase in range(GYRO.N_vPhase):\\n for vSlice in range(GYRO.N_vSlice):\\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\\n hdotn = np.abs(GYRO.hdotn[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap])\\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\\n notNanTo = notNanTo.astype(int) #cast as integer\\n isNanTo = idx[np.isnan(idx)] #indices we map power to\\n isNanTo = isNanTo.astype(int) #cast as integer\\n\\n if len(notNanFrom)>0:\\n #multiple sources can load the same target face, so we loop\\n for i in range(len(notNanFrom)):\\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\\n\\n if len(isNanFrom)>0:\\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\\n\\n\\n GYRO.gyroPowMatrix += Pgyro\\n GYRO.gyroNanPower += PNaN\\n return\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n pad=np.random.rand(nspad)/100\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_norm_padded=np.hstack((pad,trc_norm))\\n trc_entropy=self.entropy(trc_norm_padded,50)\\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\\n for i,j in enumerate(trc):\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def stepfall(double[:] v, redshifts, in_terms, double H0):\\n\\n cdef double t = v[0]\\n cdef double a = v[1]\\n # ombar_i = rho_i(t) / rho_crit(t0)\\n cdef double ombar_m = v[2]\\n cdef double ombar_r = v[3]\\n cdef double ombar_a = v[4]\\n cdef double ombar_de = v[5]\\n cdef double z = v[6]\\n cdef double dl = v[7]\\n\\n cdef double in_v = in_terms[0]\\n cdef double in_w = in_terms[1]\\n cdef double in_x = in_terms[2]\\n\\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_a +ombar_de)**(0.5)\\n\\n# if ombar_m < 0 or ombar_de < 0 or ombar_r < 0 or ombar_a < 0:\\n# print('stepfall')\\n# print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\\n# print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\\n# 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\\n\\n if math.isnan(Hz):\\n print('stepfall')\\n print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\\n print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\\n 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\\n\\n cdef double dtdz = -1.0/((1.0+z) * Hz)\\n cdef double dadz = -(1.0+z)**(-2.0)\\n # d(ombar_i)/dz\\n cdef double domdz = (3.0*ombar_m +in_v*ombar_m*ombar_r/Hz)/(1.0+z) # w = 0\\n cdef double dordz = (4.0*ombar_r -in_v*ombar_m*ombar_r/Hz +in_w*ombar_r*ombar_a/Hz)/(1.0+z) # w = 1/3\\n cdef double doadz = (2.7*ombar_a -in_w*ombar_r*ombar_a/Hz +in_x*ombar_a*ombar_de/Hz)/(1.0+z) # w = -0.1\\n cdef double dodedz = -in_x*ombar_a*ombar_de/(1.0+z)/Hz # w = -1\\n cdef double ddldz = 1.0/Hz\\n\\n # first derivatives of functions I want to find:\\n f = [dtdz, # time\\n dadz, # scale factor\\n domdz, # w = 0\\n dordz, # w = 1/3\\n doadz, # w = -0.1\\n dodedz,# w = -1\\n 1.0, # redshift\\n ddldz] # luminosty distance\\n\\n return f\",\n \"def fourierBeam(self, centres, u_bl, v_bl, frequency, min_attenuation = 1e-10, N = 20):\\n \\n a = 1/ (2 * self._instr_core.sigma(frequency)**2)\\n \\n indx_u = np.digitize(u_bl, centres)\\n indx_v = np.digitize(v_bl, centres)\\n \\n beam = []\\n \\n for jj in range(len(u_bl)):\\n x, y = np.meshgrid(centres[indx_u[jj]-int(N/2):indx_u[jj]+int(N/2)], centres[indx_v[jj]-int(N/2):indx_v[jj]+int(N/2)],copy=False)\\n B = (np.exp(- ((x - u_bl[jj])**2 + (y - v_bl[jj])**2 )/ a)).T\\n B[B<min_attenuation] = 0\\n beam.append(B)\\n \\n indx_u+= -int(N/2)\\n indx_v+= -int(N/2)\\n \\n indx_u[indx_u<0] = 0\\n indx_v[indx_v<0] = 0 \\n \\n return beam, indx_u, indx_v\",\n \"def doCalculation(self, E1, E2, muL, muR, T, pot, C, TCalc, Density, E0, L):\\n NEcut = len(E1) #we determine the number of single-particle states that we use\\n VG=np.diag(pot)\\n E= int(0.5*np.size(VG))\\n V = VG[0:E] #since the potential of both barriers is symmetric and we only tunnel through one barrier. Therefore we only use one half of the potential.\\n dx= L/(np.size(pot))\\n\\n #Following prints are for debugging purposes:\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"Hier beginnt die Ausgabe von Rates:\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"V:\\\", V)\\n #print(\\\"E1:\\\", E1)\\n #print(\\\"E2:\\\", E2)\\n #print(\\\"C:\\\", C)\\n\\n kB=0.08629 #Boltzmann constant in meV/K\\n \\n \\n def fermi(E,mu,T):\\n \\\"\\\"\\\"This fermi-function tells us with which likelyhood a state with an E is occupied on the lead.\\n E(float): energy difference between the initial and the final state that the tunneling electron has to carry.\\n mu(float): chemical potential of either drain(muR) or source(muL).\\n T(float): temperature.\\n \\\"\\\"\\\"\\n if (E-mu)/T > 600:\\n f=0\\n\\t\\t\\t\\t\\n else:\\n f=1/(math.exp((E-mu)/(kB*T) )+1)\\n return(f)\\n \\n\\n\\t#This function is called by the Gamma_ij-equations and includes the transmission-coefficient for each tunnelling-event\\n #and the density of state function of the source and drain. \\n def Gamma(Ea,Eb,V):\\n \\\"\\\"\\\":math:`\\\\\\\\Gamma` includes the transmission coefficient and DOS: :math:`\\\\Gamma = | t |^2 * DOS`\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n V(np.array): barrier potential\\n \\\"\\\"\\\"\\n #print(Ea)\\n #print(V)\\n return (np.absolute(TCalc.calculate_transmission(Ea,V,dx))**2*Density.calculate_DensityofStates(np.absolute(Ea-Eb)))\\n \\n #These next four functions are used to calculate the transition rates.Each function for a different kind of transition:\\n #We distinguish between transitions, in which the number of electrons on the dot changes from one to two(Gamma_12) and reverse(Gamma_21).\\n #And between transitions in which the number of electrons on the dot change from zero to one(Gamma_01) and reverse(Gamma_10).\\n\\n def Gamma_12(Ea,Eb,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a one body state to a two body state.\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n summe=0\\n j=0\\n Cb=C[np.where(E2==Eb)[0][0]]\\n while j< NEcut:\\n summe=Cb[np.where(E1==Ea)[0][0]][j]+summe\\n j=j+1\\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*fermi((Eb-Ea),mu,T))\\n\\n\\n def Gamma_01(Eb,mu,T):\\n \\\"\\\"\\\"Calculates the transition rate from the vacuum state to a one-body state.\\n\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n return(Gamma(E0,Eb,V)*fermi((Eb-E0),mu,T))\\n\\n def Gamma_21(Ea,Eb,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a two body state to a one body state.\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n summe=0\\n nu=0\\n Ca=C[np.where(E2==Ea)[0][0]]\\n while nu < NEcut:\\n summe=summe+Ca[np.where(E1==Eb)[0][0]][nu]\\n nu=nu+1\\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*(1-fermi((Ea-Eb),mu,T)))\\n\\n def Gamma_10(Ea,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a one body state to the vacuum state.\\n\\n Ea(float): energy of initial state \\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n return(Gamma(Ea,E0,V)*(1-fermi((Ea-E0),mu,T)))\\n\\n #creating the output matrices that later contain all the transition rates through either\\n #the left or the right barrier\\n Gamma_R=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\\n Gamma_L=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\\n\\n #using a loop to fill the output matrices with transition rates.\\n i_=0\\n for i in E1:\\n j_=0\\n for j in E2:\\n Gamma_L[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muL,T)\\n Gamma_L[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muL,T)\\n Gamma_R[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muR,T)\\n Gamma_R[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muR,T)\\n j_=j_+1\\n Gamma_L[0][i_+1]=Gamma_10(i,muL,T)\\n Gamma_R[0][i_+1]=Gamma_10(i,muR,T)\\n Gamma_L[i_+1][0]=Gamma_01(i,muL,T)\\n Gamma_R[i_+1][0]=Gamma_01(i,muR,T)\\n i_=1+i_\\n\\n #print(\\\"Gamma_L und Gamma_R:\\\")\\n #print(Gamma_L,Gamma_R)\\n #print(\\\"-----------------------------------------------------------------------\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n return(Gamma_L,Gamma_R)\",\n \"def thermodynamic_temperature(frequency, T_cmb=None):\\n nu = frequency.to(si.GHz, spectral())\\n\\n if T_cmb is None:\\n from astropy.cosmology import default_cosmology\\n\\n T_cmb = default_cosmology.get().Tcmb0\\n\\n def f(nu, T_cmb=T_cmb):\\n x = _si.h * nu / _si.k_B / T_cmb\\n return x**2 * np.exp(x) / np.expm1(x) ** 2\\n\\n def convert_Jy_to_K(x_jybm):\\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\\n astrophys.Jy\\n )\\n return x_jybm / factor\\n\\n def convert_K_to_Jy(x_K):\\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\\n si.K\\n )\\n return x_K / factor\\n\\n return Equivalency(\\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\\n \\\"thermodynamic_temperature\\\",\\n {\\\"frequency\\\": frequency, \\\"T_cmb\\\": T_cmb},\\n )\",\n \"def mce_filter(freq, f_raw, params):\\n\\tz = np.exp(-2j*np.pi*freq/f_raw)\\n\\tb11, b12, b21, b22 = np.array(params[:4])*0.5**14\\n\\tH = (1+z)**4 / (1-b11*z+b12*z**2) / (1-b21*z+b22*z**2)\\n\\tH /= 2**4 / (1-b11+b12) / (1-b21+b22)\\n\\treturn H\",\n \"def torch_mel_to_hertz(frequencies_mel):\\r\\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\\r\\n return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\",\n \"def exotic(double[:] v, redshifts, in_terms, double H0):\\n\\n cdef double t = v[0]\\n cdef double a = v[1]\\n cdef double ombar_m = v[2]\\n cdef double ombar_r = v[3]\\n cdef double ombar_de = v[4]\\n cdef double z = v[5]\\n cdef double dl = v[6]\\n cdef double gamma = in_terms[0]\\n cdef double zeta = in_terms[1]\\n\\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_de)**(0.5)\\n\\n# if ombar_m < 0 or ombar_de < 0:\\n# print('exotic')\\n# print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\\n# print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\\n# % (ombar_m, ombar_r, ombar_de))\\n\\n if math.isnan(Hz):\\n print('exotic')\\n print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\\n print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\\n % (ombar_m, ombar_r, ombar_de))\\n\\n cdef double dtdz = -1.0/((1.0+z) * Hz)\\n cdef double dadz = -(1.0+z)**(-2.0)\\n cdef double domdz = (3.0*ombar_m +gamma*ombar_m*ombar_r /Hz) /(1.0+z)\\n cdef double dordz = (4.0*ombar_r -(gamma*ombar_m*ombar_r -zeta*ombar_r*ombar_de) /Hz ) /(1.0+z)\\n cdef double dodedz = -zeta*ombar_r*ombar_de/(1.0+z) /Hz\\n cdef double ddldz = 1.0/Hz\\n\\n # first derivatives of functions I want to find:\\n f = [dtdz,# dt/dz (= f.d wrt z of time)\\n dadz,# d(a)/dz (= f.d wrt z of scale factor)\\n domdz,# dw = 0, (ombar_m)/dz (= f.d wrt z of density_m(t) / crit density(t0))\\n dordz,# w = 1/3, d(ombar_r)/dz (= f.d wrt z of density_r(t) / crit density(t0))\\n dodedz,# w = -1, d(ombar_de)/dz (= f.d wrt z of density_de(t) / crit density(t0))\\n 1.0,# d(z)/dz (= f.d wrt z of redshift)\\n ddldz]# d(dl)/dz (= f.d wrt z of luminosty distance) # H + Hdz*(1+z)\\n\\n return f\",\n \"def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\\n # low temperatures - high numbers\\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)\",\n \"def get_rec_rate_H_caseB_Dr11(T):\\n T4 = T*1e-4\\n return 2.54e-13*T4**(-0.8163 - 0.0208*np.log(T4))\",\n \"def lrelfreq(inlist,numbins=10,defaultreallimits=None):\\r\\n h,l,b,e = histogram(inlist,numbins,defaultreallimits)\\r\\n for i in range(len(h)):\\r\\n h[i] = h[i]/float(len(inlist))\\r\\n return h,l,b,e\",\n \"def __init__(self, N=1024, fc=50., tmax=1., delay=None):\\n fc = float(fc)\\n tmax = float(tmax)\\n dt = tmax / (N-1)\\n df = 1. / tmax\\n istart = -N//2 + 1\\n nroll = -istart\\n t = np.arange(istart, N // 2 + 1) * dt\\n f = np.arange(istart, N // 2 + 1) * df\\n # arrange f as positve, negative freqs\\n f = np.roll(f, -nroll)\\n\\n # freq domain ricker\\n ricker_f = 2 * f**2 / (np.sqrt(np.pi) * fc**3) * np.exp(-(f/fc)**2)\\n\\n if delay is None:\\n delay = 1.5 / fc\\n ricker_f = ricker_f * np.exp(-1j * 2 * np.pi * f * delay)\\n\\n # time domain ricker\\n ricker_t = N * np.real(np.fft.ifft(ricker_f))\\n\\n\\n amp = np.absolute(ricker_f)\\n phase = np.unwrap(np.angle(ricker_f, False))\\n\\n # ricker_f[0] contains the zero frequency term,\\n # ricker_f[1:N//2] contains the positive-frequency terms,\\n # ricker_f[N//2 + 1:] contains the negative-frequency terms,\\n # in increasing order starting from the most negative frequency\\n self.delay = delay\\n self.fc = fc\\n self.dt = dt\\n # arange t and ricker_t in the order of increasing time; the zero phase case contains negative time\\n\\n self.ricker_t = np.roll(ricker_t, nroll)\\n self.f = f\\n self.t = t\\n self.df = df\\n self.ricker_f = ricker_f\\n self.amp = amp\\n self.phase = phase\\n self.nroll = nroll\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def cutoff_denominator(self, list_energy):\\n\\n tol = 1e-3\\n\\n z = list_energy/tol\\n\\n den = N.imag(SS.wofz(z))/tol*N.sqrt(N.pi)\\n\\n return den\",\n \"def get_fractional_degradation(bt):\\n\\n\\n\\n NomIch = 0.125 # Nominal charge current\\n NomId = 0.25 # Nominal discharge current\\n NomSoC = 0.5 # Nominal state of charge_mode\\n NomDoD = 1.0 # Nominal depth of discharge\\n B = 5 #Battery capacity\\n qt = 5 * 0.5 # Amount of energy in the battery at the start\\n # Determin charge of discharge\\n if bt > 0:\\n Id = bt/(B*1) # time interval differnece is 1\\n Ich = NomIch\\n else:\\n Ich = bt/(B*1)\\n Id = NomId\\n\\n #Calculate average State of Charge\\n SoC = 100 * (qt - 0.5*bt)/B\\n\\n #Calculate Depth of Discharge\\n DoD = 100 * bt /B\\n\\n # Functions\\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\\n nCL = nCL1 * nCL2 * nCL3\\n Fractional_D = (0.5/3650)/ nCL\\n return Fractional_D\",\n \"def _solve_freq_unc(self, d, v, a, force, freq, incrb):\\n # convert frequency in Hz to radian/sec:\\n freqw = 2 * np.pi * freq\\n freqw2 = freqw**2\\n\\n # solve rigid-body and elastic parts separately\\n # - residual-flexibility part was already solved in _init_dva\\n\\n # solve rigid-body part:\\n self._solve_freq_rb(d, v, a, force, freqw, freqw2, incrb, True)\\n\\n # solve elastic part:\\n if self.elsize:\\n el = self.el\\n _el = self._el\\n fw = freqw[None, :]\\n fw2 = freqw2[None, :]\\n if self.m is None:\\n d[el] = force[el] / (\\n 1j * (self.b[_el][:, None] @ fw) + self.k[_el][:, None] - fw2\\n )\\n else:\\n d[el] = force[el] / (\\n 1j * (self.b[_el][:, None] @ fw)\\n + self.k[_el][:, None]\\n - self.m[_el][:, None] @ fw2\\n )\\n a[el] = d[el] * -(freqw2)\\n v[el] = d[el] * (1j * freqw)\",\n \"def calculate_bandwidth(self, complist):\\n\\n self.type = complist[0]\\n self.spot = complist[2]\\n self.value = complist[1]\\n self.fail = False\\n\\n if self.spot == \\\"1\\\" or self.spot == \\\"2\\\":\\n # print \\\"Calculation if Loop 1st filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c1 == 0:\\n self.c1 = self.value\\n else:\\n self.fail = True\\n else:\\n if self.r1 == 0:\\n self.r1 = self.value\\n else:\\n self.fail = True\\n\\n if self.spot == \\\"3\\\" or self.spot == \\\"4\\\":\\n # print \\\"Calculation if loop 2nd filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c2 == 0:\\n self.c2 = self.value\\n else:\\n self.fail = True\\n else: #self.type == \\\"R\\\"\\n if self.r2 == 0:\\n self.r2 = self.value\\n else:\\n self.fail = True\\n\\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\\n #print \\\"hello!\\\"\\n cf_low = str(cf_low)\\n self.cutoff_freql = cf_low\\n self.cutoff_freql_text = cf_low + \\\"K\\\"\\n print self.cutoff_freql_text\\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\\n cf_high = str(cf_high)\\n self.cutoff_freqh = cf_high\\n self.cutoff_freqh_text = cf_high + \\\"K\\\"\\n print self.cutoff_freqh_text\\n voltage_change = float((self.r2)/self.r1)\\n voltage = 5 + voltage_change\\n self.voltage = str(voltage)\\n print self.voltage\",\n \"def div(\\n coeff_rho,\\n momentum_x,\\n momentum_y,\\n momentum_z,\\n ):\\n # Compute the fourth order derivative of the pressure for the face\\n # velocity correction.\\n p_corr = (\\n states['p']\\n if self._params.enable_rhie_chow_correction else states['dp'])\\n d4p_dx4 = self._kernel_op.apply_kernel_op_x(p_corr, 'k4d2x')\\n d4p_dy4 = self._kernel_op.apply_kernel_op_y(p_corr, 'k4d2y')\\n d4p_dz4 = self._kernel_op.apply_kernel_op_z(p_corr, 'k4d2z',\\n 'k4d2zsh')\\n\\n # Compute velocity gradient based on interpolated values on cell faces.\\n coeff_x = dt / (4. * coeff_rho * dx**2)\\n du = self._kernel_op.apply_kernel_op_x(momentum_x, 'kDx')\\n du_dx = [\\n du_i / (2. * dx) + coeff_x * d4p_dx4_i\\n for du_i, d4p_dx4_i in zip(du, d4p_dx4)\\n ]\\n\\n coeff_y = dt / (4. * coeff_rho * dy**2)\\n dv = self._kernel_op.apply_kernel_op_y(momentum_y, 'kDy')\\n dv_dy = [\\n dv_i / (2. * dy) + coeff_y * d4p_dy4_i\\n for dv_i, d4p_dy4_i in zip(dv, d4p_dy4)\\n ]\\n\\n coeff_z = dt / (4. * coeff_rho * dz**2)\\n dw = self._kernel_op.apply_kernel_op_z(momentum_z, 'kDz', 'kDzsh')\\n dw_dz = [\\n dw_i / (2. * dz) + coeff_z * d4p_dz4_i\\n for dw_i, d4p_dz4_i in zip(dw, d4p_dz4)\\n ]\\n\\n return [\\n du_dx_i + dv_dy_i + dw_dz_i\\n for du_dx_i, dv_dy_i, dw_dz_i in zip(du_dx, dv_dy, dw_dz)\\n ]\",\n \"def torch_hertz_to_mel(frequencies_hertz):\\r\\n # return _MEL_HIGH_FREQUENCY_Q * tf.math.log(\\r\\n # 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\\r\\n return _MEL_HIGH_FREQUENCY_Q * np.log(\\r\\n 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\",\n \"def effective_temperature(R,times):\\n T_eff = np.empty((len(R),times))\\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \\n for i in range (len(R)):\\n for t in range(times): \\n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\\n return T_eff\",\n \"def apply_band_pass(ftd, freq, omega, bp_wid=1):\\n # Find number of frequencies\\n nf = len(freq)\\n # Find index for band pass, only consider indices of positive freqs\\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\\n # Filter out frequencies left of band pass\\n ftd[:,0:idx_om-1-bp_wid] = 0.0\\n # Filter out frequencies left of omega\\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\\n # Correct for lost amplitude\\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\\n return ftd\",\n \"def HeatEqn_FT(D, L, x, t, u_0):\\n n = x.size\\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\\n u_0t = np.fft.fft(u_0)\\n\\n U = np.zeros((t.size, x.size))\\n for ti in range(t.size):\\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\\n\\n return U\",\n \"def integrate_rd(D=2e-3, t0=1., tend=13., x0=1e-10, xend=1.0, N=256,\\n nt=42, logt=False, logy=False, logx=False,\\n random=False, k=1.0, nstencil=3, linterpol=False,\\n rinterpol=False, num_jacobian=False, method='bdf',\\n integrator='scipy', iter_type='undecided',\\n linear_solver='default', atol=1e-8, rtol=1e-10, factor=1e5,\\n random_seed=42, plot=False, savefig='None', verbose=False,\\n scaling=1.0, ilu_limit=1000.0, first_step=0.0, n_jac_diags=0, use_log2=False):\\n if t0 == 0.0:\\n raise ValueError(\\\"t0==0 => Dirac delta function C0 profile.\\\")\\n if random_seed:\\n np.random.seed(random_seed)\\n tout = np.linspace(t0, tend, nt)\\n\\n units = defaultdict(lambda: 1)\\n units['amount'] = 1.0/scaling\\n\\n # Setup the grid\\n x = generate_grid(x0, xend, N, logx, random=random)\\n modulation = [1 if (i == 0) else 0 for i in range(N)]\\n\\n rd = ReactionDiffusion.nondimensionalisation(\\n 2,\\n [[0], [1]],\\n [[1], [0]],\\n [k, factor*k],\\n N=N,\\n D=[0, D],\\n x=x,\\n logy=logy,\\n logt=logt,\\n logx=logx,\\n nstencil=nstencil,\\n lrefl=not linterpol,\\n rrefl=not rinterpol,\\n modulated_rxns=[0, 1],\\n modulation=[modulation, modulation],\\n unit_registry=units,\\n ilu_limit=ilu_limit,\\n n_jac_diags=n_jac_diags,\\n faraday_const=1,\\n vacuum_permittivity=1,\\n use_log2=use_log2\\n )\\n\\n # Calc initial conditions / analytic reference values\\n Cref = analytic(rd.xcenters, tout, D, x0, xend, logx, use_log2=use_log2).reshape(\\n nt, N, 1)\\n source = np.zeros_like(Cref[0, ...])\\n source[0, 0] = factor\\n y0 = np.concatenate((source, Cref[0, ...]), axis=1)\\n\\n # Run the integration\\n integr = Integration(\\n rd, y0, tout, integrator=integrator, atol=atol, rtol=rtol,\\n with_jacobian=(not num_jacobian), method=method,\\n iter_type=iter_type,\\n linear_solver=linear_solver, first_step=first_step)\\n Cout = integr.with_units('Cout')\\n if verbose:\\n import pprint\\n pprint.pprint(integr.info)\\n spat_ave_rmsd_over_atol = spat_ave_rmsd_vs_time(\\n Cout[:, :, 1], Cref[:, :, 0]) / atol\\n tot_ave_rmsd_over_atol = np.average(spat_ave_rmsd_over_atol)\\n\\n if plot:\\n # Plot results\\n import matplotlib.pyplot as plt\\n plt.figure(figsize=(6, 10))\\n\\n def _plot(C, c, ttl=None, vlines=False,\\n smooth=True):\\n if vlines:\\n plt.vlines(rd.x, 0, np.ones_like(rd.x)*max(C),\\n linewidth=1, colors='gray')\\n if smooth:\\n plt.plot(rd.xcenters, C, c=c)\\n else:\\n for i, _C in enumerate(C):\\n plt.plot([rd.x[i], rd.x[i+1]], [_C, _C], c=c)\\n\\n plt.xlabel('x / m')\\n plt.ylabel('C / M')\\n if ttl:\\n plt.title(ttl)\\n\\n for i in range(nt):\\n kwargs = dict(smooth=(N >= 20),\\n vlines=(i == 0 and N < 20))\\n\\n c = 1-tout[i]/tend\\n c = (1.0-c, .5-c/2, .5-c/2)\\n plt.subplot(4, 1, 1)\\n _plot(Cout[i, :, 1], c, 'Simulation (N={})'.format(rd.N),\\n **kwargs)\\n\\n plt.subplot(4, 1, 2)\\n _plot(Cref[i, :, 0], c, 'Analytic', **kwargs)\\n\\n plt.subplot(4, 1, 3)\\n _plot((Cout[i, :, 1]-Cref[i, :, 0]), c,\\n \\\"Error\\\",\\n **kwargs)\\n\\n plt.subplot(4, 1, 4)\\n plt.plot(integr.tout, spat_ave_rmsd_over_atol)\\n plt.plot([integr.tout[0], integr.tout[-1]],\\n [tot_ave_rmsd_over_atol]*2, '--')\\n plt.title(\\\"RMSD / atol\\\")\\n\\n plt.tight_layout()\\n save_and_or_show_plot(savefig=savefig)\\n\\n return tout, Cout, integr.info, rd, tot_ave_rmsd_over_atol\",\n \"def freq2den(freq):\\n\\n return freq * freq * k_2\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\n \"def freq_defl_comp(fmax, p=75, p1=database['K+'], p2=database['pi+'],\\r\\n p3=database['p+'], L_t=79.6, l=2.74, E=1e6, plot=True,\\r\\n details=False, n=1000, delta_p=1.6e-2, fmin=0, just_pi=False):\\r\\n f_range = np.linspace(fmin, fmax, n)\\r\\n min_defl, d2, d3 = [], [], []\\r\\n for f in f_range:\\r\\n if just_pi == True:\\r\\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\\r\\n min_defl.append(d2[-1])\\r\\n if just_pi == False: \\r\\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\\r\\n d3.append(ang_deflection(p, f, p1, p3, L_t, l, E, delta_p))\\r\\n min_defl.append(np.min([d2[-1], d3[-1]]))\\r\\n if plot == True:\\r\\n fig = plt.figure(figsize=[9, 5])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n if details == True:\\r\\n ax.plot(f_range, d2, 'r', alpha=0.5, label=f'{p2.name} deflection')\\r\\n ax.plot(f_range, d3, 'b', alpha=0.5, label=f'{p3.name} deflection')\\r\\n else:\\r\\n ax.plot(f_range, min_defl, color=[1, 0, 1], alpha=0.5, label='min deflection')\\r\\n# ax.set_xlim(fmin, fmax)\\r\\n ax.set_ylim(0)\\r\\n ax.set_xlabel('Frequency / Hz', fontsize=20)\\r\\n text = r'$D_{'\\r\\n text += p2.name + '/' + p3.name\\r\\n text += '}$ / mrad'\\r\\n ax.set_ylabel(text, fontsize=20)\\r\\n ax.set_xscale('log')\\r\\n ax.legend(fontsize=20)\\r\\n plt.show()\\r\\n opt_freq = f_range[np.argmax(min_defl)]\\r\\n d_opt = (fmax-fmin)/1000\\r\\n d_opt_perc = (d_opt/opt_freq)*100\\r\\n if details == True:\\r\\n return 'optimum frequency = {0:.0f} +/- {1:.5f}%'.format(opt_freq, d_opt_perc)\\r\\n return opt_freq\",\n \"def F_rxth(mx, rhoc, Temp):\\n return 64. * m.pow(Temp/1.e+5,0.5) * m.pow(1.e+14/rhoc,0.5) * m.pow(100./mx,0.5) # cm\",\n \"def calc(self,index,counter_values):\\n gr = self.grSign * self.grPitch['Value'].value\\n m = self.mSign * self.mPitch['Value'].value\\n \\n offsetG,offsetM = self.checkOffset()\\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\\n alpha = (2.0*theta) + beta\\n numerator = (math.sin(alpha) + math.sin(beta))\\n denominator = (self.DiffrOrder * self.look_at_grx())\\n wavelength = numerator / denominator\\n \\n if wavelength == 0.0:\\n energy_physicalmot = 0.0\\n else:\\n energy_physicalmot = self.hc / wavelength\\n #if self.FixedM2Pit: \\n Cff = math.cos(beta)/math.cos(alpha)\\n if energy_physicalmot < 0 :\\n #warning: wavelength se vuelve negativo ... ??????\\n energy_physicalmot = energy_physicalmot *(-1) \\n \\n # Real Energy is equal to the energy calculated by the encoders\\n # minus an offset that depends on the same energy calculated by the \\n # encoders:\\n # E_physicalmot = Ereal + offset\\n # with offset = a*Ereal + b\\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \\n a_coeff = self.EnergyDP.a_offset_coeff\\n b_coeff = self.EnergyDP.b_offset_coeff\\n numerator = energy_physicalmot - b_coeff\\n denominator = 1 + a_coeff\\n energy = numerator / denominator\\n \\n if index == 1:\\n return energy\\n elif index == 2:\\n return Cff\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_partitionfunction(Tlist, self.frequency, self.barrier) ** self.degeneracy\",\n \"def butter_lpf(fc, fs, order):\\n nyq = 0.5 * fs\\n high = fc / nyq\\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def get_quantum_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n f = 0\\n for m in self.input.structure.get_masses():\\n hbar_omega = (\\n HBAR\\n * np.sqrt(self.input.spring_constant / m)\\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\\n )\\n f += (3.0 / 2) * hbar_omega + (\\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\\n )\\n return f\",\n \"def refraction(el, temp, press, hum, freq=150.0):\\n\\n fvec = np.vectorize(qp.qp_refraction, [np.double])\\n delta = fvec(el, temp, press, hum, freq)\\n if delta.shape == ():\\n return delta[()]\\n return delta\",\n \"def zMCEff1D(ZReco, ZAcc, bins, obs, region='inclusive', sel=''):\\n print(\\\">>> make differential efficiencies for \\\"+obs+\\\" in \\\"+region+\\\" region\\\")\\n\\n if sel != '':\\n ZReco = ZReco.query(sel)\\n ZAcc = ZAcc.query(sel)\\n\\n ZEff = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\\n ZEff_sel = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\\n ZEff_glo = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\\n\\n MuEff_HLT_Sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Sel_Glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Glo_StaOrTrk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Trk_Sta = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Sta_Trk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n\\n ZMuMuEff = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n ZMuMuEff_sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n ZMuMuEff_glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n\\n for i in range(0, len(bins)-1):\\n bin_low = bins[i]\\n bin_high = bins[i+1]\\n sel = '{0}>{1} & {0}<{2}'.format(obs, bin_low, bin_high)\\n\\n ZReco_i = ZReco.query(sel)\\n\\n qHLT = 'muon_Category==5 & antiMuon_Category==5'\\n qSel = '(muon_Category==5 & antiMuon_Category==4) | (muon_Category==4 & antiMuon_Category==5)'\\n qGlo = '(muon_Category==5 & antiMuon_Category==3) | (muon_Category==3 & antiMuon_Category==5)'\\n qSta = '(muon_Category==5 & antiMuon_Category==2) | (muon_Category==2 & antiMuon_Category==5)'\\n qTrk = '(muon_Category==5 & antiMuon_Category==1) | (muon_Category==1 & antiMuon_Category==5)'\\n\\n nHLT = len(ZReco_i.query(qHLT))\\n nSel = len(ZReco_i.query(qSel))\\n nGlo = len(ZReco_i.query(qGlo))\\n nSta = len(ZReco_i.query(qSta))\\n nTrk = len(ZReco_i.query(qTrk))\\n\\n MuEff_HLT_Sel[0][i], MuEff_HLT_Sel[1][i] = muTagAndProbeEff(nHLT, 0, nSel)\\n MuEff_Sel_Glo[0][i], MuEff_Sel_Glo[1][i] = muTagAndProbeEff(nHLT, nSel, nGlo)\\n MuEff_Glo_StaOrTrk[0][i], MuEff_Glo_StaOrTrk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo, nSta + nTrk)\\n MuEff_Trk_Sta[0][i], MuEff_Trk_Sta[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nTrk, nSta)\\n MuEff_Sta_Trk[0][i], MuEff_Sta_Trk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nSta, nTrk)\\n\\n ZMuMuEff[0][i], ZMuMuEff[1][i] = eff_ztomumu_old(nHLT, nSel, nGlo, nSta, nTrk)\\n ZMuMuEff_sel[0][i], ZMuMuEff_sel[1][i] = eff_ztomumu_sel(nHLT, nSel, nGlo, nSta, nTrk)\\n ZMuMuEff_glo[0][i], ZMuMuEff_glo[1][i] = eff_ztomumu_glo(nHLT, nSel, nGlo, nSta, nTrk)\\n\\n # full true Z efficiency\\n ZAcc_i = ZAcc.query(sel)\\n ZReco_i = ZReco.query(sel + '& (muon_Category==5 | antiMuon_Category==5) & muon_Category>=4 & antiMuon_Category>=4')\\n\\n nReco_i = len(ZReco_i)\\n nAcc_i = len(ZAcc_i)\\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\\n\\n ZEff[0][i], ZEff[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\\n\\n # true Z efficiency at selection level (without requiring trigger)\\n ZAcc_i = ZAcc.query(sel)\\n ZReco_i = ZReco.query(sel + ' & muon_Category>=4 & antiMuon_Category>=4')\\n\\n nReco_i = len(ZReco_i)\\n nAcc_i = len(ZAcc_i)\\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\\n\\n ZEff_sel[0][i], ZEff_sel[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\\n\\n # true Z efficiency at gobal muon level (requiring two global muons)\\n ZAcc_i = ZAcc.query(sel)\\n ZReco_i = ZReco.query(sel + '& muon_Category>=3 & antiMuon_Category>=3 ')\\n\\n nReco_i = len(ZReco_i)\\n nAcc_i = len(ZAcc_i)\\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\\n\\n ZEff_glo[0][i], ZEff_glo[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\\n\\n x = bins[:-1] + (bins[1:] - bins[:-1])/2\\n\\n def plot_zeff(eff_true, eff_tnp, name):\\n plt.clf()\\n fig, ax = plt.subplots(2, 1, sharex=True, gridspec_kw={'height_ratios': [2, 1]})\\n fig.subplots_adjust(hspace=0)\\n\\n ax[0].errorbar(x, eff_true[0], xerr=np.zeros(len(x)), yerr=eff_true[1], fmt='bo', label='true')\\n ax[0].errorbar(x, eff_tnp[0], xerr=np.zeros(len(x)), yerr=eff_tnp[1], fmt='ro', label='tnp')\\n ax[0].set(xlim=(bins[0], bins[-1]), ylim=(0.75, 1.1))\\n ax[0].legend()\\n ax[0].text(0.05, 0.9, r'$66\\\\ \\\\mathrm{GeV} < \\\\mathrm{M}_{\\\\mu\\\\mu} < 116\\\\ \\\\mathrm{GeV}$', transform=ax[0].transAxes)\\n ax[0].text(0.05, 0.82, r'$p_\\\\mathrm{t}(\\\\mu) > 27\\\\ \\\\mathrm{GeV} \\\\qquad |\\\\eta(\\\\mu)| < 2.4$', transform=ax[0].transAxes)\\n ax[0].text(0.05, 0.74, region, transform=ax[0].transAxes)\\n ax[0].set_ylabel(r'$\\\\epsilon_\\\\mathrm{Z}$')\\n ax[0].set_xlabel(obs)\\n ax[0].set_yticks([0.8, 0.85, 0.9, 0.95, 1.0, 1.05])\\n ax[0].set_title(\\\"Z efficiency at {0} muon level\\\".format(name))\\n\\n pulls = eff_tnp[0] - eff_true[0]\\n pulls_sig = np.sqrt(eff_tnp[1]**2 + eff_true[1]**2)\\n\\n ax[1].errorbar(x, pulls, xerr=np.zeros(len(x)), yerr=pulls_sig, fmt='ko')# , label='factorized - true')\\n ax[1].plot(x, np.zeros(len(x)), color='gray', linestyle='dashed')\\n ax[1].set_ylim(-0.02, 0.04)\\n ax[1].set_ylabel(r'$\\\\epsilon^\\\\mathrm{tnp}_\\\\mathrm{Z} - \\\\epsilon^\\\\mathrm{true}_\\\\mathrm{Z}$')\\n ax[1].set_xlabel(obs)\\n ax[1].set_yticks([-0.01, 0., 0.01, 0.02, 0.03])\\n plt.savefig(output+'/ZMuMu_{0}_{1}_{2}_level.png'.format(obs, region, name))\\n plt.close()\\n\\n plot_zeff(ZEff, ZMuMuEff, \\\"hlt\\\")\\n plot_zeff(ZEff_sel, ZMuMuEff_sel, \\\"selection\\\")\\n plot_zeff(ZEff_glo, ZMuMuEff_glo, \\\"global\\\")\",\n \"def far_fields(horn_width, horn_height, eplane_effective_length, hplane_effective_length, frequency, r, theta, phi):\\n # Calculate the wavenumber\\n k = 2.0 * pi * frequency / c\\n\\n # Calculate the wave impedance\\n eta = sqrt(mu_0 / epsilon_0)\\n\\n # Define the radial-component of the electric field\\n e_r = 0.0\\n\\n # Define the theta-component of the electric field\\n e_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Define the phi-component of the electric field\\n e_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * cos(phi) * (1.0 + cos(theta)) * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Define the radial-component of the magnetic field\\n h_r = 0.0\\n\\n # Define the theta-component of the magnetic field\\n h_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * -cos(phi) * (1.0 + cos(theta)) / eta * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Define the phi-component of the magnetic field\\n h_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) / eta * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Return all six components of the far field\\n return e_r, e_theta, e_phi, h_r, h_theta, h_phi\",\n \"def freqz_resp_list(b,a=np.array([1]),mode = 'dB',fs=1.0,Npts = 1024,fsize=(6,4)):\\r\\n if type(b) == list:\\r\\n # We have a list of filters\\r\\n N_filt = len(b)\\r\\n f = np.arange(0,Npts)/(2.0*Npts)\\r\\n for n in range(N_filt):\\r\\n w,H = signal.freqz(b[n],a[n],2*np.pi*f)\\r\\n if n == 0:\\r\\n plt.figure(figsize=fsize)\\r\\n if mode.lower() == 'db':\\r\\n plt.plot(f*fs,20*np.log10(np.abs(H)))\\r\\n if n == N_filt-1:\\r\\n plt.xlabel('Frequency (Hz)')\\r\\n plt.ylabel('Gain (dB)')\\r\\n plt.title('Frequency Response - Magnitude')\\r\\n\\r\\n elif mode.lower() == 'phase':\\r\\n plt.plot(f*fs,np.angle(H))\\r\\n if n == N_filt-1:\\r\\n plt.xlabel('Frequency (Hz)')\\r\\n plt.ylabel('Phase (rad)')\\r\\n plt.title('Frequency Response - Phase')\\r\\n\\r\\n elif (mode.lower() == 'groupdelay_s') or (mode.lower() == 'groupdelay_t'):\\r\\n \\\"\\\"\\\"\\r\\n Notes\\r\\n -----\\r\\n\\r\\n Since this calculation involves finding the derivative of the\\r\\n phase response, care must be taken at phase wrapping points \\r\\n and when the phase jumps by +/-pi, which occurs when the \\r\\n amplitude response changes sign. Since the amplitude response\\r\\n is zero when the sign changes, the jumps do not alter the group \\r\\n delay results.\\r\\n \\\"\\\"\\\"\\r\\n theta = np.unwrap(np.angle(H))\\r\\n # Since theta for an FIR filter is likely to have many pi phase\\r\\n # jumps too, we unwrap a second time 2*theta and divide by 2\\r\\n theta2 = np.unwrap(2*theta)/2.\\r\\n theta_dif = np.diff(theta2)\\r\\n f_diff = np.diff(f)\\r\\n Tg = -np.diff(theta2)/np.diff(w)\\r\\n # For gain almost zero set groupdelay = 0\\r\\n idx = pylab.find(20*np.log10(H[:-1]) < -400)\\r\\n Tg[idx] = np.zeros(len(idx))\\r\\n max_Tg = np.max(Tg)\\r\\n #print(max_Tg)\\r\\n if mode.lower() == 'groupdelay_t':\\r\\n max_Tg /= fs\\r\\n plt.plot(f[:-1]*fs,Tg/fs)\\r\\n plt.ylim([0,1.2*max_Tg])\\r\\n else:\\r\\n plt.plot(f[:-1]*fs,Tg)\\r\\n plt.ylim([0,1.2*max_Tg])\\r\\n if n == N_filt-1:\\r\\n plt.xlabel('Frequency (Hz)')\\r\\n if mode.lower() == 'groupdelay_t':\\r\\n plt.ylabel('Group Delay (s)')\\r\\n else:\\r\\n plt.ylabel('Group Delay (samples)')\\r\\n plt.title('Frequency Response - Group Delay')\\r\\n else:\\r\\n s1 = 'Error, mode must be \\\"dB\\\", \\\"phase, '\\r\\n s2 = '\\\"groupdelay_s\\\", or \\\"groupdelay_t\\\"'\\r\\n print(s1 + s2)\",\n \"def trc_fgen_postfb(self,trc,dt,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_entropy=self.entropy(trc_norm,50)\\n trc_fdm=self.fdm(trc_norm,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm,hwin2)\\n for i,j in enumerate(trc):\\n if i<len(trc)-vlen-1:\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm)))[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(fb/dt):np.int(fb/dt)+vlen]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(fb/dt):np.int(fb/dt)+vlen]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\\n\\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\\n\\td = dist * 1e3 * pc\\n\\t# Radius (in unit of pc)\\n\\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\\n\\t# Mass\\n\\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\\n\\t# Number density\\n\\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\\n\\t# Sigmav of 2.33H\\n\\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\\n\\t# Virial\\n\\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\\n\\t# Virial parameter with B-field, assume 1 mG\\n\\tB = 1 * 1e-3 # G\\n\\trho = density * 2.8 * mp # g/cm3\\n\\talfven = B / np.sqrt(4*np.pi*rho)\\n\\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\\n\\n\\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B\",\n \"def buoyancy_frequency(self, z, h=0.01):\\n # Check validity of the input z values\\n if np.max(z) > self.z_max or np.min(z) < self.z_min:\\n raise ValueError('Selected depths outside range of ' + \\\\\\n 'CTD data: %g to %g m' % (self.z_min, \\n self.z_max))\\n if h > 1.0 or h < 0.0:\\n raise ValueError('Input parameter h must be between 0.0 ' + \\\\\\n 'and 1.0.')\\n \\n # Prepare space to store the solution\\n if not isinstance(z, np.ndarray):\\n N = np.zeros(1)\\n z = np.array([z])\\n elements = 0\\n else:\\n N = np.zeros(z.shape)\\n elements = range(len(N))\\n \\n # Compute the length-scale for the finite difference method\\n dz = (self.z_max - self.z_min) * h\\n \\n # Fill the solution matrix\\n for i in range(len(z)):\\n # Get the end-points of z for the finite difference formula\\n if z[i] + dz > self.z_max:\\n z1 = self.z_max\\n z0 = z1 - 2 * dz\\n elif z[i] - dz < self.z_min:\\n z0 = self.z_min\\n z1 = z0 + 2 * dz\\n else:\\n z0 = z[i] - dz\\n z1 = z[i] + dz\\n \\n # Get the density at z0 and z1. Use atmospheric pressure to \\n # compute the potential density and remove the effect of \\n # compressibility\\n T0, S0 = self.get_values(z0, self.ztsp[1:3])\\n T1, S1 = self.get_values(z1, self.ztsp[1:3])\\n Pa = 101325.\\n rho_0 = seawater.density(T0, S0, Pa)\\n rho_1 = seawater.density(T1, S1, Pa)\\n N[i] = np.sqrt(9.81 / rho_0 * (rho_1 - rho_0) / (z1 - z0))\\n \\n return N[elements]\",\n \"def calculate_NH_relaxation_from_Ct(bondtype, B_0, t, Ct):\\n gamma_1H = 267.513e6 ; # rad s^-1 T^-1\\n gamma_X = -27.116e6\\n DeltaSigma_X=-160e-6\\n r_XH=1.02e-10\\n\\n om, G = do_dft(t, Ct)\\n J = G.real\\n\\n omega, iOmH, iOmX = obtain_HX_frequencies()\\n\\n Jw=np.zeros(5)\\n for i in range(5):\\n w = omega[i]\\n Jw[i] = interpolate_point(w, om, J)\\n\\n # f_DD = 519627720.1974593 , if r_NH is at default values\\n f_DD = 7.958699205571828e-67 * r_XH**-6.0 * gamma_X**2\\n # f_CSA = 498637299.69233465, if B_0 = 600.13, and DeltaSigma=-160e-6\\n f_CSA = 2.0/15.0 * DeltaSigma_X**2 * ( gamma_X * B_0 )**2\\n\\n R1 = f_DD*( J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] ) + f_CSA*J[iOmX]\\n R2 = 0.5*f_DD*( 4*J[0] + J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] + 6*J[iOmH] ) + 1.0/6.0*f_CSA*(4*J[0] + 3*J[iOmX])\\n NOE = 1.0 + gamma_1H/gamma_X/R1 * f_DD*(6*J[iOmH+iOmX] - J[iOmH-iOmX])\\n\\n return R1, R2, NOE\",\n \"def get_kt(temps, delta_gibbs_ts):\\n # rate coefficient from Eyring equation\\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular\",\n \"def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\\n D=dmax*x[0]**n/(x[0]**n+K**n)\\n #defune the degradation effect\\n deg=0\\n #define ODEs\\n y=np.zeros([np.size(x)])\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\\n \\n return y\",\n \"def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n C_T = (\\n 2 ** (1 / 4)\\n * np.sqrt(gbar)\\n / np.pi\\n * np.sqrt(vv)\\n * tt ** (5 / 4)\\n * _1d_call(_fdk, y, k=1 / 2)\\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\\n )\\n return C_T\",\n \"def bd(y, t_r, lbda=1.0, theta_0=None, z_0=None, hrf_dur=20.0, # noqa\\n bounds=None, nb_iter=100, nb_sub_iter=1000, nb_last_iter=10000,\\n print_period=50, early_stopping=False, wind=4, tol=1.0e-12, verbose=0):\\n # force cast for Numba\\n y = y.astype(np.float64)\\n\\n # initialization\\n theta = MAX_DELTA if theta_0 is None else theta_0\\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\\n\\n if z_0 is None:\\n diff_z = np.zeros_like(y)\\n z = np.zeros_like(y)\\n x = np.zeros_like(y)\\n else:\\n diff_z = np.append(0, z_0[1:] - z_0[:-1])\\n z = z_0\\n x = spectral_convolve(h, z)\\n\\n if bounds is None:\\n bounds = [(MIN_DELTA + 1.0e-1, MAX_DELTA - 1.0e-1)]\\n\\n d = {}\\n r_0 = np.sum(np.square(x - y))\\n d['r'] = [1.0]\\n g_0 = np.sum(np.abs(diff_z))\\n d['g'] = [g_0]\\n j_0 = r_0 + lbda * g_0\\n d['J'] = [1.0]\\n d['l_alpha'] = []\\n\\n if (verbose > 0):\\n print(\\\"normalized global cost-function \\\"\\n \\\"(init): {0:.6f}\\\".format(d['J'][-1]))\\n\\n # main loop\\n for idx in range(nb_iter):\\n\\n # deconvolution\\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping,\\n wind, tol)\\n z = np.cumsum(diff_z)\\n\\n # hrf estimation\\n args = (z, y, t_r, hrf_dur)\\n theta, _, _ = fmin_l_bfgs_b(\\n func=hrf_fit_err, x0=theta, args=args,\\n bounds=bounds, approx_grad=True, maxiter=999,\\n pgtol=1.0e-12)\\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\\n x = spectral_convolve(h, z)\\n\\n # cost function\\n r = np.sum(np.square(x - y))\\n g = np.sum(np.abs(diff_z))\\n d['J'].append((r + lbda * g) / j_0 + 1.0e-30)\\n d['r'].append(r / r_0 + 1.0e-30)\\n d['g'].append(g)\\n\\n if (verbose > 0) and ((idx+1) % print_period == 0):\\n print(\\\"normalized global cost-function \\\"\\n \\\"({0:03d}/{1:03d}): {2:.6f}\\\".format(idx+1, nb_iter,\\n d['J'][-1]))\\n\\n # early stopping\\n if early_stopping:\\n if idx > wind:\\n sub_wind_len = int(wind/2)\\n old_j = np.mean(d['J'][:-sub_wind_len])\\n new_j = np.mean(d['J'][-sub_wind_len:])\\n diff = (new_j - old_j) / new_j\\n if diff < tol:\\n if verbose > 0:\\n print(\\\"\\\\n-----> early-stopping done at \\\"\\n \\\"{0:03d}/{1:03d}, global\\\"\\n \\\" normalized cost-function = \\\"\\n \\\"{2:.6f}\\\".format(idx, nb_iter, d['J'][idx]))\\n break\\n\\n # last (long) deconvolution\\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping, wind,\\n tol)\\n z = np.cumsum(diff_z)\\n x = spectral_convolve(h, z)\\n\\n # cost function\\n r = np.sum(np.square(x - y))\\n g = np.sum(np.abs(diff_z))\\n d['J'].append((r + lbda * g) / j_0)\\n d['r'].append(r / r_0)\\n d['g'].append(g)\\n\\n d['J'] = np.array(d['J'])\\n d['r'] = np.array(d['r'])\\n d['g'] = np.array(d['g'])\\n\\n return x, z, diff_z, h, d\",\n \"def rcfilter_C(freq, R):\\n R = _normalizevalue(R)\\n C = 1/(R*freq*2*math.pi)\\n return _Cap(C)\",\n \"def get_tuning_freq(self, freq):\\n if freq < self.freq_lo:\\n return\\n\\n while freq < self.NOTES.min() or freq > self.NOTES.max():\\n while freq > self.NOTES.max():\\n self.NOTES *= 2\\n while freq < self.NOTES.min():\\n self.NOTES /= 2\\n tuning_freq = min(self.NOTES, key=lambda x: abs(x-freq))\\n return tuning_freq\",\n \"def getFWHM(antenna, freq):\\n diameter = getDiameter(antenna)\\n lam = 299792458.0 / (freq * 1e9)\\n fwhmo = lam / math.pi * 180.0 * 60.0\\n fwhm = 1.22 * fwhmo / diameter\\n return fwhm\",\n \"def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_P_low *= (\\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n )\\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n # low temperatures - high numbers\\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)\",\n \"def get_frequency(self):\\r\\n # print '*********in get freq'\\r\\n self.cntr.run('FREQ 1')\\r\\n f_0_ = self.cntr.get_measurements(1)\\r\\n self.f_0 = f_0_[0]\\r\\n self.cntr.run('FREQ 2')\\r\\n f_rep_ = self.cntr.get_measurements(1)\\r\\n self.f_rep = f_rep_[0]\",\n \"def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for low temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n S_low = (\\n -gbar\\n * np.sqrt(2)\\n / (6 * np.pi ** 2)\\n * tt_low ** (3 / 2)\\n * vv_low\\n * (\\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\\n )\\n )\\n # low temperatures - high numbers\\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((S_low, S_high)).reshape(y.shape)\",\n \"def k_HF(T, n, h=1e-3):\\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\\n return dn_dmu / n\",\n \"def _get_a_freq(self, energy):\\n left_index = bisect.bisect_left(self.energy_list, energy)\\n if left_index+1 >= len(self.energy_list):\\n left_index = len(self.energy_list)-2\\n elif left_index > 0:\\n left_index -= 1\\n energy0 = self.energy_list[left_index]\\n energy1 = self.energy_list[left_index+1]\\n freq0 = 1./self.closed_orbits_t[energy0]\\n freq1 = 1./self.closed_orbits_t[energy1]\\n frequency = (freq1 - freq0)/(energy1-energy0)*(energy-energy0) + freq0\\n #print \\\"\\\\nl:\\\", left_index, \\\"e0:\\\", energy0, \\\"e1:\\\", energy1, \\\\\\n # \\\"f0:\\\", freq0, \\\"f1:\\\", freq1, \\\"DE:\\\", energy-e0, \\\"f\\\", frequency\\n return frequency\",\n \"def hertz_to_mel(freq):\\n return 2595.0 * np.log10(1 + (freq / 700.0))\",\n \"def all_dhkl(self, crystal):\\n #d_min = self.wavelength/self.max2theta*pi/2\\n d_min = self.wavelength/sin(self.max2theta/2)/2\\n \\n # This block is to find the shortest d_hkl, \\n # for all basic directions (1,0,0), (0,1,0), (1,1,0), (1,-1,0) and so on, 26 in total \\n hkl_max = np.array([1,1,1])\\n for h1 in [-1, 0, 1]:\\n for k1 in [-1, 0, 1]:\\n for l1 in [-1, 0, 1]:\\n hkl_index = np.array([[h1,k1,l1]])\\n d = float(np.linalg.norm( np.dot(hkl_index, crystal.rec_matrix), axis=1))\\n if d>0:\\n multiple = 1/d/d_min\\n hkl_index *= round(multiple)\\n for i in range(len(hkl_max)):\\n if hkl_max[i] < hkl_index[0,i]:\\n hkl_max[i] = hkl_index[0,i]\\n #h1 = 2*ceil(np.linalg.norm(crystal.cell_para[0])/d_min)\\n #k1 = 2*ceil(np.linalg.norm(crystal.cell_para[1])/d_min)\\n #l1 = 2*ceil(np.linalg.norm(crystal.cell_para[2])/d_min)\\n h1, k1, l1 = hkl_max\\n h = np.arange(-h1,h1)\\n k = np.arange(-k1,k1)\\n l = np.arange(-l1,l1)\\n \\n hkl = np.array((np.meshgrid(h,k,l))).transpose()\\n hkl_list = np.reshape(hkl, [len(h)*len(k)*len(l),3])\\n hkl_list = hkl_list[np.where(hkl_list.any(axis=1))[0]]\\n d_hkl = 1/np.linalg.norm( np.dot(hkl_list, crystal.rec_matrix), axis=1)\\n #for ix, a in enumerate(hkl_list):\\n # if np.array_equal(a, np.array([1,-1,3])) is True:\\n # print(a)\\n # break\\n #\\n #print(ix, hkl_list[ix], d_hkl[ix], d_min)\\n\\n shortlist = d_hkl > (d_min)\\n d_hkl = d_hkl[shortlist]\\n hkl_list = hkl_list[shortlist]\\n sintheta = self.wavelength/2/d_hkl\\n\\n self.theta = np.arcsin(sintheta)\\n self.hkl_list = hkl_list\\n self.d_hkl = d_hkl\\n \\n #return hkl_list, d_hkl, sintheta\",\n \"def total_band_energy(vals, T, Ec):\\n vals = np.sort(np.concatenate(vals))\\n occup = occup_TK(vals, T=T, spin=2)\\n return np.dot(vals, occup)-Ec\",\n \"def compute_f_BARR(self, R, e, D):\\n upper_LHS_RHS = 5.02 * log(R / (4.518 * log((R / 7), 10)), 10)\\n lower_LHS_RHS = R * (1 + (R**0.52) / (29 * (D/e)**0.7))\\n\\n upper_RHS_RHS = 1\\n lower_RHS_RHS = 3.7*(D/e)\\n bracket = (upper_LHS_RHS / lower_LHS_RHS) + (upper_RHS_RHS / lower_RHS_RHS)\\n \\n RHS = (-2)*log(bracket, 10)\\n f = (1/RHS)**2\\n \\n return f\",\n \"def drillSpeed(matID, W, FWHM_mm):\\n vaporH = { # kJ/mol\\n # spec heat from room temperature to melting + latent heat of fusion + spec heat from melting to boiling + latent heat of vaporization\\n # refer https://webbook.nist.gov/chemistry/ for heat capacity, this tool also has some data in specificHeatParams\\n 'Cu': 29.7 + 13.1 + 48.8 + 300,\\n 'Fe': 49.5 + 13.8 + 60.9 + 340,\\n 'W' : 118.4 + 46.9 + 82.5 + 824,\\n 'Mo': 89.9 + 37.5 + 71.9 + 598,\\n 'Al': 17.98 + 10.7 + 0.03175*1857 + 294\\n }\\n if matID not in vaporH.keys():\\n raise ValueError(f'No vaporization data for {matID}: available in {vaporH.keys()}')\\n \\n mol_mmD = 2 * np.pi * (FWHM_mm/2.355)**2 / 1000 * defaultDensity(matID) / molarMass(matID)\\n return W / (mol_mmD * vaporH[matID] * 1000)\",\n \"def density_by_ideal_gas_law(\\n p: tf.Tensor,\\n r: tf.Tensor,\\n t: tf.Tensor,\\n ) -> tf.Tensor:\\n return p / r / t\",\n \"def vib_energy(frequency, temp):\\n\\n # vibrational temperature\\n\\n vtemp = plank_const * speed_ol / boltz_const * frequency\\n\\n vtemp = np.matrix(vtemp)\\n\\n temp = 1 / np.matrix(temp)\\n\\n # need to convert to array, because the element wise exponential\\n # cannot work with matrix\\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\\n\\n # energy is a np.matrix, need to convert to array\\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\\n energy = np.array(energy)[0]\\n\\n return energy\",\n \"def fourier_coefficient(t, freq, n=1, axis=-1):\\n t, freq, n = map(np.asanyarray, (t, freq, n))\\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)\",\n \"def kld(Fk, freq, Fk_red, f_red):\\n \\n #pad the reduced input with zeros\\n f_red = [float(val) for val in f_red]\\n freq = [float(val) for val in freq]\\n f_Fk_red = dict(zip(f_red,Fk_red))\\n Fk_red_pad = []\\n #for each frequency in the nonreduced signal\\n for i,f in enumerate(freq):\\n #if the frequency is shared with the reduced signal\\n if f in f_red:\\n #add the coefficient from the reduced signal\\n Fk_red_pad.append(f_Fk_red[f])\\n #otherwise, pad it with a zero\\n else:\\n Fk_red_pad.append(0.)\\n Fk_red_pad = np.array(Fk_red_pad)\\n \\n Fk = np.abs(Fk)\\n Fk /= sum(Fk)\\n Fk_red_pad = np.abs(Fk_red_pad)\\n Fk_red_pad /= sum(Fk_red_pad)\\n \\n return stats.entropy(Fk_red_pad, Fk)\",\n \"def getf(element, energy, conv_fwhm=0):\\n try:\\n Z = int(element)\\n except: \\n if element in elements.Z:\\n Z = elements.Z[element]\\n else:\\n Z = None\\n if Z is None or Z>93:\\n raise ValueError(\\\"Invalid element / element number: %s. \\\"\\n \\\"(Only elements from H to U allowed).\\\"%str(Z))\\n energy = np.array(energy, ndmin=1)\\n diffE = np.unique(np.diff(energy))\\n if not len(diffE):\\n return deltaf.clcalc(Z, energy)\\n dE = abs(diffE.min())\\n fwhm_chan = abs(float(conv_fwhm))/dE/2.\\n # make equally spaced data:\\n if diffE.std()/diffE.mean() > 1e-5 and fwhm_chan>1e-2:\\n newenergy = np.arange(energy.min() - 10*dE, energy.max() + 10.*dE, dE)\\n do_interpolate = True\\n else:\\n newenergy = energy\\n do_interpolate = False\\n \\n f1, f2 = deltaf.clcalc(Z, newenergy)\\n if fwhm_chan>1e-2:\\n f1, f2 = deltaf.convl2(f1, f2, fwhm_chan)\\n if do_interpolate:\\n ffunc = interp1d(newenergy, (f1, f2))\\n f1, f2 = ffunc(energy)\\n return f1, f2\",\n \"def bethe_gf_omega(z, t=1.0):\\n half_bandwidth = 2 * t\\n z_rel = z / half_bandwidth\\n return 2. / half_bandwidth * z_rel * (1 - np.sqrt(1 - 1 / (z_rel * z_rel)))\",\n \"def full_freq_time(freqs, time_arr, Ref_param, dv):\\n Ref_all = pp.Reflectometer_Output(Ref_param.file_path, freqs, time_arr, \\n Ref_param.n_cross_section, \\n Ref_param.FWR_dimension, False, \\n Ref_param.receiver_file_name)\\n Ref_all.E_out = np.zeros((Ref_all.NF, Ref_all.NT, Ref_all.n_cross_section),\\n dtype='complex')\\n \\n parallel_param_list = [(f,t,Ref_param) for f in freqs for t in time_arr]\\n parallel_result = dv.map_async(single_freq_time, parallel_param_list)\\n print('Parallel runs started.')\\n parallel_result.wait_interactive()\\n print('All signals computed!')\\n E_out_scattered = parallel_result.get()\\n print('signals collected.')\\n for i in range(Ref_all.NF):\\n for j in range(Ref_all.NT):\\n Ref_all.E_out[i, j, :] = E_out_scattered[i*len(time_arr)+j][0, 0,:]\\n print(('freq {0},time {1} stored.'.format(freqs[i], time_arr[j])))\\n \\n return Ref_all\",\n \"def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\\n pi, ids = induced_distribution(hmsm, 0, level)\\n\\n discrete_free_energy = np.ndarray(pi.shape)\\n for i, id in enumerate(ids):\\n discrete_free_energy[i] = \\\\\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\\n boltzmann = np.exp(-discrete_free_energy/kT)\\n boltzmann *= (1/np.sum(boltzmann))\\n return D_KL(boltzmann, pi)\",\n \"def temperature_diff_wrapped(q: float,\\n delta_tc: np.ndarray,\\n T_r:np.ndarray,\\n order = 1) -> callable:\\n \\n def objective_function(T_cr: np.ndarray) -> np.ndarray:\\n\\n \\\"\\\"\\\"\\n the function to minimize in order to get the non-linear\\n relationship for the geometrically extrapolated cooled surface temperatures\\n \\\"\\\"\\\"\\n \\n Tm = (T_r + T_cr)/2.0\\n ks = thermal_conductivity(Tm)\\n T_cr_update = cooled_surface_temp_actual(T_r,q,delta_tc,ks)\\n \\n return np.linalg.norm(T_cr_update - T_cr,ord = 1)\\n \\n return objective_function\",\n \"def illuminationEff(freq,fD, FFBW, dB_at_bw, feed_type):\\n theta0 = fD2angle(fD,units='degrees')\\n dtt = 0.1\\n theta = np.arange(0.0,theta0/2.0+dtt,dtt)\\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\\n theta = theta*math.pi/180.0\\n kern = np.sqrt(g)*np.tan(theta/2.0)\\n num = 32.0*(fD*integ.trapz(kern,dx=dtt*math.pi/180.0))**2\\n kern = g*np.sin(theta)\\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n\\n n_ill = num/den \\n return n_ill\",\n \"def getHeatFlux(self, T):\\n\\t\\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\\n\\t\\treturn Q\",\n \"def manual_calc_kfs(wbwc_list, dec_list, timelen, timesteps):\\n global X0\\n global wbwc_kfs\\n global all_kfs\\n ####\\n t = np.linspace(0, timelen, timesteps)\\n ##\\n ## 1. set new wbwc rates\\n wbwc_kfs[wbwc_list[0]]['hf'] = wbwc_list[1][0]\\n wbwc_kfs[wbwc_list[0]]['hr'] = wbwc_list[1][1]\\n wbwc_kfs = fill_wbwc_dict(wbwc_kfs, fill='rates')\\n init() \\n #####\\n ## now, loop for each value of a rate const in dec_list\\n for k in dec_list[1]:\\n all_kfs[dec_list[0]] = k\\n kname = dec_list[0] + str(k)\\n ##\\n #init() \\n set_expdeg()\\n ode(calc_model, X0, t, stype='manual', dname = kname)\\n ###\",\n \"def coolingrate(tables, density, He_mass_frac=0.258, metallicity=0.25):\\n # list of all elements in table\\n elements = [\\n x for x in tables.keys() if x not in [\\n 'Header', 'Metal_free', 'Solar', 'Total_Metals']\\n ]\\n \\n # Helium mass fraction bins of only hydrogen and helium\\n metal_free_He_mass_frac = list(\\n tables['Metal_free']['Helium_mass_fraction_bins']\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of /Metal_free/Hydrogen_density_bins, \\n # /Metal_free/Temperature_bins, and helium abundance.\\n metal_free_ne_nh = list(\\n tables['Metal_free']['Electron_density_over_n_h']\\n )\\n \\n # Find index of He mass frac, ssuming direct match in table.\\n He_mass_frac_index = metal_free_He_mass_frac.index(np.float32(He_mass_frac))\\n # Find index of density bin, ssuming direct match in table.\\n abundance_index = list(\\n tables[elements[0]]['Hydrogen_density_bins']).index(np.float32(density)\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of temperature at given denisty and helium mass fraction.\\n metal_free_ne_nh = list(\\n tables['Metal_free']\\\\\\n ['Electron_density_over_n_h']\\\\\\n [He_mass_frac_index, :,abundance_index]\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of temperature at given density for solar abundance.\\n solar_ne_nh = tables['Solar']\\\\\\n ['Electron_density_over_n_h']\\\\\\n [:, abundance_index]\\n\\n # Normalized net cooling rate for only hydrogen and helium as a function of \\n # /Metal_free/Hydrogen_density_bins, /Metal_free/Temperature_bins, \\n # and helium abundance. \\n lambda_metal_free = tables['Metal_free']\\\\\\n ['Net_Cooling']\\\\\\n [He_mass_frac_index, :, abundance_index]\\n \\n # Temperature bins (T [K])\\n T = tables['Metal_free']['Temperature_bins']\\n \\n sum_metals = np.zeros(352)\\n for e in elements:\\n # Normalized, net cooling rate e as a function of temperature for \\n # Hydrogen density 'density'.\\n lambda_i_solar = tables[e]['Net_Cooling'][:,abundance_index]\\n \\n # Calulating the cooling contribution of element e and addind to total.\\n sum_metals += lambda_i_solar*(metal_free_ne_nh/solar_ne_nh)*metallicity\\n \\n coolingrate = lambda_metal_free + sum_metals\\n \\n return T, coolingrate\",\n \"def get_dom_freq(Fk, freq, n_freq):\\n\\n #get the magnitude of the coefficients\\n Fk_abs = np.abs(Fk)\\n #sort the coefficients in descending order\\n Fk_sort = sorted(Fk_abs, reverse=True)\\n \\n dom_Fk = []\\n dom_f = []\\n i = 0\\n while i < n_freq:\\n inds = np.where(Fk_abs == Fk_sort[i])\\n for ind in inds:\\n dom_f.append(freq[ind])\\n dom_Fk.append(Fk[ind])\\n i += 1\\n \\n #sort based on frequency from lo to hi\\n #convert from numpy float to python float for mapping\\n dom_f = [float(abs(f)) for f in dom_f]\\n f_Fk = dict(zip(dom_f,dom_Fk))\\n f_sorted = sorted(dom_f)\\n # return(dom_f, f_Fk, f_sorted, dom_Fk)\\n\\n\\n dom_Fk = []\\n for f in f_sorted:\\n dom_Fk.append(f_Fk[f][0])\\n \\n return np.array(dom_Fk), np.array(f_sorted)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71285737","0.6478923","0.6444968","0.5749547","0.56793684","0.5572982","0.54065436","0.53827864","0.5258031","0.5257182","0.52520823","0.519607","0.50965065","0.49622813","0.49369383","0.49278474","0.48772767","0.4856664","0.48498905","0.48304605","0.47984362","0.4784245","0.47806558","0.47791317","0.47772184","0.4770326","0.47618812","0.47577026","0.4752542","0.47483188","0.47401616","0.47071993","0.47017696","0.470056","0.46937975","0.46551055","0.46485546","0.46305","0.46244547","0.4622927","0.46210665","0.4619059","0.4618524","0.4614079","0.45927462","0.4585308","0.45830005","0.45825583","0.4575404","0.45666832","0.45650762","0.45530978","0.4552113","0.45410198","0.45386735","0.45348355","0.45262238","0.45254368","0.45192406","0.45162132","0.4512261","0.4508131","0.4499585","0.44932663","0.44913548","0.44895315","0.44817245","0.4476624","0.44745436","0.4471271","0.44702715","0.44685984","0.4464995","0.44644907","0.44636646","0.44613934","0.4460152","0.44595444","0.44563913","0.4454317","0.44539267","0.44503254","0.44463664","0.44449806","0.4441538","0.44361624","0.4433457","0.44274428","0.44262338","0.4422441","0.44215885","0.4420036","0.44157824","0.4414233","0.44119635","0.44113064","0.44106963","0.44042838","0.43951464","0.43899578"],"string":"[\n \"0.71285737\",\n \"0.6478923\",\n \"0.6444968\",\n \"0.5749547\",\n \"0.56793684\",\n \"0.5572982\",\n \"0.54065436\",\n \"0.53827864\",\n \"0.5258031\",\n \"0.5257182\",\n \"0.52520823\",\n \"0.519607\",\n \"0.50965065\",\n \"0.49622813\",\n \"0.49369383\",\n \"0.49278474\",\n \"0.48772767\",\n \"0.4856664\",\n \"0.48498905\",\n \"0.48304605\",\n \"0.47984362\",\n \"0.4784245\",\n \"0.47806558\",\n \"0.47791317\",\n \"0.47772184\",\n \"0.4770326\",\n \"0.47618812\",\n \"0.47577026\",\n \"0.4752542\",\n \"0.47483188\",\n \"0.47401616\",\n \"0.47071993\",\n \"0.47017696\",\n \"0.470056\",\n \"0.46937975\",\n \"0.46551055\",\n \"0.46485546\",\n \"0.46305\",\n \"0.46244547\",\n \"0.4622927\",\n \"0.46210665\",\n \"0.4619059\",\n \"0.4618524\",\n \"0.4614079\",\n \"0.45927462\",\n \"0.4585308\",\n \"0.45830005\",\n \"0.45825583\",\n \"0.4575404\",\n \"0.45666832\",\n \"0.45650762\",\n \"0.45530978\",\n \"0.4552113\",\n \"0.45410198\",\n \"0.45386735\",\n \"0.45348355\",\n \"0.45262238\",\n \"0.45254368\",\n \"0.45192406\",\n \"0.45162132\",\n \"0.4512261\",\n \"0.4508131\",\n \"0.4499585\",\n \"0.44932663\",\n \"0.44913548\",\n \"0.44895315\",\n \"0.44817245\",\n \"0.4476624\",\n \"0.44745436\",\n \"0.4471271\",\n \"0.44702715\",\n \"0.44685984\",\n \"0.4464995\",\n \"0.44644907\",\n \"0.44636646\",\n \"0.44613934\",\n \"0.4460152\",\n \"0.44595444\",\n \"0.44563913\",\n \"0.4454317\",\n \"0.44539267\",\n \"0.44503254\",\n \"0.44463664\",\n \"0.44449806\",\n \"0.4441538\",\n \"0.44361624\",\n \"0.4433457\",\n \"0.44274428\",\n \"0.44262338\",\n \"0.4422441\",\n \"0.44215885\",\n \"0.4420036\",\n \"0.44157824\",\n \"0.4414233\",\n \"0.44119635\",\n \"0.44113064\",\n \"0.44106963\",\n \"0.44042838\",\n \"0.43951464\",\n \"0.43899578\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7382771"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88356,"cells":{"query":{"kind":"string","value":"Return the first derivative of the heat capacity with respect to the hindered rotor frequency in J/molK/cm^1 at the given set of temperatures `Tlist` in K, evaluated at the frequency `freq` in cm^1 and a barrier height `barr` in cm^1."},"document":{"kind":"string","value":"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr"},"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 hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq","def hinderedRotor_heatCapacity(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)","def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq","def planck_B_nu(freq, T):\n import numpy as np\n from astropy import units as u\n from astropy import constants as c\n\n if isinstance(T, u.quantity.Quantity):\n use_units = True\n else:\n T = T * u.K\n use_units = False\n\n if not isinstance(freq, u.quantity.Quantity):\n freq *= u.Hz\n\n T = np.array(T.value, ndmin=1) * T.unit\n freq = np.array(freq.value, ndmin=1) * freq.unit\n\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\n exp = np.maximum(exp, -mx)\n\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\n\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\n if use_units:\n return output.to(cgsunit).squeeze()\n else:\n return output.to(cgsunit).value.squeeze()","def harmonicOscillator_heatCapacity(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x","def thermal(isatom, freq, scalfac,linnonlin,T):\n if isatom != \"true\":\n nfreq = len(freq)\n\n vib_temp = []\n for ifreq in range(nfreq):\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\n vib_temp.append(vib_temp_new)\n\n dE_vib = 0\n for ifreq in range(nfreq):\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\n\n dE_ZPE = 0.5 * sum(freq) * cmi2au\n\n if linnonlin == \"L\":\n dE_rot = kB * T * j2au\n elif linnonlin == \"NL\":\n dE_rot = kB * T * j2au * (3.0/2.0)\n else:\n with open(\"Thermochemistry.out\", \"a\") as ther_chem:\n ther_chem.write(\"ERROR: unknown entry for linear/nonlinear\")\n else:\n dE_ZPE = 0\n dE_vib = 0\n dE_rot = 0\n\n dE_tra = kB * T * j2au * (3.0/2.0)\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\n\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy","def getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy","def heat_capacity(r, phi, q, kT):\n pot = q*(phi - phi[0])\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\n c = np.trapz(np.exp(-pot/kT) * r, r)\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)","def rangerate_from_freq(freq,Fc):\n # print(f'freq {freq} Fc {Fc}')\n dopp_at_IF = freq - Fc\n return dopp_at_IF*scipy.constants.speed_of_light/Fc","def Hertz_dipole_ff (r, p, R, phi, f, t=0, epsr=1.):\r\n nf = len(f)\r\n rprime = r-R # r'=r-R\r\n if ndim(p) < 2:\r\n magrprime = sqrt(sum((rprime)**2))\r\n magrprimep = tile(magrprime, (len(f),1)).T\r\n phip = tile(phi, (len(f),1))\r\n w = 2*pi*f # \\omega\r\n k = w/c # wave number\r\n krp = k*magrprimep # k|r'|\r\n rprime_cross_p = cross(rprime, p) # r'x p\r\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\r\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\r\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[0],(nf,1))).T\r\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[1],(nf,1))).T\r\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[2],(nf,1))).T\r\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[0],(nf,1)).T)\r\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[1],(nf,1)).T)\r\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[2],(nf,1)).T)\r\n E = vstack((Ex,Ey,Ez))\r\n B = vstack((Bx,By,Bz))\r\n else:\r\n magrprime = sqrt(sum((rprime)**2,axis=1)) # |r'|\r\n magrprimep = tile(magrprime, (len(f),1)).T\r\n phip = tile(phi, (len(f),1))\r\n fp = tile(f,(len(magrprime),1))\r\n w = 2*pi*fp # \\omega\r\n k = w/c # wave number\r\n krp = k*magrprimep # k|r'|\r\n rprime_cross_p = cross(rprime, p) # r'x p\r\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\r\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\r\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,0],(nf,1))).T\r\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,1],(nf,1))).T\r\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,2],(nf,1))).T\r\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,0],(nf,1)).T)\r\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,1],(nf,1)).T)\r\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,2],(nf,1)).T)\r\n E = vstack((sum(Ex,axis=0),sum(Ey,axis=0),sum(Ez,axis=0)))\r\n B = vstack((sum(Bx,axis=0),sum(By,axis=0),sum(Bz,axis=0)))\r\n return E,B","def compute_energy_density(kT):\n h=u.planck\n c=u.speed_of_light\n pi=np.pi\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)","def fuel_cond(T):\n\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\n \n return kc","def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\n kB = 1.380658e-16\n h = 6.6260755e-27\n c = 29979245800.\n nu = freqGHz*1.e9\n x = h*nu/(kB*T0)\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\n cNu *= 1e23\n return cNu","def gyroHF(self, GYRO, PFC):\n print(\"Calculating gyro orbit heat loads\")\n log.info(\"Calculating gyro orbit heat loads\")\n #get divertor HF\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\n #Get fractional multipliers for each helical trace\n gyroFrac = 1.0/GYRO.N_gyroPhase\n vPhaseFrac = 1.0/GYRO.N_vPhase\n vSliceFrac = GYRO.energyFracs\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\n Pgyro = np.zeros((GYRO.Nt))\n PNaN = 0.0\n sum=0\n sum1=0\n #loop through intersect record and redistribute power using multipliers\n for gyroPhase in range(GYRO.N_gyroPhase):\n for vPhase in range(GYRO.N_vPhase):\n for vSlice in range(GYRO.N_vSlice):\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\n notNanTo = notNanTo.astype(int) #cast as integer\n isNanTo = idx[np.isnan(idx)] #indices we map power to\n isNanTo = isNanTo.astype(int) #cast as integer\n\n if len(notNanFrom)>0:\n #multiple Froms can light up the same To, so we loop\n for i in range(len(notNanFrom)):\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\n\n if len(isNanFrom)>0:\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\n\n #print(\"\\nTEST2\")\n #print(GYRO.intersectRecord[0,0,0,1711])\n #print(Pgyro[1711])\n\n GYRO.gyroPowMatrix += Pgyro\n GYRO.gyroNanPower += PNaN\n return","def calc_dtdc(tpbpcs, specs):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n Nbs = len(np.hstack(tpbpcs[0]))\n Ndraw = len(tpbpcs)\n\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\n\n for i in range(Ndraw):\n\n # Create array of times per bandpass\n dtpb[i,:] = np.hstack(tpbpcs[i])\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def get_granule_frequency(self,r=None,ids=None):\n # Simply divide the length of each spike vector by the simulation time\n # or window time.\n spikes=[] # The local copy of spikes to get the frequency on\n try:\n spikes=self.get_granule_spikes(r,ids)\n if len(spikes)==0:\n raise Exception('Unable to get mitral cell spikes')\n except Exception:\n raise\n freqg=numpy.zeros(self.num_gran)\n timems=self.sim_time\n if type(r) is tuple and len(r)==2:\n timems=float(r[1]-r[0])\n for i in range(len(spikes)):\n freqg[i]=float(len(spikes[i]))*1000./timems\n return freqg","def calc_dtdc_star(tpbpc0, spec):\n\n # Calc wavelength range of channels\n deltas = []\n for channel in CHANNELS:\n l = default_luvoir(channel=channel)\n deltas.append(l.lammax - l.lammin)\n deltas = np.array(deltas)\n\n # Create array of times per bandpass\n dtpb = np.hstack(tpbpc0)\n\n Nbs = len(dtpb)\n dcomp = np.zeros(Nbs) # completeness\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\n\n for j in range(Nbs):\n\n # Calculate delta completeness: fractional increase in completeness from observing this band\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\n\n # Calculate d(exposure time) / d(completeness)\n dtdc = dtpb / dcomp\n\n return dtpb, dcomp, dtdc","def getHeatCapacity(self, Tlist, V=1.0):\n\t\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)","def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \n av = akv * 1e3 # Convert kilovots to volts\n cs = cs * 1e7 # Convert spherical aberation from mm to A\n \n # wavelength of electrons\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\n \n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\n wgh2 = dscale*wgh\n\n ix = freqs[:,0]\n iy = freqs[:,1]\n freq_radius = n.sqrt(ix**2 + iy**2)\n\n angle = elambda*freq_radius\n angspt = n.arctan2(iy,ix)\n if rots is not None:\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\n angle = angle.reshape((-1,1)) \n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\n c2 = -c1*cs*angle**2/2.0\n angdif = angspt - angastf\n ccos = n.cos(2.0*angdif)\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\n chi = c1*df + c2\n\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\n \n if bfactor is not None:\n ctf *= envelope_function(freq_radius, bfactor)\n\n return n.require(ctf,dtype = freqs.dtype)","def CMB_spec(eng, temp):\n if np.issubdtype(type(eng), float):\n eng = np.array([eng])\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\n\n if np.issubdtype(type(eng), float): \n return phot_spec_density[0] \n else: \n return phot_spec_density","def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\n if len(Tlist) != len(Cvlist):\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\n\n # The number of optimization variables available is constrained to be less\n # than the number of heat capacity points\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\n maxVariables = len(Tlist) - 1\n if maxVariables > 16: maxVariables = 16\n\n # The type of variables fitted depends on the values of Nvib and Nrot and\n # the number of heat capacity points provided\n # For low values of Nvib and Nrot, we can fit the individual\n # parameters directly\n # For high values of Nvib and/or Nrot we are limited by the number of\n # temperatures we are fitting at, and so we can only fit\n # pseudo-oscillators and/or pseudo-rotors\n vib = []; hind = []\n if Nvib <= 0 and Nrot <= 0:\n pass\n elif Nvib + 2 * Nrot <= maxVariables:\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\n elif Nvib + 2 <= maxVariables:\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\n else:\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\n\n modes = []\n if Nvib > 0:\n vib.sort()\n ho = HarmonicOscillator(frequencies=(vib[:],\"cm^-1\"))\n modes.append(ho)\n for i in range(Nrot):\n freq = hind[i][0]\n barr = hind[i][1]\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\n barrier = barr*constants.c*100.0*constants.h*constants.Na\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\"amu*angstrom^2\"), barrier=(barrier/1000.,\"kJ/mol\"), symmetry=1, semiclassical=False, quantum=False)\n modes.append(hr)\n\n # Return the fitted modes\n return modes","def get_F_potential(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n # y = chemical_potential/temperature\n y = chemical_potential / tt\n F = gbar / np.sqrt(2.0) / np.pi ** 2 * tt ** (2.5) * vv\n F *= y * _1d_call(_fdk, y, k=0.5) - 2.0 / 3.0 * _1d_call(_fdk, y, k=1.5)\n return F","def DFTscargle(times, signal,f0,fn,df):\n f0 = 0.\n #fn *= 2*np.pi\n #df *= 2*np.pi\n #-- initialize\n nfreq = int((fn-f0)/(df))\n print \"Nfreq=\",nfreq\n tzero = times[0]\n si = 1.\n lfreq = 2*nfreq+1\n mm = 2*nfreq\n ftrx = np.zeros(mm)\n ftix = np.zeros(mm)\n om = np.zeros(mm)\n w = np.zeros(mm)\n wz = df #pi/(nn+dt)\n nn = len(times)\n \n #-- calculate DFT\n ftrx,ftix,om,w = pydft.ft(signal,times,wz,nfreq,si,lfreq,tzero,df,ftrx,ftix,om,w,nn,mm)\n \n if f0==0:\n ftrx[1:] *= np.sqrt(2)\n ftix[1:] *= np.sqrt(2)\n w[1:] *= np.sqrt(2)\n \n cut_off = len(w)\n for i in range(0,len(w))[::-1]:\n if w[i] != 0: cut_off = i+1;break\n \n om = om[:cut_off]\n ftrx = ftrx[:cut_off]\n ftix = ftix[:cut_off]\n w = w[:cut_off]\n \n # norm amplitudes for easy inversion\n T = times[-1]-times[0]\n N = len(times)\n \n w *= T/(2.*N)\n ftrx *= T/(2.*N)\n ftix *= T/(2.*N)\n \n return om*2*np.pi,w,ftrx,ftix","def frfplot(freq, H, freq_min=0, freq_max=None, type=1, legend=[]):\n FLAG = type # Plot type, should libe renamed throughout.\n freq = freq.reshape(1, -1)\n lenF = freq.shape[1]\n if len(H.shape) is 1:\n H = H.reshape(1, -1)\n\n if H.shape[0] > H.shape[1]:\n H = H.T\n\n if freq_max is None:\n freq_max = np.max(freq)\n\n if freq_min is None:\n freq_min = np.min(freq)\n\n if freq_min < np.min(freq):\n freq_min = np.min(freq)\n\n if freq_min > freq_max:\n raise ValueError('freq_min must be less than freq_max.')\n\n # print(str(np.amin(freq)))\n inlow = int(lenF * (freq_min - np.amin(freq)\n ) // (np.amax(freq) - np.amin(freq)))\n\n inhigh = int(lenF * (freq_max - np.amin(freq)\n ) // (np.amax(freq) - np.amin(freq)) - 1)\n # if inlow<1,inlow=1;end\n # if inhigh>lenF,inhigh=lenF;end\n \"\"\"print('freq shape: {}'.format(freq.shape))\n print('H shape: {}'.format(H.shape))\n print('Index of low frequency: {}'.format(inlow))\n print('Index of high frequency: {}'.format(inhigh))\"\"\"\n H = H[:, inlow:inhigh]\n # print(H.shape)\n freq = freq[:, inlow:inhigh]\n mag = 20 * np.log10(np.abs(H))\n # print(mag)\n # print(mag.shape)\n minmag = np.min(mag)\n maxmag = np.max(mag)\n phase = np.unwrap(np.angle(H)) * 180 / np.pi\n # phmin_max=[min(phase)//45)*45 ceil(max(max(phase))/45)*45];\n phmin = np.amin(phase) // 45 * 45.0\n phmax = (np.amax(phase) // 45 + 1) * 45\n \"\"\"minreal = np.amin(np.real(H))\n maxreal = np.amax(np.real(H))\n minimag = np.amin(np.imag(H))\n maximag = np.amax(np.imag(H))\"\"\"\n\n if FLAG is 1:\n fig, (ax1, ax2) = plt.subplots(2, 1)\n ax1.plot(freq.T, mag.T)\n ax1.set_xlabel('Frequency (Hz)')\n ax1.set_ylabel('Mag (dB)')\n ax1.grid()\n ax1.set_xlim(xmax=freq_max, xmin=freq_min)\n ax1.set_ylim(ymax=maxmag, ymin=minmag)\n\n ax2.plot(freq.T, phase.T)\n ax2.set_xlabel('Frequency (Hz)')\n ax2.set_ylabel('Phase (deg)')\n ax2.grid()\n ax2.set_xlim(xmax=freq_max, xmin=freq_min)\n ax2.set_ylim(ymax=phmax, ymin=phmin)\n ax2.set_yticks(np.arange(phmin, (phmax + 45), 45))\n fig.tight_layout()\n\n if len(legend) > 0:\n plt.legend(legend)\n ax = (ax1, ax2)\n else:\n print(\"Sorry, that option isn't supported yet\")\n return ax\n\n \"\"\"# elif FLAG==2:\n # subplot(2,1,1)\n # semilogx(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # % Fmin,Fmax,min(mag),max(mag)\n # axis([Fmin Fmax minmag maxmag])\n\n # subplot(2,1,2)\n # semilogx(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n\n # elif FLAG==3:\n # subplot(2,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F*2*pi,mag)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Wmin Wmax minmag maxmag])\n # zoom on\n # subplot(2,1,2)\n # semilogx(F*2*pi,phase)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n\n # elseif FLAG==4\n # subplot(2,1,1)\n # plot(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # subplot(2,1,2)\n # plot(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==5\n # subplot(1,1,1)\n # imax=round(length(F)*Fmax/max(F));\n # imin=round(length(F)*Fmin/max(F))+1;\n # plot(real(Xfer(imin:imax)),imag(Xfer(imin:imax)))\n # xlabel('Real')\n # ylabel('Imaginary')\n # grid on\n # zoom on\n # elseif FLAG==6\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # plot(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # elseif FLAG==7\n # subplot(1,1,1)\n # plot(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # elseif FLAG==8\n # subplot(1,1,1)\n # plot(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # elseif FLAG==9\n # subplot(1,1,1)\n # plot(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==10\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # elseif FLAG==11\n # subplot(1,1,1)\n # semilogx(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # elseif FLAG==12\n # subplot(1,1,1)\n # semilogx(F,real(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Real')\n # grid on\n # axis([Fmin Fmax minreal maxreal])\n # zoom on\n # elseif FLAG==13\n # subplot(1,1,1)\n # semilogx(F,imag(Xfer))\n # xlabel('Frequency (Hz)')\n # ylabel('Imaginary')\n # grid on\n # axis([Fmin Fmax minimag maximag])\n # zoom on\n # elseif FLAG==14\n # subplot(1,1,1)\n # mag=20*log10(abs(Xfer));\n # semilogx(F*2*pi,mag)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Wmin Wmax minmag maxmag])\n # zoom on\n # elseif FLAG==15\n # subplot(1,1,1)\n # semilogx(F*2*pi,phase)\n # xlabel('Frequency (Rad/s)')\n # ylabel('Phase (deg)')\n # grid on\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n # else\n # subplot(2,1,1)\n # mag=20*log10(abs(Xfer));\n # plot(F,mag)\n # xlabel('Frequency (Hz)')\n # ylabel('Mag (dB)')\n # grid on\n # axis([Fmin Fmax minmag maxmag])\n # zoom on\n # subplot(2,1,2)\n # plot(F,phase)\n # xlabel('Frequency (Hz)')\n # ylabel('Phase (deg)')\n # grid on\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\n # gridmin_max=round(phmin_max/90)*90;\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\n # zoom on\n \"\"\"","def fcut(r, rcut, trans_width):\n if (isinstance(r, list) or isinstance(r, np.ndarray)) and len(r) > 1:\n return np.array([fcut(ri, rcut, trans_width) for ri in r])\n else:\n if r > rcut:\n return 0.\n elif r > rcut-trans_width:\n return 0.5*(np.cos(np.pi*(r-rcut+trans_width)/trans_width) + 1)\n else:\n return 1.0","def butterworth_filter(freq):\n\tf_raw = 1/(0.00000002*100*33)\n\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\n\tomega = 2*np.pi*freq/f_raw\n\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\n\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\n\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16","def gyroHF2(self, GYRO, PFC):\n print(\"Calculating gyro orbit heat loads\")\n log.info(\"Calculating gyro orbit heat loads\")\n #get divertor HF\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\n #Get fractional multipliers for each helical trace\n gyroFrac = 1.0/GYRO.N_gyroPhase\n vPhaseFrac = 1.0/GYRO.N_vPhase\n vSliceFrac = GYRO.energyFracs\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\n Pgyro = np.zeros((GYRO.Nt))\n PNaN = 0.0\n sum=0\n sum1=0\n #loop through intersect record and redistribute power using multipliers\n for gyroPhase in range(GYRO.N_gyroPhase):\n for vPhase in range(GYRO.N_vPhase):\n for vSlice in range(GYRO.N_vSlice):\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\n hdotn = np.abs(GYRO.hdotn[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap])\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\n notNanTo = notNanTo.astype(int) #cast as integer\n isNanTo = idx[np.isnan(idx)] #indices we map power to\n isNanTo = isNanTo.astype(int) #cast as integer\n\n if len(notNanFrom)>0:\n #multiple sources can load the same target face, so we loop\n for i in range(len(notNanFrom)):\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\n\n if len(isNanFrom)>0:\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\n\n\n GYRO.gyroPowMatrix += Pgyro\n GYRO.gyroNanPower += PNaN\n return","def butter_hpf(highcut, fs, order):\n nyq = 0.5 * fs\n high = highcut / nyq\n b, a = signal.butter(order, high, btype='highpass')\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n pad=np.random.rand(nspad)/100\n trc_norm=trc/np.amax(np.abs(trc))\n trc_norm_padded=np.hstack((pad,trc_norm))\n trc_entropy=self.entropy(trc_norm_padded,50)\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\n for i,j in enumerate(trc):\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def stepfall(double[:] v, redshifts, in_terms, double H0):\n\n cdef double t = v[0]\n cdef double a = v[1]\n # ombar_i = rho_i(t) / rho_crit(t0)\n cdef double ombar_m = v[2]\n cdef double ombar_r = v[3]\n cdef double ombar_a = v[4]\n cdef double ombar_de = v[5]\n cdef double z = v[6]\n cdef double dl = v[7]\n\n cdef double in_v = in_terms[0]\n cdef double in_w = in_terms[1]\n cdef double in_x = in_terms[2]\n\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_a +ombar_de)**(0.5)\n\n# if ombar_m < 0 or ombar_de < 0 or ombar_r < 0 or ombar_a < 0:\n# print('stepfall')\n# print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\n# print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\n# 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\n\n if math.isnan(Hz):\n print('stepfall')\n print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\n print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\n 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\n\n cdef double dtdz = -1.0/((1.0+z) * Hz)\n cdef double dadz = -(1.0+z)**(-2.0)\n # d(ombar_i)/dz\n cdef double domdz = (3.0*ombar_m +in_v*ombar_m*ombar_r/Hz)/(1.0+z) # w = 0\n cdef double dordz = (4.0*ombar_r -in_v*ombar_m*ombar_r/Hz +in_w*ombar_r*ombar_a/Hz)/(1.0+z) # w = 1/3\n cdef double doadz = (2.7*ombar_a -in_w*ombar_r*ombar_a/Hz +in_x*ombar_a*ombar_de/Hz)/(1.0+z) # w = -0.1\n cdef double dodedz = -in_x*ombar_a*ombar_de/(1.0+z)/Hz # w = -1\n cdef double ddldz = 1.0/Hz\n\n # first derivatives of functions I want to find:\n f = [dtdz, # time\n dadz, # scale factor\n domdz, # w = 0\n dordz, # w = 1/3\n doadz, # w = -0.1\n dodedz,# w = -1\n 1.0, # redshift\n ddldz] # luminosty distance\n\n return f","def fourierBeam(self, centres, u_bl, v_bl, frequency, min_attenuation = 1e-10, N = 20):\n \n a = 1/ (2 * self._instr_core.sigma(frequency)**2)\n \n indx_u = np.digitize(u_bl, centres)\n indx_v = np.digitize(v_bl, centres)\n \n beam = []\n \n for jj in range(len(u_bl)):\n x, y = np.meshgrid(centres[indx_u[jj]-int(N/2):indx_u[jj]+int(N/2)], centres[indx_v[jj]-int(N/2):indx_v[jj]+int(N/2)],copy=False)\n B = (np.exp(- ((x - u_bl[jj])**2 + (y - v_bl[jj])**2 )/ a)).T\n B[B<min_attenuation] = 0\n beam.append(B)\n \n indx_u+= -int(N/2)\n indx_v+= -int(N/2)\n \n indx_u[indx_u<0] = 0\n indx_v[indx_v<0] = 0 \n \n return beam, indx_u, indx_v","def doCalculation(self, E1, E2, muL, muR, T, pot, C, TCalc, Density, E0, L):\n NEcut = len(E1) #we determine the number of single-particle states that we use\n VG=np.diag(pot)\n E= int(0.5*np.size(VG))\n V = VG[0:E] #since the potential of both barriers is symmetric and we only tunnel through one barrier. Therefore we only use one half of the potential.\n dx= L/(np.size(pot))\n\n #Following prints are for debugging purposes:\n #print(\"---------------------------------------------------------------------\")\n #print(\"---------------------------------------------------------------------\")\n #print(\"Hier beginnt die Ausgabe von Rates:\")\n #print(\"---------------------------------------------------------------------\")\n #print(\"V:\", V)\n #print(\"E1:\", E1)\n #print(\"E2:\", E2)\n #print(\"C:\", C)\n\n kB=0.08629 #Boltzmann constant in meV/K\n \n \n def fermi(E,mu,T):\n \"\"\"This fermi-function tells us with which likelyhood a state with an E is occupied on the lead.\n E(float): energy difference between the initial and the final state that the tunneling electron has to carry.\n mu(float): chemical potential of either drain(muR) or source(muL).\n T(float): temperature.\n \"\"\"\n if (E-mu)/T > 600:\n f=0\n\t\t\t\t\n else:\n f=1/(math.exp((E-mu)/(kB*T) )+1)\n return(f)\n \n\n\t#This function is called by the Gamma_ij-equations and includes the transmission-coefficient for each tunnelling-event\n #and the density of state function of the source and drain. \n def Gamma(Ea,Eb,V):\n \"\"\":math:`\\\\Gamma` includes the transmission coefficient and DOS: :math:`\\Gamma = | t |^2 * DOS`\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n V(np.array): barrier potential\n \"\"\"\n #print(Ea)\n #print(V)\n return (np.absolute(TCalc.calculate_transmission(Ea,V,dx))**2*Density.calculate_DensityofStates(np.absolute(Ea-Eb)))\n \n #These next four functions are used to calculate the transition rates.Each function for a different kind of transition:\n #We distinguish between transitions, in which the number of electrons on the dot changes from one to two(Gamma_12) and reverse(Gamma_21).\n #And between transitions in which the number of electrons on the dot change from zero to one(Gamma_01) and reverse(Gamma_10).\n\n def Gamma_12(Ea,Eb,mu,T):\n \"\"\"Calculates the rate of a transition from a one body state to a two body state.\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n summe=0\n j=0\n Cb=C[np.where(E2==Eb)[0][0]]\n while j< NEcut:\n summe=Cb[np.where(E1==Ea)[0][0]][j]+summe\n j=j+1\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*fermi((Eb-Ea),mu,T))\n\n\n def Gamma_01(Eb,mu,T):\n \"\"\"Calculates the transition rate from the vacuum state to a one-body state.\n\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n return(Gamma(E0,Eb,V)*fermi((Eb-E0),mu,T))\n\n def Gamma_21(Ea,Eb,mu,T):\n \"\"\"Calculates the rate of a transition from a two body state to a one body state.\n\n Ea(float): energy of initial state\n Eb(float): energy of final state\n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n summe=0\n nu=0\n Ca=C[np.where(E2==Ea)[0][0]]\n while nu < NEcut:\n summe=summe+Ca[np.where(E1==Eb)[0][0]][nu]\n nu=nu+1\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*(1-fermi((Ea-Eb),mu,T)))\n\n def Gamma_10(Ea,mu,T):\n \"\"\"Calculates the rate of a transition from a one body state to the vacuum state.\n\n Ea(float): energy of initial state \n mu(float): chemical potential of either drain(muR) or source(muL)\n T(float): temperature\n \"\"\"\n return(Gamma(Ea,E0,V)*(1-fermi((Ea-E0),mu,T)))\n\n #creating the output matrices that later contain all the transition rates through either\n #the left or the right barrier\n Gamma_R=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\n Gamma_L=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\n\n #using a loop to fill the output matrices with transition rates.\n i_=0\n for i in E1:\n j_=0\n for j in E2:\n Gamma_L[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muL,T)\n Gamma_L[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muL,T)\n Gamma_R[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muR,T)\n Gamma_R[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muR,T)\n j_=j_+1\n Gamma_L[0][i_+1]=Gamma_10(i,muL,T)\n Gamma_R[0][i_+1]=Gamma_10(i,muR,T)\n Gamma_L[i_+1][0]=Gamma_01(i,muL,T)\n Gamma_R[i_+1][0]=Gamma_01(i,muR,T)\n i_=1+i_\n\n #print(\"Gamma_L und Gamma_R:\")\n #print(Gamma_L,Gamma_R)\n #print(\"-----------------------------------------------------------------------\")\n #print(\"---------------------------------------------------------------------\")\n return(Gamma_L,Gamma_R)","def thermodynamic_temperature(frequency, T_cmb=None):\n nu = frequency.to(si.GHz, spectral())\n\n if T_cmb is None:\n from astropy.cosmology import default_cosmology\n\n T_cmb = default_cosmology.get().Tcmb0\n\n def f(nu, T_cmb=T_cmb):\n x = _si.h * nu / _si.k_B / T_cmb\n return x**2 * np.exp(x) / np.expm1(x) ** 2\n\n def convert_Jy_to_K(x_jybm):\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\n astrophys.Jy\n )\n return x_jybm / factor\n\n def convert_K_to_Jy(x_K):\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\n si.K\n )\n return x_K / factor\n\n return Equivalency(\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\n \"thermodynamic_temperature\",\n {\"frequency\": frequency, \"T_cmb\": T_cmb},\n )","def mce_filter(freq, f_raw, params):\n\tz = np.exp(-2j*np.pi*freq/f_raw)\n\tb11, b12, b21, b22 = np.array(params[:4])*0.5**14\n\tH = (1+z)**4 / (1-b11*z+b12*z**2) / (1-b21*z+b22*z**2)\n\tH /= 2**4 / (1-b11+b12) / (1-b21+b22)\n\treturn H","def torch_mel_to_hertz(frequencies_mel):\r\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\r\n return _MEL_BREAK_FREQUENCY_HERTZ * (\r\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)","def exotic(double[:] v, redshifts, in_terms, double H0):\n\n cdef double t = v[0]\n cdef double a = v[1]\n cdef double ombar_m = v[2]\n cdef double ombar_r = v[3]\n cdef double ombar_de = v[4]\n cdef double z = v[5]\n cdef double dl = v[6]\n cdef double gamma = in_terms[0]\n cdef double zeta = in_terms[1]\n\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_de)**(0.5)\n\n# if ombar_m < 0 or ombar_de < 0:\n# print('exotic')\n# print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\n# print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\n# % (ombar_m, ombar_r, ombar_de))\n\n if math.isnan(Hz):\n print('exotic')\n print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\n print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\n % (ombar_m, ombar_r, ombar_de))\n\n cdef double dtdz = -1.0/((1.0+z) * Hz)\n cdef double dadz = -(1.0+z)**(-2.0)\n cdef double domdz = (3.0*ombar_m +gamma*ombar_m*ombar_r /Hz) /(1.0+z)\n cdef double dordz = (4.0*ombar_r -(gamma*ombar_m*ombar_r -zeta*ombar_r*ombar_de) /Hz ) /(1.0+z)\n cdef double dodedz = -zeta*ombar_r*ombar_de/(1.0+z) /Hz\n cdef double ddldz = 1.0/Hz\n\n # first derivatives of functions I want to find:\n f = [dtdz,# dt/dz (= f.d wrt z of time)\n dadz,# d(a)/dz (= f.d wrt z of scale factor)\n domdz,# dw = 0, (ombar_m)/dz (= f.d wrt z of density_m(t) / crit density(t0))\n dordz,# w = 1/3, d(ombar_r)/dz (= f.d wrt z of density_r(t) / crit density(t0))\n dodedz,# w = -1, d(ombar_de)/dz (= f.d wrt z of density_de(t) / crit density(t0))\n 1.0,# d(z)/dz (= f.d wrt z of redshift)\n ddldz]# d(dl)/dz (= f.d wrt z of luminosty distance) # H + Hdz*(1+z)\n\n return f","def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\n # low temperatures - high numbers\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)","def get_rec_rate_H_caseB_Dr11(T):\n T4 = T*1e-4\n return 2.54e-13*T4**(-0.8163 - 0.0208*np.log(T4))","def lrelfreq(inlist,numbins=10,defaultreallimits=None):\r\n h,l,b,e = histogram(inlist,numbins,defaultreallimits)\r\n for i in range(len(h)):\r\n h[i] = h[i]/float(len(inlist))\r\n return h,l,b,e","def getHeatCapacity(self, Tlist):\n\t\tCp = np.ones((len(Tlist)), np.float64)\n\t\tfor mode in self.modes:\n\t\t\tCp += mode.getHeatCapacity(Tlist)\n\t\treturn Cp","def __init__(self, N=1024, fc=50., tmax=1., delay=None):\n fc = float(fc)\n tmax = float(tmax)\n dt = tmax / (N-1)\n df = 1. / tmax\n istart = -N//2 + 1\n nroll = -istart\n t = np.arange(istart, N // 2 + 1) * dt\n f = np.arange(istart, N // 2 + 1) * df\n # arrange f as positve, negative freqs\n f = np.roll(f, -nroll)\n\n # freq domain ricker\n ricker_f = 2 * f**2 / (np.sqrt(np.pi) * fc**3) * np.exp(-(f/fc)**2)\n\n if delay is None:\n delay = 1.5 / fc\n ricker_f = ricker_f * np.exp(-1j * 2 * np.pi * f * delay)\n\n # time domain ricker\n ricker_t = N * np.real(np.fft.ifft(ricker_f))\n\n\n amp = np.absolute(ricker_f)\n phase = np.unwrap(np.angle(ricker_f, False))\n\n # ricker_f[0] contains the zero frequency term,\n # ricker_f[1:N//2] contains the positive-frequency terms,\n # ricker_f[N//2 + 1:] contains the negative-frequency terms,\n # in increasing order starting from the most negative frequency\n self.delay = delay\n self.fc = fc\n self.dt = dt\n # arange t and ricker_t in the order of increasing time; the zero phase case contains negative time\n\n self.ricker_t = np.roll(ricker_t, nroll)\n self.f = f\n self.t = t\n self.df = df\n self.ricker_f = ricker_f\n self.amp = amp\n self.phase = phase\n self.nroll = nroll","def cutoff_denominator(self, list_energy):\n\n tol = 1e-3\n\n z = list_energy/tol\n\n den = N.imag(SS.wofz(z))/tol*N.sqrt(N.pi)\n\n return den","def get_fractional_degradation(bt):\n\n\n\n NomIch = 0.125 # Nominal charge current\n NomId = 0.25 # Nominal discharge current\n NomSoC = 0.5 # Nominal state of charge_mode\n NomDoD = 1.0 # Nominal depth of discharge\n B = 5 #Battery capacity\n qt = 5 * 0.5 # Amount of energy in the battery at the start\n # Determin charge of discharge\n if bt > 0:\n Id = bt/(B*1) # time interval differnece is 1\n Ich = NomIch\n else:\n Ich = bt/(B*1)\n Id = NomId\n\n #Calculate average State of Charge\n SoC = 100 * (qt - 0.5*bt)/B\n\n #Calculate Depth of Discharge\n DoD = 100 * bt /B\n\n # Functions\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\n nCL = nCL1 * nCL2 * nCL3\n Fractional_D = (0.5/3650)/ nCL\n return Fractional_D","def _solve_freq_unc(self, d, v, a, force, freq, incrb):\n # convert frequency in Hz to radian/sec:\n freqw = 2 * np.pi * freq\n freqw2 = freqw**2\n\n # solve rigid-body and elastic parts separately\n # - residual-flexibility part was already solved in _init_dva\n\n # solve rigid-body part:\n self._solve_freq_rb(d, v, a, force, freqw, freqw2, incrb, True)\n\n # solve elastic part:\n if self.elsize:\n el = self.el\n _el = self._el\n fw = freqw[None, :]\n fw2 = freqw2[None, :]\n if self.m is None:\n d[el] = force[el] / (\n 1j * (self.b[_el][:, None] @ fw) + self.k[_el][:, None] - fw2\n )\n else:\n d[el] = force[el] / (\n 1j * (self.b[_el][:, None] @ fw)\n + self.k[_el][:, None]\n - self.m[_el][:, None] @ fw2\n )\n a[el] = d[el] * -(freqw2)\n v[el] = d[el] * (1j * freqw)","def calculate_bandwidth(self, complist):\n\n self.type = complist[0]\n self.spot = complist[2]\n self.value = complist[1]\n self.fail = False\n\n if self.spot == \"1\" or self.spot == \"2\":\n # print \"Calculation if Loop 1st filter\"\n if self.type == \"C\":\n if self.c1 == 0:\n self.c1 = self.value\n else:\n self.fail = True\n else:\n if self.r1 == 0:\n self.r1 = self.value\n else:\n self.fail = True\n\n if self.spot == \"3\" or self.spot == \"4\":\n # print \"Calculation if loop 2nd filter\"\n if self.type == \"C\":\n if self.c2 == 0:\n self.c2 = self.value\n else:\n self.fail = True\n else: #self.type == \"R\"\n if self.r2 == 0:\n self.r2 = self.value\n else:\n self.fail = True\n\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\n #print \"hello!\"\n cf_low = str(cf_low)\n self.cutoff_freql = cf_low\n self.cutoff_freql_text = cf_low + \"K\"\n print self.cutoff_freql_text\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\n cf_high = str(cf_high)\n self.cutoff_freqh = cf_high\n self.cutoff_freqh_text = cf_high + \"K\"\n print self.cutoff_freqh_text\n voltage_change = float((self.r2)/self.r1)\n voltage = 5 + voltage_change\n self.voltage = str(voltage)\n print self.voltage","def div(\n coeff_rho,\n momentum_x,\n momentum_y,\n momentum_z,\n ):\n # Compute the fourth order derivative of the pressure for the face\n # velocity correction.\n p_corr = (\n states['p']\n if self._params.enable_rhie_chow_correction else states['dp'])\n d4p_dx4 = self._kernel_op.apply_kernel_op_x(p_corr, 'k4d2x')\n d4p_dy4 = self._kernel_op.apply_kernel_op_y(p_corr, 'k4d2y')\n d4p_dz4 = self._kernel_op.apply_kernel_op_z(p_corr, 'k4d2z',\n 'k4d2zsh')\n\n # Compute velocity gradient based on interpolated values on cell faces.\n coeff_x = dt / (4. * coeff_rho * dx**2)\n du = self._kernel_op.apply_kernel_op_x(momentum_x, 'kDx')\n du_dx = [\n du_i / (2. * dx) + coeff_x * d4p_dx4_i\n for du_i, d4p_dx4_i in zip(du, d4p_dx4)\n ]\n\n coeff_y = dt / (4. * coeff_rho * dy**2)\n dv = self._kernel_op.apply_kernel_op_y(momentum_y, 'kDy')\n dv_dy = [\n dv_i / (2. * dy) + coeff_y * d4p_dy4_i\n for dv_i, d4p_dy4_i in zip(dv, d4p_dy4)\n ]\n\n coeff_z = dt / (4. * coeff_rho * dz**2)\n dw = self._kernel_op.apply_kernel_op_z(momentum_z, 'kDz', 'kDzsh')\n dw_dz = [\n dw_i / (2. * dz) + coeff_z * d4p_dz4_i\n for dw_i, d4p_dz4_i in zip(dw, d4p_dz4)\n ]\n\n return [\n du_dx_i + dv_dy_i + dw_dz_i\n for du_dx_i, dv_dy_i, dw_dz_i in zip(du_dx, dv_dy, dw_dz)\n ]","def torch_hertz_to_mel(frequencies_hertz):\r\n # return _MEL_HIGH_FREQUENCY_Q * tf.math.log(\r\n # 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\r\n return _MEL_HIGH_FREQUENCY_Q * np.log(\r\n 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))","def effective_temperature(R,times):\n T_eff = np.empty((len(R),times))\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \n for i in range (len(R)):\n for t in range(times): \n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\n return T_eff","def apply_band_pass(ftd, freq, omega, bp_wid=1):\n # Find number of frequencies\n nf = len(freq)\n # Find index for band pass, only consider indices of positive freqs\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\n # Filter out frequencies left of band pass\n ftd[:,0:idx_om-1-bp_wid] = 0.0\n # Filter out frequencies left of omega\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\n # Correct for lost amplitude\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\n return ftd","def HeatEqn_FT(D, L, x, t, u_0):\n n = x.size\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\n u_0t = np.fft.fft(u_0)\n\n U = np.zeros((t.size, x.size))\n for ti in range(t.size):\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\n\n return U","def integrate_rd(D=2e-3, t0=1., tend=13., x0=1e-10, xend=1.0, N=256,\n nt=42, logt=False, logy=False, logx=False,\n random=False, k=1.0, nstencil=3, linterpol=False,\n rinterpol=False, num_jacobian=False, method='bdf',\n integrator='scipy', iter_type='undecided',\n linear_solver='default', atol=1e-8, rtol=1e-10, factor=1e5,\n random_seed=42, plot=False, savefig='None', verbose=False,\n scaling=1.0, ilu_limit=1000.0, first_step=0.0, n_jac_diags=0, use_log2=False):\n if t0 == 0.0:\n raise ValueError(\"t0==0 => Dirac delta function C0 profile.\")\n if random_seed:\n np.random.seed(random_seed)\n tout = np.linspace(t0, tend, nt)\n\n units = defaultdict(lambda: 1)\n units['amount'] = 1.0/scaling\n\n # Setup the grid\n x = generate_grid(x0, xend, N, logx, random=random)\n modulation = [1 if (i == 0) else 0 for i in range(N)]\n\n rd = ReactionDiffusion.nondimensionalisation(\n 2,\n [[0], [1]],\n [[1], [0]],\n [k, factor*k],\n N=N,\n D=[0, D],\n x=x,\n logy=logy,\n logt=logt,\n logx=logx,\n nstencil=nstencil,\n lrefl=not linterpol,\n rrefl=not rinterpol,\n modulated_rxns=[0, 1],\n modulation=[modulation, modulation],\n unit_registry=units,\n ilu_limit=ilu_limit,\n n_jac_diags=n_jac_diags,\n faraday_const=1,\n vacuum_permittivity=1,\n use_log2=use_log2\n )\n\n # Calc initial conditions / analytic reference values\n Cref = analytic(rd.xcenters, tout, D, x0, xend, logx, use_log2=use_log2).reshape(\n nt, N, 1)\n source = np.zeros_like(Cref[0, ...])\n source[0, 0] = factor\n y0 = np.concatenate((source, Cref[0, ...]), axis=1)\n\n # Run the integration\n integr = Integration(\n rd, y0, tout, integrator=integrator, atol=atol, rtol=rtol,\n with_jacobian=(not num_jacobian), method=method,\n iter_type=iter_type,\n linear_solver=linear_solver, first_step=first_step)\n Cout = integr.with_units('Cout')\n if verbose:\n import pprint\n pprint.pprint(integr.info)\n spat_ave_rmsd_over_atol = spat_ave_rmsd_vs_time(\n Cout[:, :, 1], Cref[:, :, 0]) / atol\n tot_ave_rmsd_over_atol = np.average(spat_ave_rmsd_over_atol)\n\n if plot:\n # Plot results\n import matplotlib.pyplot as plt\n plt.figure(figsize=(6, 10))\n\n def _plot(C, c, ttl=None, vlines=False,\n smooth=True):\n if vlines:\n plt.vlines(rd.x, 0, np.ones_like(rd.x)*max(C),\n linewidth=1, colors='gray')\n if smooth:\n plt.plot(rd.xcenters, C, c=c)\n else:\n for i, _C in enumerate(C):\n plt.plot([rd.x[i], rd.x[i+1]], [_C, _C], c=c)\n\n plt.xlabel('x / m')\n plt.ylabel('C / M')\n if ttl:\n plt.title(ttl)\n\n for i in range(nt):\n kwargs = dict(smooth=(N >= 20),\n vlines=(i == 0 and N < 20))\n\n c = 1-tout[i]/tend\n c = (1.0-c, .5-c/2, .5-c/2)\n plt.subplot(4, 1, 1)\n _plot(Cout[i, :, 1], c, 'Simulation (N={})'.format(rd.N),\n **kwargs)\n\n plt.subplot(4, 1, 2)\n _plot(Cref[i, :, 0], c, 'Analytic', **kwargs)\n\n plt.subplot(4, 1, 3)\n _plot((Cout[i, :, 1]-Cref[i, :, 0]), c,\n \"Error\",\n **kwargs)\n\n plt.subplot(4, 1, 4)\n plt.plot(integr.tout, spat_ave_rmsd_over_atol)\n plt.plot([integr.tout[0], integr.tout[-1]],\n [tot_ave_rmsd_over_atol]*2, '--')\n plt.title(\"RMSD / atol\")\n\n plt.tight_layout()\n save_and_or_show_plot(savefig=savefig)\n\n return tout, Cout, integr.info, rd, tot_ave_rmsd_over_atol","def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\n n_cpu, n_trial_boot, num_intermediate_states):\n\n # Construct dictionary of parameter update instructions:\n param_dict = {}\n \n # if len(param_names) == 1:\n # # 1D optimization:\n # param_dict[param_names[0]] = param_values * units[0]\n\n for i in range(len(param_names)):\n param_dict[param_names[i]] = param_values[i] * units[i]\n \n if verbose:\n print(f'Current parameters: {param_dict}') \n \n # Re-evaluate energy with current force field parameters:\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\n # apply the sample_spacing only to the heat capacity part\n U_eval, simulation = eval_energy(\n cgmodel,\n file_list,\n temperature_list,\n param_dict,\n frame_begin=frame_begin,\n frame_stride=sparsify_stride,\n frame_end=frame_end,\n n_cpu=n_cpu,\n verbose=verbose,\n )\n\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\n (new_temperature_list, C_v_values, C_v_uncertainty,\n Tm_value, Tm_uncertainty,\n Cv_height_value, Cv_height_uncertainty,\n FWHM_value, FWHM_uncertainty,\n N_eff_values) = bootstrap_heat_capacity(\n U_kln=U_eval,\n output_data=output_data,\n frame_begin=frame_begin,\n frame_end=frame_end,\n sample_spacing=sample_spacing,\n sparsify_stride=sparsify_stride,\n num_intermediate_states=num_intermediate_states,\n n_trial_boot=n_trial_boot,\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\n )\n \n if verbose:\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\n \n # Check for minimum N_eff criteria.\n # If too small, the minimization should stop if we're using a gradient method.\n # If we're not using a gradient method, return a large value.\n \n if np.min(N_eff_values) < min_eff_samples:\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\n \n # print(f'Creating a cgmodel with current parameters...,end='')\n # Create the cgmodel\n # print('done')\n \n exit()\n \n return FWHM_value.value_in_unit(unit.kelvin)","def freq2den(freq):\n\n return freq * freq * k_2","def freq_defl_comp(fmax, p=75, p1=database['K+'], p2=database['pi+'],\r\n p3=database['p+'], L_t=79.6, l=2.74, E=1e6, plot=True,\r\n details=False, n=1000, delta_p=1.6e-2, fmin=0, just_pi=False):\r\n f_range = np.linspace(fmin, fmax, n)\r\n min_defl, d2, d3 = [], [], []\r\n for f in f_range:\r\n if just_pi == True:\r\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\r\n min_defl.append(d2[-1])\r\n if just_pi == False: \r\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\r\n d3.append(ang_deflection(p, f, p1, p3, L_t, l, E, delta_p))\r\n min_defl.append(np.min([d2[-1], d3[-1]]))\r\n if plot == True:\r\n fig = plt.figure(figsize=[9, 5])\r\n ax = fig.add_subplot(1, 1, 1)\r\n if details == True:\r\n ax.plot(f_range, d2, 'r', alpha=0.5, label=f'{p2.name} deflection')\r\n ax.plot(f_range, d3, 'b', alpha=0.5, label=f'{p3.name} deflection')\r\n else:\r\n ax.plot(f_range, min_defl, color=[1, 0, 1], alpha=0.5, label='min deflection')\r\n# ax.set_xlim(fmin, fmax)\r\n ax.set_ylim(0)\r\n ax.set_xlabel('Frequency / Hz', fontsize=20)\r\n text = r'$D_{'\r\n text += p2.name + '/' + p3.name\r\n text += '}$ / mrad'\r\n ax.set_ylabel(text, fontsize=20)\r\n ax.set_xscale('log')\r\n ax.legend(fontsize=20)\r\n plt.show()\r\n opt_freq = f_range[np.argmax(min_defl)]\r\n d_opt = (fmax-fmin)/1000\r\n d_opt_perc = (d_opt/opt_freq)*100\r\n if details == True:\r\n return 'optimum frequency = {0:.0f} +/- {1:.5f}%'.format(opt_freq, d_opt_perc)\r\n return opt_freq","def F_rxth(mx, rhoc, Temp):\n return 64. * m.pow(Temp/1.e+5,0.5) * m.pow(1.e+14/rhoc,0.5) * m.pow(100./mx,0.5) # cm","def calc(self,index,counter_values):\n gr = self.grSign * self.grPitch['Value'].value\n m = self.mSign * self.mPitch['Value'].value\n \n offsetG,offsetM = self.checkOffset()\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\n alpha = (2.0*theta) + beta\n numerator = (math.sin(alpha) + math.sin(beta))\n denominator = (self.DiffrOrder * self.look_at_grx())\n wavelength = numerator / denominator\n \n if wavelength == 0.0:\n energy_physicalmot = 0.0\n else:\n energy_physicalmot = self.hc / wavelength\n #if self.FixedM2Pit: \n Cff = math.cos(beta)/math.cos(alpha)\n if energy_physicalmot < 0 :\n #warning: wavelength se vuelve negativo ... ??????\n energy_physicalmot = energy_physicalmot *(-1) \n \n # Real Energy is equal to the energy calculated by the encoders\n # minus an offset that depends on the same energy calculated by the \n # encoders:\n # E_physicalmot = Ereal + offset\n # with offset = a*Ereal + b\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \n a_coeff = self.EnergyDP.a_offset_coeff\n b_coeff = self.EnergyDP.b_offset_coeff\n numerator = energy_physicalmot - b_coeff\n denominator = 1 + a_coeff\n energy = numerator / denominator\n \n if index == 1:\n return energy\n elif index == 2:\n return Cff","def getPartitionFunction(self, Tlist):\n\t\treturn _modes.hinderedrotor_partitionfunction(Tlist, self.frequency, self.barrier) ** self.degeneracy","def butter_lpf(fc, fs, order):\n nyq = 0.5 * fs\n high = fc / nyq\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\n w, h = signal.freqz(b, a, worN=1000)\n# plt.figure()\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\n return b, a","def get_quantum_harmonic_free_energy(self, temperatures=None):\n if temperatures is None:\n temperatures = self.input.temperature\n temperatures = np.clip(temperatures, 1e-6, np.inf)\n beta = 1.0 / (KB * temperatures)\n f = 0\n for m in self.input.structure.get_masses():\n hbar_omega = (\n HBAR\n * np.sqrt(self.input.spring_constant / m)\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\n )\n f += (3.0 / 2) * hbar_omega + (\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\n )\n return f","def refraction(el, temp, press, hum, freq=150.0):\n\n fvec = np.vectorize(qp.qp_refraction, [np.double])\n delta = fvec(el, temp, press, hum, freq)\n if delta.shape == ():\n return delta[()]\n return delta","def zMCEff1D(ZReco, ZAcc, bins, obs, region='inclusive', sel=''):\n print(\">>> make differential efficiencies for \"+obs+\" in \"+region+\" region\")\n\n if sel != '':\n ZReco = ZReco.query(sel)\n ZAcc = ZAcc.query(sel)\n\n ZEff = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\n ZEff_sel = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\n ZEff_glo = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\n\n MuEff_HLT_Sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Sel_Glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Glo_StaOrTrk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Trk_Sta = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n MuEff_Sta_Trk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n\n ZMuMuEff = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n ZMuMuEff_sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n ZMuMuEff_glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\n\n for i in range(0, len(bins)-1):\n bin_low = bins[i]\n bin_high = bins[i+1]\n sel = '{0}>{1} & {0}<{2}'.format(obs, bin_low, bin_high)\n\n ZReco_i = ZReco.query(sel)\n\n qHLT = 'muon_Category==5 & antiMuon_Category==5'\n qSel = '(muon_Category==5 & antiMuon_Category==4) | (muon_Category==4 & antiMuon_Category==5)'\n qGlo = '(muon_Category==5 & antiMuon_Category==3) | (muon_Category==3 & antiMuon_Category==5)'\n qSta = '(muon_Category==5 & antiMuon_Category==2) | (muon_Category==2 & antiMuon_Category==5)'\n qTrk = '(muon_Category==5 & antiMuon_Category==1) | (muon_Category==1 & antiMuon_Category==5)'\n\n nHLT = len(ZReco_i.query(qHLT))\n nSel = len(ZReco_i.query(qSel))\n nGlo = len(ZReco_i.query(qGlo))\n nSta = len(ZReco_i.query(qSta))\n nTrk = len(ZReco_i.query(qTrk))\n\n MuEff_HLT_Sel[0][i], MuEff_HLT_Sel[1][i] = muTagAndProbeEff(nHLT, 0, nSel)\n MuEff_Sel_Glo[0][i], MuEff_Sel_Glo[1][i] = muTagAndProbeEff(nHLT, nSel, nGlo)\n MuEff_Glo_StaOrTrk[0][i], MuEff_Glo_StaOrTrk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo, nSta + nTrk)\n MuEff_Trk_Sta[0][i], MuEff_Trk_Sta[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nTrk, nSta)\n MuEff_Sta_Trk[0][i], MuEff_Sta_Trk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nSta, nTrk)\n\n ZMuMuEff[0][i], ZMuMuEff[1][i] = eff_ztomumu_old(nHLT, nSel, nGlo, nSta, nTrk)\n ZMuMuEff_sel[0][i], ZMuMuEff_sel[1][i] = eff_ztomumu_sel(nHLT, nSel, nGlo, nSta, nTrk)\n ZMuMuEff_glo[0][i], ZMuMuEff_glo[1][i] = eff_ztomumu_glo(nHLT, nSel, nGlo, nSta, nTrk)\n\n # full true Z efficiency\n ZAcc_i = ZAcc.query(sel)\n ZReco_i = ZReco.query(sel + '& (muon_Category==5 | antiMuon_Category==5) & muon_Category>=4 & antiMuon_Category>=4')\n\n nReco_i = len(ZReco_i)\n nAcc_i = len(ZAcc_i)\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\n\n ZEff[0][i], ZEff[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\n\n # true Z efficiency at selection level (without requiring trigger)\n ZAcc_i = ZAcc.query(sel)\n ZReco_i = ZReco.query(sel + ' & muon_Category>=4 & antiMuon_Category>=4')\n\n nReco_i = len(ZReco_i)\n nAcc_i = len(ZAcc_i)\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\n\n ZEff_sel[0][i], ZEff_sel[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\n\n # true Z efficiency at gobal muon level (requiring two global muons)\n ZAcc_i = ZAcc.query(sel)\n ZReco_i = ZReco.query(sel + '& muon_Category>=3 & antiMuon_Category>=3 ')\n\n nReco_i = len(ZReco_i)\n nAcc_i = len(ZAcc_i)\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\n\n ZEff_glo[0][i], ZEff_glo[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\n\n x = bins[:-1] + (bins[1:] - bins[:-1])/2\n\n def plot_zeff(eff_true, eff_tnp, name):\n plt.clf()\n fig, ax = plt.subplots(2, 1, sharex=True, gridspec_kw={'height_ratios': [2, 1]})\n fig.subplots_adjust(hspace=0)\n\n ax[0].errorbar(x, eff_true[0], xerr=np.zeros(len(x)), yerr=eff_true[1], fmt='bo', label='true')\n ax[0].errorbar(x, eff_tnp[0], xerr=np.zeros(len(x)), yerr=eff_tnp[1], fmt='ro', label='tnp')\n ax[0].set(xlim=(bins[0], bins[-1]), ylim=(0.75, 1.1))\n ax[0].legend()\n ax[0].text(0.05, 0.9, r'$66\\ \\mathrm{GeV} < \\mathrm{M}_{\\mu\\mu} < 116\\ \\mathrm{GeV}$', transform=ax[0].transAxes)\n ax[0].text(0.05, 0.82, r'$p_\\mathrm{t}(\\mu) > 27\\ \\mathrm{GeV} \\qquad |\\eta(\\mu)| < 2.4$', transform=ax[0].transAxes)\n ax[0].text(0.05, 0.74, region, transform=ax[0].transAxes)\n ax[0].set_ylabel(r'$\\epsilon_\\mathrm{Z}$')\n ax[0].set_xlabel(obs)\n ax[0].set_yticks([0.8, 0.85, 0.9, 0.95, 1.0, 1.05])\n ax[0].set_title(\"Z efficiency at {0} muon level\".format(name))\n\n pulls = eff_tnp[0] - eff_true[0]\n pulls_sig = np.sqrt(eff_tnp[1]**2 + eff_true[1]**2)\n\n ax[1].errorbar(x, pulls, xerr=np.zeros(len(x)), yerr=pulls_sig, fmt='ko')# , label='factorized - true')\n ax[1].plot(x, np.zeros(len(x)), color='gray', linestyle='dashed')\n ax[1].set_ylim(-0.02, 0.04)\n ax[1].set_ylabel(r'$\\epsilon^\\mathrm{tnp}_\\mathrm{Z} - \\epsilon^\\mathrm{true}_\\mathrm{Z}$')\n ax[1].set_xlabel(obs)\n ax[1].set_yticks([-0.01, 0., 0.01, 0.02, 0.03])\n plt.savefig(output+'/ZMuMu_{0}_{1}_{2}_level.png'.format(obs, region, name))\n plt.close()\n\n plot_zeff(ZEff, ZMuMuEff, \"hlt\")\n plot_zeff(ZEff_sel, ZMuMuEff_sel, \"selection\")\n plot_zeff(ZEff_glo, ZMuMuEff_glo, \"global\")","def far_fields(horn_width, horn_height, eplane_effective_length, hplane_effective_length, frequency, r, theta, phi):\n # Calculate the wavenumber\n k = 2.0 * pi * frequency / c\n\n # Calculate the wave impedance\n eta = sqrt(mu_0 / epsilon_0)\n\n # Define the radial-component of the electric field\n e_r = 0.0\n\n # Define the theta-component of the electric field\n e_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Define the phi-component of the electric field\n e_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * cos(phi) * (1.0 + cos(theta)) * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Define the radial-component of the magnetic field\n h_r = 0.0\n\n # Define the theta-component of the magnetic field\n h_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * -cos(phi) * (1.0 + cos(theta)) / eta * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Define the phi-component of the magnetic field\n h_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) / eta * \\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\n I2(k, horn_height, eplane_effective_length, theta, phi)\n\n # Return all six components of the far field\n return e_r, e_theta, e_phi, h_r, h_theta, h_phi","def freqz_resp_list(b,a=np.array([1]),mode = 'dB',fs=1.0,Npts = 1024,fsize=(6,4)):\r\n if type(b) == list:\r\n # We have a list of filters\r\n N_filt = len(b)\r\n f = np.arange(0,Npts)/(2.0*Npts)\r\n for n in range(N_filt):\r\n w,H = signal.freqz(b[n],a[n],2*np.pi*f)\r\n if n == 0:\r\n plt.figure(figsize=fsize)\r\n if mode.lower() == 'db':\r\n plt.plot(f*fs,20*np.log10(np.abs(H)))\r\n if n == N_filt-1:\r\n plt.xlabel('Frequency (Hz)')\r\n plt.ylabel('Gain (dB)')\r\n plt.title('Frequency Response - Magnitude')\r\n\r\n elif mode.lower() == 'phase':\r\n plt.plot(f*fs,np.angle(H))\r\n if n == N_filt-1:\r\n plt.xlabel('Frequency (Hz)')\r\n plt.ylabel('Phase (rad)')\r\n plt.title('Frequency Response - Phase')\r\n\r\n elif (mode.lower() == 'groupdelay_s') or (mode.lower() == 'groupdelay_t'):\r\n \"\"\"\r\n Notes\r\n -----\r\n\r\n Since this calculation involves finding the derivative of the\r\n phase response, care must be taken at phase wrapping points \r\n and when the phase jumps by +/-pi, which occurs when the \r\n amplitude response changes sign. Since the amplitude response\r\n is zero when the sign changes, the jumps do not alter the group \r\n delay results.\r\n \"\"\"\r\n theta = np.unwrap(np.angle(H))\r\n # Since theta for an FIR filter is likely to have many pi phase\r\n # jumps too, we unwrap a second time 2*theta and divide by 2\r\n theta2 = np.unwrap(2*theta)/2.\r\n theta_dif = np.diff(theta2)\r\n f_diff = np.diff(f)\r\n Tg = -np.diff(theta2)/np.diff(w)\r\n # For gain almost zero set groupdelay = 0\r\n idx = pylab.find(20*np.log10(H[:-1]) < -400)\r\n Tg[idx] = np.zeros(len(idx))\r\n max_Tg = np.max(Tg)\r\n #print(max_Tg)\r\n if mode.lower() == 'groupdelay_t':\r\n max_Tg /= fs\r\n plt.plot(f[:-1]*fs,Tg/fs)\r\n plt.ylim([0,1.2*max_Tg])\r\n else:\r\n plt.plot(f[:-1]*fs,Tg)\r\n plt.ylim([0,1.2*max_Tg])\r\n if n == N_filt-1:\r\n plt.xlabel('Frequency (Hz)')\r\n if mode.lower() == 'groupdelay_t':\r\n plt.ylabel('Group Delay (s)')\r\n else:\r\n plt.ylabel('Group Delay (samples)')\r\n plt.title('Frequency Response - Group Delay')\r\n else:\r\n s1 = 'Error, mode must be \"dB\", \"phase, '\r\n s2 = '\"groupdelay_s\", or \"groupdelay_t\"'\r\n print(s1 + s2)","def trc_fgen_postfb(self,trc,dt,hwin=150,vlen=51):\n output=np.zeros((len(trc),((11*(vlen))+1)))\n trc_norm=trc/np.amax(np.abs(trc))\n trc_entropy=self.entropy(trc_norm,50)\n trc_fdm=self.fdm(trc_norm,50,np.arange(1,4),15)\n trc_slta=trigger.classic_sta_lta(trc_norm,2,100)\n trc_fq_win_sum=self.fq_win_sum(trc_norm,hwin,dt)\n hwin2=50\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm,hwin2)\n for i,j in enumerate(trc):\n if i<len(trc)-vlen-1:\n ftrc=[]\n fb=i*dt\n ftrc=np.append(ftrc,trc_norm[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm)))[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(fb/dt):np.int(fb/dt)+vlen]) \n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(fb/dt):np.int(fb/dt)+vlen]) \n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(fb/dt):np.int(fb/dt)+vlen])\n ftrc=np.append(ftrc,1)\n output[i,:]=ftrc\n return output","def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\n\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\n\td = dist * 1e3 * pc\n\t# Radius (in unit of pc)\n\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\n\t# Mass\n\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\n\t# Number density\n\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\n\t# Sigmav of 2.33H\n\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\n\t# Virial\n\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\n\t# Virial parameter with B-field, assume 1 mG\n\tB = 1 * 1e-3 # G\n\trho = density * 2.8 * mp # g/cm3\n\talfven = B / np.sqrt(4*np.pi*rho)\n\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\n\n\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B","def buoyancy_frequency(self, z, h=0.01):\n # Check validity of the input z values\n if np.max(z) > self.z_max or np.min(z) < self.z_min:\n raise ValueError('Selected depths outside range of ' + \\\n 'CTD data: %g to %g m' % (self.z_min, \n self.z_max))\n if h > 1.0 or h < 0.0:\n raise ValueError('Input parameter h must be between 0.0 ' + \\\n 'and 1.0.')\n \n # Prepare space to store the solution\n if not isinstance(z, np.ndarray):\n N = np.zeros(1)\n z = np.array([z])\n elements = 0\n else:\n N = np.zeros(z.shape)\n elements = range(len(N))\n \n # Compute the length-scale for the finite difference method\n dz = (self.z_max - self.z_min) * h\n \n # Fill the solution matrix\n for i in range(len(z)):\n # Get the end-points of z for the finite difference formula\n if z[i] + dz > self.z_max:\n z1 = self.z_max\n z0 = z1 - 2 * dz\n elif z[i] - dz < self.z_min:\n z0 = self.z_min\n z1 = z0 + 2 * dz\n else:\n z0 = z[i] - dz\n z1 = z[i] + dz\n \n # Get the density at z0 and z1. Use atmospheric pressure to \n # compute the potential density and remove the effect of \n # compressibility\n T0, S0 = self.get_values(z0, self.ztsp[1:3])\n T1, S1 = self.get_values(z1, self.ztsp[1:3])\n Pa = 101325.\n rho_0 = seawater.density(T0, S0, Pa)\n rho_1 = seawater.density(T1, S1, Pa)\n N[i] = np.sqrt(9.81 / rho_0 * (rho_1 - rho_0) / (z1 - z0))\n \n return N[elements]","def calculate_NH_relaxation_from_Ct(bondtype, B_0, t, Ct):\n gamma_1H = 267.513e6 ; # rad s^-1 T^-1\n gamma_X = -27.116e6\n DeltaSigma_X=-160e-6\n r_XH=1.02e-10\n\n om, G = do_dft(t, Ct)\n J = G.real\n\n omega, iOmH, iOmX = obtain_HX_frequencies()\n\n Jw=np.zeros(5)\n for i in range(5):\n w = omega[i]\n Jw[i] = interpolate_point(w, om, J)\n\n # f_DD = 519627720.1974593 , if r_NH is at default values\n f_DD = 7.958699205571828e-67 * r_XH**-6.0 * gamma_X**2\n # f_CSA = 498637299.69233465, if B_0 = 600.13, and DeltaSigma=-160e-6\n f_CSA = 2.0/15.0 * DeltaSigma_X**2 * ( gamma_X * B_0 )**2\n\n R1 = f_DD*( J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] ) + f_CSA*J[iOmX]\n R2 = 0.5*f_DD*( 4*J[0] + J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] + 6*J[iOmH] ) + 1.0/6.0*f_CSA*(4*J[0] + 3*J[iOmX])\n NOE = 1.0 + gamma_1H/gamma_X/R1 * f_DD*(6*J[iOmH+iOmX] - J[iOmH-iOmX])\n\n return R1, R2, NOE","def get_kt(temps, delta_gibbs_ts):\n # rate coefficient from Eyring equation\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular","def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n C_T = (\n 2 ** (1 / 4)\n * np.sqrt(gbar)\n / np.pi\n * np.sqrt(vv)\n * tt ** (5 / 4)\n * _1d_call(_fdk, y, k=1 / 2)\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\n )\n return C_T","def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\n D=dmax*x[0]**n/(x[0]**n+K**n)\n #defune the degradation effect\n deg=0\n #define ODEs\n y=np.zeros([np.size(x)])\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\n \n return y","def bd(y, t_r, lbda=1.0, theta_0=None, z_0=None, hrf_dur=20.0, # noqa\n bounds=None, nb_iter=100, nb_sub_iter=1000, nb_last_iter=10000,\n print_period=50, early_stopping=False, wind=4, tol=1.0e-12, verbose=0):\n # force cast for Numba\n y = y.astype(np.float64)\n\n # initialization\n theta = MAX_DELTA if theta_0 is None else theta_0\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\n\n if z_0 is None:\n diff_z = np.zeros_like(y)\n z = np.zeros_like(y)\n x = np.zeros_like(y)\n else:\n diff_z = np.append(0, z_0[1:] - z_0[:-1])\n z = z_0\n x = spectral_convolve(h, z)\n\n if bounds is None:\n bounds = [(MIN_DELTA + 1.0e-1, MAX_DELTA - 1.0e-1)]\n\n d = {}\n r_0 = np.sum(np.square(x - y))\n d['r'] = [1.0]\n g_0 = np.sum(np.abs(diff_z))\n d['g'] = [g_0]\n j_0 = r_0 + lbda * g_0\n d['J'] = [1.0]\n d['l_alpha'] = []\n\n if (verbose > 0):\n print(\"normalized global cost-function \"\n \"(init): {0:.6f}\".format(d['J'][-1]))\n\n # main loop\n for idx in range(nb_iter):\n\n # deconvolution\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping,\n wind, tol)\n z = np.cumsum(diff_z)\n\n # hrf estimation\n args = (z, y, t_r, hrf_dur)\n theta, _, _ = fmin_l_bfgs_b(\n func=hrf_fit_err, x0=theta, args=args,\n bounds=bounds, approx_grad=True, maxiter=999,\n pgtol=1.0e-12)\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\n x = spectral_convolve(h, z)\n\n # cost function\n r = np.sum(np.square(x - y))\n g = np.sum(np.abs(diff_z))\n d['J'].append((r + lbda * g) / j_0 + 1.0e-30)\n d['r'].append(r / r_0 + 1.0e-30)\n d['g'].append(g)\n\n if (verbose > 0) and ((idx+1) % print_period == 0):\n print(\"normalized global cost-function \"\n \"({0:03d}/{1:03d}): {2:.6f}\".format(idx+1, nb_iter,\n d['J'][-1]))\n\n # early stopping\n if early_stopping:\n if idx > wind:\n sub_wind_len = int(wind/2)\n old_j = np.mean(d['J'][:-sub_wind_len])\n new_j = np.mean(d['J'][-sub_wind_len:])\n diff = (new_j - old_j) / new_j\n if diff < tol:\n if verbose > 0:\n print(\"\\n-----> early-stopping done at \"\n \"{0:03d}/{1:03d}, global\"\n \" normalized cost-function = \"\n \"{2:.6f}\".format(idx, nb_iter, d['J'][idx]))\n break\n\n # last (long) deconvolution\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping, wind,\n tol)\n z = np.cumsum(diff_z)\n x = spectral_convolve(h, z)\n\n # cost function\n r = np.sum(np.square(x - y))\n g = np.sum(np.abs(diff_z))\n d['J'].append((r + lbda * g) / j_0)\n d['r'].append(r / r_0)\n d['g'].append(g)\n\n d['J'] = np.array(d['J'])\n d['r'] = np.array(d['r'])\n d['g'] = np.array(d['g'])\n\n return x, z, diff_z, h, d","def rcfilter_C(freq, R):\n R = _normalizevalue(R)\n C = 1/(R*freq*2*math.pi)\n return _Cap(C)","def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for high temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\n C_P_low *= (\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\n )\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\n # low temperatures - high numbers\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)","def get_tuning_freq(self, freq):\n if freq < self.freq_lo:\n return\n\n while freq < self.NOTES.min() or freq > self.NOTES.max():\n while freq > self.NOTES.max():\n self.NOTES *= 2\n while freq < self.NOTES.min():\n self.NOTES /= 2\n tuning_freq = min(self.NOTES, key=lambda x: abs(x-freq))\n return tuning_freq","def getFWHM(antenna, freq):\n diameter = getDiameter(antenna)\n lam = 299792458.0 / (freq * 1e9)\n fwhmo = lam / math.pi * 180.0 * 60.0\n fwhm = 1.22 * fwhmo / diameter\n return fwhm","def get_frequency(self):\r\n # print '*********in get freq'\r\n self.cntr.run('FREQ 1')\r\n f_0_ = self.cntr.get_measurements(1)\r\n self.f_0 = f_0_[0]\r\n self.cntr.run('FREQ 2')\r\n f_rep_ = self.cntr.get_measurements(1)\r\n self.f_rep = f_rep_[0]","def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\n y = chemical_potential / tt\n # There is a precision problem with \"-\" (minus) operator\n # We'll use asymptotic formula for low temperatures to avoid that problem\n y_low = y[y < THRESHOLD]\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\n # high temperatures - low numbers\n S_low = (\n -gbar\n * np.sqrt(2)\n / (6 * np.pi ** 2)\n * tt_low ** (3 / 2)\n * vv_low\n * (\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\n )\n )\n # low temperatures - high numbers\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\n return np.concatenate((S_low, S_high)).reshape(y.shape)","def _get_a_freq(self, energy):\n left_index = bisect.bisect_left(self.energy_list, energy)\n if left_index+1 >= len(self.energy_list):\n left_index = len(self.energy_list)-2\n elif left_index > 0:\n left_index -= 1\n energy0 = self.energy_list[left_index]\n energy1 = self.energy_list[left_index+1]\n freq0 = 1./self.closed_orbits_t[energy0]\n freq1 = 1./self.closed_orbits_t[energy1]\n frequency = (freq1 - freq0)/(energy1-energy0)*(energy-energy0) + freq0\n #print \"\\nl:\", left_index, \"e0:\", energy0, \"e1:\", energy1, \\\n # \"f0:\", freq0, \"f1:\", freq1, \"DE:\", energy-e0, \"f\", frequency\n return frequency","def k_HF(T, n, h=1e-3):\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\n return dn_dmu / n","def hertz_to_mel(freq):\n return 2595.0 * np.log10(1 + (freq / 700.0))","def total_band_energy(vals, T, Ec):\n vals = np.sort(np.concatenate(vals))\n occup = occup_TK(vals, T=T, spin=2)\n return np.dot(vals, occup)-Ec","def all_dhkl(self, crystal):\n #d_min = self.wavelength/self.max2theta*pi/2\n d_min = self.wavelength/sin(self.max2theta/2)/2\n \n # This block is to find the shortest d_hkl, \n # for all basic directions (1,0,0), (0,1,0), (1,1,0), (1,-1,0) and so on, 26 in total \n hkl_max = np.array([1,1,1])\n for h1 in [-1, 0, 1]:\n for k1 in [-1, 0, 1]:\n for l1 in [-1, 0, 1]:\n hkl_index = np.array([[h1,k1,l1]])\n d = float(np.linalg.norm( np.dot(hkl_index, crystal.rec_matrix), axis=1))\n if d>0:\n multiple = 1/d/d_min\n hkl_index *= round(multiple)\n for i in range(len(hkl_max)):\n if hkl_max[i] < hkl_index[0,i]:\n hkl_max[i] = hkl_index[0,i]\n #h1 = 2*ceil(np.linalg.norm(crystal.cell_para[0])/d_min)\n #k1 = 2*ceil(np.linalg.norm(crystal.cell_para[1])/d_min)\n #l1 = 2*ceil(np.linalg.norm(crystal.cell_para[2])/d_min)\n h1, k1, l1 = hkl_max\n h = np.arange(-h1,h1)\n k = np.arange(-k1,k1)\n l = np.arange(-l1,l1)\n \n hkl = np.array((np.meshgrid(h,k,l))).transpose()\n hkl_list = np.reshape(hkl, [len(h)*len(k)*len(l),3])\n hkl_list = hkl_list[np.where(hkl_list.any(axis=1))[0]]\n d_hkl = 1/np.linalg.norm( np.dot(hkl_list, crystal.rec_matrix), axis=1)\n #for ix, a in enumerate(hkl_list):\n # if np.array_equal(a, np.array([1,-1,3])) is True:\n # print(a)\n # break\n #\n #print(ix, hkl_list[ix], d_hkl[ix], d_min)\n\n shortlist = d_hkl > (d_min)\n d_hkl = d_hkl[shortlist]\n hkl_list = hkl_list[shortlist]\n sintheta = self.wavelength/2/d_hkl\n\n self.theta = np.arcsin(sintheta)\n self.hkl_list = hkl_list\n self.d_hkl = d_hkl\n \n #return hkl_list, d_hkl, sintheta","def compute_f_BARR(self, R, e, D):\n upper_LHS_RHS = 5.02 * log(R / (4.518 * log((R / 7), 10)), 10)\n lower_LHS_RHS = R * (1 + (R**0.52) / (29 * (D/e)**0.7))\n\n upper_RHS_RHS = 1\n lower_RHS_RHS = 3.7*(D/e)\n bracket = (upper_LHS_RHS / lower_LHS_RHS) + (upper_RHS_RHS / lower_RHS_RHS)\n \n RHS = (-2)*log(bracket, 10)\n f = (1/RHS)**2\n \n return f","def drillSpeed(matID, W, FWHM_mm):\n vaporH = { # kJ/mol\n # spec heat from room temperature to melting + latent heat of fusion + spec heat from melting to boiling + latent heat of vaporization\n # refer https://webbook.nist.gov/chemistry/ for heat capacity, this tool also has some data in specificHeatParams\n 'Cu': 29.7 + 13.1 + 48.8 + 300,\n 'Fe': 49.5 + 13.8 + 60.9 + 340,\n 'W' : 118.4 + 46.9 + 82.5 + 824,\n 'Mo': 89.9 + 37.5 + 71.9 + 598,\n 'Al': 17.98 + 10.7 + 0.03175*1857 + 294\n }\n if matID not in vaporH.keys():\n raise ValueError(f'No vaporization data for {matID}: available in {vaporH.keys()}')\n \n mol_mmD = 2 * np.pi * (FWHM_mm/2.355)**2 / 1000 * defaultDensity(matID) / molarMass(matID)\n return W / (mol_mmD * vaporH[matID] * 1000)","def density_by_ideal_gas_law(\n p: tf.Tensor,\n r: tf.Tensor,\n t: tf.Tensor,\n ) -> tf.Tensor:\n return p / r / t","def vib_energy(frequency, temp):\n\n # vibrational temperature\n\n vtemp = plank_const * speed_ol / boltz_const * frequency\n\n vtemp = np.matrix(vtemp)\n\n temp = 1 / np.matrix(temp)\n\n # need to convert to array, because the element wise exponential\n # cannot work with matrix\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\n\n # energy is a np.matrix, need to convert to array\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\n energy = np.array(energy)[0]\n\n return energy","def fourier_coefficient(t, freq, n=1, axis=-1):\n t, freq, n = map(np.asanyarray, (t, freq, n))\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)","def getf(element, energy, conv_fwhm=0):\n try:\n Z = int(element)\n except: \n if element in elements.Z:\n Z = elements.Z[element]\n else:\n Z = None\n if Z is None or Z>93:\n raise ValueError(\"Invalid element / element number: %s. \"\n \"(Only elements from H to U allowed).\"%str(Z))\n energy = np.array(energy, ndmin=1)\n diffE = np.unique(np.diff(energy))\n if not len(diffE):\n return deltaf.clcalc(Z, energy)\n dE = abs(diffE.min())\n fwhm_chan = abs(float(conv_fwhm))/dE/2.\n # make equally spaced data:\n if diffE.std()/diffE.mean() > 1e-5 and fwhm_chan>1e-2:\n newenergy = np.arange(energy.min() - 10*dE, energy.max() + 10.*dE, dE)\n do_interpolate = True\n else:\n newenergy = energy\n do_interpolate = False\n \n f1, f2 = deltaf.clcalc(Z, newenergy)\n if fwhm_chan>1e-2:\n f1, f2 = deltaf.convl2(f1, f2, fwhm_chan)\n if do_interpolate:\n ffunc = interp1d(newenergy, (f1, f2))\n f1, f2 = ffunc(energy)\n return f1, f2","def bethe_gf_omega(z, t=1.0):\n half_bandwidth = 2 * t\n z_rel = z / half_bandwidth\n return 2. / half_bandwidth * z_rel * (1 - np.sqrt(1 - 1 / (z_rel * z_rel)))","def kld(Fk, freq, Fk_red, f_red):\n \n #pad the reduced input with zeros\n f_red = [float(val) for val in f_red]\n freq = [float(val) for val in freq]\n f_Fk_red = dict(zip(f_red,Fk_red))\n Fk_red_pad = []\n #for each frequency in the nonreduced signal\n for i,f in enumerate(freq):\n #if the frequency is shared with the reduced signal\n if f in f_red:\n #add the coefficient from the reduced signal\n Fk_red_pad.append(f_Fk_red[f])\n #otherwise, pad it with a zero\n else:\n Fk_red_pad.append(0.)\n Fk_red_pad = np.array(Fk_red_pad)\n \n Fk = np.abs(Fk)\n Fk /= sum(Fk)\n Fk_red_pad = np.abs(Fk_red_pad)\n Fk_red_pad /= sum(Fk_red_pad)\n \n return stats.entropy(Fk_red_pad, Fk)","def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\n pi, ids = induced_distribution(hmsm, 0, level)\n\n discrete_free_energy = np.ndarray(pi.shape)\n for i, id in enumerate(ids):\n discrete_free_energy[i] = \\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\n boltzmann = np.exp(-discrete_free_energy/kT)\n boltzmann *= (1/np.sum(boltzmann))\n return D_KL(boltzmann, pi)","def full_freq_time(freqs, time_arr, Ref_param, dv):\n Ref_all = pp.Reflectometer_Output(Ref_param.file_path, freqs, time_arr, \n Ref_param.n_cross_section, \n Ref_param.FWR_dimension, False, \n Ref_param.receiver_file_name)\n Ref_all.E_out = np.zeros((Ref_all.NF, Ref_all.NT, Ref_all.n_cross_section),\n dtype='complex')\n \n parallel_param_list = [(f,t,Ref_param) for f in freqs for t in time_arr]\n parallel_result = dv.map_async(single_freq_time, parallel_param_list)\n print('Parallel runs started.')\n parallel_result.wait_interactive()\n print('All signals computed!')\n E_out_scattered = parallel_result.get()\n print('signals collected.')\n for i in range(Ref_all.NF):\n for j in range(Ref_all.NT):\n Ref_all.E_out[i, j, :] = E_out_scattered[i*len(time_arr)+j][0, 0,:]\n print(('freq {0},time {1} stored.'.format(freqs[i], time_arr[j])))\n \n return Ref_all","def getHeatFlux(self, T):\n\t\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\n\t\treturn Q","def illuminationEff(freq,fD, FFBW, dB_at_bw, feed_type):\n theta0 = fD2angle(fD,units='degrees')\n dtt = 0.1\n theta = np.arange(0.0,theta0/2.0+dtt,dtt)\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\n theta = theta*math.pi/180.0\n kern = np.sqrt(g)*np.tan(theta/2.0)\n num = 32.0*(fD*integ.trapz(kern,dx=dtt*math.pi/180.0))**2\n kern = g*np.sin(theta)\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\n\n n_ill = num/den \n return n_ill","def temperature_diff_wrapped(q: float,\n delta_tc: np.ndarray,\n T_r:np.ndarray,\n order = 1) -> callable:\n \n def objective_function(T_cr: np.ndarray) -> np.ndarray:\n\n \"\"\"\n the function to minimize in order to get the non-linear\n relationship for the geometrically extrapolated cooled surface temperatures\n \"\"\"\n \n Tm = (T_r + T_cr)/2.0\n ks = thermal_conductivity(Tm)\n T_cr_update = cooled_surface_temp_actual(T_r,q,delta_tc,ks)\n \n return np.linalg.norm(T_cr_update - T_cr,ord = 1)\n \n return objective_function","def manual_calc_kfs(wbwc_list, dec_list, timelen, timesteps):\n global X0\n global wbwc_kfs\n global all_kfs\n ####\n t = np.linspace(0, timelen, timesteps)\n ##\n ## 1. set new wbwc rates\n wbwc_kfs[wbwc_list[0]]['hf'] = wbwc_list[1][0]\n wbwc_kfs[wbwc_list[0]]['hr'] = wbwc_list[1][1]\n wbwc_kfs = fill_wbwc_dict(wbwc_kfs, fill='rates')\n init() \n #####\n ## now, loop for each value of a rate const in dec_list\n for k in dec_list[1]:\n all_kfs[dec_list[0]] = k\n kname = dec_list[0] + str(k)\n ##\n #init() \n set_expdeg()\n ode(calc_model, X0, t, stype='manual', dname = kname)\n ###","def coolingrate(tables, density, He_mass_frac=0.258, metallicity=0.25):\n # list of all elements in table\n elements = [\n x for x in tables.keys() if x not in [\n 'Header', 'Metal_free', 'Solar', 'Total_Metals']\n ]\n \n # Helium mass fraction bins of only hydrogen and helium\n metal_free_He_mass_frac = list(\n tables['Metal_free']['Helium_mass_fraction_bins']\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of /Metal_free/Hydrogen_density_bins, \n # /Metal_free/Temperature_bins, and helium abundance.\n metal_free_ne_nh = list(\n tables['Metal_free']['Electron_density_over_n_h']\n )\n \n # Find index of He mass frac, ssuming direct match in table.\n He_mass_frac_index = metal_free_He_mass_frac.index(np.float32(He_mass_frac))\n # Find index of density bin, ssuming direct match in table.\n abundance_index = list(\n tables[elements[0]]['Hydrogen_density_bins']).index(np.float32(density)\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of temperature at given denisty and helium mass fraction.\n metal_free_ne_nh = list(\n tables['Metal_free']\\\n ['Electron_density_over_n_h']\\\n [He_mass_frac_index, :,abundance_index]\n )\n\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \n # function of temperature at given density for solar abundance.\n solar_ne_nh = tables['Solar']\\\n ['Electron_density_over_n_h']\\\n [:, abundance_index]\n\n # Normalized net cooling rate for only hydrogen and helium as a function of \n # /Metal_free/Hydrogen_density_bins, /Metal_free/Temperature_bins, \n # and helium abundance. \n lambda_metal_free = tables['Metal_free']\\\n ['Net_Cooling']\\\n [He_mass_frac_index, :, abundance_index]\n \n # Temperature bins (T [K])\n T = tables['Metal_free']['Temperature_bins']\n \n sum_metals = np.zeros(352)\n for e in elements:\n # Normalized, net cooling rate e as a function of temperature for \n # Hydrogen density 'density'.\n lambda_i_solar = tables[e]['Net_Cooling'][:,abundance_index]\n \n # Calulating the cooling contribution of element e and addind to total.\n sum_metals += lambda_i_solar*(metal_free_ne_nh/solar_ne_nh)*metallicity\n \n coolingrate = lambda_metal_free + sum_metals\n \n return T, coolingrate","def get_dom_freq(Fk, freq, n_freq):\n\n #get the magnitude of the coefficients\n Fk_abs = np.abs(Fk)\n #sort the coefficients in descending order\n Fk_sort = sorted(Fk_abs, reverse=True)\n \n dom_Fk = []\n dom_f = []\n i = 0\n while i < n_freq:\n inds = np.where(Fk_abs == Fk_sort[i])\n for ind in inds:\n dom_f.append(freq[ind])\n dom_Fk.append(Fk[ind])\n i += 1\n \n #sort based on frequency from lo to hi\n #convert from numpy float to python float for mapping\n dom_f = [float(abs(f)) for f in dom_f]\n f_Fk = dict(zip(dom_f,dom_Fk))\n f_sorted = sorted(dom_f)\n # return(dom_f, f_Fk, f_sorted, dom_Fk)\n\n\n dom_Fk = []\n for f in f_sorted:\n dom_Fk.append(f_Fk[f][0])\n \n return np.array(dom_Fk), np.array(f_sorted)"],"string":"[\n \"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def hinderedRotor_heatCapacity(T, freq, barr):\\n x = constants.h * constants.c * 100. * freq / constants.kB / T\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\\n BB = scipy.special.i1(z) / scipy.special.i0(z)\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x - 0.5 + z * (z - BB - z * BB * BB)\",\n \"def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq\",\n \"def planck_B_nu(freq, T):\\n import numpy as np\\n from astropy import units as u\\n from astropy import constants as c\\n\\n if isinstance(T, u.quantity.Quantity):\\n use_units = True\\n else:\\n T = T * u.K\\n use_units = False\\n\\n if not isinstance(freq, u.quantity.Quantity):\\n freq *= u.Hz\\n\\n T = np.array(T.value, ndmin=1) * T.unit\\n freq = np.array(freq.value, ndmin=1) * freq.unit\\n\\n f_ov_T = freq[np.newaxis, :] / T[:, np.newaxis]\\n mx = np.floor(np.log(np.finfo(f_ov_T.ravel()[0].value).max))\\n exp = np.minimum(f_ov_T * c.h / c.k_B, mx)\\n exp = np.maximum(exp, -mx)\\n\\n output = 2 * c.h * freq**3 / c.c**2 / (np.exp(exp) - 1.0) / u.sr\\n\\n cgsunit = 'erg/(s*sr*cm**2*Hz)'\\n if use_units:\\n return output.to(cgsunit).squeeze()\\n else:\\n return output.to(cgsunit).value.squeeze()\",\n \"def harmonicOscillator_heatCapacity(T, freq):\\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\\n exp_x = math.exp(x)\\n one_minus_exp_x = 1.0 - exp_x\\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x\",\n \"def thermal(isatom, freq, scalfac,linnonlin,T):\\n if isatom != \\\"true\\\":\\n nfreq = len(freq)\\n\\n vib_temp = []\\n for ifreq in range(nfreq):\\n freq[ifreq] = float(freq[ifreq]) * float(scalfac)\\n vib_temp_new = c * 100.0 * h * float(freq[ifreq]) / kB\\n vib_temp.append(vib_temp_new)\\n\\n dE_vib = 0\\n for ifreq in range(nfreq):\\n dE_vib = dE_vib + kB * vib_temp[ifreq] * j2au * ( 0.5 + 1 / ( np.exp(vib_temp[ifreq]/T) - 1) )\\n\\n dE_ZPE = 0.5 * sum(freq) * cmi2au\\n\\n if linnonlin == \\\"L\\\":\\n dE_rot = kB * T * j2au\\n elif linnonlin == \\\"NL\\\":\\n dE_rot = kB * T * j2au * (3.0/2.0)\\n else:\\n with open(\\\"Thermochemistry.out\\\", \\\"a\\\") as ther_chem:\\n ther_chem.write(\\\"ERROR: unknown entry for linear/nonlinear\\\")\\n else:\\n dE_ZPE = 0\\n dE_vib = 0\\n dE_rot = 0\\n\\n dE_tra = kB * T * j2au * (3.0/2.0)\\n dE_thermal = (dE_vib - dE_ZPE) + dE_rot + dE_tra\\n\\n return(dE_ZPE, dE_vib, dE_rot, dE_tra, dE_thermal)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.freerotor_heatcapacity(Tlist, self.frequencies, 1 if self.linear else 0)\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_heatcapacity(Tlist, self.frequency, self.barrier) * self.degeneracy\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy\",\n \"def heat_capacity(r, phi, q, kT):\\n pot = q*(phi - phi[0])\\n a = np.trapz(pot**2 * np.exp(-pot/kT) * r, r)\\n b = np.trapz(pot * np.exp(-pot/kT) * r, r)\\n c = np.trapz(np.exp(-pot/kT) * r, r)\\n return 3/2 + 1/kT**2 * (a/c - b**2/c**2)\",\n \"def rangerate_from_freq(freq,Fc):\\n # print(f'freq {freq} Fc {Fc}')\\n dopp_at_IF = freq - Fc\\n return dopp_at_IF*scipy.constants.speed_of_light/Fc\",\n \"def Hertz_dipole_ff (r, p, R, phi, f, t=0, epsr=1.):\\r\\n nf = len(f)\\r\\n rprime = r-R # r'=r-R\\r\\n if ndim(p) < 2:\\r\\n magrprime = sqrt(sum((rprime)**2))\\r\\n magrprimep = tile(magrprime, (len(f),1)).T\\r\\n phip = tile(phi, (len(f),1))\\r\\n w = 2*pi*f # \\\\omega\\r\\n k = w/c # wave number\\r\\n krp = k*magrprimep # k|r'|\\r\\n rprime_cross_p = cross(rprime, p) # r'x p\\r\\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\\r\\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\\r\\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[0],(nf,1))).T\\r\\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[1],(nf,1))).T\\r\\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[2],(nf,1))).T\\r\\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[0],(nf,1)).T)\\r\\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[1],(nf,1)).T)\\r\\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[2],(nf,1)).T)\\r\\n E = vstack((Ex,Ey,Ez))\\r\\n B = vstack((Bx,By,Bz))\\r\\n else:\\r\\n magrprime = sqrt(sum((rprime)**2,axis=1)) # |r'|\\r\\n magrprimep = tile(magrprime, (len(f),1)).T\\r\\n phip = tile(phi, (len(f),1))\\r\\n fp = tile(f,(len(magrprime),1))\\r\\n w = 2*pi*fp # \\\\omega\\r\\n k = w/c # wave number\\r\\n krp = k*magrprimep # k|r'|\\r\\n rprime_cross_p = cross(rprime, p) # r'x p\\r\\n rp_c_p_c_rp = cross(rprime_cross_p, rprime) # (r' x p) x r'\\r\\n expfac = exp(1j*(w*t-krp+phip.T))/(4*pi*eps0*epsr)\\r\\n Ex = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,0],(nf,1))).T\\r\\n Ey = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,1],(nf,1))).T\\r\\n Ez = (w**2/(c**2*magrprimep**3) * expfac)* (tile(rp_c_p_c_rp[:,2],(nf,1))).T\\r\\n Bx = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,0],(nf,1)).T)\\r\\n By = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,1],(nf,1)).T)\\r\\n Bz = expfac/(magrprimep**2*c**3)*(w**2*tile(rprime_cross_p[:,2],(nf,1)).T)\\r\\n E = vstack((sum(Ex,axis=0),sum(Ey,axis=0),sum(Ez,axis=0)))\\r\\n B = vstack((sum(Bx,axis=0),sum(By,axis=0),sum(Bz,axis=0)))\\r\\n return E,B\",\n \"def compute_energy_density(kT):\\n h=u.planck\\n c=u.speed_of_light\\n pi=np.pi\\n return (8*pi/(h*c)**3)*((pi*kT)**4/15)\",\n \"def fuel_cond(T):\\n\\n kc = 1.841e-19*math.pow(T,6) - 2.097e-15*math.pow(T,5) +\\\\\\n 9.721e-12*math.pow(T,4) - 2.369e-8*math.pow(T,3) +\\\\\\n 3.283e-5*math.pow(T,2) - 0.0267*T + 63.18\\n \\n return kc\",\n \"def deltaTOverTcmbToJyPerSr(freqGHz,T0 = 2.726):\\n kB = 1.380658e-16\\n h = 6.6260755e-27\\n c = 29979245800.\\n nu = freqGHz*1.e9\\n x = h*nu/(kB*T0)\\n cNu = 2*(kB*T0)**3/(h**2*c**2)*x**4/(4*(np.sinh(x/2.))**2)\\n cNu *= 1e23\\n return cNu\",\n \"def gyroHF(self, GYRO, PFC):\\n print(\\\"Calculating gyro orbit heat loads\\\")\\n log.info(\\\"Calculating gyro orbit heat loads\\\")\\n #get divertor HF\\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\\n #Get fractional multipliers for each helical trace\\n gyroFrac = 1.0/GYRO.N_gyroPhase\\n vPhaseFrac = 1.0/GYRO.N_vPhase\\n vSliceFrac = GYRO.energyFracs\\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\\n Pgyro = np.zeros((GYRO.Nt))\\n PNaN = 0.0\\n sum=0\\n sum1=0\\n #loop through intersect record and redistribute power using multipliers\\n for gyroPhase in range(GYRO.N_gyroPhase):\\n for vPhase in range(GYRO.N_vPhase):\\n for vSlice in range(GYRO.N_vSlice):\\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\\n notNanTo = notNanTo.astype(int) #cast as integer\\n isNanTo = idx[np.isnan(idx)] #indices we map power to\\n isNanTo = isNanTo.astype(int) #cast as integer\\n\\n if len(notNanFrom)>0:\\n #multiple Froms can light up the same To, so we loop\\n for i in range(len(notNanFrom)):\\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\\n\\n if len(isNanFrom)>0:\\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\\n\\n #print(\\\"\\\\nTEST2\\\")\\n #print(GYRO.intersectRecord[0,0,0,1711])\\n #print(Pgyro[1711])\\n\\n GYRO.gyroPowMatrix += Pgyro\\n GYRO.gyroNanPower += PNaN\\n return\",\n \"def calc_dtdc(tpbpcs, specs):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n Nbs = len(np.hstack(tpbpcs[0]))\\n Ndraw = len(tpbpcs)\\n\\n dtpb = np.zeros((Ndraw, Nbs)) # Time per band\\n dcomp = np.zeros((Ndraw, Nbs)) # completeness\\n dtdc = np.zeros((Ndraw, Nbs)) # d(time) / d(completeness)\\n\\n for i in range(Ndraw):\\n\\n # Create array of times per bandpass\\n dtpb[i,:] = np.hstack(tpbpcs[i])\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[i,j] = (specs[i][0][j][-1] - specs[i][0][j][0] + np.mean(specs[i][1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def get_granule_frequency(self,r=None,ids=None):\\n # Simply divide the length of each spike vector by the simulation time\\n # or window time.\\n spikes=[] # The local copy of spikes to get the frequency on\\n try:\\n spikes=self.get_granule_spikes(r,ids)\\n if len(spikes)==0:\\n raise Exception('Unable to get mitral cell spikes')\\n except Exception:\\n raise\\n freqg=numpy.zeros(self.num_gran)\\n timems=self.sim_time\\n if type(r) is tuple and len(r)==2:\\n timems=float(r[1]-r[0])\\n for i in range(len(spikes)):\\n freqg[i]=float(len(spikes[i]))*1000./timems\\n return freqg\",\n \"def calc_dtdc_star(tpbpc0, spec):\\n\\n # Calc wavelength range of channels\\n deltas = []\\n for channel in CHANNELS:\\n l = default_luvoir(channel=channel)\\n deltas.append(l.lammax - l.lammin)\\n deltas = np.array(deltas)\\n\\n # Create array of times per bandpass\\n dtpb = np.hstack(tpbpc0)\\n\\n Nbs = len(dtpb)\\n dcomp = np.zeros(Nbs) # completeness\\n dtdc = np.zeros(Nbs) # d(time) / d(completeness)\\n\\n for j in range(Nbs):\\n\\n # Calculate delta completeness: fractional increase in completeness from observing this band\\n dcomp[j] = (spec[0][j][-1] - spec[0][j][0] + np.mean(spec[1][j][:])) / np.sum(deltas)\\n\\n # Calculate d(exposure time) / d(completeness)\\n dtdc = dtpb / dcomp\\n\\n return dtpb, dcomp, dtdc\",\n \"def getHeatCapacity(self, Tlist, V=1.0):\\n\\t\\treturn _modes.translation_heatcapacity(Tlist, self.mass, self.dimension, V)\",\n \"def compute_ctf(freqs,rots,akv,cs,wgh,dfmid1f,dfmid2f,angastf,dscale,bfactor=None): \\n av = akv * 1e3 # Convert kilovots to volts\\n cs = cs * 1e7 # Convert spherical aberation from mm to A\\n \\n # wavelength of electrons\\n elambda = 12.2643247 / n.sqrt(av + av**2 * 0.978466e-6)\\n \\n wgh1 = dscale*n.sqrt(1.0 - wgh**2)\\n wgh2 = dscale*wgh\\n\\n ix = freqs[:,0]\\n iy = freqs[:,1]\\n freq_radius = n.sqrt(ix**2 + iy**2)\\n\\n angle = elambda*freq_radius\\n angspt = n.arctan2(iy,ix)\\n if rots is not None:\\n angspt = n.mod(angspt.reshape((-1,1)) + rots.reshape((1,-1)),2.0*n.pi)\\n angle = angle.reshape((-1,1)) \\n c1 = 2.0*n.pi*angle**2/(2.0*elambda)\\n c2 = -c1*cs*angle**2/2.0\\n angdif = angspt - angastf\\n ccos = n.cos(2.0*angdif)\\n df = 0.5*(dfmid1f + dfmid2f + ccos*(dfmid1f-dfmid2f))\\n chi = c1*df + c2\\n\\n ctf = -wgh1*n.sin(chi) - wgh2*n.cos(chi)\\n \\n if bfactor is not None:\\n ctf *= envelope_function(freq_radius, bfactor)\\n\\n return n.require(ctf,dtype = freqs.dtype)\",\n \"def CMB_spec(eng, temp):\\n if np.issubdtype(type(eng), float):\\n eng = np.array([eng])\\n prefactor = 8*np.pi*(eng**2)/((ele_compton*me)**3)\\n phot_spec_density = prefactor*[1/(np.exp(photeng/temp) - 1) if photeng/temp < 500 else 0 for photeng in eng]\\n\\n if np.issubdtype(type(eng), float): \\n return phot_spec_density[0] \\n else: \\n return phot_spec_density\",\n \"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\\n\\n # You must specify at least 7 heat capacity points to use in the fitting;\\n # you can specify as many as you like above that minimum\\n if len(Tlist) < 7:\\n raise StatmechFitError('You must specify at least 7 heat capacity points to fitStatmechToHeatCapacity().')\\n if len(Tlist) != len(Cvlist):\\n raise StatmechFitError('The number of heat capacity points ({0:d}) does not match the number of temperatures provided ({1:d}).'.format(len(Cvlist), len(Tlist)))\\n\\n # The number of optimization variables available is constrained to be less\\n # than the number of heat capacity points\\n # This is also capped to a (somewhat arbitrarily chosen) maximum of 16\\n maxVariables = len(Tlist) - 1\\n if maxVariables > 16: maxVariables = 16\\n\\n # The type of variables fitted depends on the values of Nvib and Nrot and\\n # the number of heat capacity points provided\\n # For low values of Nvib and Nrot, we can fit the individual\\n # parameters directly\\n # For high values of Nvib and/or Nrot we are limited by the number of\\n # temperatures we are fitting at, and so we can only fit\\n # pseudo-oscillators and/or pseudo-rotors\\n vib = []; hind = []\\n if Nvib <= 0 and Nrot <= 0:\\n pass\\n elif Nvib + 2 * Nrot <= maxVariables:\\n vib, hind = fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule)\\n elif Nvib + 2 <= maxVariables:\\n vib, hind = fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule)\\n else:\\n vib, hind = fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule)\\n\\n modes = []\\n if Nvib > 0:\\n vib.sort()\\n ho = HarmonicOscillator(frequencies=(vib[:],\\\"cm^-1\\\"))\\n modes.append(ho)\\n for i in range(Nrot):\\n freq = hind[i][0]\\n barr = hind[i][1]\\n inertia = (barr*constants.c*100.0*constants.h) / (8 * math.pi * math.pi * (freq*constants.c*100.0)**2)\\n barrier = barr*constants.c*100.0*constants.h*constants.Na\\n hr = HinderedRotor(inertia=(inertia*constants.Na*1e23,\\\"amu*angstrom^2\\\"), barrier=(barrier/1000.,\\\"kJ/mol\\\"), symmetry=1, semiclassical=False, quantum=False)\\n modes.append(hr)\\n\\n # Return the fitted modes\\n return modes\",\n \"def get_F_potential(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n # y = chemical_potential/temperature\\n y = chemical_potential / tt\\n F = gbar / np.sqrt(2.0) / np.pi ** 2 * tt ** (2.5) * vv\\n F *= y * _1d_call(_fdk, y, k=0.5) - 2.0 / 3.0 * _1d_call(_fdk, y, k=1.5)\\n return F\",\n \"def DFTscargle(times, signal,f0,fn,df):\\n f0 = 0.\\n #fn *= 2*np.pi\\n #df *= 2*np.pi\\n #-- initialize\\n nfreq = int((fn-f0)/(df))\\n print \\\"Nfreq=\\\",nfreq\\n tzero = times[0]\\n si = 1.\\n lfreq = 2*nfreq+1\\n mm = 2*nfreq\\n ftrx = np.zeros(mm)\\n ftix = np.zeros(mm)\\n om = np.zeros(mm)\\n w = np.zeros(mm)\\n wz = df #pi/(nn+dt)\\n nn = len(times)\\n \\n #-- calculate DFT\\n ftrx,ftix,om,w = pydft.ft(signal,times,wz,nfreq,si,lfreq,tzero,df,ftrx,ftix,om,w,nn,mm)\\n \\n if f0==0:\\n ftrx[1:] *= np.sqrt(2)\\n ftix[1:] *= np.sqrt(2)\\n w[1:] *= np.sqrt(2)\\n \\n cut_off = len(w)\\n for i in range(0,len(w))[::-1]:\\n if w[i] != 0: cut_off = i+1;break\\n \\n om = om[:cut_off]\\n ftrx = ftrx[:cut_off]\\n ftix = ftix[:cut_off]\\n w = w[:cut_off]\\n \\n # norm amplitudes for easy inversion\\n T = times[-1]-times[0]\\n N = len(times)\\n \\n w *= T/(2.*N)\\n ftrx *= T/(2.*N)\\n ftix *= T/(2.*N)\\n \\n return om*2*np.pi,w,ftrx,ftix\",\n \"def frfplot(freq, H, freq_min=0, freq_max=None, type=1, legend=[]):\\n FLAG = type # Plot type, should libe renamed throughout.\\n freq = freq.reshape(1, -1)\\n lenF = freq.shape[1]\\n if len(H.shape) is 1:\\n H = H.reshape(1, -1)\\n\\n if H.shape[0] > H.shape[1]:\\n H = H.T\\n\\n if freq_max is None:\\n freq_max = np.max(freq)\\n\\n if freq_min is None:\\n freq_min = np.min(freq)\\n\\n if freq_min < np.min(freq):\\n freq_min = np.min(freq)\\n\\n if freq_min > freq_max:\\n raise ValueError('freq_min must be less than freq_max.')\\n\\n # print(str(np.amin(freq)))\\n inlow = int(lenF * (freq_min - np.amin(freq)\\n ) // (np.amax(freq) - np.amin(freq)))\\n\\n inhigh = int(lenF * (freq_max - np.amin(freq)\\n ) // (np.amax(freq) - np.amin(freq)) - 1)\\n # if inlow<1,inlow=1;end\\n # if inhigh>lenF,inhigh=lenF;end\\n \\\"\\\"\\\"print('freq shape: {}'.format(freq.shape))\\n print('H shape: {}'.format(H.shape))\\n print('Index of low frequency: {}'.format(inlow))\\n print('Index of high frequency: {}'.format(inhigh))\\\"\\\"\\\"\\n H = H[:, inlow:inhigh]\\n # print(H.shape)\\n freq = freq[:, inlow:inhigh]\\n mag = 20 * np.log10(np.abs(H))\\n # print(mag)\\n # print(mag.shape)\\n minmag = np.min(mag)\\n maxmag = np.max(mag)\\n phase = np.unwrap(np.angle(H)) * 180 / np.pi\\n # phmin_max=[min(phase)//45)*45 ceil(max(max(phase))/45)*45];\\n phmin = np.amin(phase) // 45 * 45.0\\n phmax = (np.amax(phase) // 45 + 1) * 45\\n \\\"\\\"\\\"minreal = np.amin(np.real(H))\\n maxreal = np.amax(np.real(H))\\n minimag = np.amin(np.imag(H))\\n maximag = np.amax(np.imag(H))\\\"\\\"\\\"\\n\\n if FLAG is 1:\\n fig, (ax1, ax2) = plt.subplots(2, 1)\\n ax1.plot(freq.T, mag.T)\\n ax1.set_xlabel('Frequency (Hz)')\\n ax1.set_ylabel('Mag (dB)')\\n ax1.grid()\\n ax1.set_xlim(xmax=freq_max, xmin=freq_min)\\n ax1.set_ylim(ymax=maxmag, ymin=minmag)\\n\\n ax2.plot(freq.T, phase.T)\\n ax2.set_xlabel('Frequency (Hz)')\\n ax2.set_ylabel('Phase (deg)')\\n ax2.grid()\\n ax2.set_xlim(xmax=freq_max, xmin=freq_min)\\n ax2.set_ylim(ymax=phmax, ymin=phmin)\\n ax2.set_yticks(np.arange(phmin, (phmax + 45), 45))\\n fig.tight_layout()\\n\\n if len(legend) > 0:\\n plt.legend(legend)\\n ax = (ax1, ax2)\\n else:\\n print(\\\"Sorry, that option isn't supported yet\\\")\\n return ax\\n\\n \\\"\\\"\\\"# elif FLAG==2:\\n # subplot(2,1,1)\\n # semilogx(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # % Fmin,Fmax,min(mag),max(mag)\\n # axis([Fmin Fmax minmag maxmag])\\n\\n # subplot(2,1,2)\\n # semilogx(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n\\n # elif FLAG==3:\\n # subplot(2,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F*2*pi,mag)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Wmin Wmax minmag maxmag])\\n # zoom on\\n # subplot(2,1,2)\\n # semilogx(F*2*pi,phase)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n\\n # elseif FLAG==4\\n # subplot(2,1,1)\\n # plot(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # subplot(2,1,2)\\n # plot(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==5\\n # subplot(1,1,1)\\n # imax=round(length(F)*Fmax/max(F));\\n # imin=round(length(F)*Fmin/max(F))+1;\\n # plot(real(Xfer(imin:imax)),imag(Xfer(imin:imax)))\\n # xlabel('Real')\\n # ylabel('Imaginary')\\n # grid on\\n # zoom on\\n # elseif FLAG==6\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # plot(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==7\\n # subplot(1,1,1)\\n # plot(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # elseif FLAG==8\\n # subplot(1,1,1)\\n # plot(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # elseif FLAG==9\\n # subplot(1,1,1)\\n # plot(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==10\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==11\\n # subplot(1,1,1)\\n # semilogx(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # elseif FLAG==12\\n # subplot(1,1,1)\\n # semilogx(F,real(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Real')\\n # grid on\\n # axis([Fmin Fmax minreal maxreal])\\n # zoom on\\n # elseif FLAG==13\\n # subplot(1,1,1)\\n # semilogx(F,imag(Xfer))\\n # xlabel('Frequency (Hz)')\\n # ylabel('Imaginary')\\n # grid on\\n # axis([Fmin Fmax minimag maximag])\\n # zoom on\\n # elseif FLAG==14\\n # subplot(1,1,1)\\n # mag=20*log10(abs(Xfer));\\n # semilogx(F*2*pi,mag)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Wmin Wmax minmag maxmag])\\n # zoom on\\n # elseif FLAG==15\\n # subplot(1,1,1)\\n # semilogx(F*2*pi,phase)\\n # xlabel('Frequency (Rad/s)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # axis([Wmin Wmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n # else\\n # subplot(2,1,1)\\n # mag=20*log10(abs(Xfer));\\n # plot(F,mag)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Mag (dB)')\\n # grid on\\n # axis([Fmin Fmax minmag maxmag])\\n # zoom on\\n # subplot(2,1,2)\\n # plot(F,phase)\\n # xlabel('Frequency (Hz)')\\n # ylabel('Phase (deg)')\\n # grid on\\n # phmin_max=[floor(min(phase)/45)*45 ceil(max(phase)/45)*45];\\n # axis([Fmin Fmax phmin_max(1) phmin_max(2)])\\n # gridmin_max=round(phmin_max/90)*90;\\n # set(gca,'YTick',gridmin_max(1):90:gridmin_max(2))\\n # zoom on\\n \\\"\\\"\\\"\",\n \"def fcut(r, rcut, trans_width):\\n if (isinstance(r, list) or isinstance(r, np.ndarray)) and len(r) > 1:\\n return np.array([fcut(ri, rcut, trans_width) for ri in r])\\n else:\\n if r > rcut:\\n return 0.\\n elif r > rcut-trans_width:\\n return 0.5*(np.cos(np.pi*(r-rcut+trans_width)/trans_width) + 1)\\n else:\\n return 1.0\",\n \"def butterworth_filter(freq):\\n\\tf_raw = 1/(0.00000002*100*33)\\n\\tb = np.array([[-32092,15750],[-31238,14895]])*2.0**(-14)\\n\\tomega = 2*np.pi*freq/f_raw\\n\\te1, e2 = np.exp(-1j*omega), np.exp(-2j*omega)\\n\\ttmp = (1+2*e1+e2)**2/(1+b[0,0]*e1+b[0,1]*e2)/(1+b[1,0]*e1+b[1,1]*e2)\\n\\treturn tmp * (1+sum(b[0]))*(1+sum(b[1]))/16\",\n \"def gyroHF2(self, GYRO, PFC):\\n print(\\\"Calculating gyro orbit heat loads\\\")\\n log.info(\\\"Calculating gyro orbit heat loads\\\")\\n #get divertor HF\\n qDiv = PFC.qDiv[PFC.PFC_GYROmap] / self.elecFrac\\n Pdiv = qDiv * PFC.areas[PFC.PFC_GYROmap]\\n #Get fractional multipliers for each helical trace\\n gyroFrac = 1.0/GYRO.N_gyroPhase\\n vPhaseFrac = 1.0/GYRO.N_vPhase\\n vSliceFrac = GYRO.energyFracs\\n #qMatrix = np.zeros((GYRO.N_gyroPhase,GYRO.N_vPhase,GYRO.N_vSlice,len(q)))\\n Pgyro = np.zeros((GYRO.Nt))\\n PNaN = 0.0\\n sum=0\\n sum1=0\\n #loop through intersect record and redistribute power using multipliers\\n for gyroPhase in range(GYRO.N_gyroPhase):\\n for vPhase in range(GYRO.N_vPhase):\\n for vSlice in range(GYRO.N_vSlice):\\n idx = GYRO.intersectRecord[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap]\\n hdotn = np.abs(GYRO.hdotn[gyroPhase,vPhase,vSlice,PFC.CADHOT_GYROmap])\\n isNanFrom = np.where(np.isnan(idx)==True)[0] #include NaNs (NaNs = no intersection) index we map from\\n notNanFrom = np.where(np.isnan(idx)==False)[0] #dont include NaNs (NaNs = no intersection) index we map from\\n notNanTo = idx[~np.isnan(idx)] #indices we map power to\\n notNanTo = notNanTo.astype(int) #cast as integer\\n isNanTo = idx[np.isnan(idx)] #indices we map power to\\n isNanTo = isNanTo.astype(int) #cast as integer\\n\\n if len(notNanFrom)>0:\\n #multiple sources can load the same target face, so we loop\\n for i in range(len(notNanFrom)):\\n Pgyro[notNanTo[i]] += Pdiv[notNanFrom[i]]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[notNanFrom[i],vSlice]\\n\\n if len(isNanFrom)>0:\\n PNaN += np.sum(Pdiv[isNanFrom]*GYRO.ionFrac*gyroFrac*vPhaseFrac*vSliceFrac[isNanFrom,vSlice])\\n\\n\\n GYRO.gyroPowMatrix += Pgyro\\n GYRO.gyroNanPower += PNaN\\n return\",\n \"def butter_hpf(highcut, fs, order):\\n nyq = 0.5 * fs\\n high = highcut / nyq\\n b, a = signal.butter(order, high, btype='highpass')\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def trc_fgen_prefb(self,trc,dt,nspad=200,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n pad=np.random.rand(nspad)/100\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_norm_padded=np.hstack((pad,trc_norm))\\n trc_entropy=self.entropy(trc_norm_padded,50)\\n trc_fdm=self.fdm(trc_norm_padded,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm_padded,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm_padded,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm_padded,hwin2)\\n for i,j in enumerate(trc):\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm_padded[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm_padded)))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(nspad+fb/dt)-vlen+1:np.int(nspad+fb/dt)+1])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def stepfall(double[:] v, redshifts, in_terms, double H0):\\n\\n cdef double t = v[0]\\n cdef double a = v[1]\\n # ombar_i = rho_i(t) / rho_crit(t0)\\n cdef double ombar_m = v[2]\\n cdef double ombar_r = v[3]\\n cdef double ombar_a = v[4]\\n cdef double ombar_de = v[5]\\n cdef double z = v[6]\\n cdef double dl = v[7]\\n\\n cdef double in_v = in_terms[0]\\n cdef double in_w = in_terms[1]\\n cdef double in_x = in_terms[2]\\n\\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_a +ombar_de)**(0.5)\\n\\n# if ombar_m < 0 or ombar_de < 0 or ombar_r < 0 or ombar_a < 0:\\n# print('stepfall')\\n# print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\\n# print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\\n# 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\\n\\n if math.isnan(Hz):\\n print('stepfall')\\n print('z = %s, Hz = %s, in_terms = %s'% (z, Hz, in_terms))\\n print('ombar_m = ',ombar_m,'ombar_r = ',ombar_r,\\n 'ombar_a = ',ombar_a,'ombar_de = ',ombar_de)\\n\\n cdef double dtdz = -1.0/((1.0+z) * Hz)\\n cdef double dadz = -(1.0+z)**(-2.0)\\n # d(ombar_i)/dz\\n cdef double domdz = (3.0*ombar_m +in_v*ombar_m*ombar_r/Hz)/(1.0+z) # w = 0\\n cdef double dordz = (4.0*ombar_r -in_v*ombar_m*ombar_r/Hz +in_w*ombar_r*ombar_a/Hz)/(1.0+z) # w = 1/3\\n cdef double doadz = (2.7*ombar_a -in_w*ombar_r*ombar_a/Hz +in_x*ombar_a*ombar_de/Hz)/(1.0+z) # w = -0.1\\n cdef double dodedz = -in_x*ombar_a*ombar_de/(1.0+z)/Hz # w = -1\\n cdef double ddldz = 1.0/Hz\\n\\n # first derivatives of functions I want to find:\\n f = [dtdz, # time\\n dadz, # scale factor\\n domdz, # w = 0\\n dordz, # w = 1/3\\n doadz, # w = -0.1\\n dodedz,# w = -1\\n 1.0, # redshift\\n ddldz] # luminosty distance\\n\\n return f\",\n \"def fourierBeam(self, centres, u_bl, v_bl, frequency, min_attenuation = 1e-10, N = 20):\\n \\n a = 1/ (2 * self._instr_core.sigma(frequency)**2)\\n \\n indx_u = np.digitize(u_bl, centres)\\n indx_v = np.digitize(v_bl, centres)\\n \\n beam = []\\n \\n for jj in range(len(u_bl)):\\n x, y = np.meshgrid(centres[indx_u[jj]-int(N/2):indx_u[jj]+int(N/2)], centres[indx_v[jj]-int(N/2):indx_v[jj]+int(N/2)],copy=False)\\n B = (np.exp(- ((x - u_bl[jj])**2 + (y - v_bl[jj])**2 )/ a)).T\\n B[B<min_attenuation] = 0\\n beam.append(B)\\n \\n indx_u+= -int(N/2)\\n indx_v+= -int(N/2)\\n \\n indx_u[indx_u<0] = 0\\n indx_v[indx_v<0] = 0 \\n \\n return beam, indx_u, indx_v\",\n \"def doCalculation(self, E1, E2, muL, muR, T, pot, C, TCalc, Density, E0, L):\\n NEcut = len(E1) #we determine the number of single-particle states that we use\\n VG=np.diag(pot)\\n E= int(0.5*np.size(VG))\\n V = VG[0:E] #since the potential of both barriers is symmetric and we only tunnel through one barrier. Therefore we only use one half of the potential.\\n dx= L/(np.size(pot))\\n\\n #Following prints are for debugging purposes:\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"Hier beginnt die Ausgabe von Rates:\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n #print(\\\"V:\\\", V)\\n #print(\\\"E1:\\\", E1)\\n #print(\\\"E2:\\\", E2)\\n #print(\\\"C:\\\", C)\\n\\n kB=0.08629 #Boltzmann constant in meV/K\\n \\n \\n def fermi(E,mu,T):\\n \\\"\\\"\\\"This fermi-function tells us with which likelyhood a state with an E is occupied on the lead.\\n E(float): energy difference between the initial and the final state that the tunneling electron has to carry.\\n mu(float): chemical potential of either drain(muR) or source(muL).\\n T(float): temperature.\\n \\\"\\\"\\\"\\n if (E-mu)/T > 600:\\n f=0\\n\\t\\t\\t\\t\\n else:\\n f=1/(math.exp((E-mu)/(kB*T) )+1)\\n return(f)\\n \\n\\n\\t#This function is called by the Gamma_ij-equations and includes the transmission-coefficient for each tunnelling-event\\n #and the density of state function of the source and drain. \\n def Gamma(Ea,Eb,V):\\n \\\"\\\"\\\":math:`\\\\\\\\Gamma` includes the transmission coefficient and DOS: :math:`\\\\Gamma = | t |^2 * DOS`\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n V(np.array): barrier potential\\n \\\"\\\"\\\"\\n #print(Ea)\\n #print(V)\\n return (np.absolute(TCalc.calculate_transmission(Ea,V,dx))**2*Density.calculate_DensityofStates(np.absolute(Ea-Eb)))\\n \\n #These next four functions are used to calculate the transition rates.Each function for a different kind of transition:\\n #We distinguish between transitions, in which the number of electrons on the dot changes from one to two(Gamma_12) and reverse(Gamma_21).\\n #And between transitions in which the number of electrons on the dot change from zero to one(Gamma_01) and reverse(Gamma_10).\\n\\n def Gamma_12(Ea,Eb,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a one body state to a two body state.\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n summe=0\\n j=0\\n Cb=C[np.where(E2==Eb)[0][0]]\\n while j< NEcut:\\n summe=Cb[np.where(E1==Ea)[0][0]][j]+summe\\n j=j+1\\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*fermi((Eb-Ea),mu,T))\\n\\n\\n def Gamma_01(Eb,mu,T):\\n \\\"\\\"\\\"Calculates the transition rate from the vacuum state to a one-body state.\\n\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n return(Gamma(E0,Eb,V)*fermi((Eb-E0),mu,T))\\n\\n def Gamma_21(Ea,Eb,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a two body state to a one body state.\\n\\n Ea(float): energy of initial state\\n Eb(float): energy of final state\\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n summe=0\\n nu=0\\n Ca=C[np.where(E2==Ea)[0][0]]\\n while nu < NEcut:\\n summe=summe+Ca[np.where(E1==Eb)[0][0]][nu]\\n nu=nu+1\\n return(Gamma(Ea,Eb,V)*(np.absolute(summe))**2*(1-fermi((Ea-Eb),mu,T)))\\n\\n def Gamma_10(Ea,mu,T):\\n \\\"\\\"\\\"Calculates the rate of a transition from a one body state to the vacuum state.\\n\\n Ea(float): energy of initial state \\n mu(float): chemical potential of either drain(muR) or source(muL)\\n T(float): temperature\\n \\\"\\\"\\\"\\n return(Gamma(Ea,E0,V)*(1-fermi((Ea-E0),mu,T)))\\n\\n #creating the output matrices that later contain all the transition rates through either\\n #the left or the right barrier\\n Gamma_R=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\\n Gamma_L=np.zeros((1+np.size(E1)+np.size(E2),1+np.size(E1)+np.size(E2)))\\n\\n #using a loop to fill the output matrices with transition rates.\\n i_=0\\n for i in E1:\\n j_=0\\n for j in E2:\\n Gamma_L[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muL,T)\\n Gamma_L[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muL,T)\\n Gamma_R[i_+1][j_+1+np.size(E1)]=Gamma_12(i,j,muR,T)\\n Gamma_R[j_+1+np.size(E1)][i_+1]=Gamma_21(j,i,muR,T)\\n j_=j_+1\\n Gamma_L[0][i_+1]=Gamma_10(i,muL,T)\\n Gamma_R[0][i_+1]=Gamma_10(i,muR,T)\\n Gamma_L[i_+1][0]=Gamma_01(i,muL,T)\\n Gamma_R[i_+1][0]=Gamma_01(i,muR,T)\\n i_=1+i_\\n\\n #print(\\\"Gamma_L und Gamma_R:\\\")\\n #print(Gamma_L,Gamma_R)\\n #print(\\\"-----------------------------------------------------------------------\\\")\\n #print(\\\"---------------------------------------------------------------------\\\")\\n return(Gamma_L,Gamma_R)\",\n \"def thermodynamic_temperature(frequency, T_cmb=None):\\n nu = frequency.to(si.GHz, spectral())\\n\\n if T_cmb is None:\\n from astropy.cosmology import default_cosmology\\n\\n T_cmb = default_cosmology.get().Tcmb0\\n\\n def f(nu, T_cmb=T_cmb):\\n x = _si.h * nu / _si.k_B / T_cmb\\n return x**2 * np.exp(x) / np.expm1(x) ** 2\\n\\n def convert_Jy_to_K(x_jybm):\\n factor = (f(nu) * 2 * _si.k_B * si.K * nu**2 / _si.c**2).to_value(\\n astrophys.Jy\\n )\\n return x_jybm / factor\\n\\n def convert_K_to_Jy(x_K):\\n factor = (astrophys.Jy / (f(nu) * 2 * _si.k_B * nu**2 / _si.c**2)).to_value(\\n si.K\\n )\\n return x_K / factor\\n\\n return Equivalency(\\n [(astrophys.Jy / si.sr, si.K, convert_Jy_to_K, convert_K_to_Jy)],\\n \\\"thermodynamic_temperature\\\",\\n {\\\"frequency\\\": frequency, \\\"T_cmb\\\": T_cmb},\\n )\",\n \"def mce_filter(freq, f_raw, params):\\n\\tz = np.exp(-2j*np.pi*freq/f_raw)\\n\\tb11, b12, b21, b22 = np.array(params[:4])*0.5**14\\n\\tH = (1+z)**4 / (1-b11*z+b12*z**2) / (1-b21*z+b22*z**2)\\n\\tH /= 2**4 / (1-b11+b12) / (1-b21+b22)\\n\\treturn H\",\n \"def torch_mel_to_hertz(frequencies_mel):\\r\\n # return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n # tf.math.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\\r\\n return _MEL_BREAK_FREQUENCY_HERTZ * (\\r\\n np.exp(frequencies_mel / _MEL_HIGH_FREQUENCY_Q) - 1.)\",\n \"def exotic(double[:] v, redshifts, in_terms, double H0):\\n\\n cdef double t = v[0]\\n cdef double a = v[1]\\n cdef double ombar_m = v[2]\\n cdef double ombar_r = v[3]\\n cdef double ombar_de = v[4]\\n cdef double z = v[5]\\n cdef double dl = v[6]\\n cdef double gamma = in_terms[0]\\n cdef double zeta = in_terms[1]\\n\\n cdef double Hz = H0 * (ombar_m +ombar_r +ombar_de)**(0.5)\\n\\n# if ombar_m < 0 or ombar_de < 0:\\n# print('exotic')\\n# print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\\n# print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\\n# % (ombar_m, ombar_r, ombar_de))\\n\\n if math.isnan(Hz):\\n print('exotic')\\n print('z = %s, Hz = %s, gamma = %s, zeta = %s'% (z, Hz, gamma, zeta))\\n print('ombar_m = %s, ombar_r = %s, ombar_de = %s'\\n % (ombar_m, ombar_r, ombar_de))\\n\\n cdef double dtdz = -1.0/((1.0+z) * Hz)\\n cdef double dadz = -(1.0+z)**(-2.0)\\n cdef double domdz = (3.0*ombar_m +gamma*ombar_m*ombar_r /Hz) /(1.0+z)\\n cdef double dordz = (4.0*ombar_r -(gamma*ombar_m*ombar_r -zeta*ombar_r*ombar_de) /Hz ) /(1.0+z)\\n cdef double dodedz = -zeta*ombar_r*ombar_de/(1.0+z) /Hz\\n cdef double ddldz = 1.0/Hz\\n\\n # first derivatives of functions I want to find:\\n f = [dtdz,# dt/dz (= f.d wrt z of time)\\n dadz,# d(a)/dz (= f.d wrt z of scale factor)\\n domdz,# dw = 0, (ombar_m)/dz (= f.d wrt z of density_m(t) / crit density(t0))\\n dordz,# w = 1/3, d(ombar_r)/dz (= f.d wrt z of density_r(t) / crit density(t0))\\n dodedz,# w = -1, d(ombar_de)/dz (= f.d wrt z of density_de(t) / crit density(t0))\\n 1.0,# d(z)/dz (= f.d wrt z of redshift)\\n ddldz]# d(dl)/dz (= f.d wrt z of luminosty distance) # H + Hdz*(1+z)\\n\\n return f\",\n \"def get_heat_capacity_volume(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_V_low = 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n C_V_low -= 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n C_V_low *= gbar * np.sqrt(2) / (4 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_V_low /= _1d_call(_fdk, y_low, k=-1 / 2)\\n # low temperatures - high numbers\\n C_V_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_V_low, C_V_high)).reshape(y.shape)\",\n \"def get_rec_rate_H_caseB_Dr11(T):\\n T4 = T*1e-4\\n return 2.54e-13*T4**(-0.8163 - 0.0208*np.log(T4))\",\n \"def lrelfreq(inlist,numbins=10,defaultreallimits=None):\\r\\n h,l,b,e = histogram(inlist,numbins,defaultreallimits)\\r\\n for i in range(len(h)):\\r\\n h[i] = h[i]/float(len(inlist))\\r\\n return h,l,b,e\",\n \"def getHeatCapacity(self, Tlist):\\n\\t\\tCp = np.ones((len(Tlist)), np.float64)\\n\\t\\tfor mode in self.modes:\\n\\t\\t\\tCp += mode.getHeatCapacity(Tlist)\\n\\t\\treturn Cp\",\n \"def __init__(self, N=1024, fc=50., tmax=1., delay=None):\\n fc = float(fc)\\n tmax = float(tmax)\\n dt = tmax / (N-1)\\n df = 1. / tmax\\n istart = -N//2 + 1\\n nroll = -istart\\n t = np.arange(istart, N // 2 + 1) * dt\\n f = np.arange(istart, N // 2 + 1) * df\\n # arrange f as positve, negative freqs\\n f = np.roll(f, -nroll)\\n\\n # freq domain ricker\\n ricker_f = 2 * f**2 / (np.sqrt(np.pi) * fc**3) * np.exp(-(f/fc)**2)\\n\\n if delay is None:\\n delay = 1.5 / fc\\n ricker_f = ricker_f * np.exp(-1j * 2 * np.pi * f * delay)\\n\\n # time domain ricker\\n ricker_t = N * np.real(np.fft.ifft(ricker_f))\\n\\n\\n amp = np.absolute(ricker_f)\\n phase = np.unwrap(np.angle(ricker_f, False))\\n\\n # ricker_f[0] contains the zero frequency term,\\n # ricker_f[1:N//2] contains the positive-frequency terms,\\n # ricker_f[N//2 + 1:] contains the negative-frequency terms,\\n # in increasing order starting from the most negative frequency\\n self.delay = delay\\n self.fc = fc\\n self.dt = dt\\n # arange t and ricker_t in the order of increasing time; the zero phase case contains negative time\\n\\n self.ricker_t = np.roll(ricker_t, nroll)\\n self.f = f\\n self.t = t\\n self.df = df\\n self.ricker_f = ricker_f\\n self.amp = amp\\n self.phase = phase\\n self.nroll = nroll\",\n \"def cutoff_denominator(self, list_energy):\\n\\n tol = 1e-3\\n\\n z = list_energy/tol\\n\\n den = N.imag(SS.wofz(z))/tol*N.sqrt(N.pi)\\n\\n return den\",\n \"def get_fractional_degradation(bt):\\n\\n\\n\\n NomIch = 0.125 # Nominal charge current\\n NomId = 0.25 # Nominal discharge current\\n NomSoC = 0.5 # Nominal state of charge_mode\\n NomDoD = 1.0 # Nominal depth of discharge\\n B = 5 #Battery capacity\\n qt = 5 * 0.5 # Amount of energy in the battery at the start\\n # Determin charge of discharge\\n if bt > 0:\\n Id = bt/(B*1) # time interval differnece is 1\\n Ich = NomIch\\n else:\\n Ich = bt/(B*1)\\n Id = NomId\\n\\n #Calculate average State of Charge\\n SoC = 100 * (qt - 0.5*bt)/B\\n\\n #Calculate Depth of Discharge\\n DoD = 100 * bt /B\\n\\n # Functions\\n nCL1 = (e * np.exp (f * Id) + g * np.exp(h * Id))/ (e * np.exp (f * NomId) + g * np.exp(h * NomId))\\n nCL2 = (m * np.exp (n * Ich) + o * np.exp(p * Ich))/ (m* np.exp (n* NomIch) + o * np.exp(p * NomIch))\\n nCL3 = get_CL4(DoD, SoC)/get_CL4(NomDoD, NomSoC)\\n nCL = nCL1 * nCL2 * nCL3\\n Fractional_D = (0.5/3650)/ nCL\\n return Fractional_D\",\n \"def _solve_freq_unc(self, d, v, a, force, freq, incrb):\\n # convert frequency in Hz to radian/sec:\\n freqw = 2 * np.pi * freq\\n freqw2 = freqw**2\\n\\n # solve rigid-body and elastic parts separately\\n # - residual-flexibility part was already solved in _init_dva\\n\\n # solve rigid-body part:\\n self._solve_freq_rb(d, v, a, force, freqw, freqw2, incrb, True)\\n\\n # solve elastic part:\\n if self.elsize:\\n el = self.el\\n _el = self._el\\n fw = freqw[None, :]\\n fw2 = freqw2[None, :]\\n if self.m is None:\\n d[el] = force[el] / (\\n 1j * (self.b[_el][:, None] @ fw) + self.k[_el][:, None] - fw2\\n )\\n else:\\n d[el] = force[el] / (\\n 1j * (self.b[_el][:, None] @ fw)\\n + self.k[_el][:, None]\\n - self.m[_el][:, None] @ fw2\\n )\\n a[el] = d[el] * -(freqw2)\\n v[el] = d[el] * (1j * freqw)\",\n \"def calculate_bandwidth(self, complist):\\n\\n self.type = complist[0]\\n self.spot = complist[2]\\n self.value = complist[1]\\n self.fail = False\\n\\n if self.spot == \\\"1\\\" or self.spot == \\\"2\\\":\\n # print \\\"Calculation if Loop 1st filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c1 == 0:\\n self.c1 = self.value\\n else:\\n self.fail = True\\n else:\\n if self.r1 == 0:\\n self.r1 = self.value\\n else:\\n self.fail = True\\n\\n if self.spot == \\\"3\\\" or self.spot == \\\"4\\\":\\n # print \\\"Calculation if loop 2nd filter\\\"\\n if self.type == \\\"C\\\":\\n if self.c2 == 0:\\n self.c2 = self.value\\n else:\\n self.fail = True\\n else: #self.type == \\\"R\\\"\\n if self.r2 == 0:\\n self.r2 = self.value\\n else:\\n self.fail = True\\n\\n if self.c1 != 0 and self.c2 != 0 and self.r1 != 0 and self.r2 != 0:\\n cf_low = int((1/(2*pi*(self.r1)*(self.c1))/1000))\\n #print \\\"hello!\\\"\\n cf_low = str(cf_low)\\n self.cutoff_freql = cf_low\\n self.cutoff_freql_text = cf_low + \\\"K\\\"\\n print self.cutoff_freql_text\\n cf_high = int((1/(2*pi*(self.r2)*(self.c2))/1000))\\n cf_high = str(cf_high)\\n self.cutoff_freqh = cf_high\\n self.cutoff_freqh_text = cf_high + \\\"K\\\"\\n print self.cutoff_freqh_text\\n voltage_change = float((self.r2)/self.r1)\\n voltage = 5 + voltage_change\\n self.voltage = str(voltage)\\n print self.voltage\",\n \"def div(\\n coeff_rho,\\n momentum_x,\\n momentum_y,\\n momentum_z,\\n ):\\n # Compute the fourth order derivative of the pressure for the face\\n # velocity correction.\\n p_corr = (\\n states['p']\\n if self._params.enable_rhie_chow_correction else states['dp'])\\n d4p_dx4 = self._kernel_op.apply_kernel_op_x(p_corr, 'k4d2x')\\n d4p_dy4 = self._kernel_op.apply_kernel_op_y(p_corr, 'k4d2y')\\n d4p_dz4 = self._kernel_op.apply_kernel_op_z(p_corr, 'k4d2z',\\n 'k4d2zsh')\\n\\n # Compute velocity gradient based on interpolated values on cell faces.\\n coeff_x = dt / (4. * coeff_rho * dx**2)\\n du = self._kernel_op.apply_kernel_op_x(momentum_x, 'kDx')\\n du_dx = [\\n du_i / (2. * dx) + coeff_x * d4p_dx4_i\\n for du_i, d4p_dx4_i in zip(du, d4p_dx4)\\n ]\\n\\n coeff_y = dt / (4. * coeff_rho * dy**2)\\n dv = self._kernel_op.apply_kernel_op_y(momentum_y, 'kDy')\\n dv_dy = [\\n dv_i / (2. * dy) + coeff_y * d4p_dy4_i\\n for dv_i, d4p_dy4_i in zip(dv, d4p_dy4)\\n ]\\n\\n coeff_z = dt / (4. * coeff_rho * dz**2)\\n dw = self._kernel_op.apply_kernel_op_z(momentum_z, 'kDz', 'kDzsh')\\n dw_dz = [\\n dw_i / (2. * dz) + coeff_z * d4p_dz4_i\\n for dw_i, d4p_dz4_i in zip(dw, d4p_dz4)\\n ]\\n\\n return [\\n du_dx_i + dv_dy_i + dw_dz_i\\n for du_dx_i, dv_dy_i, dw_dz_i in zip(du_dx, dv_dy, dw_dz)\\n ]\",\n \"def torch_hertz_to_mel(frequencies_hertz):\\r\\n # return _MEL_HIGH_FREQUENCY_Q * tf.math.log(\\r\\n # 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\\r\\n return _MEL_HIGH_FREQUENCY_Q * np.log(\\r\\n 1. + (frequencies_hertz / _MEL_BREAK_FREQUENCY_HERTZ))\",\n \"def effective_temperature(R,times):\\n T_eff = np.empty((len(R),times))\\n #T_c = ((3 * G * M_body) / (8 * np.pi * sigma)) #constants for a blackbody \\n for i in range (len(R)):\\n for t in range(times): \\n T_eff[i][t] = ((m_dot[i][t])/(R[i]**3.0))**(1.0/4.0)\\n return T_eff\",\n \"def apply_band_pass(ftd, freq, omega, bp_wid=1):\\n # Find number of frequencies\\n nf = len(freq)\\n # Find index for band pass, only consider indices of positive freqs\\n idx_om = hf.find_nearest_index(freq[0:nf//2], omega)\\n # Filter out frequencies left of band pass\\n ftd[:,0:idx_om-1-bp_wid] = 0.0\\n # Filter out frequencies left of omega\\n ftd[:,idx_om+1+bp_wid:-1] = 0.0\\n # Correct for lost amplitude\\n ftd[:,idx_om-bp_wid:idx_om+bp_wid] = ftd[:,idx_om-bp_wid:idx_om+bp_wid] * 2.0\\n return ftd\",\n \"def HeatEqn_FT(D, L, x, t, u_0):\\n n = x.size\\n k = (2 * np.pi / L) * np.fft.fftfreq(n, d=1 / n)\\n u_0t = np.fft.fft(u_0)\\n\\n U = np.zeros((t.size, x.size))\\n for ti in range(t.size):\\n U[ti, :] = np.fft.ifft(np.exp(-D * k**2 * t[ti]) * u_0t)\\n\\n return U\",\n \"def integrate_rd(D=2e-3, t0=1., tend=13., x0=1e-10, xend=1.0, N=256,\\n nt=42, logt=False, logy=False, logx=False,\\n random=False, k=1.0, nstencil=3, linterpol=False,\\n rinterpol=False, num_jacobian=False, method='bdf',\\n integrator='scipy', iter_type='undecided',\\n linear_solver='default', atol=1e-8, rtol=1e-10, factor=1e5,\\n random_seed=42, plot=False, savefig='None', verbose=False,\\n scaling=1.0, ilu_limit=1000.0, first_step=0.0, n_jac_diags=0, use_log2=False):\\n if t0 == 0.0:\\n raise ValueError(\\\"t0==0 => Dirac delta function C0 profile.\\\")\\n if random_seed:\\n np.random.seed(random_seed)\\n tout = np.linspace(t0, tend, nt)\\n\\n units = defaultdict(lambda: 1)\\n units['amount'] = 1.0/scaling\\n\\n # Setup the grid\\n x = generate_grid(x0, xend, N, logx, random=random)\\n modulation = [1 if (i == 0) else 0 for i in range(N)]\\n\\n rd = ReactionDiffusion.nondimensionalisation(\\n 2,\\n [[0], [1]],\\n [[1], [0]],\\n [k, factor*k],\\n N=N,\\n D=[0, D],\\n x=x,\\n logy=logy,\\n logt=logt,\\n logx=logx,\\n nstencil=nstencil,\\n lrefl=not linterpol,\\n rrefl=not rinterpol,\\n modulated_rxns=[0, 1],\\n modulation=[modulation, modulation],\\n unit_registry=units,\\n ilu_limit=ilu_limit,\\n n_jac_diags=n_jac_diags,\\n faraday_const=1,\\n vacuum_permittivity=1,\\n use_log2=use_log2\\n )\\n\\n # Calc initial conditions / analytic reference values\\n Cref = analytic(rd.xcenters, tout, D, x0, xend, logx, use_log2=use_log2).reshape(\\n nt, N, 1)\\n source = np.zeros_like(Cref[0, ...])\\n source[0, 0] = factor\\n y0 = np.concatenate((source, Cref[0, ...]), axis=1)\\n\\n # Run the integration\\n integr = Integration(\\n rd, y0, tout, integrator=integrator, atol=atol, rtol=rtol,\\n with_jacobian=(not num_jacobian), method=method,\\n iter_type=iter_type,\\n linear_solver=linear_solver, first_step=first_step)\\n Cout = integr.with_units('Cout')\\n if verbose:\\n import pprint\\n pprint.pprint(integr.info)\\n spat_ave_rmsd_over_atol = spat_ave_rmsd_vs_time(\\n Cout[:, :, 1], Cref[:, :, 0]) / atol\\n tot_ave_rmsd_over_atol = np.average(spat_ave_rmsd_over_atol)\\n\\n if plot:\\n # Plot results\\n import matplotlib.pyplot as plt\\n plt.figure(figsize=(6, 10))\\n\\n def _plot(C, c, ttl=None, vlines=False,\\n smooth=True):\\n if vlines:\\n plt.vlines(rd.x, 0, np.ones_like(rd.x)*max(C),\\n linewidth=1, colors='gray')\\n if smooth:\\n plt.plot(rd.xcenters, C, c=c)\\n else:\\n for i, _C in enumerate(C):\\n plt.plot([rd.x[i], rd.x[i+1]], [_C, _C], c=c)\\n\\n plt.xlabel('x / m')\\n plt.ylabel('C / M')\\n if ttl:\\n plt.title(ttl)\\n\\n for i in range(nt):\\n kwargs = dict(smooth=(N >= 20),\\n vlines=(i == 0 and N < 20))\\n\\n c = 1-tout[i]/tend\\n c = (1.0-c, .5-c/2, .5-c/2)\\n plt.subplot(4, 1, 1)\\n _plot(Cout[i, :, 1], c, 'Simulation (N={})'.format(rd.N),\\n **kwargs)\\n\\n plt.subplot(4, 1, 2)\\n _plot(Cref[i, :, 0], c, 'Analytic', **kwargs)\\n\\n plt.subplot(4, 1, 3)\\n _plot((Cout[i, :, 1]-Cref[i, :, 0]), c,\\n \\\"Error\\\",\\n **kwargs)\\n\\n plt.subplot(4, 1, 4)\\n plt.plot(integr.tout, spat_ave_rmsd_over_atol)\\n plt.plot([integr.tout[0], integr.tout[-1]],\\n [tot_ave_rmsd_over_atol]*2, '--')\\n plt.title(\\\"RMSD / atol\\\")\\n\\n plt.tight_layout()\\n save_and_or_show_plot(savefig=savefig)\\n\\n return tout, Cout, integr.info, rd, tot_ave_rmsd_over_atol\",\n \"def get_reeval_FWHM(param_values, cgmodel, file_list, temperature_list, output_data,\\n param_names, units, frame_begin, sample_spacing, sparsify_stride, frame_end,\\n n_cpu, n_trial_boot, num_intermediate_states):\\n\\n # Construct dictionary of parameter update instructions:\\n param_dict = {}\\n \\n # if len(param_names) == 1:\\n # # 1D optimization:\\n # param_dict[param_names[0]] = param_values * units[0]\\n\\n for i in range(len(param_names)):\\n param_dict[param_names[i]] = param_values[i] * units[i]\\n \\n if verbose:\\n print(f'Current parameters: {param_dict}') \\n \\n # Re-evaluate energy with current force field parameters:\\n # For bootstrapping, evaluate all frames between [frame_begin:sparsify_stride:frame_end], and\\n # apply the sample_spacing only to the heat capacity part\\n U_eval, simulation = eval_energy(\\n cgmodel,\\n file_list,\\n temperature_list,\\n param_dict,\\n frame_begin=frame_begin,\\n frame_stride=sparsify_stride,\\n frame_end=frame_end,\\n n_cpu=n_cpu,\\n verbose=verbose,\\n )\\n\\n # Evaluate heat capacity and full-width half-maximum from bootstrapping:\\n (new_temperature_list, C_v_values, C_v_uncertainty,\\n Tm_value, Tm_uncertainty,\\n Cv_height_value, Cv_height_uncertainty,\\n FWHM_value, FWHM_uncertainty,\\n N_eff_values) = bootstrap_heat_capacity(\\n U_kln=U_eval,\\n output_data=output_data,\\n frame_begin=frame_begin,\\n frame_end=frame_end,\\n sample_spacing=sample_spacing,\\n sparsify_stride=sparsify_stride,\\n num_intermediate_states=num_intermediate_states,\\n n_trial_boot=n_trial_boot,\\n plot_file=f'heat_capacity_boot_{param_names[0]}_{param_values}.pdf',\\n )\\n \\n if verbose:\\n print(f'Current FWHM: {FWHM_value} +/- {FWHM_uncertainty[0]}')\\n print(f'Current minimum N_eff: {np.min(N_eff_values)}')\\n \\n # Check for minimum N_eff criteria.\\n # If too small, the minimization should stop if we're using a gradient method.\\n # If we're not using a gradient method, return a large value.\\n \\n if np.min(N_eff_values) < min_eff_samples:\\n print(f'Insufficient number of effective samples ({np.min(N_eff_values)})')\\n \\n # print(f'Creating a cgmodel with current parameters...,end='')\\n # Create the cgmodel\\n # print('done')\\n \\n exit()\\n \\n return FWHM_value.value_in_unit(unit.kelvin)\",\n \"def freq2den(freq):\\n\\n return freq * freq * k_2\",\n \"def freq_defl_comp(fmax, p=75, p1=database['K+'], p2=database['pi+'],\\r\\n p3=database['p+'], L_t=79.6, l=2.74, E=1e6, plot=True,\\r\\n details=False, n=1000, delta_p=1.6e-2, fmin=0, just_pi=False):\\r\\n f_range = np.linspace(fmin, fmax, n)\\r\\n min_defl, d2, d3 = [], [], []\\r\\n for f in f_range:\\r\\n if just_pi == True:\\r\\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\\r\\n min_defl.append(d2[-1])\\r\\n if just_pi == False: \\r\\n d2.append(ang_deflection(p, f, p1, p2, L_t, l, E, delta_p))\\r\\n d3.append(ang_deflection(p, f, p1, p3, L_t, l, E, delta_p))\\r\\n min_defl.append(np.min([d2[-1], d3[-1]]))\\r\\n if plot == True:\\r\\n fig = plt.figure(figsize=[9, 5])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n if details == True:\\r\\n ax.plot(f_range, d2, 'r', alpha=0.5, label=f'{p2.name} deflection')\\r\\n ax.plot(f_range, d3, 'b', alpha=0.5, label=f'{p3.name} deflection')\\r\\n else:\\r\\n ax.plot(f_range, min_defl, color=[1, 0, 1], alpha=0.5, label='min deflection')\\r\\n# ax.set_xlim(fmin, fmax)\\r\\n ax.set_ylim(0)\\r\\n ax.set_xlabel('Frequency / Hz', fontsize=20)\\r\\n text = r'$D_{'\\r\\n text += p2.name + '/' + p3.name\\r\\n text += '}$ / mrad'\\r\\n ax.set_ylabel(text, fontsize=20)\\r\\n ax.set_xscale('log')\\r\\n ax.legend(fontsize=20)\\r\\n plt.show()\\r\\n opt_freq = f_range[np.argmax(min_defl)]\\r\\n d_opt = (fmax-fmin)/1000\\r\\n d_opt_perc = (d_opt/opt_freq)*100\\r\\n if details == True:\\r\\n return 'optimum frequency = {0:.0f} +/- {1:.5f}%'.format(opt_freq, d_opt_perc)\\r\\n return opt_freq\",\n \"def F_rxth(mx, rhoc, Temp):\\n return 64. * m.pow(Temp/1.e+5,0.5) * m.pow(1.e+14/rhoc,0.5) * m.pow(100./mx,0.5) # cm\",\n \"def calc(self,index,counter_values):\\n gr = self.grSign * self.grPitch['Value'].value\\n m = self.mSign * self.mPitch['Value'].value\\n \\n offsetG,offsetM = self.checkOffset()\\n beta = self.toRadians(gr) - (math.pi/2.0) - offsetG\\n theta = (math.pi/2.0) - (self.toRadians(m)) - offsetM\\n alpha = (2.0*theta) + beta\\n numerator = (math.sin(alpha) + math.sin(beta))\\n denominator = (self.DiffrOrder * self.look_at_grx())\\n wavelength = numerator / denominator\\n \\n if wavelength == 0.0:\\n energy_physicalmot = 0.0\\n else:\\n energy_physicalmot = self.hc / wavelength\\n #if self.FixedM2Pit: \\n Cff = math.cos(beta)/math.cos(alpha)\\n if energy_physicalmot < 0 :\\n #warning: wavelength se vuelve negativo ... ??????\\n energy_physicalmot = energy_physicalmot *(-1) \\n \\n # Real Energy is equal to the energy calculated by the encoders\\n # minus an offset that depends on the same energy calculated by the \\n # encoders:\\n # E_physicalmot = Ereal + offset\\n # with offset = a*Ereal + b\\n # This implies that: Ereal = (Ephysicalmot - b)/(1+a) \\n a_coeff = self.EnergyDP.a_offset_coeff\\n b_coeff = self.EnergyDP.b_offset_coeff\\n numerator = energy_physicalmot - b_coeff\\n denominator = 1 + a_coeff\\n energy = numerator / denominator\\n \\n if index == 1:\\n return energy\\n elif index == 2:\\n return Cff\",\n \"def getPartitionFunction(self, Tlist):\\n\\t\\treturn _modes.hinderedrotor_partitionfunction(Tlist, self.frequency, self.barrier) ** self.degeneracy\",\n \"def butter_lpf(fc, fs, order):\\n nyq = 0.5 * fs\\n high = fc / nyq\\n b, a = signal.butter(order, high, btype='lowpass', analog=False)\\n w, h = signal.freqz(b, a, worN=1000)\\n# plt.figure()\\n# plt.plot((fs * 0.5 / np.pi) * w, abs(h))\\n return b, a\",\n \"def get_quantum_harmonic_free_energy(self, temperatures=None):\\n if temperatures is None:\\n temperatures = self.input.temperature\\n temperatures = np.clip(temperatures, 1e-6, np.inf)\\n beta = 1.0 / (KB * temperatures)\\n f = 0\\n for m in self.input.structure.get_masses():\\n hbar_omega = (\\n HBAR\\n * np.sqrt(self.input.spring_constant / m)\\n * ROOT_EV_PER_ANGSTROM_SQUARE_PER_AMU_IN_S\\n )\\n f += (3.0 / 2) * hbar_omega + (\\n (3.0 / beta) * np.log(1 - np.exp(-beta * hbar_omega))\\n )\\n return f\",\n \"def refraction(el, temp, press, hum, freq=150.0):\\n\\n fvec = np.vectorize(qp.qp_refraction, [np.double])\\n delta = fvec(el, temp, press, hum, freq)\\n if delta.shape == ():\\n return delta[()]\\n return delta\",\n \"def zMCEff1D(ZReco, ZAcc, bins, obs, region='inclusive', sel=''):\\n print(\\\">>> make differential efficiencies for \\\"+obs+\\\" in \\\"+region+\\\" region\\\")\\n\\n if sel != '':\\n ZReco = ZReco.query(sel)\\n ZAcc = ZAcc.query(sel)\\n\\n ZEff = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\\n ZEff_sel = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\\n ZEff_glo = [np.zeros(len(bins)-1), np.zeros(len(bins)-1)]\\n\\n MuEff_HLT_Sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Sel_Glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Glo_StaOrTrk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Trk_Sta = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n MuEff_Sta_Trk = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n\\n ZMuMuEff = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n ZMuMuEff_sel = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n ZMuMuEff_glo = [np.zeros(len(bins) - 1), np.zeros(len(bins) - 1)]\\n\\n for i in range(0, len(bins)-1):\\n bin_low = bins[i]\\n bin_high = bins[i+1]\\n sel = '{0}>{1} & {0}<{2}'.format(obs, bin_low, bin_high)\\n\\n ZReco_i = ZReco.query(sel)\\n\\n qHLT = 'muon_Category==5 & antiMuon_Category==5'\\n qSel = '(muon_Category==5 & antiMuon_Category==4) | (muon_Category==4 & antiMuon_Category==5)'\\n qGlo = '(muon_Category==5 & antiMuon_Category==3) | (muon_Category==3 & antiMuon_Category==5)'\\n qSta = '(muon_Category==5 & antiMuon_Category==2) | (muon_Category==2 & antiMuon_Category==5)'\\n qTrk = '(muon_Category==5 & antiMuon_Category==1) | (muon_Category==1 & antiMuon_Category==5)'\\n\\n nHLT = len(ZReco_i.query(qHLT))\\n nSel = len(ZReco_i.query(qSel))\\n nGlo = len(ZReco_i.query(qGlo))\\n nSta = len(ZReco_i.query(qSta))\\n nTrk = len(ZReco_i.query(qTrk))\\n\\n MuEff_HLT_Sel[0][i], MuEff_HLT_Sel[1][i] = muTagAndProbeEff(nHLT, 0, nSel)\\n MuEff_Sel_Glo[0][i], MuEff_Sel_Glo[1][i] = muTagAndProbeEff(nHLT, nSel, nGlo)\\n MuEff_Glo_StaOrTrk[0][i], MuEff_Glo_StaOrTrk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo, nSta + nTrk)\\n MuEff_Trk_Sta[0][i], MuEff_Trk_Sta[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nTrk, nSta)\\n MuEff_Sta_Trk[0][i], MuEff_Sta_Trk[1][i] = muTagAndProbeEff(nHLT, nSel + nGlo + nSta, nTrk)\\n\\n ZMuMuEff[0][i], ZMuMuEff[1][i] = eff_ztomumu_old(nHLT, nSel, nGlo, nSta, nTrk)\\n ZMuMuEff_sel[0][i], ZMuMuEff_sel[1][i] = eff_ztomumu_sel(nHLT, nSel, nGlo, nSta, nTrk)\\n ZMuMuEff_glo[0][i], ZMuMuEff_glo[1][i] = eff_ztomumu_glo(nHLT, nSel, nGlo, nSta, nTrk)\\n\\n # full true Z efficiency\\n ZAcc_i = ZAcc.query(sel)\\n ZReco_i = ZReco.query(sel + '& (muon_Category==5 | antiMuon_Category==5) & muon_Category>=4 & antiMuon_Category>=4')\\n\\n nReco_i = len(ZReco_i)\\n nAcc_i = len(ZAcc_i)\\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\\n\\n ZEff[0][i], ZEff[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\\n\\n # true Z efficiency at selection level (without requiring trigger)\\n ZAcc_i = ZAcc.query(sel)\\n ZReco_i = ZReco.query(sel + ' & muon_Category>=4 & antiMuon_Category>=4')\\n\\n nReco_i = len(ZReco_i)\\n nAcc_i = len(ZAcc_i)\\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\\n\\n ZEff_sel[0][i], ZEff_sel[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\\n\\n # true Z efficiency at gobal muon level (requiring two global muons)\\n ZAcc_i = ZAcc.query(sel)\\n ZReco_i = ZReco.query(sel + '& muon_Category>=3 & antiMuon_Category>=3 ')\\n\\n nReco_i = len(ZReco_i)\\n nAcc_i = len(ZAcc_i)\\n nBoth_i = len(np.intersect1d(ZReco_i['LepPt'], ZAcc_i['LepPt']))\\n\\n ZEff_glo[0][i], ZEff_glo[1][i] = zEff(nReco_i, nAcc_i, nBoth_i)\\n\\n x = bins[:-1] + (bins[1:] - bins[:-1])/2\\n\\n def plot_zeff(eff_true, eff_tnp, name):\\n plt.clf()\\n fig, ax = plt.subplots(2, 1, sharex=True, gridspec_kw={'height_ratios': [2, 1]})\\n fig.subplots_adjust(hspace=0)\\n\\n ax[0].errorbar(x, eff_true[0], xerr=np.zeros(len(x)), yerr=eff_true[1], fmt='bo', label='true')\\n ax[0].errorbar(x, eff_tnp[0], xerr=np.zeros(len(x)), yerr=eff_tnp[1], fmt='ro', label='tnp')\\n ax[0].set(xlim=(bins[0], bins[-1]), ylim=(0.75, 1.1))\\n ax[0].legend()\\n ax[0].text(0.05, 0.9, r'$66\\\\ \\\\mathrm{GeV} < \\\\mathrm{M}_{\\\\mu\\\\mu} < 116\\\\ \\\\mathrm{GeV}$', transform=ax[0].transAxes)\\n ax[0].text(0.05, 0.82, r'$p_\\\\mathrm{t}(\\\\mu) > 27\\\\ \\\\mathrm{GeV} \\\\qquad |\\\\eta(\\\\mu)| < 2.4$', transform=ax[0].transAxes)\\n ax[0].text(0.05, 0.74, region, transform=ax[0].transAxes)\\n ax[0].set_ylabel(r'$\\\\epsilon_\\\\mathrm{Z}$')\\n ax[0].set_xlabel(obs)\\n ax[0].set_yticks([0.8, 0.85, 0.9, 0.95, 1.0, 1.05])\\n ax[0].set_title(\\\"Z efficiency at {0} muon level\\\".format(name))\\n\\n pulls = eff_tnp[0] - eff_true[0]\\n pulls_sig = np.sqrt(eff_tnp[1]**2 + eff_true[1]**2)\\n\\n ax[1].errorbar(x, pulls, xerr=np.zeros(len(x)), yerr=pulls_sig, fmt='ko')# , label='factorized - true')\\n ax[1].plot(x, np.zeros(len(x)), color='gray', linestyle='dashed')\\n ax[1].set_ylim(-0.02, 0.04)\\n ax[1].set_ylabel(r'$\\\\epsilon^\\\\mathrm{tnp}_\\\\mathrm{Z} - \\\\epsilon^\\\\mathrm{true}_\\\\mathrm{Z}$')\\n ax[1].set_xlabel(obs)\\n ax[1].set_yticks([-0.01, 0., 0.01, 0.02, 0.03])\\n plt.savefig(output+'/ZMuMu_{0}_{1}_{2}_level.png'.format(obs, region, name))\\n plt.close()\\n\\n plot_zeff(ZEff, ZMuMuEff, \\\"hlt\\\")\\n plot_zeff(ZEff_sel, ZMuMuEff_sel, \\\"selection\\\")\\n plot_zeff(ZEff_glo, ZMuMuEff_glo, \\\"global\\\")\",\n \"def far_fields(horn_width, horn_height, eplane_effective_length, hplane_effective_length, frequency, r, theta, phi):\\n # Calculate the wavenumber\\n k = 2.0 * pi * frequency / c\\n\\n # Calculate the wave impedance\\n eta = sqrt(mu_0 / epsilon_0)\\n\\n # Define the radial-component of the electric field\\n e_r = 0.0\\n\\n # Define the theta-component of the electric field\\n e_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Define the phi-component of the electric field\\n e_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * cos(phi) * (1.0 + cos(theta)) * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Define the radial-component of the magnetic field\\n h_r = 0.0\\n\\n # Define the theta-component of the magnetic field\\n h_theta = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * -cos(phi) * (1.0 + cos(theta)) / eta * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Define the phi-component of the magnetic field\\n h_phi = 1j * k / (4.0 * pi * r) * exp(-1j * k * r) * sin(phi) * (1.0 + cos(theta)) / eta * \\\\\\n I1(k, horn_width, hplane_effective_length, theta, phi) * \\\\\\n I2(k, horn_height, eplane_effective_length, theta, phi)\\n\\n # Return all six components of the far field\\n return e_r, e_theta, e_phi, h_r, h_theta, h_phi\",\n \"def freqz_resp_list(b,a=np.array([1]),mode = 'dB',fs=1.0,Npts = 1024,fsize=(6,4)):\\r\\n if type(b) == list:\\r\\n # We have a list of filters\\r\\n N_filt = len(b)\\r\\n f = np.arange(0,Npts)/(2.0*Npts)\\r\\n for n in range(N_filt):\\r\\n w,H = signal.freqz(b[n],a[n],2*np.pi*f)\\r\\n if n == 0:\\r\\n plt.figure(figsize=fsize)\\r\\n if mode.lower() == 'db':\\r\\n plt.plot(f*fs,20*np.log10(np.abs(H)))\\r\\n if n == N_filt-1:\\r\\n plt.xlabel('Frequency (Hz)')\\r\\n plt.ylabel('Gain (dB)')\\r\\n plt.title('Frequency Response - Magnitude')\\r\\n\\r\\n elif mode.lower() == 'phase':\\r\\n plt.plot(f*fs,np.angle(H))\\r\\n if n == N_filt-1:\\r\\n plt.xlabel('Frequency (Hz)')\\r\\n plt.ylabel('Phase (rad)')\\r\\n plt.title('Frequency Response - Phase')\\r\\n\\r\\n elif (mode.lower() == 'groupdelay_s') or (mode.lower() == 'groupdelay_t'):\\r\\n \\\"\\\"\\\"\\r\\n Notes\\r\\n -----\\r\\n\\r\\n Since this calculation involves finding the derivative of the\\r\\n phase response, care must be taken at phase wrapping points \\r\\n and when the phase jumps by +/-pi, which occurs when the \\r\\n amplitude response changes sign. Since the amplitude response\\r\\n is zero when the sign changes, the jumps do not alter the group \\r\\n delay results.\\r\\n \\\"\\\"\\\"\\r\\n theta = np.unwrap(np.angle(H))\\r\\n # Since theta for an FIR filter is likely to have many pi phase\\r\\n # jumps too, we unwrap a second time 2*theta and divide by 2\\r\\n theta2 = np.unwrap(2*theta)/2.\\r\\n theta_dif = np.diff(theta2)\\r\\n f_diff = np.diff(f)\\r\\n Tg = -np.diff(theta2)/np.diff(w)\\r\\n # For gain almost zero set groupdelay = 0\\r\\n idx = pylab.find(20*np.log10(H[:-1]) < -400)\\r\\n Tg[idx] = np.zeros(len(idx))\\r\\n max_Tg = np.max(Tg)\\r\\n #print(max_Tg)\\r\\n if mode.lower() == 'groupdelay_t':\\r\\n max_Tg /= fs\\r\\n plt.plot(f[:-1]*fs,Tg/fs)\\r\\n plt.ylim([0,1.2*max_Tg])\\r\\n else:\\r\\n plt.plot(f[:-1]*fs,Tg)\\r\\n plt.ylim([0,1.2*max_Tg])\\r\\n if n == N_filt-1:\\r\\n plt.xlabel('Frequency (Hz)')\\r\\n if mode.lower() == 'groupdelay_t':\\r\\n plt.ylabel('Group Delay (s)')\\r\\n else:\\r\\n plt.ylabel('Group Delay (samples)')\\r\\n plt.title('Frequency Response - Group Delay')\\r\\n else:\\r\\n s1 = 'Error, mode must be \\\"dB\\\", \\\"phase, '\\r\\n s2 = '\\\"groupdelay_s\\\", or \\\"groupdelay_t\\\"'\\r\\n print(s1 + s2)\",\n \"def trc_fgen_postfb(self,trc,dt,hwin=150,vlen=51):\\n output=np.zeros((len(trc),((11*(vlen))+1)))\\n trc_norm=trc/np.amax(np.abs(trc))\\n trc_entropy=self.entropy(trc_norm,50)\\n trc_fdm=self.fdm(trc_norm,50,np.arange(1,4),15)\\n trc_slta=trigger.classic_sta_lta(trc_norm,2,100)\\n trc_fq_win_sum=self.fq_win_sum(trc_norm,hwin,dt)\\n hwin2=50\\n trc_kurtosis_skew=self.kurtosis_skewness(trc_norm,hwin2)\\n for i,j in enumerate(trc):\\n if i<len(trc)-vlen-1:\\n ftrc=[]\\n fb=i*dt\\n ftrc=np.append(ftrc,trc_norm[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(np.abs(trc_norm)))[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_entropy)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_entropy))[np.int(fb/dt):np.int(fb/dt)+vlen]) \\n ftrc=np.append(ftrc,self.norm(trc_fdm)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fdm))[np.int(fb/dt):np.int(fb/dt)+vlen]) \\n ftrc=np.append(ftrc,self.norm(trc_slta)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_fq_win_sum)[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(np.gradient(trc_fq_win_sum))[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[0])[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,self.norm(trc_kurtosis_skew[1])[np.int(fb/dt):np.int(fb/dt)+vlen])\\n ftrc=np.append(ftrc,1)\\n output[i,:]=ftrc\\n return output\",\n \"def coreprop(freq, tdust, flux, dist, kappa, sigmav, tgas, smaj, smin, wmol):\\n\\tBT = blackbody_nu(freq*u.GHz, tdust*u.K).cgs.value\\n\\td = dist * 1e3 * pc\\n\\t# Radius (in unit of pc)\\n\\tradius = np.sqrt(smaj*smin)/2/3600/180*np.pi * d / pc\\n\\t# Mass\\n\\tm = 1e2 * flux * jy * d**2 / BT / kappa / msun\\n\\t# Number density\\n\\tdensity = m*msun / (4./3. * np.pi * (radius * pc)**3) / (2.8 * mp)\\n\\t# Sigmav of 2.33H\\n\\tsigmav = np.sqrt((sigmav*1e5)**2 - kb*tgas/wmol/mp + kb*tgas/2.33/mp) / 1e5\\n\\t# Virial\\n\\talpha = 5 * (sigmav * 1e5)**2 * (radius * pc) / G / (m * msun)\\n\\t# Virial parameter with B-field, assume 1 mG\\n\\tB = 1 * 1e-3 # G\\n\\trho = density * 2.8 * mp # g/cm3\\n\\talfven = B / np.sqrt(4*np.pi*rho)\\n\\talpha_B = 5 * ( (sigmav * 1e5)**2 + (alfven)**2/6.) * (radius * pc) / G / (m * msun)\\n\\n\\treturn sigmav, radius, m, density, alpha, alfven*1e-5, alpha_B\",\n \"def buoyancy_frequency(self, z, h=0.01):\\n # Check validity of the input z values\\n if np.max(z) > self.z_max or np.min(z) < self.z_min:\\n raise ValueError('Selected depths outside range of ' + \\\\\\n 'CTD data: %g to %g m' % (self.z_min, \\n self.z_max))\\n if h > 1.0 or h < 0.0:\\n raise ValueError('Input parameter h must be between 0.0 ' + \\\\\\n 'and 1.0.')\\n \\n # Prepare space to store the solution\\n if not isinstance(z, np.ndarray):\\n N = np.zeros(1)\\n z = np.array([z])\\n elements = 0\\n else:\\n N = np.zeros(z.shape)\\n elements = range(len(N))\\n \\n # Compute the length-scale for the finite difference method\\n dz = (self.z_max - self.z_min) * h\\n \\n # Fill the solution matrix\\n for i in range(len(z)):\\n # Get the end-points of z for the finite difference formula\\n if z[i] + dz > self.z_max:\\n z1 = self.z_max\\n z0 = z1 - 2 * dz\\n elif z[i] - dz < self.z_min:\\n z0 = self.z_min\\n z1 = z0 + 2 * dz\\n else:\\n z0 = z[i] - dz\\n z1 = z[i] + dz\\n \\n # Get the density at z0 and z1. Use atmospheric pressure to \\n # compute the potential density and remove the effect of \\n # compressibility\\n T0, S0 = self.get_values(z0, self.ztsp[1:3])\\n T1, S1 = self.get_values(z1, self.ztsp[1:3])\\n Pa = 101325.\\n rho_0 = seawater.density(T0, S0, Pa)\\n rho_1 = seawater.density(T1, S1, Pa)\\n N[i] = np.sqrt(9.81 / rho_0 * (rho_1 - rho_0) / (z1 - z0))\\n \\n return N[elements]\",\n \"def calculate_NH_relaxation_from_Ct(bondtype, B_0, t, Ct):\\n gamma_1H = 267.513e6 ; # rad s^-1 T^-1\\n gamma_X = -27.116e6\\n DeltaSigma_X=-160e-6\\n r_XH=1.02e-10\\n\\n om, G = do_dft(t, Ct)\\n J = G.real\\n\\n omega, iOmH, iOmX = obtain_HX_frequencies()\\n\\n Jw=np.zeros(5)\\n for i in range(5):\\n w = omega[i]\\n Jw[i] = interpolate_point(w, om, J)\\n\\n # f_DD = 519627720.1974593 , if r_NH is at default values\\n f_DD = 7.958699205571828e-67 * r_XH**-6.0 * gamma_X**2\\n # f_CSA = 498637299.69233465, if B_0 = 600.13, and DeltaSigma=-160e-6\\n f_CSA = 2.0/15.0 * DeltaSigma_X**2 * ( gamma_X * B_0 )**2\\n\\n R1 = f_DD*( J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] ) + f_CSA*J[iOmX]\\n R2 = 0.5*f_DD*( 4*J[0] + J[iOmH-iOmX] + 3*J[iOmX] + 6*J[iOmH+iOmX] + 6*J[iOmH] ) + 1.0/6.0*f_CSA*(4*J[0] + 3*J[iOmX])\\n NOE = 1.0 + gamma_1H/gamma_X/R1 * f_DD*(6*J[iOmH+iOmX] - J[iOmH-iOmX])\\n\\n return R1, R2, NOE\",\n \"def get_kt(temps, delta_gibbs_ts):\\n # rate coefficient from Eyring equation\\n return KB / H * temps * np.exp(-delta_gibbs_ts / RG / temps) # [1/s] if unimolecular\",\n \"def get_sound_speed_temperature(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n C_T = (\\n 2 ** (1 / 4)\\n * np.sqrt(gbar)\\n / np.pi\\n * np.sqrt(vv)\\n * tt ** (5 / 4)\\n * _1d_call(_fdk, y, k=1 / 2)\\n / np.sqrt(_1d_call(_fdk, y, k=-1 / 2))\\n )\\n return C_T\",\n \"def DynamicsCheat(x, t, T0, alpha, cost, K, n, r):\\n D=dmax*x[0]**n/(x[0]**n+K**n)\\n #defune the degradation effect\\n deg=0\\n #define ODEs\\n y=np.zeros([np.size(x)])\\n y[0]=alpha*T0-deg*x[0]-alpha*x[0] #dt/dt\\n y[1]=x[1]*(r*(1-cost)*(1-x[1])-D-alpha)#d Co/dt\\n \\n return y\",\n \"def bd(y, t_r, lbda=1.0, theta_0=None, z_0=None, hrf_dur=20.0, # noqa\\n bounds=None, nb_iter=100, nb_sub_iter=1000, nb_last_iter=10000,\\n print_period=50, early_stopping=False, wind=4, tol=1.0e-12, verbose=0):\\n # force cast for Numba\\n y = y.astype(np.float64)\\n\\n # initialization\\n theta = MAX_DELTA if theta_0 is None else theta_0\\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\\n\\n if z_0 is None:\\n diff_z = np.zeros_like(y)\\n z = np.zeros_like(y)\\n x = np.zeros_like(y)\\n else:\\n diff_z = np.append(0, z_0[1:] - z_0[:-1])\\n z = z_0\\n x = spectral_convolve(h, z)\\n\\n if bounds is None:\\n bounds = [(MIN_DELTA + 1.0e-1, MAX_DELTA - 1.0e-1)]\\n\\n d = {}\\n r_0 = np.sum(np.square(x - y))\\n d['r'] = [1.0]\\n g_0 = np.sum(np.abs(diff_z))\\n d['g'] = [g_0]\\n j_0 = r_0 + lbda * g_0\\n d['J'] = [1.0]\\n d['l_alpha'] = []\\n\\n if (verbose > 0):\\n print(\\\"normalized global cost-function \\\"\\n \\\"(init): {0:.6f}\\\".format(d['J'][-1]))\\n\\n # main loop\\n for idx in range(nb_iter):\\n\\n # deconvolution\\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping,\\n wind, tol)\\n z = np.cumsum(diff_z)\\n\\n # hrf estimation\\n args = (z, y, t_r, hrf_dur)\\n theta, _, _ = fmin_l_bfgs_b(\\n func=hrf_fit_err, x0=theta, args=args,\\n bounds=bounds, approx_grad=True, maxiter=999,\\n pgtol=1.0e-12)\\n h, _ = spm_hrf(theta, t_r, hrf_dur, False)\\n x = spectral_convolve(h, z)\\n\\n # cost function\\n r = np.sum(np.square(x - y))\\n g = np.sum(np.abs(diff_z))\\n d['J'].append((r + lbda * g) / j_0 + 1.0e-30)\\n d['r'].append(r / r_0 + 1.0e-30)\\n d['g'].append(g)\\n\\n if (verbose > 0) and ((idx+1) % print_period == 0):\\n print(\\\"normalized global cost-function \\\"\\n \\\"({0:03d}/{1:03d}): {2:.6f}\\\".format(idx+1, nb_iter,\\n d['J'][-1]))\\n\\n # early stopping\\n if early_stopping:\\n if idx > wind:\\n sub_wind_len = int(wind/2)\\n old_j = np.mean(d['J'][:-sub_wind_len])\\n new_j = np.mean(d['J'][-sub_wind_len:])\\n diff = (new_j - old_j) / new_j\\n if diff < tol:\\n if verbose > 0:\\n print(\\\"\\\\n-----> early-stopping done at \\\"\\n \\\"{0:03d}/{1:03d}, global\\\"\\n \\\" normalized cost-function = \\\"\\n \\\"{2:.6f}\\\".format(idx, nb_iter, d['J'][idx]))\\n break\\n\\n # last (long) deconvolution\\n H = toeplitz_from_kernel(h, dim_in=len(y), dim_out=len(y))\\n diff_z = _loops_deconv(y, diff_z, H, lbda, nb_iter, early_stopping, wind,\\n tol)\\n z = np.cumsum(diff_z)\\n x = spectral_convolve(h, z)\\n\\n # cost function\\n r = np.sum(np.square(x - y))\\n g = np.sum(np.abs(diff_z))\\n d['J'].append((r + lbda * g) / j_0)\\n d['r'].append(r / r_0)\\n d['g'].append(g)\\n\\n d['J'] = np.array(d['J'])\\n d['r'] = np.array(d['r'])\\n d['g'] = np.array(d['g'])\\n\\n return x, z, diff_z, h, d\",\n \"def rcfilter_C(freq, R):\\n R = _normalizevalue(R)\\n C = 1/(R*freq*2*math.pi)\\n return _Cap(C)\",\n \"def get_heat_capacity_pressure(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for high temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n C_P_low = 5 * gbar * np.sqrt(2) / (36 * np.pi ** 2) * tt_low ** (3 / 2) * vv_low\\n C_P_low *= (\\n 5 * _1d_call(_fdk, y_low, k=-1 / 2) * _1d_call(_fdk, y_low, k=3 / 2)\\n - 9 * _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n )\\n C_P_low *= _1d_call(_fdk, y_low, k=3 / 2) / _1d_call(_fdk, y_low, k=1 / 2) ** 2\\n # low temperatures - high numbers\\n C_P_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((C_P_low, C_P_high)).reshape(y.shape)\",\n \"def get_tuning_freq(self, freq):\\n if freq < self.freq_lo:\\n return\\n\\n while freq < self.NOTES.min() or freq > self.NOTES.max():\\n while freq > self.NOTES.max():\\n self.NOTES *= 2\\n while freq < self.NOTES.min():\\n self.NOTES /= 2\\n tuning_freq = min(self.NOTES, key=lambda x: abs(x-freq))\\n return tuning_freq\",\n \"def getFWHM(antenna, freq):\\n diameter = getDiameter(antenna)\\n lam = 299792458.0 / (freq * 1e9)\\n fwhmo = lam / math.pi * 180.0 * 60.0\\n fwhm = 1.22 * fwhmo / diameter\\n return fwhm\",\n \"def get_frequency(self):\\r\\n # print '*********in get freq'\\r\\n self.cntr.run('FREQ 1')\\r\\n f_0_ = self.cntr.get_measurements(1)\\r\\n self.f_0 = f_0_[0]\\r\\n self.cntr.run('FREQ 2')\\r\\n f_rep_ = self.cntr.get_measurements(1)\\r\\n self.f_rep = f_rep_[0]\",\n \"def get_entropy(vv, tt, chemical_potential, gbar=2.0, *args, **kwargs):\\n # type: (np.ndarray, np.ndarray, np.ndarray, float, list, dict) -> np.ndarray\\n y = chemical_potential / tt\\n # There is a precision problem with \\\"-\\\" (minus) operator\\n # We'll use asymptotic formula for low temperatures to avoid that problem\\n y_low = y[y < THRESHOLD]\\n vv_low, vv_high = vv[y < THRESHOLD], vv[y >= THRESHOLD]\\n tt_low, tt_high = tt[y < THRESHOLD], tt[y >= THRESHOLD]\\n # high temperatures - low numbers\\n S_low = (\\n -gbar\\n * np.sqrt(2)\\n / (6 * np.pi ** 2)\\n * tt_low ** (3 / 2)\\n * vv_low\\n * (\\n 3 * y_low * _1d_call(_fdk, y_low, k=1 / 2)\\n - 5 * _1d_call(_fdk, y_low, k=3 / 2)\\n )\\n )\\n # low temperatures - high numbers\\n S_high = (gbar * np.pi / 6) ** (2 / 3) * tt_high * vv_high ** (2 / 3)\\n return np.concatenate((S_low, S_high)).reshape(y.shape)\",\n \"def _get_a_freq(self, energy):\\n left_index = bisect.bisect_left(self.energy_list, energy)\\n if left_index+1 >= len(self.energy_list):\\n left_index = len(self.energy_list)-2\\n elif left_index > 0:\\n left_index -= 1\\n energy0 = self.energy_list[left_index]\\n energy1 = self.energy_list[left_index+1]\\n freq0 = 1./self.closed_orbits_t[energy0]\\n freq1 = 1./self.closed_orbits_t[energy1]\\n frequency = (freq1 - freq0)/(energy1-energy0)*(energy-energy0) + freq0\\n #print \\\"\\\\nl:\\\", left_index, \\\"e0:\\\", energy0, \\\"e1:\\\", energy1, \\\\\\n # \\\"f0:\\\", freq0, \\\"f1:\\\", freq1, \\\"DE:\\\", energy-e0, \\\"f\\\", frequency\\n return frequency\",\n \"def k_HF(T, n, h=1e-3):\\n mu_p, _ = physics_solver_mu(n * (1 + h), T)\\n mu_m, _ = physics_solver_mu(n * (1 - h), T)\\n dn_dmu = 2 * h / (mu_p - mu_m) # second order diff\\n return dn_dmu / n\",\n \"def hertz_to_mel(freq):\\n return 2595.0 * np.log10(1 + (freq / 700.0))\",\n \"def total_band_energy(vals, T, Ec):\\n vals = np.sort(np.concatenate(vals))\\n occup = occup_TK(vals, T=T, spin=2)\\n return np.dot(vals, occup)-Ec\",\n \"def all_dhkl(self, crystal):\\n #d_min = self.wavelength/self.max2theta*pi/2\\n d_min = self.wavelength/sin(self.max2theta/2)/2\\n \\n # This block is to find the shortest d_hkl, \\n # for all basic directions (1,0,0), (0,1,0), (1,1,0), (1,-1,0) and so on, 26 in total \\n hkl_max = np.array([1,1,1])\\n for h1 in [-1, 0, 1]:\\n for k1 in [-1, 0, 1]:\\n for l1 in [-1, 0, 1]:\\n hkl_index = np.array([[h1,k1,l1]])\\n d = float(np.linalg.norm( np.dot(hkl_index, crystal.rec_matrix), axis=1))\\n if d>0:\\n multiple = 1/d/d_min\\n hkl_index *= round(multiple)\\n for i in range(len(hkl_max)):\\n if hkl_max[i] < hkl_index[0,i]:\\n hkl_max[i] = hkl_index[0,i]\\n #h1 = 2*ceil(np.linalg.norm(crystal.cell_para[0])/d_min)\\n #k1 = 2*ceil(np.linalg.norm(crystal.cell_para[1])/d_min)\\n #l1 = 2*ceil(np.linalg.norm(crystal.cell_para[2])/d_min)\\n h1, k1, l1 = hkl_max\\n h = np.arange(-h1,h1)\\n k = np.arange(-k1,k1)\\n l = np.arange(-l1,l1)\\n \\n hkl = np.array((np.meshgrid(h,k,l))).transpose()\\n hkl_list = np.reshape(hkl, [len(h)*len(k)*len(l),3])\\n hkl_list = hkl_list[np.where(hkl_list.any(axis=1))[0]]\\n d_hkl = 1/np.linalg.norm( np.dot(hkl_list, crystal.rec_matrix), axis=1)\\n #for ix, a in enumerate(hkl_list):\\n # if np.array_equal(a, np.array([1,-1,3])) is True:\\n # print(a)\\n # break\\n #\\n #print(ix, hkl_list[ix], d_hkl[ix], d_min)\\n\\n shortlist = d_hkl > (d_min)\\n d_hkl = d_hkl[shortlist]\\n hkl_list = hkl_list[shortlist]\\n sintheta = self.wavelength/2/d_hkl\\n\\n self.theta = np.arcsin(sintheta)\\n self.hkl_list = hkl_list\\n self.d_hkl = d_hkl\\n \\n #return hkl_list, d_hkl, sintheta\",\n \"def compute_f_BARR(self, R, e, D):\\n upper_LHS_RHS = 5.02 * log(R / (4.518 * log((R / 7), 10)), 10)\\n lower_LHS_RHS = R * (1 + (R**0.52) / (29 * (D/e)**0.7))\\n\\n upper_RHS_RHS = 1\\n lower_RHS_RHS = 3.7*(D/e)\\n bracket = (upper_LHS_RHS / lower_LHS_RHS) + (upper_RHS_RHS / lower_RHS_RHS)\\n \\n RHS = (-2)*log(bracket, 10)\\n f = (1/RHS)**2\\n \\n return f\",\n \"def drillSpeed(matID, W, FWHM_mm):\\n vaporH = { # kJ/mol\\n # spec heat from room temperature to melting + latent heat of fusion + spec heat from melting to boiling + latent heat of vaporization\\n # refer https://webbook.nist.gov/chemistry/ for heat capacity, this tool also has some data in specificHeatParams\\n 'Cu': 29.7 + 13.1 + 48.8 + 300,\\n 'Fe': 49.5 + 13.8 + 60.9 + 340,\\n 'W' : 118.4 + 46.9 + 82.5 + 824,\\n 'Mo': 89.9 + 37.5 + 71.9 + 598,\\n 'Al': 17.98 + 10.7 + 0.03175*1857 + 294\\n }\\n if matID not in vaporH.keys():\\n raise ValueError(f'No vaporization data for {matID}: available in {vaporH.keys()}')\\n \\n mol_mmD = 2 * np.pi * (FWHM_mm/2.355)**2 / 1000 * defaultDensity(matID) / molarMass(matID)\\n return W / (mol_mmD * vaporH[matID] * 1000)\",\n \"def density_by_ideal_gas_law(\\n p: tf.Tensor,\\n r: tf.Tensor,\\n t: tf.Tensor,\\n ) -> tf.Tensor:\\n return p / r / t\",\n \"def vib_energy(frequency, temp):\\n\\n # vibrational temperature\\n\\n vtemp = plank_const * speed_ol / boltz_const * frequency\\n\\n vtemp = np.matrix(vtemp)\\n\\n temp = 1 / np.matrix(temp)\\n\\n # need to convert to array, because the element wise exponential\\n # cannot work with matrix\\n intermediate = np.array(vtemp.T * np.transpose(temp).T)\\n\\n # energy is a np.matrix, need to convert to array\\n energy = R * vtemp * np.matrix((0.5 + (np.exp(intermediate) - 1) ** -1))\\n energy = np.array(energy)[0]\\n\\n return energy\",\n \"def fourier_coefficient(t, freq, n=1, axis=-1):\\n t, freq, n = map(np.asanyarray, (t, freq, n))\\n return np.exp(1j * 2 * np.pi * freq * n * t).sum(axis=axis)\",\n \"def getf(element, energy, conv_fwhm=0):\\n try:\\n Z = int(element)\\n except: \\n if element in elements.Z:\\n Z = elements.Z[element]\\n else:\\n Z = None\\n if Z is None or Z>93:\\n raise ValueError(\\\"Invalid element / element number: %s. \\\"\\n \\\"(Only elements from H to U allowed).\\\"%str(Z))\\n energy = np.array(energy, ndmin=1)\\n diffE = np.unique(np.diff(energy))\\n if not len(diffE):\\n return deltaf.clcalc(Z, energy)\\n dE = abs(diffE.min())\\n fwhm_chan = abs(float(conv_fwhm))/dE/2.\\n # make equally spaced data:\\n if diffE.std()/diffE.mean() > 1e-5 and fwhm_chan>1e-2:\\n newenergy = np.arange(energy.min() - 10*dE, energy.max() + 10.*dE, dE)\\n do_interpolate = True\\n else:\\n newenergy = energy\\n do_interpolate = False\\n \\n f1, f2 = deltaf.clcalc(Z, newenergy)\\n if fwhm_chan>1e-2:\\n f1, f2 = deltaf.convl2(f1, f2, fwhm_chan)\\n if do_interpolate:\\n ffunc = interp1d(newenergy, (f1, f2))\\n f1, f2 = ffunc(energy)\\n return f1, f2\",\n \"def bethe_gf_omega(z, t=1.0):\\n half_bandwidth = 2 * t\\n z_rel = z / half_bandwidth\\n return 2. / half_bandwidth * z_rel * (1 - np.sqrt(1 - 1 / (z_rel * z_rel)))\",\n \"def kld(Fk, freq, Fk_red, f_red):\\n \\n #pad the reduced input with zeros\\n f_red = [float(val) for val in f_red]\\n freq = [float(val) for val in freq]\\n f_Fk_red = dict(zip(f_red,Fk_red))\\n Fk_red_pad = []\\n #for each frequency in the nonreduced signal\\n for i,f in enumerate(freq):\\n #if the frequency is shared with the reduced signal\\n if f in f_red:\\n #add the coefficient from the reduced signal\\n Fk_red_pad.append(f_Fk_red[f])\\n #otherwise, pad it with a zero\\n else:\\n Fk_red_pad.append(0.)\\n Fk_red_pad = np.array(Fk_red_pad)\\n \\n Fk = np.abs(Fk)\\n Fk /= sum(Fk)\\n Fk_red_pad = np.abs(Fk_red_pad)\\n Fk_red_pad /= sum(Fk_red_pad)\\n \\n return stats.entropy(Fk_red_pad, Fk)\",\n \"def boltzmann_test(hmsm, level, discretizer, energy, kT, n_samples=15):\\n pi, ids = induced_distribution(hmsm, 0, level)\\n\\n discrete_free_energy = np.ndarray(pi.shape)\\n for i, id in enumerate(ids):\\n discrete_free_energy[i] = \\\\\\n np.mean([energy(discretizer.sample_from(id)) for i in range(n_samples)])\\n boltzmann = np.exp(-discrete_free_energy/kT)\\n boltzmann *= (1/np.sum(boltzmann))\\n return D_KL(boltzmann, pi)\",\n \"def full_freq_time(freqs, time_arr, Ref_param, dv):\\n Ref_all = pp.Reflectometer_Output(Ref_param.file_path, freqs, time_arr, \\n Ref_param.n_cross_section, \\n Ref_param.FWR_dimension, False, \\n Ref_param.receiver_file_name)\\n Ref_all.E_out = np.zeros((Ref_all.NF, Ref_all.NT, Ref_all.n_cross_section),\\n dtype='complex')\\n \\n parallel_param_list = [(f,t,Ref_param) for f in freqs for t in time_arr]\\n parallel_result = dv.map_async(single_freq_time, parallel_param_list)\\n print('Parallel runs started.')\\n parallel_result.wait_interactive()\\n print('All signals computed!')\\n E_out_scattered = parallel_result.get()\\n print('signals collected.')\\n for i in range(Ref_all.NF):\\n for j in range(Ref_all.NT):\\n Ref_all.E_out[i, j, :] = E_out_scattered[i*len(time_arr)+j][0, 0,:]\\n print(('freq {0},time {1} stored.'.format(freqs[i], time_arr[j])))\\n \\n return Ref_all\",\n \"def getHeatFlux(self, T):\\n\\t\\tQ = self.heat_transfer_coefficient * (self.T_wall - T)\\n\\t\\treturn Q\",\n \"def illuminationEff(freq,fD, FFBW, dB_at_bw, feed_type):\\n theta0 = fD2angle(fD,units='degrees')\\n dtt = 0.1\\n theta = np.arange(0.0,theta0/2.0+dtt,dtt)\\n g = feedPattern(freq, theta, FFBW, dB_at_bw, feed_type)\\n theta = theta*math.pi/180.0\\n kern = np.sqrt(g)*np.tan(theta/2.0)\\n num = 32.0*(fD*integ.trapz(kern,dx=dtt*math.pi/180.0))**2\\n kern = g*np.sin(theta)\\n den = integ.trapz(kern,dx=dtt*math.pi/180.0)\\n\\n n_ill = num/den \\n return n_ill\",\n \"def temperature_diff_wrapped(q: float,\\n delta_tc: np.ndarray,\\n T_r:np.ndarray,\\n order = 1) -> callable:\\n \\n def objective_function(T_cr: np.ndarray) -> np.ndarray:\\n\\n \\\"\\\"\\\"\\n the function to minimize in order to get the non-linear\\n relationship for the geometrically extrapolated cooled surface temperatures\\n \\\"\\\"\\\"\\n \\n Tm = (T_r + T_cr)/2.0\\n ks = thermal_conductivity(Tm)\\n T_cr_update = cooled_surface_temp_actual(T_r,q,delta_tc,ks)\\n \\n return np.linalg.norm(T_cr_update - T_cr,ord = 1)\\n \\n return objective_function\",\n \"def manual_calc_kfs(wbwc_list, dec_list, timelen, timesteps):\\n global X0\\n global wbwc_kfs\\n global all_kfs\\n ####\\n t = np.linspace(0, timelen, timesteps)\\n ##\\n ## 1. set new wbwc rates\\n wbwc_kfs[wbwc_list[0]]['hf'] = wbwc_list[1][0]\\n wbwc_kfs[wbwc_list[0]]['hr'] = wbwc_list[1][1]\\n wbwc_kfs = fill_wbwc_dict(wbwc_kfs, fill='rates')\\n init() \\n #####\\n ## now, loop for each value of a rate const in dec_list\\n for k in dec_list[1]:\\n all_kfs[dec_list[0]] = k\\n kname = dec_list[0] + str(k)\\n ##\\n #init() \\n set_expdeg()\\n ode(calc_model, X0, t, stype='manual', dname = kname)\\n ###\",\n \"def coolingrate(tables, density, He_mass_frac=0.258, metallicity=0.25):\\n # list of all elements in table\\n elements = [\\n x for x in tables.keys() if x not in [\\n 'Header', 'Metal_free', 'Solar', 'Total_Metals']\\n ]\\n \\n # Helium mass fraction bins of only hydrogen and helium\\n metal_free_He_mass_frac = list(\\n tables['Metal_free']['Helium_mass_fraction_bins']\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of /Metal_free/Hydrogen_density_bins, \\n # /Metal_free/Temperature_bins, and helium abundance.\\n metal_free_ne_nh = list(\\n tables['Metal_free']['Electron_density_over_n_h']\\n )\\n \\n # Find index of He mass frac, ssuming direct match in table.\\n He_mass_frac_index = metal_free_He_mass_frac.index(np.float32(He_mass_frac))\\n # Find index of density bin, ssuming direct match in table.\\n abundance_index = list(\\n tables[elements[0]]['Hydrogen_density_bins']).index(np.float32(density)\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of temperature at given denisty and helium mass fraction.\\n metal_free_ne_nh = list(\\n tables['Metal_free']\\\\\\n ['Electron_density_over_n_h']\\\\\\n [He_mass_frac_index, :,abundance_index]\\n )\\n\\n # Ratio of free electron and hydrogen number densities (n_e/n_H) as a \\n # function of temperature at given density for solar abundance.\\n solar_ne_nh = tables['Solar']\\\\\\n ['Electron_density_over_n_h']\\\\\\n [:, abundance_index]\\n\\n # Normalized net cooling rate for only hydrogen and helium as a function of \\n # /Metal_free/Hydrogen_density_bins, /Metal_free/Temperature_bins, \\n # and helium abundance. \\n lambda_metal_free = tables['Metal_free']\\\\\\n ['Net_Cooling']\\\\\\n [He_mass_frac_index, :, abundance_index]\\n \\n # Temperature bins (T [K])\\n T = tables['Metal_free']['Temperature_bins']\\n \\n sum_metals = np.zeros(352)\\n for e in elements:\\n # Normalized, net cooling rate e as a function of temperature for \\n # Hydrogen density 'density'.\\n lambda_i_solar = tables[e]['Net_Cooling'][:,abundance_index]\\n \\n # Calulating the cooling contribution of element e and addind to total.\\n sum_metals += lambda_i_solar*(metal_free_ne_nh/solar_ne_nh)*metallicity\\n \\n coolingrate = lambda_metal_free + sum_metals\\n \\n return T, coolingrate\",\n \"def get_dom_freq(Fk, freq, n_freq):\\n\\n #get the magnitude of the coefficients\\n Fk_abs = np.abs(Fk)\\n #sort the coefficients in descending order\\n Fk_sort = sorted(Fk_abs, reverse=True)\\n \\n dom_Fk = []\\n dom_f = []\\n i = 0\\n while i < n_freq:\\n inds = np.where(Fk_abs == Fk_sort[i])\\n for ind in inds:\\n dom_f.append(freq[ind])\\n dom_Fk.append(Fk[ind])\\n i += 1\\n \\n #sort based on frequency from lo to hi\\n #convert from numpy float to python float for mapping\\n dom_f = [float(abs(f)) for f in dom_f]\\n f_Fk = dict(zip(dom_f,dom_Fk))\\n f_sorted = sorted(dom_f)\\n # return(dom_f, f_Fk, f_sorted, dom_Fk)\\n\\n\\n dom_Fk = []\\n for f in f_sorted:\\n dom_Fk.append(f_Fk[f][0])\\n \\n return np.array(dom_Fk), np.array(f_sorted)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73835194","0.64815336","0.64464134","0.57504225","0.5682341","0.557329","0.54102564","0.53866494","0.5260977","0.5259946","0.5251516","0.5194793","0.5095279","0.49629185","0.4936573","0.49281287","0.48756847","0.48563507","0.48486865","0.4834765","0.47976914","0.4785458","0.47842708","0.4777554","0.47764975","0.47700933","0.47611704","0.47591278","0.47526872","0.4749305","0.47394043","0.47060958","0.47021395","0.46996185","0.46944943","0.46564695","0.4649095","0.4628741","0.46281993","0.46224642","0.46218145","0.4621319","0.4617628","0.46139583","0.45910692","0.4584005","0.458169","0.4580404","0.45763233","0.45665568","0.45657414","0.4553693","0.45498008","0.4539717","0.45394784","0.45336077","0.45263287","0.45244813","0.45182675","0.45164046","0.4513333","0.45060343","0.4497684","0.44929034","0.44903755","0.44886354","0.44819298","0.44775206","0.4474168","0.44710433","0.446903","0.4468456","0.44647315","0.4464408","0.4463756","0.44636345","0.44626984","0.4458663","0.44583717","0.4454386","0.44533557","0.4451877","0.44463333","0.44456616","0.44394702","0.44358444","0.44326988","0.4429016","0.44252348","0.44222555","0.4420589","0.44193235","0.4415191","0.44147298","0.44126683","0.44112164","0.44098","0.44016612","0.4396628","0.4388209"],"string":"[\n \"0.73835194\",\n \"0.64815336\",\n \"0.64464134\",\n \"0.57504225\",\n \"0.5682341\",\n \"0.557329\",\n \"0.54102564\",\n \"0.53866494\",\n \"0.5260977\",\n \"0.5259946\",\n \"0.5251516\",\n \"0.5194793\",\n \"0.5095279\",\n \"0.49629185\",\n \"0.4936573\",\n \"0.49281287\",\n \"0.48756847\",\n \"0.48563507\",\n \"0.48486865\",\n \"0.4834765\",\n \"0.47976914\",\n \"0.4785458\",\n \"0.47842708\",\n \"0.4777554\",\n \"0.47764975\",\n \"0.47700933\",\n \"0.47611704\",\n \"0.47591278\",\n \"0.47526872\",\n \"0.4749305\",\n \"0.47394043\",\n \"0.47060958\",\n \"0.47021395\",\n \"0.46996185\",\n \"0.46944943\",\n \"0.46564695\",\n \"0.4649095\",\n \"0.4628741\",\n \"0.46281993\",\n \"0.46224642\",\n \"0.46218145\",\n \"0.4621319\",\n \"0.4617628\",\n \"0.46139583\",\n \"0.45910692\",\n \"0.4584005\",\n \"0.458169\",\n \"0.4580404\",\n \"0.45763233\",\n \"0.45665568\",\n \"0.45657414\",\n \"0.4553693\",\n \"0.45498008\",\n \"0.4539717\",\n \"0.45394784\",\n \"0.45336077\",\n \"0.45263287\",\n \"0.45244813\",\n \"0.45182675\",\n \"0.45164046\",\n \"0.4513333\",\n \"0.45060343\",\n \"0.4497684\",\n \"0.44929034\",\n \"0.44903755\",\n \"0.44886354\",\n \"0.44819298\",\n \"0.44775206\",\n \"0.4474168\",\n \"0.44710433\",\n \"0.446903\",\n \"0.4468456\",\n \"0.44647315\",\n \"0.4464408\",\n \"0.4463756\",\n \"0.44636345\",\n \"0.44626984\",\n \"0.4458663\",\n \"0.44583717\",\n \"0.4454386\",\n \"0.44533557\",\n \"0.4451877\",\n \"0.44463333\",\n \"0.44456616\",\n \"0.44394702\",\n \"0.44358444\",\n \"0.44326988\",\n \"0.4429016\",\n \"0.44252348\",\n \"0.44222555\",\n \"0.4420589\",\n \"0.44193235\",\n \"0.4415191\",\n \"0.44147298\",\n \"0.44126683\",\n \"0.44112164\",\n \"0.44098\",\n \"0.44016612\",\n \"0.4396628\",\n \"0.4388209\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.71289545"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88357,"cells":{"query":{"kind":"string","value":"compute the n period relative strength indicator"},"document":{"kind":"string","value":"def relative_strength(prices, n):\n\n deltas = np.diff(prices)\n seed = deltas[:n+1] # takes the last 1 price differences? 12 market days?\n up = seed[seed>=0].sum()/n\n down = -seed[seed<0].sum()/n\n rs = up/down\n rsi = np.zeros_like(prices)\n rsi[:n] = 100. - 100./(1.+rs)\n\n for i in range(n, len(prices)):\n delta = deltas[i-1] # cause the diff is 1 shorter\n\n if delta>0:\n upval = delta\n downval = 0.\n else:\n upval = 0.\n downval = -delta\n\n up = (up*(n-1) + upval)/n\n down = (down*(n-1) + downval)/n\n\n rs = up/down\n rsi[i] = 100. - 100./(1.+rs)\n\n return rsi"},"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 calculateRelativeStrengthIndex(self, series, interval=14):\n\n if not isinstance(series, pd.Series):\n raise TypeError('Pandas Series required.')\n\n if not isinstance(interval, int):\n raise TypeError('Interval integer required.')\n\n if(len(series) < interval):\n raise IndexError('Pandas Series smaller than interval.')\n\n diff = series.diff(1).dropna()\n\n sum_gains = 0 * diff\n sum_gains[diff > 0] = diff[diff > 0]\n avg_gains = sum_gains.ewm(com=interval-1, min_periods=interval).mean()\n\n sum_losses = 0 * diff\n sum_losses[diff < 0] = diff[diff < 0]\n avg_losses = sum_losses.ewm(\n com=interval-1, min_periods=interval).mean()\n\n rs = abs(avg_gains / avg_losses)\n rsi = 100 - 100 / (1 + rs)\n\n return rsi","def semitone_diff_to_frequency(n: float) -> float:\n return A4 * A**n","def RelativeStrengthIndex(self, timeperiod=14):\r\n return ta.RSI(self.data.close,timeperiod)","def period(self) -> int:","def polynomial_learning_rate(n, w=0.5):\n assert n > 0, \"Make sure the number of times a state action pair has been observed is always greater than 0 before calling polynomial_learning_rate\"\n\n return 1./n**w","def duty_cycle(self):\n diff = np.diff(self.lc.time)\n t = np.median(diff)\n std = np.std(diff)\n mask = diff > (t + 3 * std)\n return (1 - np.sum(diff[mask]) / np.sum(diff))","def varience_of_slope(slope,NoOfPoints,tframe,redn,gain):\n Var = 6*(NoOfPoints**2 + 1)*np.abs(slope) / (5*NoOfPoints*(NoOfPoints**2 -1)*tframe) +\\\n 12*(redn**2 + gain**2 / 12.)/(NoOfPoints*(NoOfPoints**2 -1)*tframe**2)\n return Var","def linear_annealing(self, n, total, p_initial, p_final):\n if n == total:\n print \"exploration period over\"\n if n >= total:\n return p_final\n else:\n return p_initial - (n * (p_initial - p_final)) / (total)","def _period( self ):\r\n\treturn 2 * pi * sqrt( self.orbital_elements[0]**3 / self.mu_central_body )\r\n\t# http://en.wikipedia.org/wiki/Orbital_period#Calculation\r","def get_strength(self):\n return 10 - self.get_agility()","def strength(self) -> float:\n ...","def prob_no_match(n):\n return math.factorial(n)*math.comb(365,n)/(365**n)","def final_amt(p,r,n,t):\n\n a = p * (1 + r/n) ** (n*t)\n return a #This is what makes the function \"fruitful\"","def dishlist_avg_cal(n:list)->float:\r\n all_cal = dishlist_cal(n)\r\n return sum(all_cal)/len(all_cal)","def func_kc_318(n, series):\n if series == \"3D3\":\n try:\n return 2*np.pi/(wl_3D3[str(n)]*1e-9)\n except:\n return 0","def normal_lifetime(r, freq=1):\n return np.tan(np.angle(r - 0.5) / 2) / (2 * np.pi * freq)","def IMPORTANCE(attribute_name, examples, attribues):\n p = 0\n n = 0\n # First count the number of p and n \n for item in examples:\n if item[-1] == 'Yes':\n p += 1\n else:\n n += 1\n Gain = B(p/(p+n)) - REMAINDER(attribute_name, examples, attribues)\n return Gain","def tGain(self, dt, r):\n\t return 1./(10.**6)*r#*precip.r","def P_Tn(self,\n yn:float,\n n:int) -> float:\n return 1 / ((1 + yn * 0.5) **n)","def _dispersion_spread(self, n):\n\n return pow(self.max_iters-self.iteration, n) / pow(self.max_iters, n) * \\\n (self.max_std - self.min_std) + self.min_std","def compute_duty_factor():\n [time,\n ankle_l_trajectory,\n ankle_r_trajectory,\n foot_l_contact,\n foot_r_contact,\n muscle_lh_activations,\n muscle_rh_activations,\n muscle_lh_forces,\n muscle_rh_forces,\n joint_lh_positions,\n joint_rh_positions] = load_data()\n \n print(np.sum(foot_l_contact)/len(foot_l_contact))\n print(np.sum(foot_r_contact)/len(foot_r_contact))\n\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5","def williams_variable_accum_dist(close, open, high, low, volume):\n range = high - low","def lp_factor(self):\n num = 1 + np.cos(2 * self.angle) ** 2\n den = np.cos(self.angle) * np.sin(self.angle) ** 2\n return num / den","def periodicity_metric(light_curve_rms, sm_phase_rms):\n return (sm_phase_rms ** 2) / (light_curve_rms ** 2)","def modulation_lifetime(r, freq=1):\n return np.sqrt(1 / np.abs(r) ** 2 - 1) / (2 * np.pi * freq)","def nPVI(durations):\n if not durations:\n sys.exit(\"Empty durations. Exit!\")\n s = []\n for idx in range(1,len(durations)):\n s.append(float(durations[idx-1]-durations[idx])/float((durations[idx-1]+durations[idx])/2))\n\n return 100 / float(len(durations)-1) * np.sum(np.abs(s))","def relative_range(self):\n self.calculate_relative_mags()\n string = '{:.0f}-{:.0f}Hz: {:.5f}'\n s_ind = self.get_bin(self.s_freq)\n e_ind = self.get_bin(self.e_freq)\n lst = self.rel_mags[s_ind:e_ind+1]\n return sum(lst)/len(lst)","def _get_n(self):#@Needs to fix it for general case\n n_60 = 0.55 * 1 * 1 * 0.75 * self._data[SoilProperty.SPT_N] /0.6\n if not self.is_clayey() and n_60>15: #apply dilitracy correction\n n_60 = 15 + 0.5 * (n_60 - 15)\n return n_60","def effective_snr(self, effective_width, period):\n return sqrt((period - effective_width) / (effective_width * 1.0)) if period > effective_width else 0","def seriesResistance(self):\n return 13.38 * math.pow(self.concentration, -0.8397)","def get_period(n):\n remainder = 1\n i = 1\n cache = {}\n while True:\n remainder = (10 * remainder) % n\n if remainder in cache:\n return i - cache[remainder]\n\n cache.update({remainder: i})\n i += 1","def stirling(n):\n return n**n*isqrt(2*math.pi*n)/math.e**n","def accPulse (t,Dp,t1,Tp):\r\n\tdiscretePulse=-(Dp*math.pi**2)/(float(2)*Tp**2)*np.sin(math.pi*(t-t1-Tp/float(2))/float(Tp))\r\n\treturn discretePulse/float(981)","def calc(self,index, counter_values):\n try:\n angles = self.ik220_dev.read_attribute('Angles').value\n if index == 9:\n return sum(angles[:3])/3.0 # Excluded channel 4 of grating pitch encoder because of problems of Homing in the last header of the RON grating encoder.\n elif index == 10:\n return sum(angles[4:6])/2.0 # Modified from 4 channels to 2 channels because of problems of Homing in the 2 last headers of the RON mirror3 encoder.\n else:\n return angles[index - 1]\n except:\n return 1e-100","def d_weights(n):\n i = np.arange(1, n)\n return np.sqrt(n / (i * (n - i)))","def net_present_value(certificate, t):\n return sum(certificate['cash_flow_in_period'][i] / (1+RISK_FREE_INTEREST_RATE)**i for i in range(t+1))","def prob1(n):\n\n # create a giant draw from a normal distribution\n random_draws = np.random.normal(loc= 0, scale = 1, size = n)\n\n # mask the values\n mask = random_draws > 3\n\n return np.sum(mask)/float(n)","def discount(self, period):\n\t\treturn 1.0/compound(period)","def rsi_apply_nb(ts, window, ewm, adjust, cache_dict):\n h = hash((window, ewm))\n roll_up, roll_down = cache_dict[h]\n rs = roll_up / roll_down\n return 100 - 100 / (1 + rs)","def item_tres(n):\n if n <= 0.167:\n return 0\n elif n > 0.167 and n <= 0.333:\n return 1\n elif n > 0.333 and n <= 0.500:\n return 2\n elif n > 0.500 and n <= 0.667:\n return 3\n elif n > 0.667 and n <= 0.834:\n return 4\n elif n > 0.834 and n <= 1.000:\n return 5","def reg_slope(sum_ind_times_dep, sum_independent, sum_dependent, sum_dependent_squared, n):\n return (\n (\n (n * sum_ind_times_dep) - (sum_independent * sum_dependent)\n ) / (\n (n * sum_dependent_squared) - (sum_dependent * sum_dependent)\n )\n )","def ramp2n(params, phase, args=dict(n=3, guess=[1, 26.6, 7.8])):\n # 2013-12-07 14:08 IJMC: Created.\n\n return params[0] * (1. - np.exp(-params[1]*phase + params[2]))","def ps_freq_axis(dt, n):\n\n frequency = sp.arange(n//2, dtype=float)\n df = 1.0/dt/n\n frequency *= df\n return frequency","def likelihood_weighting_estimate(self,var,e,n,sampling_weight='uniform'):\n\t\tncpt = self.variables[var].cpt\n\t\tncount = dict((value,0.0) for value in ncpt.values())\n\t\twsum = 0.0\n\t\tfor iter in xrange(n):\n (w,sample) = self.importance_sample(e,sampling_weight)\n assert all(sample[key]==value for (key,value) in e.iteritems())\n \n ncount[sample[var]] += w\n wsum += w\n if wsum==0: return 'Undefined'\n for value in ncount.iterkeys():\n ncount[value] = float(ncount[value])/float(wsum)\n return ncount","def pv(rate, n_years):\n return 1 / fv(rate, n_years)","def get_duration(period, aor, e):\n return 0.25 * period * np.sqrt(1 - e**2) / aor","def calc_calories(gpx_track, wt = 175, activity='Run'):","def theoretical_effective(dataset):\n return float(sum(dataset))/len(dataset)","def calc(self,newValue):\n return np.sum(self.values<=newValue)/self.n","def _calc_freeze_probability(self, num_iterations, final_fraction):\n return 1.0 - (final_fraction ** (1.0 / num_iterations))","def energy(n):\n return (n * pi * hbar / (2 * a)) ** 2 / (2 * m)","def get_crossover_accept_rate(n: int):\n return 1 / (2 ** n)","def _prorata_rate(self, days_used, days_in_month):\n return (100 * days_used // days_in_month) / 100.0","def duty_translate(self, n):\n return int((float(n) / 255) * 1023)","def band_penalty(self):\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\n n = min(fc_ix, self.ix10k - fc_ix)\n if n == 0:\n return 0.0\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - (self.gain - self.fr[fc_ix + n - 1:fc_ix - 1:-1])))","def PV_ExpsMaint(t):\n if t > last_t:\n return 0\n else:\n return - prj_exps_Maint(t) + PV_ExpsMaint(t + 1) / (1 + DiscRate(t))","def get_learn_rate_and_momentum(self, n_iter):\n return self.learn_rate_schedule.get_var_at_iter(n_iter), \\\n self.momentum_schedule.get_var_at_iter(n_iter)","def expected_return(self, n_step):\r\n value = 0\r\n n_experiences = 50\r\n for i in range(n_experiences):\r\n trajectory = self.domain_exploration(n_step)\r\n value += self.compute_j(trajectory)\r\n return value/n_experiences","def band(n, steps):\n return math.floor(n * steps) / steps","def get_blr_strength(self,\n blr: BoundedLinearRegressions) -> float:\n # Return 0 if slopes are different signs.\n if blr.minima_regression.slope * blr.maxima_regression.slope < 0:\n return 0\n\n # Return 0 if not enough data.\n if len(blr.candles) <= 3:\n return 0\n\n # Find high and low prices of the trendline period.\n high_price = max([candle.high for candle in blr.candles])\n low_price = max([candle.low for candle in blr.candles])\n\n # Find start and end of the period.\n start_moment = max([candle.moment for candle in blr.candles])\n end_moment = min([candle.moment for candle in blr.candles])\n\n # Take signal strength to be the average of the two slopes.\n minima_slope_pct = abs(blr.minima_regression.y_of_x(end_moment) - blr.minima_regression.y_of_x(start_moment)) \\\n / max(0.01, high_price - low_price)\n maxima_slope_pct = abs(blr.maxima_regression.y_of_x(end_moment) - blr.maxima_regression.y_of_x(start_moment)) \\\n / max(0.01, high_price - low_price)\n signal_strength = (minima_slope_pct + maxima_slope_pct) / 2.0\n\n # Scale down signal strength.\n signal_strength = min(1, signal_strength / 5.0)\n\n # Ensure the signal strength has the correct sign.\n if blr.minima_regression.slope < 0:\n signal_strength += -1\n\n return signal_strength","def emission_rate_per_person_when_present(self) -> _VectorisedFloat:\n return (self.emission_rate_per_aerosol_per_person_when_present() *\n self.aerosols())","def silverman(n: int, ess: float) -> float:\n\n return (ess * (n + 2) / 4) ** (-1 / (n + 4))","def P(lag):\n N = len(SP)\n ratios = SP[lag:N]/SP[0:N-lag]\n P = 100.*(ratios-1.)\n return P","def powAlpha( n ):\n return (1-betaval)*Fib(n) + Fib(n-1)\n #return Fib(n+1) - Fib(n) * betaval","def fv(rate, n_years):\n return pow(1 + rate, n_years)","def calculate_emission_prob(cls, w, t):\n #\n # p_w_t = cls._emission_counts[w, t]\n # p_t = cls._uni_transition_counts[t]\n\n return float(cls._emission_counts[w, t] / cls._uni_transition_counts[t])","def heterodyner_signal(self, n=1):\n omega = self.fvec*2*np.pi*n\n phvec = np.cumsum(omega)\n return np.exp(1j*phvec)","def testPeriod1(self):\n rsi = std.rsi_calc(self.gldf['Gain'], self.gldf['Loss'], 1)\n self.assertGreater(rsi.iloc[1], 99.0, \"RSI value was not close to 100 for all gain.\")\n self.assertLess(rsi.iloc[3], 0.01, \"RSI value was not close to 0 for all loss.\")","def prob1(n):\n#raise NotImplementedError(\"Problem 1 Incomplete\")\n if n == 0 :\n raise ValueError(\"Sampling 0 points is not defined.\")\n total = 0\n for i in xrange(n) :\n if np.random.normal() > 3 :\n total += 1\n return float(total)/n","def efficiency(w, L_t=79.6, p=75, fmax=1e12, p1=database['K+'],\r\n p2=database['pi+'], p3=database['p+'], E=1e6, delta_p=1.6e-2,\r\n n=10000, ng=50, nl=50, nf=100, plot=True, set_freq=5.7e9):\r\n if L_t == 79.6 and p == 75 and fmax == 1e12:\r\n opt = [296.5e9, 25.73, 13.33, 9.21]\r\n if L_t == 641.4-22.8 and p == 75 and fmax == 5.7e9:\r\n opt = [5.7e9, 206.2, 104.1, 134.8]\r\n else:\r\n opt = cavity_gap_comp(L_t, p, fmax, p1, p2, p3, E, False, delta_p, ng, nl,\r\n nf, False, False, set_freq)\r\n d_2 = abs_deflection(ang_deflection(p, opt[0], p1, p2, L_t-opt[1], opt[2], E, delta_p), opt[1])\r\n d_3 = abs_deflection(ang_deflection(p, opt[0], p1, p3, L_t-opt[1], opt[2], E, delta_p), opt[1])\r\n phase_range = np.linspace(0, 2*np.pi, n)\r\n disp_2, disp_3, count_2, count_3 = [], [], 0, 0\r\n for tau in phase_range:\r\n disp_2.append(-d_2*np.cos(tau))\r\n disp_3.append(-d_3*np.cos(tau))\r\n if abs(disp_2[-1]) > w:\r\n count_2 += 1\r\n if abs(disp_3[-1]) > w:\r\n count_3 += 1 \r\n num_K = 6*decay_proportion(L_t, p1, p, None)/Gaussian_integral(w/26.4, plot=False)\r\n purity = (num_K/(num_K+((70*(n-count_2))/n)+((23*(n-count_3))/n)))*100\r\n if plot == True:\r\n fig = plt.figure(figsize=[12, 4])\r\n ax = fig.add_subplot(1, 1, 1)\r\n ax.plot(phase_range, disp_2, 'r', lw=2, label=r'$\\pi^+$')\r\n ax.plot(phase_range, disp_3, 'b', lw=2, label=r'$p^+$')\r\n blank = np.zeros(n)\r\n ymin, ymax = np.min(disp_2 + disp_3)*1.1, np.max(disp_2 + disp_3)*1.1\r\n ax.fill_between(phase_range, blank+w, blank+ymax, color='k', alpha=0.5)\r\n ax.fill_between(phase_range, blank-w, blank+ymin, color='k', alpha=0.5)\r\n ax.set_xlim(0, 2*np.pi)\r\n ax.set_ylim(ymin, ymax)\r\n ax.set_xlabel('Phase', fontsize=20)\r\n ax.set_ylabel('Displacement', fontsize=20)\r\n ax.set_xticks([])\r\n ax.set_yticks([])\r\n ax.set_title('Phase dependence of unwanted particle absorbance in the beam stopper', fontsize=17)\r\n ax.legend(fontsize=20)\r\n plt.show()\r\n fig.savefig('Efficiency_Blank.pdf', bbox_inches='tight')\r\n print('{0} efficiency = {1:.1f}%\\n{2} efficiency = {3:.1f}%\\nBeam purity = {4:.1f}%'.format(p2.name, (count_2/n)*100, p3.name, (count_3/n)*100, purity))\r\n return purity","def get_power_one_side(alpha, n, k, effect_size):\n c = sc.t.ppf(1 - alpha, (1 + k) * n - 2)\n delta_norm = effect_size * np.sqrt(1 / (1 / n + 1 / (n * k)))\n p = 1 - sc.nct.cdf(c, (1 + k) * n - 2, delta_norm)\n return p","def pulse_width_percent(self) -> float:","def twr_ret(self) -> float:\n if float(self.tsdf.iloc[0]) == 0.0:\n raise Exception('First data point == 0.0')\n return float(((self.tsdf.iloc[-1] / self.tsdf.iloc[0]) ** (1 / self.length) - 1) * self.periods_in_a_year)","def _temperature_policy(self, N: np.ndarray) -> np.ndarray:\n t = 1 / self.temperature\n pi = N ** t + np.finfo(np.float32).eps # Add tiny value to remove 0s\n pi = pi / pi.sum()\n return pi","def expectancyPcnt(self, p):\n return (2 * p) - 1","def _calculate_snr_spread(self):\n\n dmSpacing, percentage = 100, 0\n while percentage < 0.5: \n x = np.linspace(self.centerDm - dmSpacing, self.centerDm + dmSpacing, 500)\n y = np.array([self.effective_snr(self.effective_width(self.pulseWidth, self.centerDm - dm_val, self.bandwidth, self.freq), self.pulseWidth * 20) for dm_val in x])\n y = (y / (np.max(y) * 1.0)) if np.max(y) > 0 else y\n percentage = np.size(np.where(y > 0)) / 1000.0\n dmSpacing = dmSpacing*0.6\n \n return x, y","def get_periodicity(self):\n\n per = 1\n is_antiper = False\n\n if \"antiperiod\" in self.symmetries:\n if self.symmetries[\"antiperiod\"] > 1:\n per = self.symmetries[\"antiperiod\"]\n is_antiper = True\n elif \"period\" in self.symmetries:\n if self.symmetries[\"period\"] > 1:\n per = self.symmetries[\"period\"]\n\n return (per, is_antiper)","def prior(n=10):\r\n p = []\r\n trials = 0\r\n acc = 0\r\n while acc < n:\r\n trials += 1\r\n r = np.random.rand(2) * np.array([4, 2]) + np.array([-2, -1])\r\n # print(\"r: \", r)\r\n if r[1] + r[0] >= -1 and r[1] - r[0] >= -1:\r\n p.append(r)\r\n acc += 1\r\n # print(\"trials: \", trials, \", acc: \", acc)\r\n return p","def moment(self, p):\n return sum([val**p for val in self.counts.values()])","def get_percent(self, n):\n controlled = 0.00\n for i in range(len(self.tile_contents)):\n if(self.tile_contents[i].player_number == n):\n controlled += 1.00\n \n return float(controlled / self.paint_blocks)","def calc_relhum(dewpt,t):\n\n relhum=100.*(np.exp((const.es_Abolton*dewpt)/(const.es_Bbolton+dewpt))/np.exp((const.es_Abolton*t)/(const.es_Bbolton+t)))\n return relhum","def calculate_variance(n, p):\n return p * (1 - p) / n","def calc_gain(s, i):\n return math.sqrt((i + s) / (6 * s))","def item_um(n):\n if n <= 0.250:\n return 0\n elif n > 0.250 and n <= 0.500:\n return 1\n elif n > 0.500 and n <= 0.750:\n return 2\n elif n > 0.750 and n <= 1.000:\n return 3","def puissance(x: float, n: int) -> float:\n resultat: float = 1\n signe: int = 1\n if n != 0:\n if n <= 0:\n n = -n\n signe = -1\n for cpt in range(1, n + 1):\n resultat = resultat * x\n if signe < 0:\n resultat = 1 / resultat\n return resultat","def sumArithmeticSeries(a: float, d: float, n: int) -> float:\n return (a + d * (n + 1) / 2) * n","def getDemodGain(self, inpwr):\n return min(100, max(0, int(100-2*(inpwr+40))))","def band_penalty(self):\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\n n = min(fc_ix, self.ix10k - fc_ix)\n if n == 0:\n return 0.0\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - self.fr[fc_ix + n - 1:fc_ix - 1:-1]))","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)","def acN(self):\n acSum = 0.0\n for i in self.longPosE:\n if self.enginePos == 'wing': # wing mounted engines\n ln = self.acW - i\n elif self.enginePos == 'fuselage': # tail mounted engines\n ln = self.acW - (i + self.nacelleLength)\n acSum = +self.kn * ln * (self.nacelleDiameter**2) / (self.surfaceW * self.cMACW * self.clAlphaWF)\n return acSum","def digital_gain():\n def r(x):\n return x/512.\n\n def w(x):\n return int(x*512)\n return r, w","def stick_breaking(n:int,alpha:float) -> np.ndarray:\n betas = G.beta(a=alpha, b=1.0, size=n)\n betas[1:] *= np.cumprod(1-betas[:-1])\n weights = np.sort(betas)[::-1]\n return weights","def polytropicProfile(n=[1.5]):\n\t\tdx = 0.001\n\t\txs = []\n\t\tthetas = []\n\t\tfor j, index in enumerate(n):\n\t\t\ttheta = [1]\n\t\t\tdtheta_dx = [0]\n\t\t\tx = [1E-6]\n\t\t\ti=0\n\t\t\twhile theta[i] > 0 and i<5000:\n\t\t\t\tdtheta_dx.append(dtheta_dx[i] - (2*dtheta_dx[i]/x[i] + theta[i]**index)*dx)\n\t\t\t\ttheta.append(theta[i] + dtheta_dx[i]*dx)\n\t\t\t\tx.append(x[i] + dx)\n\t\t\t\ti+=1\n\t\t\txs.append(np.array(x))\n\t\t\tthetas.append(np.array(theta))\n\t\treturn xs, thetas","def extendability(self):\n self._extendability = 0.50 * self.ANA - 0.50 * self.DCC + 0.50 * self.MFA + 0.50 * self.NOP\n return round(self._extendability, 5)","def get_pwin(star, period):\n M = star.dataspan / period\n f = star.dutycycle\n omf = 1.0 - f\n pw = 1 - omf**M - M*f*omf**(M-1) - 0.5*M*(M-1)*f*f*omf**(M-2)\n msk = (pw >= 0.0) * (M >= 2.0)\n return pw * msk","def binary_reg_fn(strengths):\n term = 3.25 * strengths - 1.625\n return 1 / (1 + torch.pow(term, 12))","def get_ratio_guarantee_advance(self):\n return (\n self.ratio_guarantee_advance *\n self.get_period_guarantee_advance *\n self.ratio2_guarantee_advance\n )","def get_n1(r,N):\n n1 = N - np.sum(r)\n return n1","def DW_cal(data, data_sm):\n n = len(data)\n numerator = 0\n denominator = 0\n for i in range(n):\n if i == 0:\n numerator = numerator + 0\n else:\n numerator = numerator + ((data[i] - data_sm[i]) - (data[i-1] - data_sm[i-1]))**2\n denominator = denominator + (data[i] - data_sm[i])**2\n return numerator/denominator*n/(n - 1)","def formula_n(self, n: int, x: np.ndarray) -> np.ndarray:\n\n # express x as z = x/(x-1)\n z = x / (x - 1)\n\n # special case @n=0\n if n == 0:\n kn = 1 - self._vlerchphi(1 / z, n + 1)\n else:\n kn = 1 / n - self._vzlerchphi(1 / z, n + 1)\n\n # return\n return kn"],"string":"[\n \"def calculateRelativeStrengthIndex(self, series, interval=14):\\n\\n if not isinstance(series, pd.Series):\\n raise TypeError('Pandas Series required.')\\n\\n if not isinstance(interval, int):\\n raise TypeError('Interval integer required.')\\n\\n if(len(series) < interval):\\n raise IndexError('Pandas Series smaller than interval.')\\n\\n diff = series.diff(1).dropna()\\n\\n sum_gains = 0 * diff\\n sum_gains[diff > 0] = diff[diff > 0]\\n avg_gains = sum_gains.ewm(com=interval-1, min_periods=interval).mean()\\n\\n sum_losses = 0 * diff\\n sum_losses[diff < 0] = diff[diff < 0]\\n avg_losses = sum_losses.ewm(\\n com=interval-1, min_periods=interval).mean()\\n\\n rs = abs(avg_gains / avg_losses)\\n rsi = 100 - 100 / (1 + rs)\\n\\n return rsi\",\n \"def semitone_diff_to_frequency(n: float) -> float:\\n return A4 * A**n\",\n \"def RelativeStrengthIndex(self, timeperiod=14):\\r\\n return ta.RSI(self.data.close,timeperiod)\",\n \"def period(self) -> int:\",\n \"def polynomial_learning_rate(n, w=0.5):\\n assert n > 0, \\\"Make sure the number of times a state action pair has been observed is always greater than 0 before calling polynomial_learning_rate\\\"\\n\\n return 1./n**w\",\n \"def duty_cycle(self):\\n diff = np.diff(self.lc.time)\\n t = np.median(diff)\\n std = np.std(diff)\\n mask = diff > (t + 3 * std)\\n return (1 - np.sum(diff[mask]) / np.sum(diff))\",\n \"def varience_of_slope(slope,NoOfPoints,tframe,redn,gain):\\n Var = 6*(NoOfPoints**2 + 1)*np.abs(slope) / (5*NoOfPoints*(NoOfPoints**2 -1)*tframe) +\\\\\\n 12*(redn**2 + gain**2 / 12.)/(NoOfPoints*(NoOfPoints**2 -1)*tframe**2)\\n return Var\",\n \"def linear_annealing(self, n, total, p_initial, p_final):\\n if n == total:\\n print \\\"exploration period over\\\"\\n if n >= total:\\n return p_final\\n else:\\n return p_initial - (n * (p_initial - p_final)) / (total)\",\n \"def _period( self ):\\r\\n\\treturn 2 * pi * sqrt( self.orbital_elements[0]**3 / self.mu_central_body )\\r\\n\\t# http://en.wikipedia.org/wiki/Orbital_period#Calculation\\r\",\n \"def get_strength(self):\\n return 10 - self.get_agility()\",\n \"def strength(self) -> float:\\n ...\",\n \"def prob_no_match(n):\\n return math.factorial(n)*math.comb(365,n)/(365**n)\",\n \"def final_amt(p,r,n,t):\\n\\n a = p * (1 + r/n) ** (n*t)\\n return a #This is what makes the function \\\"fruitful\\\"\",\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 func_kc_318(n, series):\\n if series == \\\"3D3\\\":\\n try:\\n return 2*np.pi/(wl_3D3[str(n)]*1e-9)\\n except:\\n return 0\",\n \"def normal_lifetime(r, freq=1):\\n return np.tan(np.angle(r - 0.5) / 2) / (2 * np.pi * freq)\",\n \"def IMPORTANCE(attribute_name, examples, attribues):\\n p = 0\\n n = 0\\n # First count the number of p and n \\n for item in examples:\\n if item[-1] == 'Yes':\\n p += 1\\n else:\\n n += 1\\n Gain = B(p/(p+n)) - REMAINDER(attribute_name, examples, attribues)\\n return Gain\",\n \"def tGain(self, dt, r):\\n\\t return 1./(10.**6)*r#*precip.r\",\n \"def P_Tn(self,\\n yn:float,\\n n:int) -> float:\\n return 1 / ((1 + yn * 0.5) **n)\",\n \"def _dispersion_spread(self, n):\\n\\n return pow(self.max_iters-self.iteration, n) / pow(self.max_iters, n) * \\\\\\n (self.max_std - self.min_std) + self.min_std\",\n \"def compute_duty_factor():\\n [time,\\n ankle_l_trajectory,\\n ankle_r_trajectory,\\n foot_l_contact,\\n foot_r_contact,\\n muscle_lh_activations,\\n muscle_rh_activations,\\n muscle_lh_forces,\\n muscle_rh_forces,\\n joint_lh_positions,\\n joint_rh_positions] = load_data()\\n \\n print(np.sum(foot_l_contact)/len(foot_l_contact))\\n print(np.sum(foot_r_contact)/len(foot_r_contact))\\n\\n return np.sum(foot_l_contact)/len(foot_l_contact)*0.5 + np.sum(foot_r_contact)/len(foot_r_contact)*0.5\",\n \"def williams_variable_accum_dist(close, open, high, low, volume):\\n range = high - low\",\n \"def lp_factor(self):\\n num = 1 + np.cos(2 * self.angle) ** 2\\n den = np.cos(self.angle) * np.sin(self.angle) ** 2\\n return num / den\",\n \"def periodicity_metric(light_curve_rms, sm_phase_rms):\\n return (sm_phase_rms ** 2) / (light_curve_rms ** 2)\",\n \"def modulation_lifetime(r, freq=1):\\n return np.sqrt(1 / np.abs(r) ** 2 - 1) / (2 * np.pi * freq)\",\n \"def nPVI(durations):\\n if not durations:\\n sys.exit(\\\"Empty durations. Exit!\\\")\\n s = []\\n for idx in range(1,len(durations)):\\n s.append(float(durations[idx-1]-durations[idx])/float((durations[idx-1]+durations[idx])/2))\\n\\n return 100 / float(len(durations)-1) * np.sum(np.abs(s))\",\n \"def relative_range(self):\\n self.calculate_relative_mags()\\n string = '{:.0f}-{:.0f}Hz: {:.5f}'\\n s_ind = self.get_bin(self.s_freq)\\n e_ind = self.get_bin(self.e_freq)\\n lst = self.rel_mags[s_ind:e_ind+1]\\n return sum(lst)/len(lst)\",\n \"def _get_n(self):#@Needs to fix it for general case\\n n_60 = 0.55 * 1 * 1 * 0.75 * self._data[SoilProperty.SPT_N] /0.6\\n if not self.is_clayey() and n_60>15: #apply dilitracy correction\\n n_60 = 15 + 0.5 * (n_60 - 15)\\n return n_60\",\n \"def effective_snr(self, effective_width, period):\\n return sqrt((period - effective_width) / (effective_width * 1.0)) if period > effective_width else 0\",\n \"def seriesResistance(self):\\n return 13.38 * math.pow(self.concentration, -0.8397)\",\n \"def get_period(n):\\n remainder = 1\\n i = 1\\n cache = {}\\n while True:\\n remainder = (10 * remainder) % n\\n if remainder in cache:\\n return i - cache[remainder]\\n\\n cache.update({remainder: i})\\n i += 1\",\n \"def stirling(n):\\n return n**n*isqrt(2*math.pi*n)/math.e**n\",\n \"def accPulse (t,Dp,t1,Tp):\\r\\n\\tdiscretePulse=-(Dp*math.pi**2)/(float(2)*Tp**2)*np.sin(math.pi*(t-t1-Tp/float(2))/float(Tp))\\r\\n\\treturn discretePulse/float(981)\",\n \"def calc(self,index, counter_values):\\n try:\\n angles = self.ik220_dev.read_attribute('Angles').value\\n if index == 9:\\n return sum(angles[:3])/3.0 # Excluded channel 4 of grating pitch encoder because of problems of Homing in the last header of the RON grating encoder.\\n elif index == 10:\\n return sum(angles[4:6])/2.0 # Modified from 4 channels to 2 channels because of problems of Homing in the 2 last headers of the RON mirror3 encoder.\\n else:\\n return angles[index - 1]\\n except:\\n return 1e-100\",\n \"def d_weights(n):\\n i = np.arange(1, n)\\n return np.sqrt(n / (i * (n - i)))\",\n \"def net_present_value(certificate, t):\\n return sum(certificate['cash_flow_in_period'][i] / (1+RISK_FREE_INTEREST_RATE)**i for i in range(t+1))\",\n \"def prob1(n):\\n\\n # create a giant draw from a normal distribution\\n random_draws = np.random.normal(loc= 0, scale = 1, size = n)\\n\\n # mask the values\\n mask = random_draws > 3\\n\\n return np.sum(mask)/float(n)\",\n \"def discount(self, period):\\n\\t\\treturn 1.0/compound(period)\",\n \"def rsi_apply_nb(ts, window, ewm, adjust, cache_dict):\\n h = hash((window, ewm))\\n roll_up, roll_down = cache_dict[h]\\n rs = roll_up / roll_down\\n return 100 - 100 / (1 + rs)\",\n \"def item_tres(n):\\n if n <= 0.167:\\n return 0\\n elif n > 0.167 and n <= 0.333:\\n return 1\\n elif n > 0.333 and n <= 0.500:\\n return 2\\n elif n > 0.500 and n <= 0.667:\\n return 3\\n elif n > 0.667 and n <= 0.834:\\n return 4\\n elif n > 0.834 and n <= 1.000:\\n return 5\",\n \"def reg_slope(sum_ind_times_dep, sum_independent, sum_dependent, sum_dependent_squared, n):\\n return (\\n (\\n (n * sum_ind_times_dep) - (sum_independent * sum_dependent)\\n ) / (\\n (n * sum_dependent_squared) - (sum_dependent * sum_dependent)\\n )\\n )\",\n \"def ramp2n(params, phase, args=dict(n=3, guess=[1, 26.6, 7.8])):\\n # 2013-12-07 14:08 IJMC: Created.\\n\\n return params[0] * (1. - np.exp(-params[1]*phase + params[2]))\",\n \"def ps_freq_axis(dt, n):\\n\\n frequency = sp.arange(n//2, dtype=float)\\n df = 1.0/dt/n\\n frequency *= df\\n return frequency\",\n \"def likelihood_weighting_estimate(self,var,e,n,sampling_weight='uniform'):\\n\\t\\tncpt = self.variables[var].cpt\\n\\t\\tncount = dict((value,0.0) for value in ncpt.values())\\n\\t\\twsum = 0.0\\n\\t\\tfor iter in xrange(n):\\n (w,sample) = self.importance_sample(e,sampling_weight)\\n assert all(sample[key]==value for (key,value) in e.iteritems())\\n \\n ncount[sample[var]] += w\\n wsum += w\\n if wsum==0: return 'Undefined'\\n for value in ncount.iterkeys():\\n ncount[value] = float(ncount[value])/float(wsum)\\n return ncount\",\n \"def pv(rate, n_years):\\n return 1 / fv(rate, n_years)\",\n \"def get_duration(period, aor, e):\\n return 0.25 * period * np.sqrt(1 - e**2) / aor\",\n \"def calc_calories(gpx_track, wt = 175, activity='Run'):\",\n \"def theoretical_effective(dataset):\\n return float(sum(dataset))/len(dataset)\",\n \"def calc(self,newValue):\\n return np.sum(self.values<=newValue)/self.n\",\n \"def _calc_freeze_probability(self, num_iterations, final_fraction):\\n return 1.0 - (final_fraction ** (1.0 / num_iterations))\",\n \"def energy(n):\\n return (n * pi * hbar / (2 * a)) ** 2 / (2 * m)\",\n \"def get_crossover_accept_rate(n: int):\\n return 1 / (2 ** n)\",\n \"def _prorata_rate(self, days_used, days_in_month):\\n return (100 * days_used // days_in_month) / 100.0\",\n \"def duty_translate(self, n):\\n return int((float(n) / 255) * 1023)\",\n \"def band_penalty(self):\\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\\n n = min(fc_ix, self.ix10k - fc_ix)\\n if n == 0:\\n return 0.0\\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - (self.gain - self.fr[fc_ix + n - 1:fc_ix - 1:-1])))\",\n \"def PV_ExpsMaint(t):\\n if t > last_t:\\n return 0\\n else:\\n return - prj_exps_Maint(t) + PV_ExpsMaint(t + 1) / (1 + DiscRate(t))\",\n \"def get_learn_rate_and_momentum(self, n_iter):\\n return self.learn_rate_schedule.get_var_at_iter(n_iter), \\\\\\n self.momentum_schedule.get_var_at_iter(n_iter)\",\n \"def expected_return(self, n_step):\\r\\n value = 0\\r\\n n_experiences = 50\\r\\n for i in range(n_experiences):\\r\\n trajectory = self.domain_exploration(n_step)\\r\\n value += self.compute_j(trajectory)\\r\\n return value/n_experiences\",\n \"def band(n, steps):\\n return math.floor(n * steps) / steps\",\n \"def get_blr_strength(self,\\n blr: BoundedLinearRegressions) -> float:\\n # Return 0 if slopes are different signs.\\n if blr.minima_regression.slope * blr.maxima_regression.slope < 0:\\n return 0\\n\\n # Return 0 if not enough data.\\n if len(blr.candles) <= 3:\\n return 0\\n\\n # Find high and low prices of the trendline period.\\n high_price = max([candle.high for candle in blr.candles])\\n low_price = max([candle.low for candle in blr.candles])\\n\\n # Find start and end of the period.\\n start_moment = max([candle.moment for candle in blr.candles])\\n end_moment = min([candle.moment for candle in blr.candles])\\n\\n # Take signal strength to be the average of the two slopes.\\n minima_slope_pct = abs(blr.minima_regression.y_of_x(end_moment) - blr.minima_regression.y_of_x(start_moment)) \\\\\\n / max(0.01, high_price - low_price)\\n maxima_slope_pct = abs(blr.maxima_regression.y_of_x(end_moment) - blr.maxima_regression.y_of_x(start_moment)) \\\\\\n / max(0.01, high_price - low_price)\\n signal_strength = (minima_slope_pct + maxima_slope_pct) / 2.0\\n\\n # Scale down signal strength.\\n signal_strength = min(1, signal_strength / 5.0)\\n\\n # Ensure the signal strength has the correct sign.\\n if blr.minima_regression.slope < 0:\\n signal_strength += -1\\n\\n return signal_strength\",\n \"def emission_rate_per_person_when_present(self) -> _VectorisedFloat:\\n return (self.emission_rate_per_aerosol_per_person_when_present() *\\n self.aerosols())\",\n \"def silverman(n: int, ess: float) -> float:\\n\\n return (ess * (n + 2) / 4) ** (-1 / (n + 4))\",\n \"def P(lag):\\n N = len(SP)\\n ratios = SP[lag:N]/SP[0:N-lag]\\n P = 100.*(ratios-1.)\\n return P\",\n \"def powAlpha( n ):\\n return (1-betaval)*Fib(n) + Fib(n-1)\\n #return Fib(n+1) - Fib(n) * betaval\",\n \"def fv(rate, n_years):\\n return pow(1 + rate, n_years)\",\n \"def calculate_emission_prob(cls, w, t):\\n #\\n # p_w_t = cls._emission_counts[w, t]\\n # p_t = cls._uni_transition_counts[t]\\n\\n return float(cls._emission_counts[w, t] / cls._uni_transition_counts[t])\",\n \"def heterodyner_signal(self, n=1):\\n omega = self.fvec*2*np.pi*n\\n phvec = np.cumsum(omega)\\n return np.exp(1j*phvec)\",\n \"def testPeriod1(self):\\n rsi = std.rsi_calc(self.gldf['Gain'], self.gldf['Loss'], 1)\\n self.assertGreater(rsi.iloc[1], 99.0, \\\"RSI value was not close to 100 for all gain.\\\")\\n self.assertLess(rsi.iloc[3], 0.01, \\\"RSI value was not close to 0 for all loss.\\\")\",\n \"def prob1(n):\\n#raise NotImplementedError(\\\"Problem 1 Incomplete\\\")\\n if n == 0 :\\n raise ValueError(\\\"Sampling 0 points is not defined.\\\")\\n total = 0\\n for i in xrange(n) :\\n if np.random.normal() > 3 :\\n total += 1\\n return float(total)/n\",\n \"def efficiency(w, L_t=79.6, p=75, fmax=1e12, p1=database['K+'],\\r\\n p2=database['pi+'], p3=database['p+'], E=1e6, delta_p=1.6e-2,\\r\\n n=10000, ng=50, nl=50, nf=100, plot=True, set_freq=5.7e9):\\r\\n if L_t == 79.6 and p == 75 and fmax == 1e12:\\r\\n opt = [296.5e9, 25.73, 13.33, 9.21]\\r\\n if L_t == 641.4-22.8 and p == 75 and fmax == 5.7e9:\\r\\n opt = [5.7e9, 206.2, 104.1, 134.8]\\r\\n else:\\r\\n opt = cavity_gap_comp(L_t, p, fmax, p1, p2, p3, E, False, delta_p, ng, nl,\\r\\n nf, False, False, set_freq)\\r\\n d_2 = abs_deflection(ang_deflection(p, opt[0], p1, p2, L_t-opt[1], opt[2], E, delta_p), opt[1])\\r\\n d_3 = abs_deflection(ang_deflection(p, opt[0], p1, p3, L_t-opt[1], opt[2], E, delta_p), opt[1])\\r\\n phase_range = np.linspace(0, 2*np.pi, n)\\r\\n disp_2, disp_3, count_2, count_3 = [], [], 0, 0\\r\\n for tau in phase_range:\\r\\n disp_2.append(-d_2*np.cos(tau))\\r\\n disp_3.append(-d_3*np.cos(tau))\\r\\n if abs(disp_2[-1]) > w:\\r\\n count_2 += 1\\r\\n if abs(disp_3[-1]) > w:\\r\\n count_3 += 1 \\r\\n num_K = 6*decay_proportion(L_t, p1, p, None)/Gaussian_integral(w/26.4, plot=False)\\r\\n purity = (num_K/(num_K+((70*(n-count_2))/n)+((23*(n-count_3))/n)))*100\\r\\n if plot == True:\\r\\n fig = plt.figure(figsize=[12, 4])\\r\\n ax = fig.add_subplot(1, 1, 1)\\r\\n ax.plot(phase_range, disp_2, 'r', lw=2, label=r'$\\\\pi^+$')\\r\\n ax.plot(phase_range, disp_3, 'b', lw=2, label=r'$p^+$')\\r\\n blank = np.zeros(n)\\r\\n ymin, ymax = np.min(disp_2 + disp_3)*1.1, np.max(disp_2 + disp_3)*1.1\\r\\n ax.fill_between(phase_range, blank+w, blank+ymax, color='k', alpha=0.5)\\r\\n ax.fill_between(phase_range, blank-w, blank+ymin, color='k', alpha=0.5)\\r\\n ax.set_xlim(0, 2*np.pi)\\r\\n ax.set_ylim(ymin, ymax)\\r\\n ax.set_xlabel('Phase', fontsize=20)\\r\\n ax.set_ylabel('Displacement', fontsize=20)\\r\\n ax.set_xticks([])\\r\\n ax.set_yticks([])\\r\\n ax.set_title('Phase dependence of unwanted particle absorbance in the beam stopper', fontsize=17)\\r\\n ax.legend(fontsize=20)\\r\\n plt.show()\\r\\n fig.savefig('Efficiency_Blank.pdf', bbox_inches='tight')\\r\\n print('{0} efficiency = {1:.1f}%\\\\n{2} efficiency = {3:.1f}%\\\\nBeam purity = {4:.1f}%'.format(p2.name, (count_2/n)*100, p3.name, (count_3/n)*100, purity))\\r\\n return purity\",\n \"def get_power_one_side(alpha, n, k, effect_size):\\n c = sc.t.ppf(1 - alpha, (1 + k) * n - 2)\\n delta_norm = effect_size * np.sqrt(1 / (1 / n + 1 / (n * k)))\\n p = 1 - sc.nct.cdf(c, (1 + k) * n - 2, delta_norm)\\n return p\",\n \"def pulse_width_percent(self) -> float:\",\n \"def twr_ret(self) -> float:\\n if float(self.tsdf.iloc[0]) == 0.0:\\n raise Exception('First data point == 0.0')\\n return float(((self.tsdf.iloc[-1] / self.tsdf.iloc[0]) ** (1 / self.length) - 1) * self.periods_in_a_year)\",\n \"def _temperature_policy(self, N: np.ndarray) -> np.ndarray:\\n t = 1 / self.temperature\\n pi = N ** t + np.finfo(np.float32).eps # Add tiny value to remove 0s\\n pi = pi / pi.sum()\\n return pi\",\n \"def expectancyPcnt(self, p):\\n return (2 * p) - 1\",\n \"def _calculate_snr_spread(self):\\n\\n dmSpacing, percentage = 100, 0\\n while percentage < 0.5: \\n x = np.linspace(self.centerDm - dmSpacing, self.centerDm + dmSpacing, 500)\\n y = np.array([self.effective_snr(self.effective_width(self.pulseWidth, self.centerDm - dm_val, self.bandwidth, self.freq), self.pulseWidth * 20) for dm_val in x])\\n y = (y / (np.max(y) * 1.0)) if np.max(y) > 0 else y\\n percentage = np.size(np.where(y > 0)) / 1000.0\\n dmSpacing = dmSpacing*0.6\\n \\n return x, y\",\n \"def get_periodicity(self):\\n\\n per = 1\\n is_antiper = False\\n\\n if \\\"antiperiod\\\" in self.symmetries:\\n if self.symmetries[\\\"antiperiod\\\"] > 1:\\n per = self.symmetries[\\\"antiperiod\\\"]\\n is_antiper = True\\n elif \\\"period\\\" in self.symmetries:\\n if self.symmetries[\\\"period\\\"] > 1:\\n per = self.symmetries[\\\"period\\\"]\\n\\n return (per, is_antiper)\",\n \"def prior(n=10):\\r\\n p = []\\r\\n trials = 0\\r\\n acc = 0\\r\\n while acc < n:\\r\\n trials += 1\\r\\n r = np.random.rand(2) * np.array([4, 2]) + np.array([-2, -1])\\r\\n # print(\\\"r: \\\", r)\\r\\n if r[1] + r[0] >= -1 and r[1] - r[0] >= -1:\\r\\n p.append(r)\\r\\n acc += 1\\r\\n # print(\\\"trials: \\\", trials, \\\", acc: \\\", acc)\\r\\n return p\",\n \"def moment(self, p):\\n return sum([val**p for val in self.counts.values()])\",\n \"def get_percent(self, n):\\n controlled = 0.00\\n for i in range(len(self.tile_contents)):\\n if(self.tile_contents[i].player_number == n):\\n controlled += 1.00\\n \\n return float(controlled / self.paint_blocks)\",\n \"def calc_relhum(dewpt,t):\\n\\n relhum=100.*(np.exp((const.es_Abolton*dewpt)/(const.es_Bbolton+dewpt))/np.exp((const.es_Abolton*t)/(const.es_Bbolton+t)))\\n return relhum\",\n \"def calculate_variance(n, p):\\n return p * (1 - p) / n\",\n \"def calc_gain(s, i):\\n return math.sqrt((i + s) / (6 * s))\",\n \"def item_um(n):\\n if n <= 0.250:\\n return 0\\n elif n > 0.250 and n <= 0.500:\\n return 1\\n elif n > 0.500 and n <= 0.750:\\n return 2\\n elif n > 0.750 and n <= 1.000:\\n return 3\",\n \"def puissance(x: float, n: int) -> float:\\n resultat: float = 1\\n signe: int = 1\\n if n != 0:\\n if n <= 0:\\n n = -n\\n signe = -1\\n for cpt in range(1, n + 1):\\n resultat = resultat * x\\n if signe < 0:\\n resultat = 1 / resultat\\n return resultat\",\n \"def sumArithmeticSeries(a: float, d: float, n: int) -> float:\\n return (a + d * (n + 1) / 2) * n\",\n \"def getDemodGain(self, inpwr):\\n return min(100, max(0, int(100-2*(inpwr+40))))\",\n \"def band_penalty(self):\\n fc_ix = np.argmin(np.abs(self.f - self.fc)) # Index to frequency array closes to center frequency\\n # Number of indexes on each side of center frequency, not extending outside, only up to 10 kHz\\n n = min(fc_ix, self.ix10k - fc_ix)\\n if n == 0:\\n return 0.0\\n return np.mean(np.square(self.fr[fc_ix - n:fc_ix] - self.fr[fc_ix + n - 1:fc_ix - 1:-1]))\",\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 acN(self):\\n acSum = 0.0\\n for i in self.longPosE:\\n if self.enginePos == 'wing': # wing mounted engines\\n ln = self.acW - i\\n elif self.enginePos == 'fuselage': # tail mounted engines\\n ln = self.acW - (i + self.nacelleLength)\\n acSum = +self.kn * ln * (self.nacelleDiameter**2) / (self.surfaceW * self.cMACW * self.clAlphaWF)\\n return acSum\",\n \"def digital_gain():\\n def r(x):\\n return x/512.\\n\\n def w(x):\\n return int(x*512)\\n return r, w\",\n \"def stick_breaking(n:int,alpha:float) -> np.ndarray:\\n betas = G.beta(a=alpha, b=1.0, size=n)\\n betas[1:] *= np.cumprod(1-betas[:-1])\\n weights = np.sort(betas)[::-1]\\n return weights\",\n \"def polytropicProfile(n=[1.5]):\\n\\t\\tdx = 0.001\\n\\t\\txs = []\\n\\t\\tthetas = []\\n\\t\\tfor j, index in enumerate(n):\\n\\t\\t\\ttheta = [1]\\n\\t\\t\\tdtheta_dx = [0]\\n\\t\\t\\tx = [1E-6]\\n\\t\\t\\ti=0\\n\\t\\t\\twhile theta[i] > 0 and i<5000:\\n\\t\\t\\t\\tdtheta_dx.append(dtheta_dx[i] - (2*dtheta_dx[i]/x[i] + theta[i]**index)*dx)\\n\\t\\t\\t\\ttheta.append(theta[i] + dtheta_dx[i]*dx)\\n\\t\\t\\t\\tx.append(x[i] + dx)\\n\\t\\t\\t\\ti+=1\\n\\t\\t\\txs.append(np.array(x))\\n\\t\\t\\tthetas.append(np.array(theta))\\n\\t\\treturn xs, thetas\",\n \"def extendability(self):\\n self._extendability = 0.50 * self.ANA - 0.50 * self.DCC + 0.50 * self.MFA + 0.50 * self.NOP\\n return round(self._extendability, 5)\",\n \"def get_pwin(star, period):\\n M = star.dataspan / period\\n f = star.dutycycle\\n omf = 1.0 - f\\n pw = 1 - omf**M - M*f*omf**(M-1) - 0.5*M*(M-1)*f*f*omf**(M-2)\\n msk = (pw >= 0.0) * (M >= 2.0)\\n return pw * msk\",\n \"def binary_reg_fn(strengths):\\n term = 3.25 * strengths - 1.625\\n return 1 / (1 + torch.pow(term, 12))\",\n \"def get_ratio_guarantee_advance(self):\\n return (\\n self.ratio_guarantee_advance *\\n self.get_period_guarantee_advance *\\n self.ratio2_guarantee_advance\\n )\",\n \"def get_n1(r,N):\\n n1 = N - np.sum(r)\\n return n1\",\n \"def DW_cal(data, data_sm):\\n n = len(data)\\n numerator = 0\\n denominator = 0\\n for i in range(n):\\n if i == 0:\\n numerator = numerator + 0\\n else:\\n numerator = numerator + ((data[i] - data_sm[i]) - (data[i-1] - data_sm[i-1]))**2\\n denominator = denominator + (data[i] - data_sm[i])**2\\n return numerator/denominator*n/(n - 1)\",\n \"def formula_n(self, n: int, x: np.ndarray) -> np.ndarray:\\n\\n # express x as z = x/(x-1)\\n z = x / (x - 1)\\n\\n # special case @n=0\\n if n == 0:\\n kn = 1 - self._vlerchphi(1 / z, n + 1)\\n else:\\n kn = 1 / n - self._vzlerchphi(1 / z, n + 1)\\n\\n # return\\n return kn\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62993854","0.6251063","0.62505263","0.61611295","0.6143028","0.5975309","0.5954106","0.58517736","0.5804187","0.57787424","0.57643014","0.5751086","0.5728138","0.5679147","0.56747293","0.5648136","0.56302524","0.56128484","0.55958307","0.556552","0.5563491","0.55467206","0.5545674","0.5542203","0.55341","0.5533269","0.5531048","0.55275476","0.5520377","0.5516092","0.5509402","0.55085504","0.5507479","0.54947126","0.5493758","0.5486679","0.5483039","0.548199","0.54689497","0.54686725","0.54548824","0.54349005","0.54236394","0.54208773","0.54207885","0.5415693","0.54122275","0.54112124","0.5401614","0.5399225","0.5390394","0.5388543","0.53870755","0.5379197","0.53769004","0.5375394","0.5370029","0.53645504","0.53607947","0.5359945","0.5349718","0.53482145","0.5347281","0.5336712","0.53266037","0.5323346","0.53223723","0.5321055","0.5319514","0.5315368","0.5311304","0.5309272","0.53090924","0.5302576","0.5296936","0.52951115","0.52928007","0.5289021","0.5286065","0.5285199","0.5281363","0.52774185","0.52747047","0.5271461","0.5270337","0.5258527","0.52564186","0.5249406","0.52470165","0.5246675","0.52459997","0.5243512","0.52318835","0.52294713","0.5225951","0.5224551","0.5221919","0.5216076","0.5215116","0.5211601"],"string":"[\n \"0.62993854\",\n \"0.6251063\",\n \"0.62505263\",\n \"0.61611295\",\n \"0.6143028\",\n \"0.5975309\",\n \"0.5954106\",\n \"0.58517736\",\n \"0.5804187\",\n \"0.57787424\",\n \"0.57643014\",\n \"0.5751086\",\n \"0.5728138\",\n \"0.5679147\",\n \"0.56747293\",\n \"0.5648136\",\n \"0.56302524\",\n \"0.56128484\",\n \"0.55958307\",\n \"0.556552\",\n \"0.5563491\",\n \"0.55467206\",\n \"0.5545674\",\n \"0.5542203\",\n \"0.55341\",\n \"0.5533269\",\n \"0.5531048\",\n \"0.55275476\",\n \"0.5520377\",\n \"0.5516092\",\n \"0.5509402\",\n \"0.55085504\",\n \"0.5507479\",\n \"0.54947126\",\n \"0.5493758\",\n \"0.5486679\",\n \"0.5483039\",\n \"0.548199\",\n \"0.54689497\",\n \"0.54686725\",\n \"0.54548824\",\n \"0.54349005\",\n \"0.54236394\",\n \"0.54208773\",\n \"0.54207885\",\n \"0.5415693\",\n \"0.54122275\",\n \"0.54112124\",\n \"0.5401614\",\n \"0.5399225\",\n \"0.5390394\",\n \"0.5388543\",\n \"0.53870755\",\n \"0.5379197\",\n \"0.53769004\",\n \"0.5375394\",\n \"0.5370029\",\n \"0.53645504\",\n \"0.53607947\",\n \"0.5359945\",\n \"0.5349718\",\n \"0.53482145\",\n \"0.5347281\",\n \"0.5336712\",\n \"0.53266037\",\n \"0.5323346\",\n \"0.53223723\",\n \"0.5321055\",\n \"0.5319514\",\n \"0.5315368\",\n \"0.5311304\",\n \"0.5309272\",\n \"0.53090924\",\n \"0.5302576\",\n \"0.5296936\",\n \"0.52951115\",\n \"0.52928007\",\n \"0.5289021\",\n \"0.5286065\",\n \"0.5285199\",\n \"0.5281363\",\n \"0.52774185\",\n \"0.52747047\",\n \"0.5271461\",\n \"0.5270337\",\n \"0.5258527\",\n \"0.52564186\",\n \"0.5249406\",\n \"0.52470165\",\n \"0.5246675\",\n \"0.52459997\",\n \"0.5243512\",\n \"0.52318835\",\n \"0.52294713\",\n \"0.5225951\",\n \"0.5224551\",\n \"0.5221919\",\n \"0.5216076\",\n \"0.5215116\",\n \"0.5211601\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.66415566"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88358,"cells":{"query":{"kind":"string","value":"r\"\"\"Encodes the input by passing through the encoder network and returns the latent codes."},"document":{"kind":"string","value":"def encode(self, inputs):\n result = self.encoder(inputs) # [N x 512 x 4 x 4]\n result = torch.flatten(result, start_dim=1) # [N x 8192]\n \n return self.fc_mu(result), self.fc_var(result)"},"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 encoder(self, inputs):\n pass","def encode(self):\n with tf.name_scope(\"encode\"):\n self.encoder_inputs = tf.layers.dense(\n inputs=self.encoder_inputs,\n units=self.options['hidden_size'], activation=None, use_bias=True,\n kernel_initializer=tf.keras.initializers.he_normal(seed=None),\n bias_initializer=tf.zeros_initializer(),\n kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,\n kernel_constraint=None, bias_constraint=None, trainable=True,\n name=None, reuse=None)\n self.encoder_inputs = tf.layers.batch_normalization(self.encoder_inputs,\n axis=-1,\n momentum=0.99,\n epsilon=0.001,\n center=True,\n scale=True,\n beta_initializer=tf.zeros_initializer(),\n gamma_initializer=tf.ones_initializer(),\n moving_mean_initializer=tf.zeros_initializer(),\n moving_variance_initializer=tf.ones_initializer(),\n training=self.is_training,\n trainable=True,\n renorm=False,\n renorm_momentum=0.99)\n # Prepare inputs to the layer stack by adding positional encodings and\n # applying dropout.\n # embedded_inputs = self.embedding_softmax_layer(inputs)\n #\n inputs_padding = transformer_model_utils.get_padding(tf.cast(\n tf.reduce_max(100*self.encoder_inputs, [-1]),\n dtype=tf.int32))\n\n with tf.name_scope(\"add_pos_encoding\"):\n length = tf.shape(self.encoder_inputs)[1]\n pos_encoding = transformer_model_utils.get_position_encoding(\n length, self.options[\"hidden_size\"])\n encoder_inputs = self.encoder_inputs + pos_encoding\n\n if self.is_training:\n encoder_inputs = tf.nn.dropout(\n encoder_inputs, 1 - self.options[\"layer_postprocess_dropout\"])\n\n return self.encoder_stack(encoder_inputs, self.attention_bias, inputs_padding)","def encode(self, input_):\n return self.encoder(input_)","def encode_input(self, x_tensor, inp_lens_tensor):\r\n input_emb = self.input_emb.forward(x_tensor)\r\n enc_output_each_word, enc_context_mask, enc_final_states = self.encoder(input_emb, inp_lens_tensor)\r\n enc_final_states_reshaped = (enc_final_states[0].unsqueeze(0), enc_final_states[1].unsqueeze(0))\r\n # print('lest go', enc_final_states_reshaped[1].shape)\r\n return enc_output_each_word, enc_context_mask, enc_final_states_reshaped","def encode(input):\n return ModelEncoder().encode(input)","def encoder(enc_input, attn_bias, n_layer, n_head,\n d_key, d_value, d_model, d_inner_hid, pos_enc,\n preporstprocess_dropout, attention_dropout,\n relu_dropout, preprocess_cmd='n',\n postprocess_cmd='da'):\n for i in range(n_layer):\n enc_output = encoder_layer(enc_input, attn_bias, n_head,\n d_key, d_value, d_model,d_inner_hid, pos_enc,\n prepostprocess_dropout, attention_dropout,relu_dropout,\n preprocess_cmd, postprocess_cmd\n )\n enc_input = enc_output\n enc_output = pre_process_layer(enc_output,\n preprocess_cmd, preporstprocess_dropout)\n return enc_output","def encode(data, encoder):\n # Get the list of hidden depths\n\thd = encoder.hidden_depths\n # Find the middle hidden layer\n\tmiddle_layer_index = (len(hd)-1)/2\n # Initialize empty container for the encoded data\n\tdata_encoded = np.zeros((data.shape[0],hd[middle_layer_index]))\n\tfor i, d_ in enumerate(data):\n # feed forward, get all the activations, and just keep\n # the middle layer, which is the encoding\n\t\tx, z_container, x_container = encoder.ff(d_,True,True)\n\t\tx_encoded = x_container[1+middle_layer_index]\n\t\tdata_encoded[i] = x_encoded\n\t#\n\treturn data_encoded","def encode(self, inputs, mask=None, sample_shape=()):\n inputs = tf.nest.flatten(inputs)[:len(self._vae.encoder.inputs)]\n latents = self._vae.encode(inputs[0] if len(inputs) == 1 else inputs,\n training=False,\n mask=mask,\n sample_shape=sample_shape)\n # only support single returned latent variable now\n for z in tf.nest.flatten(latents):\n assert isinstance(z, tfd.Distribution), \\\n \"The latent code return from `vae.encode` must be instance of \" + \\\n \"tensorflow_probability.Distribution, but returned: %s\" % \\\n str(z)\n return latents","def encode_all(self, inputs, encoder):\n input_shape = tf.shape(inputs)\n num_timesteps, batch_size = input_shape[0], input_shape[1]\n reshaped_inputs = tf.reshape(inputs, [-1, inputs.shape[-1]])\n inputs_encoded = encoder(reshaped_inputs)\n inputs_encoded = tf.reshape(inputs_encoded, [num_timesteps, batch_size, encoder.output_size])\n return inputs_encoded","def _encode(self):\n with tf.variable_scope('encoding'):\n self.sep_p_encodes, _ = bilstm_layer(self.p_emb, self.p_length, self.hidden_size)\n tf.get_variable_scope().reuse_variables()\n self.sep_q_encodes, _ = bilstm_layer(self.q_emb, self.q_length, self.hidden_size)\n if self.use_dropout:\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, 1-self.dropout)\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, 1-self.dropout)","def encode(self, inputs, masks):\n with tf.variable_scope(\"encoder\") as scope_encoder:\n #compute sequence length\n sequence_lengths = tf.reduce_sum(masks, axis = 1) \n #create a forward cell\n fw_cell = tf.contrib.rnn.LSTMCell(self.size)\n\n #pass the cells to bilstm and create the bilstm\n bw_cell = tf.contrib.rnn.LSTMCell(self.size)\n output, final_state = tf.nn.bidirectional_dynamic_rnn(fw_cell, \\\n bw_cell, inputs, \\\n sequence_length = sequence_lengths, \\\n dtype = tf.float32, \\\n parallel_iterations = 256)\n output_lstm = tf.concat([output[0], output[1]], axis = -1)\n final_state_lstm = tf.concat([final_state[0], final_state[1]], axis = -1)\n return output_lstm, final_state_lstm","def forward(self, x):\n # Get results of encoder network\n q = self.encode_nn(x)\n\n return q","def encode(self, X):\r\n return self._encoder.predict(X)","def encode(self, x):\n self.eval()\n x = torch.as_tensor(x).unsqueeze(0)\n if self.do_mt:\n enc_output, _ = self.encoder_mt(x, None)\n else:\n enc_output, _ = self.encoder(x, None)\n return enc_output.squeeze(0)","def encode_input_for_decoder(x_tensor, inp_lens_tensor, model_input_emb: EmbeddingLayer, model_enc: RNNEncoder):\n input_emb = model_input_emb.forward(x_tensor)\n (enc_output_each_word, enc_context_mask, enc_final_states) = model_enc.forward(input_emb, inp_lens_tensor)\n enc_final_states_reshaped = (enc_final_states[0].unsqueeze(0), enc_final_states[1].unsqueeze(0))\n return (enc_output_each_word, enc_context_mask, enc_final_states_reshaped)","def call(self, inputs, *args, **kwargs):\n outputs = self.encoder(inputs, *args, **kwargs)\n return outputs","def encode(self,x,x_len):\n\n ## Check to see if batch_size parameter is fixed or base on input batch\n cur_batch_size = x.size()[1]\n encode_init_state = self.encoder.initialize_hidden_state(cur_batch_size)\n encoder_state, encoder_outputs = self.encoder.forward(x, encode_init_state, x_len)\n\n return encoder_outputs, encoder_state","def encode(self, input):\n h = np.zeros(self.hidden_size) \n \n preactivation = np.dot(self.W.T, input) + self.b\n sigmoid(preactivation, h)\n \n return h","def encoder(self, x):\n # Input (batch_size, Channels=1, Width=28, Height=28)\n x = self.enc_conv(x) # (batch_size, lin_before_latent_dim)\n mean = self.enc_mean(x) # (batch_size, latent_dim)\n logvar = self.enc_logvar(x) # (batch_size, latent_dim)\n return mean, logvar","def encode(self, state):\n raise NotImplementedError","def _encode(self):\n with tf.variable_scope('passage_encoding'):\n self.sep_p_encodes, _ = rnn('bi-lstm', self.p_emb, self.p_length, self.hidden_size)\n with tf.variable_scope('question_encoding'):\n self.sep_q_encodes, _ = rnn('bi-lstm', self.q_emb, self.q_length, self.hidden_size)\n if self.use_dropout:\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, self.dropout_keep_prob)\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, self.dropout_keep_prob)","def encode(self, input):\n out = self.encoder(input)\n out = torch.flatten(out, start_dim=1)\n mu = self.fc_mu(out)\n log_var = self.fc_var(out)\n return [mu, log_var]","def encode(self, seq):","def encode(self, inputs, target_space, hparams, features=None, losses=None):\n del losses\n\n inputs = common_layers.flatten4d3d(inputs)\n\n encoder_input, self_attention_bias, encoder_decoder_attention_bias = (\n transformer.transformer_prepare_encoder(\n inputs, target_space, hparams, features=features))\n\n encoder_input = tf.nn.dropout(encoder_input,\n 1.0 - hparams.layer_prepostprocess_dropout)\n\n (encoder_output, encoder_extra_output) = (\n my_universal_transformer_util.universal_transformer_encoder(\n encoder_input,\n self_attention_bias,\n hparams,\n nonpadding=transformer.features_to_nonpadding(features, \"inputs\"),\n save_weights_to=self.attention_weights))\n\n return encoder_output, encoder_decoder_attention_bias, encoder_extra_output","def encoder_decoder_archi_gan(inputs, is_train):\n\n encoder_layers = []\n\n encoded = inputs\n\n encoder_layers.append(encoded)\n\n for i in range(config.encoder_layers):\n encoded = encoder_conv_block_gan(encoded, i, is_train)\n encoder_layers.append(encoded)\n \n encoder_layers.reverse()\n\n\n\n decoded = encoder_layers[0]\n\n for i in range(config.encoder_layers):\n decoded = decoder_conv_block_gan(decoded, encoder_layers[i+1], i, is_train)\n\n return decoded","def make_encoder(self, input_size: int, latent_size: int) -> nn.Module:\n pass","def call(self, inputs, training=False):\n features, predicted = inputs\n enc = self.encoder(features, training=training)\n pred, _ = self.predict_net(predicted, training=training)\n outputs = self.joint_net([enc, pred], training=training)\n return outputs","def encoder_layer(enc_input, attn_bias, n_head, d_key,\n d_value, d_model, d_inner_hid, pos_enc, prepostprocess_dropout,\n attention_dropout, relu_dropout, preprocess_cmd='n',\n postprocess_cmd='da'):\n attn_output = multi_head_attention(\n pre_process_layer(enc_input, preprocess_cmd, prepostprocess_dropout),\n None, None, attn_bias, d_key, d_value, d_model, pos_enc,\n n_head, attention_dropout\n )\n attn_output = post_process_layer(enc_input, attn_output,\n postprocess_cmd, prepostprocess_dropout)\n ffd_output = positionwise_feed_forward(\n pre_process_layer(attn_output, preprocess_cmd, prepostprocess_dropout),\n d_inner_hid, d_model, relu_dropout\n )\n return post_process_layer(attn_output, ffd_output,\n postprocess_cmd, prepostprocess_dropout)","def fit_transform(self):\n if self.enc_types == \"label\":\n return self._label_encoding()\n elif self.enc_types == \"ohe\":\n return self._one_hot_encoder()\n elif self.enc_types == \"binary\":\n return self._binarization()\n else:\n raise Exception(\"Encoding type not understood\")","def _define_encoder(self):\n self.encoder = nn.Sequential(View((-1, 64 * 64 * 3)),\n nn.Linear(64 * 64 * 3, 5120, bias=False), nn.SELU(),\n nn.BatchNorm1d(5120),\n nn.Linear(5120, 2560, bias=False), nn.SELU(),\n nn.BatchNorm1d(2560),\n nn.Linear(2560, 512, bias=False), nn.SELU(),\n nn.BatchNorm1d(512),\n nn.Linear(512, 128, bias=False), nn.SELU(),\n nn.BatchNorm1d(128),\n nn.Linear(128, self.encoding_shape, bias=False), nn.SELU(),\n )","def encode(self, decoded):","def encode_instruction(instruction: str) -> int:\n\ta, b, c = convert_instruction(instruction)\n\treturn encode_pair(a, encode_pair(b, c))","def encode(self, signal: np.ndarray) -> np.ndarray:\n pass","def encode(self, img):\n with tf.variable_scope('encoder'):\n #conv1 = self.conv_layer(\n # img, [5, 5], [3, 32], stride=2, initializer_type=1, name='conv1')\n #conv2 = self.conv_layer(\n # conv1, [5, 5], [32, 32], stride=2, initializer_type=1, name='conv2')\n conv3 = self.conv_layer(\n img, [5, 5], [self.in_channels, 64], stride=2, initializer_type=1, name='conv3')\n #conv4 = self.conv_bn_layer(\n conv4 = self.conv_layer(\n conv3, [5, 5], [64, 128], stride=2, #is_training=self.is_training,\n initializer_type=1, name='conv4')\n #conv5 = self.conv_bn_layer(\n conv5 = self.conv_layer(\n conv4, [5, 5], [128, 256], stride=2, #is_training=self.is_training,\n initializer_type=1, name='conv5')\n shape = conv5.get_shape().as_list()\n feature_map_size = shape[1]*shape[2]*shape[3]\n conv5_flat = tf.reshape(\n conv5, [-1, feature_map_size], 'conv5_flat')\n #fc6 = self.fc_bn_layer(conv5_flat, 1024, is_training=self.is_training,\n fc6 = self.fc_layer(conv5_flat, 1024,\n initializer_type=1, name='fc6')\n #fc7 = self.fc_layer(fc6, 1024, initializer_type=1, name='fc7')\n return fc6, shape","def terrainEncoded(self, request, result):\n pass","def encode(self, x):\n h1 = F.relu(self.conv1(x))\n h2 = F.relu(self.conv2(h1))\n h3 = F.relu(self.conv3(h2))\n h4 = F.relu(self.conv4(h3))\n h4 = h4.reshape(-1)\n mu = self.fc1(h4)\n logvar = self.fc2(h4)\n\n # we take log of var as sigma cannot be negative \n # while neural network can output negative values\n sigma = torch.exp(logvar * 0.5)\n\n normal = torch.randn_like(sigma)\n\n return mu + sigma * normal, mu, logvar","def conv_encoder(input_tensor, num_latent, is_training=True):\n del is_training\n\n e1 = tf.layers.conv2d(\n inputs=input_tensor,\n filters=32,\n kernel_size=4,\n strides=2,\n activation=tf.nn.relu,\n padding=\"same\",\n name=\"e1\",\n )\n e2 = tf.layers.conv2d(\n inputs=e1,\n filters=32,\n kernel_size=4,\n strides=2,\n activation=tf.nn.relu,\n padding=\"same\",\n name=\"e2\",\n )\n e3 = tf.layers.conv2d(\n inputs=e2,\n filters=64,\n kernel_size=2,\n strides=2,\n activation=tf.nn.relu,\n padding=\"same\",\n name=\"e3\",\n )\n e4 = tf.layers.conv2d(\n inputs=e3,\n filters=64,\n kernel_size=2,\n strides=2,\n activation=tf.nn.relu,\n padding=\"same\",\n name=\"e4\",\n )\n flat_e4 = tf.layers.flatten(e4)\n e5 = tf.layers.dense(flat_e4, 256, activation=tf.nn.relu, name=\"e5\")\n means = tf.layers.dense(e5, num_latent, activation=None, name=\"means\")\n log_var = tf.layers.dense(e5, num_latent, activation=None, name=\"log_var\")\n return means, log_var","def encode(self, src_seq, src_lens):\n src_embed = self.word_embedding(src_seq)\n src_encodings, final_states = self.encoder_lstm(src_embed, src_lens)\n\n return src_encodings, final_states, src_embed","def _define_encoder(self):\n raise NotImplementedError","def _encode(self, src_token_ids, padding_mask, training=False):\n src_seq_len = tf.shape(src_token_ids)[1]\n\n # [batch_size, src_seq_len, hidden_size]\n src_token_embeddings = self._embedding_logits_layer(\n src_token_ids, 'embedding')\n\n # [src_seq_len, hidden_size]\n positional_encoding = utils.get_positional_encoding(\n src_seq_len, self._hidden_size)\n src_token_embeddings += positional_encoding\n src_token_embeddings = self._encoder_dropout_layer(\n src_token_embeddings, training)\n\n encoder_outputs = self._encoder(\n src_token_embeddings, padding_mask, training)\n return encoder_outputs","def runit():\n print encode(\"no\")\n\n print encode(\"yes\")\n\n print encode(\"OMG\")\n\n print encode(\"O M G\")\n\n print encode(\"mindblowingly\")\n\n print encode(\"Testing, 1 2 3, testing.\")\n\n print encode(\"Truth is fiction.\")\n\n print encode(\"The quick brown fox jumps over the lazy dog.\")\n\n print decode(\"vcvix rhn\")\n\n print decode(\"zmlyh gzxov rhlug vmzhg vkkrm thglm v\")","def pretrain_forward(self, inp):\n return self.encoder(inp)","def encode(self, X_train_A, X_train_V, X_dev_A, X_dev_V):\n X_train_V, _, _, _ = self.separate_V(X_train_V)\n X_dev_A, _, _, _ = self.separate_V(X_dev_A)\n \n encoded_train = self.encoder.predict([X_train_A, X_train_V])\n encoded_dev = self.encoder.predict([X_dev_A, X_dev_V])\n self.save_representation(encoded_train, encoded_dev)\n self.decode(encoded_train, encoded_dev)","def _define_encoder(self):\n self.encoder = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=32, kernel_size=4, stride=2, padding=1), # B, 32, 32, 32\n nn.SELU(),\n nn.Conv2d(32, 32, 4, 2, 1), # B, 32, 16, 16\n nn.SELU(),\n nn.Conv2d(32, 64, 4, 2, 1), # B, 64, 8, 8\n nn.SELU(),\n nn.Conv2d(64, 64, 4, 2, 1), # B, 64, 4, 4\n nn.SELU(),\n nn.Conv2d(64, 256, 4, 1), # B, 256, 1, 1\n nn.SELU(),\n View((-1, 256 * 1 * 1)), # B, 256\n nn.Linear(256, self.encoding_shape * 2), # B, z_dim*2\n )","def encode(image):\n from encoder import launch\n launch(image)","def encoder(inputs):\n out = tf.layers.flatten(inputs)\n out = tf.layers.dense(out, 400, activation=tf.nn.relu)\n mean = tf.layers.dense(out, LATENT_SIZE)\n logstd = tf.layers.dense(out, LATENT_SIZE)\n return tf.distributions.Normal(loc=mean, scale=tf.exp(logstd))","def encode_input(sent, lemmas, pos_tags, predicates, vocab_preds, vocab_lemmas, vocab_pos_tags, bert_embedder, task_234):\n sentence = bert_embedder.embed_sentence([sent])[0]\n lens = torch.LongTensor([len(sent)])\n pos_tags = torch.tensor([vocab_pos_tags[pos_tag] for pos_tag in pos_tags])\n lemmas = torch.tensor([vocab_lemmas[lemma] if lemma in vocab_lemmas else vocab_lemmas['<unk>'] for lemma in lemmas])\n vocab_preds = {word: int(idx) for idx, word in vocab_preds.items()}\n predicate_null_token = vocab_preds['_']\n if task_234:\n # if the task is predicate disambiguation, predicates indicates only the position of the predicates in the sentence\n predicates = torch.LongTensor(predicates)\n positions = (predicates == 1).nonzero()\n else:\n # otherwise predicates must be encoded with the value stored in the vocabulary\n predicates = torch.tensor([vocab_preds[predicate] for predicate in predicates])\n positions = (predicates != predicate_null_token).nonzero()\n\n return sentence[None,...], lens, pos_tags[None,...], lemmas[None,...], predicates[None,...], positions.view(-1).tolist(), predicate_null_token","def label_encode(var, values):\n\n le = preprocessing.LabelEncoder()\n le.fit(values)\n var_encoded = le.transform(var)\n\n return var_encoded","def _gather_latent_codes(self,\n latent_code_type: str = 'train'\n ) -> Sequence[tf.Tensor]:\n if latent_code_type == 'train':\n codes_use = self.codes_train_data\n elif latent_code_type == 'test':\n codes_use = self.codes_test_data\n\n if (self._mode == 'fully_multi_level' and\n self._encoder_mode == 'input_enc+f2c'):\n if self._latent_optim_target == 'code_grid_enc':\n codes_each_level = []\n for i in range(len(codes_use)):\n codes_each_level.append(\n tf.reshape(codes_use[i](0), [1, *self.code_grid_enc_shape[i]]))\n\n return codes_each_level","def encoder(self, tensor):\n with tf.variable_scope(\"encoder\"):\n tensor = tf.nn.embedding_lookup(self.embedding, tensor)\n cell = tf.nn.rnn_cell.BasicLSTMCell(self.num_units)\n outputs, state = tf.nn.dynamic_rnn(cell, tensor, sequence_length=self.seq_len, dtype=tf.float32)\n output = outputs[:,-1,:]\n output = tf.nn.l2_normalize(output, -1)\n\n return output","def encode(self, x: Tensor) ->Tensor:\n return self.encoder(x)[0]","def label_encode(data: List) -> [np.ndarray, List[LabelEncoder]]:\n labels_encoded = []\n data_encoded = np.array(data)\n for i in range(data_encoded.shape[1]):\n le = preprocessing.LabelEncoder()\n le.fit(data_encoded[:, i])\n labels_encoded.append(le)\n data_encoded[:, i] = le.transform(data_encoded[:, i])\n\n data_encoded = data_encoded.astype(int)\n return data_encoded, labels_encoded","def autoencoder(self, data):\n with tf.variable_scope(\"autoencoder\"):\n latent = self.encoder(data)\n _, output = self.decoder(latent)\n\n return output, latent","def encode(self):\n self.preprocess_msg()\n self._find_e()\n\n self.__encoded_msg = self._calculate(self.e)","def _add_input_encoder(self, inputs, seq_len):\n with tf.variable_scope(\"encoder\"):\n cell_fw = tf.contrib.rnn.LSTMCell(config.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n cell_bw = tf.contrib.rnn.LSTMCell(config.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\n ((fw_states, bw_states), (final_fw, final_bw)) = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs, dtype=tf.float32, sequence_length=seq_len, swap_memory=True)\n\n return fw_states, bw_states, final_fw, final_bw","def preprocess(self, latent_codes, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def encode(self, encode_data, image):\r\n raise NotImplementedError(\"Not Implemented\")","def encode(bits, nt_to_bits=None):\r\n if nt_to_bits is None:\r\n nt_to_bits = DEFAULT_GOLAY_NT_TO_BITS\r\n\r\n bits = numpy.array(bits).reshape((12, 1))\r\n\r\n # cheap way to do binary xor in matrix dot\r\n res = numpy.dot(DEFAULT_G.T, bits)\r\n codeword = divmod(res.ravel(), 2)[1]\r\n\r\n return _bits_to_seq(codeword, nt_to_bits)","def encode_inputs(inputs1, inputs2, encoder1, encoder2, device):\n # get inputs\n inputs1 = inputs1[0]\n inputs2 = inputs2[0]\n\n # encode inputs into means and logs of variances\n z_mean1, z_logvar1 = encoder1(inputs1)\n z_mean2, z_logvar2 = encoder2(inputs2)\n\n encoded_inputs_list = []\n\n # put the means and logs of variances together\n for x0, x1, x2, x3 in zip(z_mean1, z_logvar1,\n z_mean2, z_logvar2):\n x0 = x0.item()\n x1 = x1.item()\n x2 = x2.item()\n x3 = x3.item()\n\n sequence = [x0, x1, x2, x3]\n\n encoded_inputs_list.append(sequence)\n\n # transform encoded inputs into tensor on device\n encoded_inputs_tensor = torch.tensor(encoded_inputs_list)\n encoded_inputs_tensor = encoded_inputs_tensor.to(device)\n\n return encoded_inputs_tensor","def encoder_inference(self, features, states):\n with tf.name_scope(f\"{self.name}_encoder\"):\n outputs = tf.expand_dims(features, axis=0)\n outputs, new_states = self.encoder.recognize(outputs, states)\n return tf.squeeze(outputs, axis=0), new_states","def encode(self, input):\n result = self.encoder(input)\n result = torch.flatten(result, start_dim=1)\n\n # Split the result into mu and var components\n # of the latent Gaussian distribution\n mu = self.fc_mu(result)\n log_var = self.fc_var(result)\n\n return [mu, log_var]","def enc_x(self, inputs, training=False):\n return self._enc_x(inputs, training)","def encode(y):\n le = LabelEncoder()\n le.fit(y)\n print(list(le.classes_))\n y = le.transform(y)\n return y","def tf_encode(pt, en):\n result_pt, result_en = tf.py_function(encode, [pt, en], [tf.int64, tf.int64])\n result_pt.set_shape([None])\n result_en.set_shape([None])\n return result_pt, result_en","def encode(self, y):\n raise NotImplementedError","def encode_next_latent_state(self, data, latent_state, dts):\n raise NotImplementedError(\"Abstract class cannot be used.\")","def encode_next_latent_state(self, data, latent_state, dts):\n raise NotImplementedError(\"Abstract class cannot be used.\")","def handle_encode(self, results):\n \n config.COD_PROMPT = config.ENC_PROMPT\n print config.ENC_PROMPT + \" encoding results...\"\n \n # while there is another decoder, run each item through the next decoder\n data = results\n success = False\n for encoder in self.encoder_list:\n current_encoder = encoder()\n full_body = getattr(current_encoder,'full_body_encode',False)\n success, data = self.recursive_decoder(current_encoder.encode, data, full_body)\n if not success:\n break\n print config.ENC_PROMPT + \"%s encoded to '%s'\" % ( current_encoder.name(),data)\n return success, data","def encode(self, game_state: ssm.SnakeStateMachine) -> int:\n state = [e.encode(game_state) for e in self._encoders]\n return self._state2id[tuple(state)]","def encode(self):\n payload = []\n\n # Generate Payload\n if self.IsEnsembleData:\n payload += self.EnsembleData.encode()\n if self.IsAncillaryData:\n payload += self.AncillaryData.encode()\n if self.IsAmplitude:\n payload += self.Amplitude.encode()\n if self.IsCorrelation:\n payload += self.Correlation.encode()\n if self.IsBeamVelocity:\n payload += self.BeamVelocity.encode()\n if self.IsInstrumentVelocity:\n payload += self.InstrumentVelocity.encode()\n if self.IsEarthVelocity:\n payload += self.EarthVelocity.encode()\n if self.IsGoodBeam:\n payload += self.GoodBeam.encode()\n if self.IsGoodEarth:\n payload += self.GoodEarth.encode()\n if self.IsBottomTrack:\n payload += self.BottomTrack.encode()\n if self.IsRangeTracking:\n payload += self.RangeTracking.encode()\n if self.IsSystemSetup:\n payload += self.SystemSetup.encode()\n if self.IsNmeaData:\n payload += self.NmeaData.encode()\n\n # Generate the header\n # Get the ensemble number\n ens_num = 0\n if self.IsEnsembleData:\n ens_num = self.EnsembleData.EnsembleNumber\n\n # Get the payload size\n payload_size = len(payload)\n\n header = Ensemble.generate_ens_header(ens_num, payload_size)\n\n # Generate the Checksum CITT\n # Parameters found at https: // pycrc.org / models.html\n #crc = pycrc.algorithms.Crc(width=16, poly=0x1021,\n # reflect_in=False, xor_in=0x1d0f,\n # reflect_out=False, xor_out=0x0000)\n #checksum = crc.bit_by_bit_fast(binascii.a2b_hex(bytes(payload)))\n #checksum = Ensemble.int32_to_bytes(CRCCCITT().calculate(input_data=bytes(payload)))\n checksum = crc16.crc16xmodem(payload)\n\n\n result = []\n result += header\n result += payload\n result += checksum\n\n return bytearray(result)","def _bert_encoder(self, sentence, attn_mask):\n output = self.bert(sentence, attn_mask)\n embedding = output['hidden_states'][-1]\n\n feats = self.hidden2tag(embedding)\n return feats","def forward(self, x):\n # Get results of encoder network\n h1 = self.encode_nn(x)\n\n # latent space\n mu = self.encode_mu(h1)\n log_var = self.encode_log_var(h1)\n\n # Reparameterize\n z = self.reparameterize(mu, log_var)\n return z, mu, log_var","def forward(self, x):\n # Get results of encoder network\n h1 = self.encode_nn(x)\n\n # latent space\n mu = self.encode_mu(h1)\n log_var = self.encode_log_var(h1)\n\n # Reparameterize\n z = self.reparameterize(mu, log_var)\n return z, mu, log_var","def encode(self):\n \n assert False, \"Not implemented.\"","def encode(self, x):\n _, hid = self.encoder(x) #All RNN classes output a tuple of 2 objects: the output of the RNN first and the hidden state from the last item in\n return hid #the input sequence second. We're only interested in the hidden state","def encode(self, uid, input_vec):\n params = {\n 'input': input_vec,\n }\n return self.context.post(\"/ckks/computation/encode/%s\" % uid, params,\n \"CKKS:: failed encoding data for uid: %s\" % uid\n )[\"data\"]","def forward(self, inputs_encoder, inputs_decoder):\n states_encoder = self.encoder(inputs_encoder)\n outputs_decoder, states_decoder = self.decoder(inputs_decoder, states_encoder)\n return outputs_decoder, states_decoder","def _bert_encoder(self, tokens, attn_masks):\n output = self.bert(tokens, attn_masks)\n embedding = output['hidden_states'][-2]\n tag_prob = self.Softmax(self.hidden2tag(embedding))\n return tag_prob","def build_encoder(self):\n with tf.variable_scope(\"encoder\") as scope:\n length1 = tf.to_int32(tf.reduce_sum(self.encode_mask1, 1), name=\"length1\")\n\n if self.config.bidirectional_encoder:\n if self.config.encoder_dim % 2:\n raise ValueError(\n \"encoder_dim must be even when using a bidirectional encoder.\")\n num_units = self.config.encoder_dim // 2\n cell_fw = self._initialize_gru_cell(num_units) # Forward encoder\n cell_bw = self._initialize_gru_cell(num_units) # Backward encoder\n _, states = tf.nn.bidirectional_dynamic_rnn(\n cell_fw=cell_fw,\n cell_bw=cell_bw,\n inputs=self.encode_emb1,\n sequence_length=length1,\n dtype=tf.float32,\n scope=scope)\n thought_vectors1 = tf.concat(states, 1, name=\"thought_vectors1\")\n else:\n cell = self._initialize_gru_cell(self.config.encoder_dim)\n _, state = tf.nn.dynamic_rnn(\n cell=cell,\n inputs=self.encode_emb1,\n sequence_length=length1,\n dtype=tf.float32,\n scope=scope)\n # Use an identity operation to name the Tensor in the Graph.\n thought_vectors1 = tf.identity(state, name=\"thought_vectors1\")\n \n scope.reuse_variables()\n\n length2 = tf.to_int32(tf.reduce_sum(self.encode_mask2, 1), name=\"length2\")\n\n if self.config.bidirectional_encoder:\n if self.config.encoder_dim % 2:\n raise ValueError(\n \"encoder_dim must be even when using a bidirectional encoder.\")\n num_units = self.config.encoder_dim // 2\n cell_fw = self._initialize_gru_cell(num_units) # Forward encoder\n cell_bw = self._initialize_gru_cell(num_units) # Backward encoder\n _, states = tf.nn.bidirectional_dynamic_rnn(\n cell_fw=cell_fw,\n cell_bw=cell_bw,\n inputs=self.encode_emb2,\n sequence_length=length2,\n dtype=tf.float32,\n scope=scope)\n thought_vectors2 = tf.concat(states, 1, name=\"thought_vectors2\")\n else:\n cell = self._initialize_gru_cell(self.config.encoder_dim)\n _, state = tf.nn.dynamic_rnn(\n cell=cell,\n inputs=self.encode_emb2,\n sequence_length=length2,\n dtype=tf.float32,\n scope=scope)\n # Use an identity operation to name the Tensor in the Graph.\n thought_vectors2 = tf.identity(state, name=\"thought_vectors2\")\n\n self.thought_vectors1 = thought_vectors1\n self.thought_vectors2 = thought_vectors2","def _encode_back(self):\n with tf.variable_scope('passage_encoding'):\n self.sep_p_encodes, _ = rnn('bi-lstm', self.p_emb, self.p_length, self.hidden_size)\n with tf.variable_scope('question_encoding'):\n self.sep_q_encodes, _ = rnn('bi-lstm', self.q_emb, self.q_length, self.hidden_size)\n if self.use_dropout:\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, self.dropout_keep_prob)\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, self.dropout_keep_prob)","def encode(self, x):\n mu = []\n logvar = []\n for i in range(self.n_views):\n mu_, logvar_ = self.encoders[i](x[i])\n mu.append(mu_)\n logvar.append(logvar_)\n mu = torch.stack(mu)\n logvar = torch.stack(logvar)\n mu_out, logvar_out = self.join_z(mu, logvar)\n qz_x = hydra.utils.instantiate( \n self.cfg.encoder.default.enc_dist, loc=mu_out, scale=logvar_out.exp().pow(0.5)\n )\n return [qz_x]","def make_encoder(self, input_size, latent_size):\n return nn.Sequential(\n nn.Linear(input_size, 500),\n nn.ReLU(),\n nn.Linear(500, 200),\n nn.ReLU(),\n nn.Linear(200, latent_size * 2)\n # times 2 because this is the concatenated vector of latent mean and variance\n )","def encode(self) -> str:\n return Activation._encoder.encode(self)","def build_encoder(shift):\n ### TODO.\n while True:\n if shift >= 0 and shift < 27 :\n break\n else:\n print \"That is not a valid input.\"\n print\n final_dict = build_coder(shift)\n return final_dict","def forward(self, *args): # noqa: R0914\r\n encoder_out, (hn, cn) = self.unified_encoder(*args)\r\n device = hn.device\r\n non_sequential_cont_decoded = self.mlp_non_seq_cont(hn)\r\n non_sequential_cat_decoded = []\r\n for mlp_non_seq_cat in self.mlp_non_seq_cat_list:\r\n non_sequential_cat_decoded.append(mlp_non_seq_cat(hn))\r\n\r\n hn = torch.unsqueeze(hn, 0)\r\n cn = torch.unsqueeze(cn, 0)\r\n # decoded is the output prediction of timestep i-1 of the decoder\r\n decoded = torch.zeros(encoder_out.shape[0], int(\r\n self.unified_encoder.seq_cont_count + self.unified_encoder.no_of_embs_seq), device=device)\r\n seq_cont_decoded = torch.Tensor(device=device)\r\n seq_cat_decoded = []\r\n for _ in range(self.unified_encoder.seq_cat_count):\r\n seq_cat_decoded.append(torch.Tensor(device=device))\r\n\r\n for _ in range(encoder_out.shape[1]):\r\n decoded, (hn, cn), out_cont, out_cat = self.decoder(decoded, (hn, cn))\r\n # Predict all categorical columns\r\n out_cat_onehot = []\r\n if self.unified_encoder.seq_cat_count != 0:\r\n for idx, out in enumerate(out_cat):\r\n out_cat_onehot.append(torch.argmax(out, dim=1).unsqueeze(-1))\r\n seq_cat_decoded[idx] = torch.cat(\r\n [seq_cat_decoded[idx], out.view(out.shape[0], 1, -1)], dim=1)\r\n out_cat_onehot = torch.cat(out_cat_onehot, -1)\r\n out_cat_embedding = self.unified_encoder.seq_emb_layers(out_cat_onehot)\r\n decoded = torch.cat([out_cat_embedding, out_cont], dim=-1)\r\n else:\r\n decoded = out_cont\r\n seq_cont_decoded = torch.cat(\r\n [seq_cont_decoded, out_cont.view(out_cont.shape[0], 1, -1)], dim=1)\r\n\r\n return non_sequential_cont_decoded, non_sequential_cat_decoded, seq_cont_decoded, seq_cat_decoded","def encode(music, encoding):\n # Extract notes\n notes = extract_notes(music, encoding[\"resolution\"])\n\n # Encode the notes\n codes = encode_notes(notes, encoding)\n\n return codes","def encode(self, peptides):\n raise NotImplementedError","def fc_encoder(input_tensor, num_latent, is_training=True):\n del is_training\n\n flattened = tf.layers.flatten(input_tensor)\n e1 = tf.layers.dense(flattened, 1200, activation=tf.nn.relu, name=\"e1\")\n e2 = tf.layers.dense(e1, 1200, activation=tf.nn.relu, name=\"e2\")\n means = tf.layers.dense(e2, num_latent, activation=None)\n log_var = tf.layers.dense(e2, num_latent, activation=None)\n return means, log_var","def _encode(self, sentence: str, **kwargs) -> Sequence[int]:\r\n return NotImplemented","def encode(input_: list):\n global n_bytes\n block = bytearray()\n\n for tup in input_:\n arr = np.array(tup[0], dtype=tup[1]).tobytes()\n n_bytes += len(arr)\n block += arr\n\n return block","def encode(self, x, encode_params, name=None):\n values = [x] + list(encode_params)\n with tf.compat.v1.name_scope(name, 'gather_encoder_encode', values):\n x = tf.convert_to_tensor(x)\n encode_params = tf.nest.map_structure(tf.convert_to_tensor, encode_params)\n return self._encode_fn(x, encode_params)","def forward(self, *args):\r\n enc_src, src_mask, src_inp = self.unified_encoder(*args)\r\n batch_size, _, hid_dim = src_inp.shape\r\n device = src_inp.device\r\n # enc_src = [batch size, src len, hid dim]\r\n # src_mask = [batch size, src len]\r\n\r\n trg_inp = torch.cat((torch.zeros((batch_size, 1, hid_dim), device=device), src_inp[:, :-1, :]), 1)\r\n decoder_output, attention = self.decoder(trg_inp, enc_src, src_mask)\r\n\r\n # decoder_output = [batch size, trg len, hid dim]\r\n # attention = [batch size, n heads, trg len, src len]\r\n\r\n outputs = self.output_layer(decoder_output)\r\n\r\n return outputs, attention","def get_encoded(self):\n pass","def _preorder_encode(self):\n features = np.expand_dims(self.get_features(), axis=0)\n\n features = np.pad(features, (1, 0),\n 'constant', constant_values=(0, 0))\n return features.transpose(1, 0), np.array([[1], [0], [0]])","def encode(self, C, num_rows):\n x = np.zeros((num_rows, len(self.chars)))\n print(C)\n for i, c in enumerate(C):\n x[i, self.char_indices[c]] = 1\n return x","def encode(self, features, training=True):\n conditioning = self.preprocessor(features, training=training)\n return conditioning if self.encoder is None else self.encoder(conditioning)","def encode(\n self,\n speech: torch.Tensor,\n speech_lengths: torch.Tensor,\n return_int_enc: bool = False,\n ) -> Tuple[torch.Tensor, torch.Tensor]:\n with autocast(False):\n # 1. Extract feats\n feats, feats_lengths = self._extract_feats(speech, speech_lengths)\n\n # 2. Data augmentation\n if self.specaug is not None and self.training:\n feats, feats_lengths = self.specaug(feats, feats_lengths)\n\n # 3. Normalization for feature: e.g. Global-CMVN, Utterance-CMVN\n if self.normalize is not None:\n feats, feats_lengths = self.normalize(feats, feats_lengths)\n\n # Pre-encoder, e.g. used for raw input data\n if self.preencoder is not None:\n feats, feats_lengths = self.preencoder(feats, feats_lengths)\n\n # 4. Forward encoder\n # feats: (Batch, Length, Dim)\n # -> encoder_out: (Batch, Length2, Dim2)\n encoder_out, encoder_out_lens, _ = self.encoder(feats, feats_lengths)\n\n if return_int_enc:\n int_encoder_out, int_encoder_out_lens = encoder_out, encoder_out_lens\n\n if self.hier_encoder is not None:\n encoder_out, encoder_out_lens, _ = self.hier_encoder(\n encoder_out, encoder_out_lens\n )\n\n # Post-encoder, e.g. NLU\n if self.postencoder is not None:\n encoder_out, encoder_out_lens = self.postencoder(\n encoder_out, encoder_out_lens\n )\n\n assert encoder_out.size(0) == speech.size(0), (\n encoder_out.size(),\n speech.size(0),\n )\n assert encoder_out.size(1) <= encoder_out_lens.max(), (\n encoder_out.size(),\n encoder_out_lens.max(),\n )\n\n if return_int_enc:\n return encoder_out, encoder_out_lens, int_encoder_out, int_encoder_out_lens\n return encoder_out, encoder_out_lens","def encode(self, strs):","def encode(self, strs):","def build_encoder_bi(tparams, options):\n\t# word embedding (source)\n\tembedding = tensor.tensor3('embedding', dtype='float32')\n\tembeddingr = embedding[::-1]\n\tx_mask = tensor.matrix('x_mask', dtype='float32')\n\txr_mask = x_mask[::-1]\n\n\t# encoder\n\tproj = get_layer(options['encoder'])[1](tparams, embedding, options,\n\t\t\t\t\t\t\t\t\t\t\tprefix='encoder',\n\t\t\t\t\t\t\t\t\t\t\tmask=x_mask)\n\tprojr = get_layer(options['encoder'])[1](tparams, embeddingr, options,\n\t\t\t\t\t\t\t\t\t\t\t prefix='encoder_r',\n\t\t\t\t\t\t\t\t\t\t\t mask=xr_mask)\n\n\tctx = tensor.concatenate([proj[0][-1], projr[0][-1]], axis=1)\n\n\treturn embedding, x_mask, ctx"],"string":"[\n \"def encoder(self, inputs):\\n pass\",\n \"def encode(self):\\n with tf.name_scope(\\\"encode\\\"):\\n self.encoder_inputs = tf.layers.dense(\\n inputs=self.encoder_inputs,\\n units=self.options['hidden_size'], activation=None, use_bias=True,\\n kernel_initializer=tf.keras.initializers.he_normal(seed=None),\\n bias_initializer=tf.zeros_initializer(),\\n kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None,\\n kernel_constraint=None, bias_constraint=None, trainable=True,\\n name=None, reuse=None)\\n self.encoder_inputs = tf.layers.batch_normalization(self.encoder_inputs,\\n axis=-1,\\n momentum=0.99,\\n epsilon=0.001,\\n center=True,\\n scale=True,\\n beta_initializer=tf.zeros_initializer(),\\n gamma_initializer=tf.ones_initializer(),\\n moving_mean_initializer=tf.zeros_initializer(),\\n moving_variance_initializer=tf.ones_initializer(),\\n training=self.is_training,\\n trainable=True,\\n renorm=False,\\n renorm_momentum=0.99)\\n # Prepare inputs to the layer stack by adding positional encodings and\\n # applying dropout.\\n # embedded_inputs = self.embedding_softmax_layer(inputs)\\n #\\n inputs_padding = transformer_model_utils.get_padding(tf.cast(\\n tf.reduce_max(100*self.encoder_inputs, [-1]),\\n dtype=tf.int32))\\n\\n with tf.name_scope(\\\"add_pos_encoding\\\"):\\n length = tf.shape(self.encoder_inputs)[1]\\n pos_encoding = transformer_model_utils.get_position_encoding(\\n length, self.options[\\\"hidden_size\\\"])\\n encoder_inputs = self.encoder_inputs + pos_encoding\\n\\n if self.is_training:\\n encoder_inputs = tf.nn.dropout(\\n encoder_inputs, 1 - self.options[\\\"layer_postprocess_dropout\\\"])\\n\\n return self.encoder_stack(encoder_inputs, self.attention_bias, inputs_padding)\",\n \"def encode(self, input_):\\n return self.encoder(input_)\",\n \"def encode_input(self, x_tensor, inp_lens_tensor):\\r\\n input_emb = self.input_emb.forward(x_tensor)\\r\\n enc_output_each_word, enc_context_mask, enc_final_states = self.encoder(input_emb, inp_lens_tensor)\\r\\n enc_final_states_reshaped = (enc_final_states[0].unsqueeze(0), enc_final_states[1].unsqueeze(0))\\r\\n # print('lest go', enc_final_states_reshaped[1].shape)\\r\\n return enc_output_each_word, enc_context_mask, enc_final_states_reshaped\",\n \"def encode(input):\\n return ModelEncoder().encode(input)\",\n \"def encoder(enc_input, attn_bias, n_layer, n_head,\\n d_key, d_value, d_model, d_inner_hid, pos_enc,\\n preporstprocess_dropout, attention_dropout,\\n relu_dropout, preprocess_cmd='n',\\n postprocess_cmd='da'):\\n for i in range(n_layer):\\n enc_output = encoder_layer(enc_input, attn_bias, n_head,\\n d_key, d_value, d_model,d_inner_hid, pos_enc,\\n prepostprocess_dropout, attention_dropout,relu_dropout,\\n preprocess_cmd, postprocess_cmd\\n )\\n enc_input = enc_output\\n enc_output = pre_process_layer(enc_output,\\n preprocess_cmd, preporstprocess_dropout)\\n return enc_output\",\n \"def encode(data, encoder):\\n # Get the list of hidden depths\\n\\thd = encoder.hidden_depths\\n # Find the middle hidden layer\\n\\tmiddle_layer_index = (len(hd)-1)/2\\n # Initialize empty container for the encoded data\\n\\tdata_encoded = np.zeros((data.shape[0],hd[middle_layer_index]))\\n\\tfor i, d_ in enumerate(data):\\n # feed forward, get all the activations, and just keep\\n # the middle layer, which is the encoding\\n\\t\\tx, z_container, x_container = encoder.ff(d_,True,True)\\n\\t\\tx_encoded = x_container[1+middle_layer_index]\\n\\t\\tdata_encoded[i] = x_encoded\\n\\t#\\n\\treturn data_encoded\",\n \"def encode(self, inputs, mask=None, sample_shape=()):\\n inputs = tf.nest.flatten(inputs)[:len(self._vae.encoder.inputs)]\\n latents = self._vae.encode(inputs[0] if len(inputs) == 1 else inputs,\\n training=False,\\n mask=mask,\\n sample_shape=sample_shape)\\n # only support single returned latent variable now\\n for z in tf.nest.flatten(latents):\\n assert isinstance(z, tfd.Distribution), \\\\\\n \\\"The latent code return from `vae.encode` must be instance of \\\" + \\\\\\n \\\"tensorflow_probability.Distribution, but returned: %s\\\" % \\\\\\n str(z)\\n return latents\",\n \"def encode_all(self, inputs, encoder):\\n input_shape = tf.shape(inputs)\\n num_timesteps, batch_size = input_shape[0], input_shape[1]\\n reshaped_inputs = tf.reshape(inputs, [-1, inputs.shape[-1]])\\n inputs_encoded = encoder(reshaped_inputs)\\n inputs_encoded = tf.reshape(inputs_encoded, [num_timesteps, batch_size, encoder.output_size])\\n return inputs_encoded\",\n \"def _encode(self):\\n with tf.variable_scope('encoding'):\\n self.sep_p_encodes, _ = bilstm_layer(self.p_emb, self.p_length, self.hidden_size)\\n tf.get_variable_scope().reuse_variables()\\n self.sep_q_encodes, _ = bilstm_layer(self.q_emb, self.q_length, self.hidden_size)\\n if self.use_dropout:\\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, 1-self.dropout)\\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, 1-self.dropout)\",\n \"def encode(self, inputs, masks):\\n with tf.variable_scope(\\\"encoder\\\") as scope_encoder:\\n #compute sequence length\\n sequence_lengths = tf.reduce_sum(masks, axis = 1) \\n #create a forward cell\\n fw_cell = tf.contrib.rnn.LSTMCell(self.size)\\n\\n #pass the cells to bilstm and create the bilstm\\n bw_cell = tf.contrib.rnn.LSTMCell(self.size)\\n output, final_state = tf.nn.bidirectional_dynamic_rnn(fw_cell, \\\\\\n bw_cell, inputs, \\\\\\n sequence_length = sequence_lengths, \\\\\\n dtype = tf.float32, \\\\\\n parallel_iterations = 256)\\n output_lstm = tf.concat([output[0], output[1]], axis = -1)\\n final_state_lstm = tf.concat([final_state[0], final_state[1]], axis = -1)\\n return output_lstm, final_state_lstm\",\n \"def forward(self, x):\\n # Get results of encoder network\\n q = self.encode_nn(x)\\n\\n return q\",\n \"def encode(self, X):\\r\\n return self._encoder.predict(X)\",\n \"def encode(self, x):\\n self.eval()\\n x = torch.as_tensor(x).unsqueeze(0)\\n if self.do_mt:\\n enc_output, _ = self.encoder_mt(x, None)\\n else:\\n enc_output, _ = self.encoder(x, None)\\n return enc_output.squeeze(0)\",\n \"def encode_input_for_decoder(x_tensor, inp_lens_tensor, model_input_emb: EmbeddingLayer, model_enc: RNNEncoder):\\n input_emb = model_input_emb.forward(x_tensor)\\n (enc_output_each_word, enc_context_mask, enc_final_states) = model_enc.forward(input_emb, inp_lens_tensor)\\n enc_final_states_reshaped = (enc_final_states[0].unsqueeze(0), enc_final_states[1].unsqueeze(0))\\n return (enc_output_each_word, enc_context_mask, enc_final_states_reshaped)\",\n \"def call(self, inputs, *args, **kwargs):\\n outputs = self.encoder(inputs, *args, **kwargs)\\n return outputs\",\n \"def encode(self,x,x_len):\\n\\n ## Check to see if batch_size parameter is fixed or base on input batch\\n cur_batch_size = x.size()[1]\\n encode_init_state = self.encoder.initialize_hidden_state(cur_batch_size)\\n encoder_state, encoder_outputs = self.encoder.forward(x, encode_init_state, x_len)\\n\\n return encoder_outputs, encoder_state\",\n \"def encode(self, input):\\n h = np.zeros(self.hidden_size) \\n \\n preactivation = np.dot(self.W.T, input) + self.b\\n sigmoid(preactivation, h)\\n \\n return h\",\n \"def encoder(self, x):\\n # Input (batch_size, Channels=1, Width=28, Height=28)\\n x = self.enc_conv(x) # (batch_size, lin_before_latent_dim)\\n mean = self.enc_mean(x) # (batch_size, latent_dim)\\n logvar = self.enc_logvar(x) # (batch_size, latent_dim)\\n return mean, logvar\",\n \"def encode(self, state):\\n raise NotImplementedError\",\n \"def _encode(self):\\n with tf.variable_scope('passage_encoding'):\\n self.sep_p_encodes, _ = rnn('bi-lstm', self.p_emb, self.p_length, self.hidden_size)\\n with tf.variable_scope('question_encoding'):\\n self.sep_q_encodes, _ = rnn('bi-lstm', self.q_emb, self.q_length, self.hidden_size)\\n if self.use_dropout:\\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, self.dropout_keep_prob)\\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, self.dropout_keep_prob)\",\n \"def encode(self, input):\\n out = self.encoder(input)\\n out = torch.flatten(out, start_dim=1)\\n mu = self.fc_mu(out)\\n log_var = self.fc_var(out)\\n return [mu, log_var]\",\n \"def encode(self, seq):\",\n \"def encode(self, inputs, target_space, hparams, features=None, losses=None):\\n del losses\\n\\n inputs = common_layers.flatten4d3d(inputs)\\n\\n encoder_input, self_attention_bias, encoder_decoder_attention_bias = (\\n transformer.transformer_prepare_encoder(\\n inputs, target_space, hparams, features=features))\\n\\n encoder_input = tf.nn.dropout(encoder_input,\\n 1.0 - hparams.layer_prepostprocess_dropout)\\n\\n (encoder_output, encoder_extra_output) = (\\n my_universal_transformer_util.universal_transformer_encoder(\\n encoder_input,\\n self_attention_bias,\\n hparams,\\n nonpadding=transformer.features_to_nonpadding(features, \\\"inputs\\\"),\\n save_weights_to=self.attention_weights))\\n\\n return encoder_output, encoder_decoder_attention_bias, encoder_extra_output\",\n \"def encoder_decoder_archi_gan(inputs, is_train):\\n\\n encoder_layers = []\\n\\n encoded = inputs\\n\\n encoder_layers.append(encoded)\\n\\n for i in range(config.encoder_layers):\\n encoded = encoder_conv_block_gan(encoded, i, is_train)\\n encoder_layers.append(encoded)\\n \\n encoder_layers.reverse()\\n\\n\\n\\n decoded = encoder_layers[0]\\n\\n for i in range(config.encoder_layers):\\n decoded = decoder_conv_block_gan(decoded, encoder_layers[i+1], i, is_train)\\n\\n return decoded\",\n \"def make_encoder(self, input_size: int, latent_size: int) -> nn.Module:\\n pass\",\n \"def call(self, inputs, training=False):\\n features, predicted = inputs\\n enc = self.encoder(features, training=training)\\n pred, _ = self.predict_net(predicted, training=training)\\n outputs = self.joint_net([enc, pred], training=training)\\n return outputs\",\n \"def encoder_layer(enc_input, attn_bias, n_head, d_key,\\n d_value, d_model, d_inner_hid, pos_enc, prepostprocess_dropout,\\n attention_dropout, relu_dropout, preprocess_cmd='n',\\n postprocess_cmd='da'):\\n attn_output = multi_head_attention(\\n pre_process_layer(enc_input, preprocess_cmd, prepostprocess_dropout),\\n None, None, attn_bias, d_key, d_value, d_model, pos_enc,\\n n_head, attention_dropout\\n )\\n attn_output = post_process_layer(enc_input, attn_output,\\n postprocess_cmd, prepostprocess_dropout)\\n ffd_output = positionwise_feed_forward(\\n pre_process_layer(attn_output, preprocess_cmd, prepostprocess_dropout),\\n d_inner_hid, d_model, relu_dropout\\n )\\n return post_process_layer(attn_output, ffd_output,\\n postprocess_cmd, prepostprocess_dropout)\",\n \"def fit_transform(self):\\n if self.enc_types == \\\"label\\\":\\n return self._label_encoding()\\n elif self.enc_types == \\\"ohe\\\":\\n return self._one_hot_encoder()\\n elif self.enc_types == \\\"binary\\\":\\n return self._binarization()\\n else:\\n raise Exception(\\\"Encoding type not understood\\\")\",\n \"def _define_encoder(self):\\n self.encoder = nn.Sequential(View((-1, 64 * 64 * 3)),\\n nn.Linear(64 * 64 * 3, 5120, bias=False), nn.SELU(),\\n nn.BatchNorm1d(5120),\\n nn.Linear(5120, 2560, bias=False), nn.SELU(),\\n nn.BatchNorm1d(2560),\\n nn.Linear(2560, 512, bias=False), nn.SELU(),\\n nn.BatchNorm1d(512),\\n nn.Linear(512, 128, bias=False), nn.SELU(),\\n nn.BatchNorm1d(128),\\n nn.Linear(128, self.encoding_shape, bias=False), nn.SELU(),\\n )\",\n \"def encode(self, decoded):\",\n \"def encode_instruction(instruction: str) -> int:\\n\\ta, b, c = convert_instruction(instruction)\\n\\treturn encode_pair(a, encode_pair(b, c))\",\n \"def encode(self, signal: np.ndarray) -> np.ndarray:\\n pass\",\n \"def encode(self, img):\\n with tf.variable_scope('encoder'):\\n #conv1 = self.conv_layer(\\n # img, [5, 5], [3, 32], stride=2, initializer_type=1, name='conv1')\\n #conv2 = self.conv_layer(\\n # conv1, [5, 5], [32, 32], stride=2, initializer_type=1, name='conv2')\\n conv3 = self.conv_layer(\\n img, [5, 5], [self.in_channels, 64], stride=2, initializer_type=1, name='conv3')\\n #conv4 = self.conv_bn_layer(\\n conv4 = self.conv_layer(\\n conv3, [5, 5], [64, 128], stride=2, #is_training=self.is_training,\\n initializer_type=1, name='conv4')\\n #conv5 = self.conv_bn_layer(\\n conv5 = self.conv_layer(\\n conv4, [5, 5], [128, 256], stride=2, #is_training=self.is_training,\\n initializer_type=1, name='conv5')\\n shape = conv5.get_shape().as_list()\\n feature_map_size = shape[1]*shape[2]*shape[3]\\n conv5_flat = tf.reshape(\\n conv5, [-1, feature_map_size], 'conv5_flat')\\n #fc6 = self.fc_bn_layer(conv5_flat, 1024, is_training=self.is_training,\\n fc6 = self.fc_layer(conv5_flat, 1024,\\n initializer_type=1, name='fc6')\\n #fc7 = self.fc_layer(fc6, 1024, initializer_type=1, name='fc7')\\n return fc6, shape\",\n \"def terrainEncoded(self, request, result):\\n pass\",\n \"def encode(self, x):\\n h1 = F.relu(self.conv1(x))\\n h2 = F.relu(self.conv2(h1))\\n h3 = F.relu(self.conv3(h2))\\n h4 = F.relu(self.conv4(h3))\\n h4 = h4.reshape(-1)\\n mu = self.fc1(h4)\\n logvar = self.fc2(h4)\\n\\n # we take log of var as sigma cannot be negative \\n # while neural network can output negative values\\n sigma = torch.exp(logvar * 0.5)\\n\\n normal = torch.randn_like(sigma)\\n\\n return mu + sigma * normal, mu, logvar\",\n \"def conv_encoder(input_tensor, num_latent, is_training=True):\\n del is_training\\n\\n e1 = tf.layers.conv2d(\\n inputs=input_tensor,\\n filters=32,\\n kernel_size=4,\\n strides=2,\\n activation=tf.nn.relu,\\n padding=\\\"same\\\",\\n name=\\\"e1\\\",\\n )\\n e2 = tf.layers.conv2d(\\n inputs=e1,\\n filters=32,\\n kernel_size=4,\\n strides=2,\\n activation=tf.nn.relu,\\n padding=\\\"same\\\",\\n name=\\\"e2\\\",\\n )\\n e3 = tf.layers.conv2d(\\n inputs=e2,\\n filters=64,\\n kernel_size=2,\\n strides=2,\\n activation=tf.nn.relu,\\n padding=\\\"same\\\",\\n name=\\\"e3\\\",\\n )\\n e4 = tf.layers.conv2d(\\n inputs=e3,\\n filters=64,\\n kernel_size=2,\\n strides=2,\\n activation=tf.nn.relu,\\n padding=\\\"same\\\",\\n name=\\\"e4\\\",\\n )\\n flat_e4 = tf.layers.flatten(e4)\\n e5 = tf.layers.dense(flat_e4, 256, activation=tf.nn.relu, name=\\\"e5\\\")\\n means = tf.layers.dense(e5, num_latent, activation=None, name=\\\"means\\\")\\n log_var = tf.layers.dense(e5, num_latent, activation=None, name=\\\"log_var\\\")\\n return means, log_var\",\n \"def encode(self, src_seq, src_lens):\\n src_embed = self.word_embedding(src_seq)\\n src_encodings, final_states = self.encoder_lstm(src_embed, src_lens)\\n\\n return src_encodings, final_states, src_embed\",\n \"def _define_encoder(self):\\n raise NotImplementedError\",\n \"def _encode(self, src_token_ids, padding_mask, training=False):\\n src_seq_len = tf.shape(src_token_ids)[1]\\n\\n # [batch_size, src_seq_len, hidden_size]\\n src_token_embeddings = self._embedding_logits_layer(\\n src_token_ids, 'embedding')\\n\\n # [src_seq_len, hidden_size]\\n positional_encoding = utils.get_positional_encoding(\\n src_seq_len, self._hidden_size)\\n src_token_embeddings += positional_encoding\\n src_token_embeddings = self._encoder_dropout_layer(\\n src_token_embeddings, training)\\n\\n encoder_outputs = self._encoder(\\n src_token_embeddings, padding_mask, training)\\n return encoder_outputs\",\n \"def runit():\\n print encode(\\\"no\\\")\\n\\n print encode(\\\"yes\\\")\\n\\n print encode(\\\"OMG\\\")\\n\\n print encode(\\\"O M G\\\")\\n\\n print encode(\\\"mindblowingly\\\")\\n\\n print encode(\\\"Testing, 1 2 3, testing.\\\")\\n\\n print encode(\\\"Truth is fiction.\\\")\\n\\n print encode(\\\"The quick brown fox jumps over the lazy dog.\\\")\\n\\n print decode(\\\"vcvix rhn\\\")\\n\\n print decode(\\\"zmlyh gzxov rhlug vmzhg vkkrm thglm v\\\")\",\n \"def pretrain_forward(self, inp):\\n return self.encoder(inp)\",\n \"def encode(self, X_train_A, X_train_V, X_dev_A, X_dev_V):\\n X_train_V, _, _, _ = self.separate_V(X_train_V)\\n X_dev_A, _, _, _ = self.separate_V(X_dev_A)\\n \\n encoded_train = self.encoder.predict([X_train_A, X_train_V])\\n encoded_dev = self.encoder.predict([X_dev_A, X_dev_V])\\n self.save_representation(encoded_train, encoded_dev)\\n self.decode(encoded_train, encoded_dev)\",\n \"def _define_encoder(self):\\n self.encoder = nn.Sequential(nn.Conv2d(in_channels=3, out_channels=32, kernel_size=4, stride=2, padding=1), # B, 32, 32, 32\\n nn.SELU(),\\n nn.Conv2d(32, 32, 4, 2, 1), # B, 32, 16, 16\\n nn.SELU(),\\n nn.Conv2d(32, 64, 4, 2, 1), # B, 64, 8, 8\\n nn.SELU(),\\n nn.Conv2d(64, 64, 4, 2, 1), # B, 64, 4, 4\\n nn.SELU(),\\n nn.Conv2d(64, 256, 4, 1), # B, 256, 1, 1\\n nn.SELU(),\\n View((-1, 256 * 1 * 1)), # B, 256\\n nn.Linear(256, self.encoding_shape * 2), # B, z_dim*2\\n )\",\n \"def encode(image):\\n from encoder import launch\\n launch(image)\",\n \"def encoder(inputs):\\n out = tf.layers.flatten(inputs)\\n out = tf.layers.dense(out, 400, activation=tf.nn.relu)\\n mean = tf.layers.dense(out, LATENT_SIZE)\\n logstd = tf.layers.dense(out, LATENT_SIZE)\\n return tf.distributions.Normal(loc=mean, scale=tf.exp(logstd))\",\n \"def encode_input(sent, lemmas, pos_tags, predicates, vocab_preds, vocab_lemmas, vocab_pos_tags, bert_embedder, task_234):\\n sentence = bert_embedder.embed_sentence([sent])[0]\\n lens = torch.LongTensor([len(sent)])\\n pos_tags = torch.tensor([vocab_pos_tags[pos_tag] for pos_tag in pos_tags])\\n lemmas = torch.tensor([vocab_lemmas[lemma] if lemma in vocab_lemmas else vocab_lemmas['<unk>'] for lemma in lemmas])\\n vocab_preds = {word: int(idx) for idx, word in vocab_preds.items()}\\n predicate_null_token = vocab_preds['_']\\n if task_234:\\n # if the task is predicate disambiguation, predicates indicates only the position of the predicates in the sentence\\n predicates = torch.LongTensor(predicates)\\n positions = (predicates == 1).nonzero()\\n else:\\n # otherwise predicates must be encoded with the value stored in the vocabulary\\n predicates = torch.tensor([vocab_preds[predicate] for predicate in predicates])\\n positions = (predicates != predicate_null_token).nonzero()\\n\\n return sentence[None,...], lens, pos_tags[None,...], lemmas[None,...], predicates[None,...], positions.view(-1).tolist(), predicate_null_token\",\n \"def label_encode(var, values):\\n\\n le = preprocessing.LabelEncoder()\\n le.fit(values)\\n var_encoded = le.transform(var)\\n\\n return var_encoded\",\n \"def _gather_latent_codes(self,\\n latent_code_type: str = 'train'\\n ) -> Sequence[tf.Tensor]:\\n if latent_code_type == 'train':\\n codes_use = self.codes_train_data\\n elif latent_code_type == 'test':\\n codes_use = self.codes_test_data\\n\\n if (self._mode == 'fully_multi_level' and\\n self._encoder_mode == 'input_enc+f2c'):\\n if self._latent_optim_target == 'code_grid_enc':\\n codes_each_level = []\\n for i in range(len(codes_use)):\\n codes_each_level.append(\\n tf.reshape(codes_use[i](0), [1, *self.code_grid_enc_shape[i]]))\\n\\n return codes_each_level\",\n \"def encoder(self, tensor):\\n with tf.variable_scope(\\\"encoder\\\"):\\n tensor = tf.nn.embedding_lookup(self.embedding, tensor)\\n cell = tf.nn.rnn_cell.BasicLSTMCell(self.num_units)\\n outputs, state = tf.nn.dynamic_rnn(cell, tensor, sequence_length=self.seq_len, dtype=tf.float32)\\n output = outputs[:,-1,:]\\n output = tf.nn.l2_normalize(output, -1)\\n\\n return output\",\n \"def encode(self, x: Tensor) ->Tensor:\\n return self.encoder(x)[0]\",\n \"def label_encode(data: List) -> [np.ndarray, List[LabelEncoder]]:\\n labels_encoded = []\\n data_encoded = np.array(data)\\n for i in range(data_encoded.shape[1]):\\n le = preprocessing.LabelEncoder()\\n le.fit(data_encoded[:, i])\\n labels_encoded.append(le)\\n data_encoded[:, i] = le.transform(data_encoded[:, i])\\n\\n data_encoded = data_encoded.astype(int)\\n return data_encoded, labels_encoded\",\n \"def autoencoder(self, data):\\n with tf.variable_scope(\\\"autoencoder\\\"):\\n latent = self.encoder(data)\\n _, output = self.decoder(latent)\\n\\n return output, latent\",\n \"def encode(self):\\n self.preprocess_msg()\\n self._find_e()\\n\\n self.__encoded_msg = self._calculate(self.e)\",\n \"def _add_input_encoder(self, inputs, seq_len):\\n with tf.variable_scope(\\\"encoder\\\"):\\n cell_fw = tf.contrib.rnn.LSTMCell(config.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n cell_bw = tf.contrib.rnn.LSTMCell(config.hidden_dim, initializer=self.rand_unif_init, state_is_tuple=True)\\n ((fw_states, bw_states), (final_fw, final_bw)) = tf.nn.bidirectional_dynamic_rnn(cell_fw, cell_bw, inputs, dtype=tf.float32, sequence_length=seq_len, swap_memory=True)\\n\\n return fw_states, bw_states, final_fw, final_bw\",\n \"def preprocess(self, latent_codes, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def encode(self, encode_data, image):\\r\\n raise NotImplementedError(\\\"Not Implemented\\\")\",\n \"def encode(bits, nt_to_bits=None):\\r\\n if nt_to_bits is None:\\r\\n nt_to_bits = DEFAULT_GOLAY_NT_TO_BITS\\r\\n\\r\\n bits = numpy.array(bits).reshape((12, 1))\\r\\n\\r\\n # cheap way to do binary xor in matrix dot\\r\\n res = numpy.dot(DEFAULT_G.T, bits)\\r\\n codeword = divmod(res.ravel(), 2)[1]\\r\\n\\r\\n return _bits_to_seq(codeword, nt_to_bits)\",\n \"def encode_inputs(inputs1, inputs2, encoder1, encoder2, device):\\n # get inputs\\n inputs1 = inputs1[0]\\n inputs2 = inputs2[0]\\n\\n # encode inputs into means and logs of variances\\n z_mean1, z_logvar1 = encoder1(inputs1)\\n z_mean2, z_logvar2 = encoder2(inputs2)\\n\\n encoded_inputs_list = []\\n\\n # put the means and logs of variances together\\n for x0, x1, x2, x3 in zip(z_mean1, z_logvar1,\\n z_mean2, z_logvar2):\\n x0 = x0.item()\\n x1 = x1.item()\\n x2 = x2.item()\\n x3 = x3.item()\\n\\n sequence = [x0, x1, x2, x3]\\n\\n encoded_inputs_list.append(sequence)\\n\\n # transform encoded inputs into tensor on device\\n encoded_inputs_tensor = torch.tensor(encoded_inputs_list)\\n encoded_inputs_tensor = encoded_inputs_tensor.to(device)\\n\\n return encoded_inputs_tensor\",\n \"def encoder_inference(self, features, states):\\n with tf.name_scope(f\\\"{self.name}_encoder\\\"):\\n outputs = tf.expand_dims(features, axis=0)\\n outputs, new_states = self.encoder.recognize(outputs, states)\\n return tf.squeeze(outputs, axis=0), new_states\",\n \"def encode(self, input):\\n result = self.encoder(input)\\n result = torch.flatten(result, start_dim=1)\\n\\n # Split the result into mu and var components\\n # of the latent Gaussian distribution\\n mu = self.fc_mu(result)\\n log_var = self.fc_var(result)\\n\\n return [mu, log_var]\",\n \"def enc_x(self, inputs, training=False):\\n return self._enc_x(inputs, training)\",\n \"def encode(y):\\n le = LabelEncoder()\\n le.fit(y)\\n print(list(le.classes_))\\n y = le.transform(y)\\n return y\",\n \"def tf_encode(pt, en):\\n result_pt, result_en = tf.py_function(encode, [pt, en], [tf.int64, tf.int64])\\n result_pt.set_shape([None])\\n result_en.set_shape([None])\\n return result_pt, result_en\",\n \"def encode(self, y):\\n raise NotImplementedError\",\n \"def encode_next_latent_state(self, data, latent_state, dts):\\n raise NotImplementedError(\\\"Abstract class cannot be used.\\\")\",\n \"def encode_next_latent_state(self, data, latent_state, dts):\\n raise NotImplementedError(\\\"Abstract class cannot be used.\\\")\",\n \"def handle_encode(self, results):\\n \\n config.COD_PROMPT = config.ENC_PROMPT\\n print config.ENC_PROMPT + \\\" encoding results...\\\"\\n \\n # while there is another decoder, run each item through the next decoder\\n data = results\\n success = False\\n for encoder in self.encoder_list:\\n current_encoder = encoder()\\n full_body = getattr(current_encoder,'full_body_encode',False)\\n success, data = self.recursive_decoder(current_encoder.encode, data, full_body)\\n if not success:\\n break\\n print config.ENC_PROMPT + \\\"%s encoded to '%s'\\\" % ( current_encoder.name(),data)\\n return success, data\",\n \"def encode(self, game_state: ssm.SnakeStateMachine) -> int:\\n state = [e.encode(game_state) for e in self._encoders]\\n return self._state2id[tuple(state)]\",\n \"def encode(self):\\n payload = []\\n\\n # Generate Payload\\n if self.IsEnsembleData:\\n payload += self.EnsembleData.encode()\\n if self.IsAncillaryData:\\n payload += self.AncillaryData.encode()\\n if self.IsAmplitude:\\n payload += self.Amplitude.encode()\\n if self.IsCorrelation:\\n payload += self.Correlation.encode()\\n if self.IsBeamVelocity:\\n payload += self.BeamVelocity.encode()\\n if self.IsInstrumentVelocity:\\n payload += self.InstrumentVelocity.encode()\\n if self.IsEarthVelocity:\\n payload += self.EarthVelocity.encode()\\n if self.IsGoodBeam:\\n payload += self.GoodBeam.encode()\\n if self.IsGoodEarth:\\n payload += self.GoodEarth.encode()\\n if self.IsBottomTrack:\\n payload += self.BottomTrack.encode()\\n if self.IsRangeTracking:\\n payload += self.RangeTracking.encode()\\n if self.IsSystemSetup:\\n payload += self.SystemSetup.encode()\\n if self.IsNmeaData:\\n payload += self.NmeaData.encode()\\n\\n # Generate the header\\n # Get the ensemble number\\n ens_num = 0\\n if self.IsEnsembleData:\\n ens_num = self.EnsembleData.EnsembleNumber\\n\\n # Get the payload size\\n payload_size = len(payload)\\n\\n header = Ensemble.generate_ens_header(ens_num, payload_size)\\n\\n # Generate the Checksum CITT\\n # Parameters found at https: // pycrc.org / models.html\\n #crc = pycrc.algorithms.Crc(width=16, poly=0x1021,\\n # reflect_in=False, xor_in=0x1d0f,\\n # reflect_out=False, xor_out=0x0000)\\n #checksum = crc.bit_by_bit_fast(binascii.a2b_hex(bytes(payload)))\\n #checksum = Ensemble.int32_to_bytes(CRCCCITT().calculate(input_data=bytes(payload)))\\n checksum = crc16.crc16xmodem(payload)\\n\\n\\n result = []\\n result += header\\n result += payload\\n result += checksum\\n\\n return bytearray(result)\",\n \"def _bert_encoder(self, sentence, attn_mask):\\n output = self.bert(sentence, attn_mask)\\n embedding = output['hidden_states'][-1]\\n\\n feats = self.hidden2tag(embedding)\\n return feats\",\n \"def forward(self, x):\\n # Get results of encoder network\\n h1 = self.encode_nn(x)\\n\\n # latent space\\n mu = self.encode_mu(h1)\\n log_var = self.encode_log_var(h1)\\n\\n # Reparameterize\\n z = self.reparameterize(mu, log_var)\\n return z, mu, log_var\",\n \"def forward(self, x):\\n # Get results of encoder network\\n h1 = self.encode_nn(x)\\n\\n # latent space\\n mu = self.encode_mu(h1)\\n log_var = self.encode_log_var(h1)\\n\\n # Reparameterize\\n z = self.reparameterize(mu, log_var)\\n return z, mu, log_var\",\n \"def encode(self):\\n \\n assert False, \\\"Not implemented.\\\"\",\n \"def encode(self, x):\\n _, hid = self.encoder(x) #All RNN classes output a tuple of 2 objects: the output of the RNN first and the hidden state from the last item in\\n return hid #the input sequence second. We're only interested in the hidden state\",\n \"def encode(self, uid, input_vec):\\n params = {\\n 'input': input_vec,\\n }\\n return self.context.post(\\\"/ckks/computation/encode/%s\\\" % uid, params,\\n \\\"CKKS:: failed encoding data for uid: %s\\\" % uid\\n )[\\\"data\\\"]\",\n \"def forward(self, inputs_encoder, inputs_decoder):\\n states_encoder = self.encoder(inputs_encoder)\\n outputs_decoder, states_decoder = self.decoder(inputs_decoder, states_encoder)\\n return outputs_decoder, states_decoder\",\n \"def _bert_encoder(self, tokens, attn_masks):\\n output = self.bert(tokens, attn_masks)\\n embedding = output['hidden_states'][-2]\\n tag_prob = self.Softmax(self.hidden2tag(embedding))\\n return tag_prob\",\n \"def build_encoder(self):\\n with tf.variable_scope(\\\"encoder\\\") as scope:\\n length1 = tf.to_int32(tf.reduce_sum(self.encode_mask1, 1), name=\\\"length1\\\")\\n\\n if self.config.bidirectional_encoder:\\n if self.config.encoder_dim % 2:\\n raise ValueError(\\n \\\"encoder_dim must be even when using a bidirectional encoder.\\\")\\n num_units = self.config.encoder_dim // 2\\n cell_fw = self._initialize_gru_cell(num_units) # Forward encoder\\n cell_bw = self._initialize_gru_cell(num_units) # Backward encoder\\n _, states = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw=cell_fw,\\n cell_bw=cell_bw,\\n inputs=self.encode_emb1,\\n sequence_length=length1,\\n dtype=tf.float32,\\n scope=scope)\\n thought_vectors1 = tf.concat(states, 1, name=\\\"thought_vectors1\\\")\\n else:\\n cell = self._initialize_gru_cell(self.config.encoder_dim)\\n _, state = tf.nn.dynamic_rnn(\\n cell=cell,\\n inputs=self.encode_emb1,\\n sequence_length=length1,\\n dtype=tf.float32,\\n scope=scope)\\n # Use an identity operation to name the Tensor in the Graph.\\n thought_vectors1 = tf.identity(state, name=\\\"thought_vectors1\\\")\\n \\n scope.reuse_variables()\\n\\n length2 = tf.to_int32(tf.reduce_sum(self.encode_mask2, 1), name=\\\"length2\\\")\\n\\n if self.config.bidirectional_encoder:\\n if self.config.encoder_dim % 2:\\n raise ValueError(\\n \\\"encoder_dim must be even when using a bidirectional encoder.\\\")\\n num_units = self.config.encoder_dim // 2\\n cell_fw = self._initialize_gru_cell(num_units) # Forward encoder\\n cell_bw = self._initialize_gru_cell(num_units) # Backward encoder\\n _, states = tf.nn.bidirectional_dynamic_rnn(\\n cell_fw=cell_fw,\\n cell_bw=cell_bw,\\n inputs=self.encode_emb2,\\n sequence_length=length2,\\n dtype=tf.float32,\\n scope=scope)\\n thought_vectors2 = tf.concat(states, 1, name=\\\"thought_vectors2\\\")\\n else:\\n cell = self._initialize_gru_cell(self.config.encoder_dim)\\n _, state = tf.nn.dynamic_rnn(\\n cell=cell,\\n inputs=self.encode_emb2,\\n sequence_length=length2,\\n dtype=tf.float32,\\n scope=scope)\\n # Use an identity operation to name the Tensor in the Graph.\\n thought_vectors2 = tf.identity(state, name=\\\"thought_vectors2\\\")\\n\\n self.thought_vectors1 = thought_vectors1\\n self.thought_vectors2 = thought_vectors2\",\n \"def _encode_back(self):\\n with tf.variable_scope('passage_encoding'):\\n self.sep_p_encodes, _ = rnn('bi-lstm', self.p_emb, self.p_length, self.hidden_size)\\n with tf.variable_scope('question_encoding'):\\n self.sep_q_encodes, _ = rnn('bi-lstm', self.q_emb, self.q_length, self.hidden_size)\\n if self.use_dropout:\\n self.sep_p_encodes = tf.nn.dropout(self.sep_p_encodes, self.dropout_keep_prob)\\n self.sep_q_encodes = tf.nn.dropout(self.sep_q_encodes, self.dropout_keep_prob)\",\n \"def encode(self, x):\\n mu = []\\n logvar = []\\n for i in range(self.n_views):\\n mu_, logvar_ = self.encoders[i](x[i])\\n mu.append(mu_)\\n logvar.append(logvar_)\\n mu = torch.stack(mu)\\n logvar = torch.stack(logvar)\\n mu_out, logvar_out = self.join_z(mu, logvar)\\n qz_x = hydra.utils.instantiate( \\n self.cfg.encoder.default.enc_dist, loc=mu_out, scale=logvar_out.exp().pow(0.5)\\n )\\n return [qz_x]\",\n \"def make_encoder(self, input_size, latent_size):\\n return nn.Sequential(\\n nn.Linear(input_size, 500),\\n nn.ReLU(),\\n nn.Linear(500, 200),\\n nn.ReLU(),\\n nn.Linear(200, latent_size * 2)\\n # times 2 because this is the concatenated vector of latent mean and variance\\n )\",\n \"def encode(self) -> str:\\n return Activation._encoder.encode(self)\",\n \"def build_encoder(shift):\\n ### TODO.\\n while True:\\n if shift >= 0 and shift < 27 :\\n break\\n else:\\n print \\\"That is not a valid input.\\\"\\n print\\n final_dict = build_coder(shift)\\n return final_dict\",\n \"def forward(self, *args): # noqa: R0914\\r\\n encoder_out, (hn, cn) = self.unified_encoder(*args)\\r\\n device = hn.device\\r\\n non_sequential_cont_decoded = self.mlp_non_seq_cont(hn)\\r\\n non_sequential_cat_decoded = []\\r\\n for mlp_non_seq_cat in self.mlp_non_seq_cat_list:\\r\\n non_sequential_cat_decoded.append(mlp_non_seq_cat(hn))\\r\\n\\r\\n hn = torch.unsqueeze(hn, 0)\\r\\n cn = torch.unsqueeze(cn, 0)\\r\\n # decoded is the output prediction of timestep i-1 of the decoder\\r\\n decoded = torch.zeros(encoder_out.shape[0], int(\\r\\n self.unified_encoder.seq_cont_count + self.unified_encoder.no_of_embs_seq), device=device)\\r\\n seq_cont_decoded = torch.Tensor(device=device)\\r\\n seq_cat_decoded = []\\r\\n for _ in range(self.unified_encoder.seq_cat_count):\\r\\n seq_cat_decoded.append(torch.Tensor(device=device))\\r\\n\\r\\n for _ in range(encoder_out.shape[1]):\\r\\n decoded, (hn, cn), out_cont, out_cat = self.decoder(decoded, (hn, cn))\\r\\n # Predict all categorical columns\\r\\n out_cat_onehot = []\\r\\n if self.unified_encoder.seq_cat_count != 0:\\r\\n for idx, out in enumerate(out_cat):\\r\\n out_cat_onehot.append(torch.argmax(out, dim=1).unsqueeze(-1))\\r\\n seq_cat_decoded[idx] = torch.cat(\\r\\n [seq_cat_decoded[idx], out.view(out.shape[0], 1, -1)], dim=1)\\r\\n out_cat_onehot = torch.cat(out_cat_onehot, -1)\\r\\n out_cat_embedding = self.unified_encoder.seq_emb_layers(out_cat_onehot)\\r\\n decoded = torch.cat([out_cat_embedding, out_cont], dim=-1)\\r\\n else:\\r\\n decoded = out_cont\\r\\n seq_cont_decoded = torch.cat(\\r\\n [seq_cont_decoded, out_cont.view(out_cont.shape[0], 1, -1)], dim=1)\\r\\n\\r\\n return non_sequential_cont_decoded, non_sequential_cat_decoded, seq_cont_decoded, seq_cat_decoded\",\n \"def encode(music, encoding):\\n # Extract notes\\n notes = extract_notes(music, encoding[\\\"resolution\\\"])\\n\\n # Encode the notes\\n codes = encode_notes(notes, encoding)\\n\\n return codes\",\n \"def encode(self, peptides):\\n raise NotImplementedError\",\n \"def fc_encoder(input_tensor, num_latent, is_training=True):\\n del is_training\\n\\n flattened = tf.layers.flatten(input_tensor)\\n e1 = tf.layers.dense(flattened, 1200, activation=tf.nn.relu, name=\\\"e1\\\")\\n e2 = tf.layers.dense(e1, 1200, activation=tf.nn.relu, name=\\\"e2\\\")\\n means = tf.layers.dense(e2, num_latent, activation=None)\\n log_var = tf.layers.dense(e2, num_latent, activation=None)\\n return means, log_var\",\n \"def _encode(self, sentence: str, **kwargs) -> Sequence[int]:\\r\\n return NotImplemented\",\n \"def encode(input_: list):\\n global n_bytes\\n block = bytearray()\\n\\n for tup in input_:\\n arr = np.array(tup[0], dtype=tup[1]).tobytes()\\n n_bytes += len(arr)\\n block += arr\\n\\n return block\",\n \"def encode(self, x, encode_params, name=None):\\n values = [x] + list(encode_params)\\n with tf.compat.v1.name_scope(name, 'gather_encoder_encode', values):\\n x = tf.convert_to_tensor(x)\\n encode_params = tf.nest.map_structure(tf.convert_to_tensor, encode_params)\\n return self._encode_fn(x, encode_params)\",\n \"def forward(self, *args):\\r\\n enc_src, src_mask, src_inp = self.unified_encoder(*args)\\r\\n batch_size, _, hid_dim = src_inp.shape\\r\\n device = src_inp.device\\r\\n # enc_src = [batch size, src len, hid dim]\\r\\n # src_mask = [batch size, src len]\\r\\n\\r\\n trg_inp = torch.cat((torch.zeros((batch_size, 1, hid_dim), device=device), src_inp[:, :-1, :]), 1)\\r\\n decoder_output, attention = self.decoder(trg_inp, enc_src, src_mask)\\r\\n\\r\\n # decoder_output = [batch size, trg len, hid dim]\\r\\n # attention = [batch size, n heads, trg len, src len]\\r\\n\\r\\n outputs = self.output_layer(decoder_output)\\r\\n\\r\\n return outputs, attention\",\n \"def get_encoded(self):\\n pass\",\n \"def _preorder_encode(self):\\n features = np.expand_dims(self.get_features(), axis=0)\\n\\n features = np.pad(features, (1, 0),\\n 'constant', constant_values=(0, 0))\\n return features.transpose(1, 0), np.array([[1], [0], [0]])\",\n \"def encode(self, C, num_rows):\\n x = np.zeros((num_rows, len(self.chars)))\\n print(C)\\n for i, c in enumerate(C):\\n x[i, self.char_indices[c]] = 1\\n return x\",\n \"def encode(self, features, training=True):\\n conditioning = self.preprocessor(features, training=training)\\n return conditioning if self.encoder is None else self.encoder(conditioning)\",\n \"def encode(\\n self,\\n speech: torch.Tensor,\\n speech_lengths: torch.Tensor,\\n return_int_enc: bool = False,\\n ) -> Tuple[torch.Tensor, torch.Tensor]:\\n with autocast(False):\\n # 1. Extract feats\\n feats, feats_lengths = self._extract_feats(speech, speech_lengths)\\n\\n # 2. Data augmentation\\n if self.specaug is not None and self.training:\\n feats, feats_lengths = self.specaug(feats, feats_lengths)\\n\\n # 3. Normalization for feature: e.g. Global-CMVN, Utterance-CMVN\\n if self.normalize is not None:\\n feats, feats_lengths = self.normalize(feats, feats_lengths)\\n\\n # Pre-encoder, e.g. used for raw input data\\n if self.preencoder is not None:\\n feats, feats_lengths = self.preencoder(feats, feats_lengths)\\n\\n # 4. Forward encoder\\n # feats: (Batch, Length, Dim)\\n # -> encoder_out: (Batch, Length2, Dim2)\\n encoder_out, encoder_out_lens, _ = self.encoder(feats, feats_lengths)\\n\\n if return_int_enc:\\n int_encoder_out, int_encoder_out_lens = encoder_out, encoder_out_lens\\n\\n if self.hier_encoder is not None:\\n encoder_out, encoder_out_lens, _ = self.hier_encoder(\\n encoder_out, encoder_out_lens\\n )\\n\\n # Post-encoder, e.g. NLU\\n if self.postencoder is not None:\\n encoder_out, encoder_out_lens = self.postencoder(\\n encoder_out, encoder_out_lens\\n )\\n\\n assert encoder_out.size(0) == speech.size(0), (\\n encoder_out.size(),\\n speech.size(0),\\n )\\n assert encoder_out.size(1) <= encoder_out_lens.max(), (\\n encoder_out.size(),\\n encoder_out_lens.max(),\\n )\\n\\n if return_int_enc:\\n return encoder_out, encoder_out_lens, int_encoder_out, int_encoder_out_lens\\n return encoder_out, encoder_out_lens\",\n \"def encode(self, strs):\",\n \"def encode(self, strs):\",\n \"def build_encoder_bi(tparams, options):\\n\\t# word embedding (source)\\n\\tembedding = tensor.tensor3('embedding', dtype='float32')\\n\\tembeddingr = embedding[::-1]\\n\\tx_mask = tensor.matrix('x_mask', dtype='float32')\\n\\txr_mask = x_mask[::-1]\\n\\n\\t# encoder\\n\\tproj = get_layer(options['encoder'])[1](tparams, embedding, options,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprefix='encoder',\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tmask=x_mask)\\n\\tprojr = get_layer(options['encoder'])[1](tparams, embeddingr, options,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t prefix='encoder_r',\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t mask=xr_mask)\\n\\n\\tctx = tensor.concatenate([proj[0][-1], projr[0][-1]], axis=1)\\n\\n\\treturn embedding, x_mask, ctx\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7359279","0.715711","0.7042397","0.6925385","0.67847055","0.6707564","0.6687429","0.66821134","0.66587514","0.6600888","0.65923876","0.65555626","0.6519889","0.64369076","0.6398737","0.634382","0.6303421","0.6291561","0.6290792","0.6282953","0.6275337","0.6252939","0.6219135","0.6195956","0.6169169","0.6124843","0.6099138","0.60956365","0.60705626","0.60550237","0.60416496","0.6023","0.6013378","0.600595","0.6002354","0.59940517","0.59903085","0.5959689","0.5934759","0.5934739","0.59281695","0.5925495","0.5913472","0.5899694","0.5890449","0.5872524","0.58717966","0.58628213","0.58605456","0.58595616","0.5848908","0.5836769","0.58365905","0.58360267","0.58338404","0.5832428","0.5802086","0.5792962","0.5777082","0.57691807","0.5766234","0.5764153","0.5746581","0.57401145","0.57362723","0.57283217","0.57283217","0.572438","0.57200867","0.57098866","0.56893116","0.5678348","0.5678348","0.5672189","0.5665993","0.566392","0.56618863","0.56571335","0.5654625","0.5654487","0.564942","0.5645199","0.5641888","0.5640664","0.5638739","0.5636977","0.5632416","0.5620002","0.56154037","0.5614368","0.5611237","0.5608959","0.55964833","0.5592544","0.55840427","0.5577304","0.55725896","0.5565979","0.5565979","0.5546461"],"string":"[\n \"0.7359279\",\n \"0.715711\",\n \"0.7042397\",\n \"0.6925385\",\n \"0.67847055\",\n \"0.6707564\",\n \"0.6687429\",\n \"0.66821134\",\n \"0.66587514\",\n \"0.6600888\",\n \"0.65923876\",\n \"0.65555626\",\n \"0.6519889\",\n \"0.64369076\",\n \"0.6398737\",\n \"0.634382\",\n \"0.6303421\",\n \"0.6291561\",\n \"0.6290792\",\n \"0.6282953\",\n \"0.6275337\",\n \"0.6252939\",\n \"0.6219135\",\n \"0.6195956\",\n \"0.6169169\",\n \"0.6124843\",\n \"0.6099138\",\n \"0.60956365\",\n \"0.60705626\",\n \"0.60550237\",\n \"0.60416496\",\n \"0.6023\",\n \"0.6013378\",\n \"0.600595\",\n \"0.6002354\",\n \"0.59940517\",\n \"0.59903085\",\n \"0.5959689\",\n \"0.5934759\",\n \"0.5934739\",\n \"0.59281695\",\n \"0.5925495\",\n \"0.5913472\",\n \"0.5899694\",\n \"0.5890449\",\n \"0.5872524\",\n \"0.58717966\",\n \"0.58628213\",\n \"0.58605456\",\n \"0.58595616\",\n \"0.5848908\",\n \"0.5836769\",\n \"0.58365905\",\n \"0.58360267\",\n \"0.58338404\",\n \"0.5832428\",\n \"0.5802086\",\n \"0.5792962\",\n \"0.5777082\",\n \"0.57691807\",\n \"0.5766234\",\n \"0.5764153\",\n \"0.5746581\",\n \"0.57401145\",\n \"0.57362723\",\n \"0.57283217\",\n \"0.57283217\",\n \"0.572438\",\n \"0.57200867\",\n \"0.57098866\",\n \"0.56893116\",\n \"0.5678348\",\n \"0.5678348\",\n \"0.5672189\",\n \"0.5665993\",\n \"0.566392\",\n \"0.56618863\",\n \"0.56571335\",\n \"0.5654625\",\n \"0.5654487\",\n \"0.564942\",\n \"0.5645199\",\n \"0.5641888\",\n \"0.5640664\",\n \"0.5638739\",\n \"0.5636977\",\n \"0.5632416\",\n \"0.5620002\",\n \"0.56154037\",\n \"0.5614368\",\n \"0.5611237\",\n \"0.5608959\",\n \"0.55964833\",\n \"0.5592544\",\n \"0.55840427\",\n \"0.5577304\",\n \"0.55725896\",\n \"0.5565979\",\n \"0.5565979\",\n \"0.5546461\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65906525"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":88359,"cells":{"query":{"kind":"string","value":"r\"\"\"Maps the given latent codes onto the image space."},"document":{"kind":"string","value":"def decode(self, z):\n result = self.decoder_input(z)\n result = result.view(-1, 512, 4, 4)\n result = self.decoder(result)\n return result"},"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 preprocess(self, latent_codes, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')","def prepare_map(self):\n for y_coord, row in enumerate(self.contents):\n for x_coord, tile in enumerate(row):\n bit_map = self.get_tile_bitmap(tile)\n self.image[y_coord * TILE_SIZE:(y_coord+1) * TILE_SIZE,\n x_coord * TILE_SIZE:(x_coord+1) * TILE_SIZE] = bit_map","def map():","def prepare_map(self):\n for y, row in enumerate(self.contents):\n for x, tile in enumerate(row):\n bm = self.get_tile(tile)\n self.image[\n y * TILE_SIZE : (y + 1) * TILE_SIZE,\n x * TILE_SIZE : (x + 1) * TILE_SIZE,\n ] = bm","def mapped(center_pt, mapping):\n if center_pt != None:\n center_pt[0] = int(center_pt[0] * mapping[0] / 512.)\n center_pt[1] = int(center_pt[1] * mapping[1] / 512.)\n return [center_pt[1], center_pt[0]]\n else:\n return None","def apply_tiles(self, code: str) -> 'ImageCollection':\n\n process_id = 'apply_tiles'\n args = {\n 'imagery':self.graph,\n 'code':{\n 'language':'python',\n 'source':code\n }\n }\n\n return self.graph_add_process(process_id, args)","def apply_tiles(self, code: str) -> 'ImageCollection':\n\n process_id = 'apply_tiles'\n args = {\n 'imagery':self.graph,\n 'code':{\n 'language':'python',\n 'source':code\n }\n }\n\n return self.graph_add_process(process_id, args)","def adjust_map(map_, n_codes):\n assert np.size(map_, 1) <= n_codes, \"Map does not fit in number of codes\"\n margin = n_codes - np.size(map_, 1)\n left = margin // 2\n right = margin - left\n return np.concatenate((map_[:, 0:1, :],)*left + (map_,) + (map_[:,-1:, :],)*right, axis=1)","def _standard_mapping(self):\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\n self.camvidMap = mapping_raw['camvidMap'] * 255\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255","def map_constructor(self):\n self.island_map = self.island_map.split('\\n')\n\n for n in range(len(self.island_map)):\n self.island_map[n] = \\\n [character for character in self.island_map[n]]\n\n self.construct_map_coordinates()","def plotCode(code):\n # rescale features\n mincode = np.amin(code)\n maxcode = np.amax(code)\n print('Min: ', mincode, 'Max: ', maxcode)\n code = (code - mincode) / (maxcode - mincode)\n # create output image\n sh = np.shape(code)\n W = sh[0]\n H = sh[1]\n out = np.zeros((3*(W+2)-2, 5*(H+2)-2))\n # copy each feature in out\n for w in range(0,3):\n for h in range(0,5):\n c = w*5 + h\n out[w*(W+2):w*(W+2)+W, h*(H+2):h*(H+2)+H] = code[:,:,c]\n return out","def img_map(ts):\n image_map = \"\"\n texdata = bpy.data.textures[ts.texture]\n if ts.mapping == \"FLAT\":\n image_map = \"map_type 0 \"\n elif ts.mapping == \"SPHERE\":\n image_map = \"map_type 1 \"\n elif ts.mapping == \"TUBE\":\n image_map = \"map_type 2 \"\n\n # map_type 3 and 4 in development (?) (ENV in pov 3.8)\n # for POV-Ray, currently they just seem to default back to Flat (type 0)\n # elif ts.mapping==\"?\":\n # image_map = \" map_type 3 \"\n # elif ts.mapping==\"?\":\n # image_map = \" map_type 4 \"\n if ts.use_interpolation: # Available if image sampling class reactivated?\n image_map += \" interpolate 2 \"\n if texdata.extension == \"CLIP\":\n image_map += \" once \"\n # image_map += \"}\"\n # if ts.mapping=='CUBE':\n # image_map+= \"warp { cubic } rotate <-90,0,180>\"\n # no direct cube type mapping. Though this should work in POV 3.7\n # it doesn't give that good results(best suited to environment maps?)\n # if image_map == \"\":\n # print(\" No texture image found \")\n return image_map","def recreate_image(codebook, labels, w, h):\n d = codebook.shape[1]\n image = np.zeros((w, h, d))\n label_idx = 0 # 第几个原始图像的像素点\n for i in range(w):\n for j in range(h):\n # 获取原始数据像素点对应的类别中心点坐标\n # 再根据中心点坐标获取对应的像素值\n image[i][j] = codebook[labels[label_idx]]\n label_idx += 1\n return image","def _maping(x,y,l,a):\n newx = (x**2 *(l* ((x**2 + y**2)**(a/2) - 1) + 2) - l * y**2 *((x**2 + y**2)**(a/2) - 1))/(x**2 + y**2) \n newy = (2 * x* y *(l* ((x**2 + y**2)**(a/2) - 1) + 1))/(x**2 + y**2)\n return newx, newy","def map(inputs, e0,e1,k):\r\n codebook = tf.cast(inputs[0][0:2 ** k], tf.float32)\r\n soft_map = tf.TensorArray(tf.float32, size=0, dynamic_size=True)\r\n for y in inputs[1]:\r\n Pxy_map = pyx(y, codebook, e0, e1)\r\n soft_map = soft_map.write(soft_map.size(), Pxy_map)\r\n\r\n soft_map = soft_map.stack()\r\n return soft_map","def _gather_latent_codes(self,\n latent_code_type: str = 'train'\n ) -> Sequence[tf.Tensor]:\n if latent_code_type == 'train':\n codes_use = self.codes_train_data\n elif latent_code_type == 'test':\n codes_use = self.codes_test_data\n\n if (self._mode == 'fully_multi_level' and\n self._encoder_mode == 'input_enc+f2c'):\n if self._latent_optim_target == 'code_grid_enc':\n codes_each_level = []\n for i in range(len(codes_use)):\n codes_each_level.append(\n tf.reshape(codes_use[i](0), [1, *self.code_grid_enc_shape[i]]))\n\n return codes_each_level","def relabel_with_map_array(image, label_list, measurement_list):\n from skimage.util import map_array\n return map_array(np.asarray(image), np.asarray(label_list), np.array(measurement_list))","def img_map_transforms(ts):\n # XXX TODO: unchecked textures give error of variable referenced before assignment XXX\n # POV-Ray \"scale\" is not a number of repetitions factor, but ,its\n # inverse, a standard scale factor.\n # 0.5 Offset is needed relatively to scale because center of the\n # scale is 0.5,0.5 in blender and 0,0 in POV\n # Strange that the translation factor for scale is not the same as for\n # translate.\n # TODO: verify both matches with other blender renderers / internal in previous versions.\n image_map_transforms = \"\"\n image_map_transforms = \"scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>\" % (\n ts.scale[0],\n ts.scale[1],\n ts.scale[2],\n ts.offset[0],\n ts.offset[1],\n ts.offset[2],\n )\n # image_map_transforms = (\" translate <-0.5,-0.5,0.0> scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>\" % \\\n # ( 1.0 / ts.scale.x,\n # 1.0 / ts.scale.y,\n # 1.0 / ts.scale.z,\n # (0.5 / ts.scale.x) + ts.offset.x,\n # (0.5 / ts.scale.y) + ts.offset.y,\n # ts.offset.z))\n # image_map_transforms = (\n # \"translate <-0.5,-0.5,0> \"\n # \"scale <-1,-1,1> * <%.4g,%.4g,%.4g> \"\n # \"translate <0.5,0.5,0> + <%.4g,%.4g,%.4g>\" % \\\n # (1.0 / ts.scale.x,\n # 1.0 / ts.scale.y,\n # 1.0 / ts.scale.z,\n # ts.offset.x,\n # ts.offset.y,\n # ts.offset.z)\n # )\n return image_map_transforms","def transform(self,image,landmarks,s0=None):\n if s0 is None:\n s0 = np.array([[127.6475, 227.8161], [79.1608, 87.0376], [176.8392, 87.0376]], np.float32)\n idx = [8,36,45] #\"\"\"Anchor points\"\"\"\n pts = np.float32(landmarks[idx,:])\n M = cv2.getAffineTransform(pts,s0)\n dst = cv2.warpAffine(image, M, (256,256))\n return dst","def register_landmarks(fname_src, fname_dest, dof, fname_affine='affine.txt', verbose=1, path_qc='./'):\n from msct_image import Image\n # open src label\n im_src = Image(fname_src)\n # coord_src = im_src.getNonZeroCoordinates(sorting='value') # landmarks are sorted by value\n coord_src = im_src.getCoordinatesAveragedByValue() # landmarks are sorted by value\n # open dest labels\n im_dest = Image(fname_dest)\n # coord_dest = im_dest.getNonZeroCoordinates(sorting='value')\n coord_dest = im_dest.getCoordinatesAveragedByValue()\n # Reorganize landmarks\n\n points_src, points_dest = [], []\n for coord in coord_src:\n point_src = im_src.transfo_pix2phys([[coord.x, coord.y, coord.z]])\n # convert NIFTI to ITK world coordinate\n # points_src.append([point_src[0][0], point_src[0][1], point_src[0][2]])\n points_src.append([-point_src[0][0], -point_src[0][1], point_src[0][2]])\n for coord in coord_dest:\n point_dest = im_dest.transfo_pix2phys([[coord.x, coord.y, coord.z]])\n # convert NIFTI to ITK world coordinate\n # points_dest.append([point_dest[0][0], point_dest[0][1], point_dest[0][2]])\n points_dest.append([-point_dest[0][0], -point_dest[0][1], point_dest[0][2]])\n\n # display\n sct.printv('Labels src: ' + str(points_src), verbose)\n sct.printv('Labels dest: ' + str(points_dest), verbose)\n sct.printv('Degrees of freedom (dof): ' + dof, verbose)\n\n if len(coord_src) != len(coord_dest):\n raise Exception('Error: number of source and destination landmarks are not the same, so landmarks cannot be paired.')\n\n # estimate transformation\n # N.B. points_src and points_dest are inverted below, because ITK uses inverted transformation matrices, i.e., src->dest is defined in dest instead of src.\n # (rotation_matrix, translation_array, points_moving_reg, points_moving_barycenter) = getRigidTransformFromLandmarks(points_dest, points_src, constraints=dof, verbose=verbose, path_qc=path_qc)\n (rotation_matrix, translation_array, points_moving_reg, points_moving_barycenter) = getRigidTransformFromLandmarks(points_src, points_dest, constraints=dof, verbose=verbose, path_qc=path_qc)\n # writing rigid transformation file\n # N.B. x and y dimensions have a negative sign to ensure compatibility between Python and ITK transfo\n text_file = open(fname_affine, 'w')\n text_file.write(\"#Insight Transform File V1.0\\n\")\n text_file.write(\"#Transform 0\\n\")\n text_file.write(\"Transform: AffineTransform_double_3_3\\n\")\n text_file.write(\"Parameters: %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f\\n\" % (\n rotation_matrix[0, 0], rotation_matrix[0, 1], rotation_matrix[0, 2],\n rotation_matrix[1, 0], rotation_matrix[1, 1], rotation_matrix[1, 2],\n rotation_matrix[2, 0], rotation_matrix[2, 1], rotation_matrix[2, 2],\n translation_array[0, 0], translation_array[0, 1], translation_array[0, 2]))\n text_file.write(\"FixedParameters: %.9f %.9f %.9f\\n\" % (points_moving_barycenter[0],\n points_moving_barycenter[1],\n points_moving_barycenter[2]))\n text_file.close()","def inv_projmap(self, img, nside=None):\n pass","def generate_latent_points(noise_dim, code_dim, n_samples, available_codes, training_noise_dict):\r\n codes = np.array([np.random.choice(available_codes) for i in range(n_samples)])\r\n codes = codes.reshape((n_samples, code_dim))\r\n z_noise = []\r\n for i in range(n_samples):\r\n z_noise.append(np.random.choice(training_noise_dict[codes[i][0]]))\r\n z_noise = np.array(z_noise).reshape((n_samples, 1))\r\n z_input = np.hstack((z_noise, codes))\r\n return z_input","def _pixel_to_map(coordinates, geotransform):\n coordinates_map = np.empty(coordinates.shape)\n coordinates_map[..., 0] = (\n geotransform[0]\n + geotransform[1] * coordinates[..., 0]\n + geotransform[2] * coordinates[..., 1]\n )\n coordinates_map[..., 1] = (\n geotransform[3]\n + geotransform[4] * coordinates[..., 0]\n + geotransform[5] * coordinates[..., 1]\n )\n return coordinates_map","def make_maps_of_2x1_pix_coordinates (sp) : \n x_rhs = np.arange(sp.colsh)*sp.pixs + sp.pixw - sp.pixsh\n x_rhs[0] = sp.pixwh # set x-coordinate of the wide pixel \n x_arr = np.hstack([-x_rhs[::-1],x_rhs])\n\n y_arr = np.arange(sp.rows) * sp.pixs\n y_arr -= y_arr[-1]/2 # move origin to the center of array\n\n sp.x_map2x1, sp.y_map2x1 = np.meshgrid(x_arr, y_arr)","def gm2code(arr, info):\n return (arr / info.pboxsize + 0.5)# * 0.999783599","def fun_location(self, l1_xpos, l1_xscale):\n const_1 = self.tik_instance.Tensor(\"float32\", (8, 8),\n name=\"const_1\",\n scope=tik.scope_ubuf)\n const_0 = self.tik_instance.Tensor(\"float32\", (8, 8),\n name=\"const_0\",\n scope=tik.scope_ubuf)\n index_256 = self.tik_instance.Tensor(\"float32\", (256, 8),\n name=\"index_256\",\n scope=tik.scope_ubuf)\n self.tik_instance.vector_dup(MASK, const_1, float(1), 1, 1, 8)\n self.tik_instance.vector_dup(MASK, const_0, 0, 1, 1, 8)\n int32_256_ub = self.tik_instance.Tensor(\"int32\", (256, 8),\n name=\"int32_256_ub\",\n scope=tik.scope_ubuf)\n scale_512_x = self.tik_instance.Tensor(\"float32\", (512, 8),\n name=\"scale_512_x\",\n scope=tik.scope_ubuf)\n const_weight = self.tik_instance.Tensor(\"float32\", (8, 8),\n name=\"const_weight\",\n scope=tik.scope_ubuf)\n self.tik_instance.vector_dup(MASK, const_weight, float(self.weight_in), 1, 1, 8)\n #x zuobiao\n with self.tik_instance.for_range(0, self.w_in_loop) as w_index:\n with self.tik_instance.for_range(0, 256) as num_index:\n self.tik_instance.vector_dup(8, index_256[num_index*8],\n w_index*256+num_index, 1, 1, 8)\n if self.half_pixel_centers:\n self.tik_instance.vadds(MASK, index_256, index_256, float(0.5),\n 32, 1, 1, 8, 8)\n self.tik_instance.vmuls(MASK, scale_512_x, index_256, float(self.weight_out),\n 32, 1, 1, 8, 8)\n self.tik_instance.vdiv(MASK, scale_512_x, scale_512_x, const_weight,\n 32, 1, 1, 1, 8, 8, 0)\n if self.half_pixel_centers:\n self.tik_instance.vadds(MASK, scale_512_x, scale_512_x, float(-0.5),\n 32, 1, 1, 8, 8)\n self.tik_instance.vmax(MASK, scale_512_x[0], scale_512_x[0], const_0[0],\n 32, 1, 1, 1, 8, 8, 0)\n self.tik_instance.vconv(MASK, \"floor\", int32_256_ub[0],\n scale_512_x[0], 32, 1, 1, 8, 8)\n self.tik_instance.vconv(MASK, \"\", scale_512_x[2048],\n int32_256_ub[0], 32, 1, 1, 8, 8)\n self.tik_instance.data_move(l1_xpos[w_index*256*8], int32_256_ub[0],\n 0, 1, 256, 0, 0)\n self.tik_instance.vsub(MASK, scale_512_x[2048],\n scale_512_x[0], scale_512_x[2048],\n 32, 1, 1, 1, 8, 8, 8)\n self.tik_instance.vsub(MASK, scale_512_x[0],\n const_1[0], scale_512_x[2048],\n 32, 1, 1, 1, 8, 0, 8)\n self.tik_instance.data_move(l1_xscale[w_index*512*8],\n scale_512_x[0], 0, 1, 512, 0, 0)","def applyMapping(self):\n pass","def apply_spherical_map(img_src, mapping, output_res=(360, 640), f_fill=np.mean):\n (y_map, x_map), (fill_y_l, fill_x_l, nonzeros_l) = mapping\n\n transfo_img = np.zeros(output_res) + 128\n transfo_img[y_map, x_map] = img_src.flatten()\n\n for y, x, nonz in zip(fill_y_l, fill_x_l, nonzeros_l):\n transfo_img[y, x] = f_fill(transfo_img[nonz])\n return transfo_img","def map(self):\r\n pass","def map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\n\n latent_coords = []\n\n for batch in data_sample:\n # run encoder\n coords = model.encoder(batch)\n latent_coords.append(coords)\n\n # return latent (per jet?)\n return np.concatenate(latent_coords, axis=0)","def easy_synthesize(self, latent_codes, **kwargs):\n outputs = self.synthesize(latent_codes, **kwargs)\n if 'image' in outputs:\n outputs['image'] = self.postprocess(outputs['image'])\n return outputs","def _do_mapping(self):\n pass","def _putCode(self, code):\n assert(type(code) == int)\n self.code[self.codeptr] = code\n self.codeptr += 1","def wrapper_map_v2(self, train):\n\n def _func(data):\n img, label = data['image'], data['label']\n image_bytes = tf.image.encode_jpeg(img)\n image_1 = imagenet_preprocess_image(\n image_bytes, is_training=train, image_size=self.image_size)\n if train:\n image_2 = imagenet_preprocess_image(\n image_bytes,\n is_training=train,\n image_size=self.image_size,\n autoaugment_name='v0',\n use_cutout=True)\n images = tf.concat(\n [tf.expand_dims(image_1, 0),\n tf.expand_dims(image_2, 0)], axis=0)\n else:\n images = image_1\n return images, label\n\n return _func","def array_to_island(self):\n\n array_map = self.string_to_array()\n array_shape = np.shape(array_map) # type: tuple\n\n nested = list(np.zeros(array_shape))\n for i, e in enumerate(nested):\n nested[i] = list(e)\n\n for i in range(array_shape[0]):\n for j in range(array_shape[1]):\n if array_map[i, j] == 'J':\n nested[i][j] = Jungle()\n elif array_map[i, j] == 'S':\n nested[i][j] = Savannah()\n elif array_map[i, j] == 'D':\n nested[i][j] = Desert()\n elif array_map[i, j] == 'O':\n nested[i][j] = Ocean()\n elif array_map[i, j] == 'M':\n nested[i][j] = Mountain()\n else:\n raise SyntaxError(\"Island geography multi-line string \"\n \"must only have these letters: \"\n \"'J', 'S', 'D', 'O', 'M'\")\n\n self.cells = np.array(nested)","def geocode(df, col):\r\n pass","def field_map(ar_field, ar_coorx, ar_coory, X, picture_out, title, flip=0):\n max_val=max(ar_field)\n\n xmin=min(ar_coorx);xmax=max(ar_coorx)\n ymin=min(ar_coory);ymax=max(ar_coory)\n step=X\n nx=(xmax-xmin)/step+1\n ny=(ymax-ymin)/step+1\n\n ar_indx=np.array((ar_coorx-xmin)/step,int)\n ar_indy=np.array((ar_coory-ymin)/step,int)\n\n ar_map=np.ones((ny,nx))*-99.9\n ar_map[ar_indy,ar_indx]=ar_field\n\n if flip==1:\n ar_map=np.flipud(ar_map)\n\n ar_map2 = ma.masked_where(ar_map <0, ar_map)\n\n\n ut.check_file_exist(picture_out)\n\n pl.clf()\n pl.imshow(ar_map2, interpolation='Nearest',\n origin='lower', vmax=max_val,vmin=0)\n\n pl.title(title)\n pl.colorbar()\n pl.savefig(picture_out)","def uvmap(self, p):\n pass","def __init__(self):\n DetectLandmarks.__init__(self)\n self.red_l = 0\n self.green_l = 0\n self.blue_l = 0\n self.red_e = 0\n self.green_e = 0\n self.blue_e = 0\n self.debug = 0\n self.image = 0\n self.width = 0\n self.height = 0\n self.im_copy = 0\n self.lip_x = []\n self.lip_y = []","def _mappings(self, inputs):\n return self.mapbias + tensor.dot(\n self._factorsX(inputs) * self._factorsY(inputs), self.whf_in.T)","def loc_to_coord(codes):\n def adfilter(codes):\n return re.findall(\"\"\"[a-zA-Z]+, [A-Z]{2}\"\"\", \";\".join(codes))\n\n api_key = \"AIzaSyCxQCjOrHFAf7T-W3vtUYqWkgSFkvMjxN4\"\n\n g = geocoders.GoogleV3(api_key = api_key)\n coords = {\"lat\":[], \"long\":[]}\n for code in adfilter(codes):\n if code != \"\":\n try:\n place = g.geocode(code)\n if place != None:\n coords[\"lat\"].append(place.latitude)\n coords[\"long\"].append(place.longitude)\n except (exc.GeocoderTimedOut, exc.GeocoderQueryError):\n pass\n return coords","def _set_mapper(self, classification_dict):\n d = {class_code: class_index for class_index, class_code in enumerate(classification_dict.keys())}\n # Here we update the dict so that code 65 remains unchanged.\n # Indeed, 65 is reserved for noise/artefacts points, that will be deleted by transform \"DropPointsByClass\".\n d.update({65: 65})\n self.mapper = np.vectorize(lambda class_code: d.get(class_code))","def _makeimap(self):\n self.map_[\"source\"] = \"nasa\"\n self.map_[\"instrument\"] = \"goes\"\n self.map_[\"physobs\"] = \"irradiance\"\n self.map_[\"provider\"] = \"sdac\"","def recreate_image(codebook, labels, w, h, d):\r\n image = np.zeros((w, h, d))\r\n label_idx = 0\r\n for i in range(w):\r\n for j in range(h):\r\n image[i][j] = codebook[labels[label_idx]]\r\n label_idx += 1\r\n return image","def data_mapping(image, statistics, method):\n if method == \"normalize\":\n image = transforms.Normalize( statistics[\"mapped_mean\"] , \n statistics[\"mapped_std\"] )(image) \n elif method == \"map_zero_one\":\n for ch in range(image.shape[0]):\n a = statistics[\"lower_bound\"][ch]\n b = statistics[\"upper_bound\"][ch]\n image[ch,:,:] = map_zero_one(image[ch,:,:], a, b)\n elif method == \"map_minus_one_to_one\":\n for ch in range(image.shape[0]):\n a = statistics[\"lower_bound\"][ch]\n b = statistics[\"upper_bound\"][ch]\n image[ch,:,:] = map_minus_one_to_one(image[ch,:,:], a, b)\n else:\n raise Exception('Wrong mapping function')\n return image","def __init__(self, island_map):\n self.map = island_map\n self.cells = None\n self.array_to_island()\n self.herbivores_on_island = None\n self.carnivores_on_island = None","def _makeimap(self):\n self.map_['source'] = 'GOES'\n self.map_['provider'] = 'NOAA'\n self.map_['instrument'] = 'SUVI'\n self.map_['physobs'] = 'flux'","def encode_labelmap(colour_img, colourlabelmap):\n colour_img = colour_img.astype(int)\n labels = np.zeros((colour_img.shape[0], colour_img.shape[1]), dtype=np.int16)\n for label_id, colour in enumerate(colourlabelmap):\n labels[np.where(np.all(colour == colour_img, axis=-1))] = label_id\n\n return labels","def recreate_image(codebook, labels, w, h):\n d = codebook.shape[1]\n image = np.zeros((w, h, d))\n label_idx = 0\n for i in range(w):\n for j in range(h):\n image[i][j] = codebook[labels[label_idx]]\n label_idx += 1\n return image","def _preprocessing(mask, mapping, image) -> np.ndarray:\n # TODO: Turn mapping into generic function.\n processed_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\n processed_image = cv.remap(processed_image, *mapping, cv.INTER_LINEAR)\n processed_image[~mask] = 255\n return processed_image","def _create_naics_map():\n # Read in list of industry topics.\n naics_codes = pd.read_excel(\n \"https://www.census.gov/eos/www/naics/2017NAICS/2-6%20digit_2017_Codes.xlsx\"\n )\n naics_codes = naics_codes.iloc[:, [1, 2]]\n naics_codes.columns = ['NAICSCode', 'Title']\n\n # Replace all ranges with individual rows. E.g. 31-33 -> 31, 32, 33.\n def range_to_array(read_code):\n if isinstance(read_code, str) and \"-\" in read_code:\n lower, upper = read_code.split(\"-\")\n return list(range(int(lower), int(upper) + 1))\n return read_code\n\n naics_codes = naics_codes.dropna()\n naics_codes['NAICSCode'] = naics_codes['NAICSCode'].apply(range_to_array)\n naics_codes = naics_codes.explode('NAICSCode')\n\n # Add unclassified code which is used in some statistical variables.\n naics_codes = naics_codes.append(\n {\n \"NAICSCode\": 99,\n \"Title\": \"Nonclassifiable\"\n }, ignore_index=True)\n\n # Query for only two digit codes.\n short_codes = naics_codes[naics_codes['NAICSCode'] < 100]\n short_codes = short_codes.set_index(\"NAICSCode\")\n short_codes = short_codes['Title'].to_dict()\n\n # Read in overview codes.\n overview_codes = pd.read_csv(\n \"https://data.bls.gov/cew/doc/titles/industry/high_level_industries.csv\"\n )\n overview_codes.columns = [\"NAICSCode\", \"Title\"]\n overview_codes = overview_codes.set_index(\"NAICSCode\")\n overview_codes = overview_codes['Title'].to_dict()\n\n # Combine the two sources of codes.\n NAICS_MAP = {}\n combined_codes = short_codes\n combined_codes.update(overview_codes)\n\n # Rename industries into Pascal case.\n for code, orig_name in combined_codes.items():\n NAICS_MAP[str(code)] = standard_name_remapper(orig_name)\n\n # Other edge cases.\n NAICS_MAP['00'] = 'Unclassified'\n return NAICS_MAP","def recreate_image(codebook, labels, w, h):\n d = codebook.shape[1]\n image = np.zeros((w, h, d))\n label_idx = 0\n for i in range(w):\n for j in range(h):\n image[i][j] = codebook[int(labels[label_idx])]\n label_idx += 1\n return image","def projLocMap2Glob(loc_map,car_pos_in_loc_map,x,y,heading):\n c = int((loc_map.shape[0]**2+loc_map.shape[1]**2)**(1/2)) #pytago\n I = np.zeros((c,c))\n r1 = (c-loc_map.shape[0])//2\n c1 = (c-loc_map.shape[1])//2\n I[r1:r1+loc_map.shape[0],c1:c1+loc_map.shape[1]] = loc_map #place it in the middle\n\n car_pos_in_imgR = [c1+c//2,r1+c//2]\n imgR = rotateImage(loc_map,heading,car_pos_in_imgR)\n plt.figure()\n plt.imshow(imgR)\n plt.show()\n\n global obst_map\n #TODO add it in obst_map\n return car_pos_in_imgR#np.zeros(obst_map.shape[:2])[x*RES,y*RES]","def getLocalMap(dist_compl):\n sdc=dist_compl*RES\n #clms are real ;)\n #rws are imaginary :D #rows\n map_padd = 1*RES #add a meter\n rws_ofs = abs(sdc.imag.min())+map_padd #offsetX\n rws = abs(sdc.imag.max())+(rws_ofs)\n clms_ofs = abs(sdc.real.min())+map_padd\n clms = abs(sdc.real.max())+(clms_ofs)\n M = np.zeros((np.round(rws+map_padd).astype(int),np.round(clms+map_padd).astype(int))).astype(dtype=MAP_D_TYPE)#empty local map\n Mg = M.copy()\n points = sdc + np.array([clms_ofs+1j*rws_ofs]) #scale\n #M[points.imag.astype(int),points.real.astype(int)]=10 \n for p in points:\n r=np.round(p.imag).astype(int)\n c=np.round(p.real).astype(int)\n try:\n #draw line in matrix\n lc = [np.round(rws_ofs).astype(int),np.round(clms_ofs).astype(int),r,c]\n rr, cc, val = line_aa(*lc) #not really demaning --> 1%\n M[rr, cc] = np.logical_or(M[rr,cc]>0, val>0) \n #add gaussian\n Mg[r-GPoints//2:r+GPoints//2,c-GPoints//2:c+GPoints//2]+=Gau\n except:\n print('Error: out of array when calculating the local map',r,c)\n Mg[Mg>100]=100 #cap the gaussian matrix\n car_pos_in_loc_mat = np.array([np.round(clms_ofs).astype(int), np.round(rws_ofs).astype(int)])\n #Mg[car_pos_in_loc_mat[1],car_pos_in_loc_mat[0]]=300 #add car pos\n return M*(-100)+Mg, car_pos_in_loc_mat","def recreate_image(codebook, labels, w, h):\n d = codebook.shape[1]\n image = np.zeros((w, h, d))\n label_idx = 0\n for i in range(w):\n for j in range(h):\n image[i][j] = codebook[labels[label_idx]]\n label_idx += 1\n return image","def __scale_and_shift(self, image, landmarks, scale_range, output_size):\n (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h) = self.get_bbox_of_landmarks(\n image, landmarks, scale_range, shift_rate=0.3)\n box_image = image[y1:y2, x1:x2]\n if need_pad:\n box_image = np.lib.pad(box_image, ((p_y, p_h), (p_x, p_w), (0, 0)), 'constant')\n box_image = cv2.resize(box_image, (output_size, output_size))\n landmarks = (landmarks - (x1 - p_x, y1 - p_y)) / (new_size, new_size)\n return box_image, landmarks","def align(img, landmarks, d_size=(400, 400), normalized=False, show=False):\n assert len(landmarks) == 10\n assert isinstance(img, np.ndarray)\n landmarks = np.array(landmarks).reshape(5, 2)\n dw, dh = d_size\n\n keypoints = landmarks.copy().astype(np.float64)\n if normalized:\n keypoints[:, 0] *= img.shape[1]\n keypoints[:, 1] *= img.shape[0]\n\n keypoints_ref = np.zeros((5, 2), dtype=np.float64)\n keypoints_ref[:, 0] = FivePointsAligner.ref_landmarks[:, 0] * dw\n keypoints_ref[:, 1] = FivePointsAligner.ref_landmarks[:, 1] * dh\n\n transform_matrix = transformation_from_points(keypoints_ref, keypoints)\n output_im = cv.warpAffine(img, transform_matrix, d_size, flags=cv.WARP_INVERSE_MAP)\n\n if show:\n tmp_output = output_im.copy()\n for point in keypoints_ref:\n cv.circle(tmp_output, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\n for point in keypoints:\n cv.circle(img, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\n img = cv.resize(img, d_size)\n cv.imshow('source/warped', np.hstack((img, tmp_output)))\n cv.waitKey()\n\n return output_im","def process_map_img(self, map, height, width, dtype=np.int8):\n img_in = np.array(map, dtype=np.uint8).reshape(height, width)\n img = img_in.copy()\n\n # NOTE(CH3): We might not need to do this conversion...\n img[(img_in == self.free_ros)] = self.free_img\n img[(img_in == self.unknown_ros)] = self.unknown_img\n img[(img_in == self.obstacle_ros)] = self.obstacle_img\n\n # Isolate layers\n free_mask = cv2.inRange(img, self.free_img, self.free_img)\n unknown_mask = cv2.inRange(img, self.unknown_img, self.unknown_img)\n obstacle_mask = cv2.inRange(img, self.obstacle_img, self.obstacle_img)\n\n # Process free layer\n if self.process_free:\n free_mask = cv2.erode(free_mask, self.kernel, iterations=self.iters)\n free_mask = cv2.dilate(free_mask, self.kernel, iterations=self.iters)\n\n # if True: # erode_free\n # free_mask = cv2.erode(free_mask, self.kernel, iterations=3)\n\n # Construct new map img\n new_img = make_img(img.shape, (self.unknown_ros), dtype=dtype)\n new_img[(free_mask != 0)] = self.free_ros\n new_img[(obstacle_mask != 0)] = self.obstacle_ros\n\n return new_img","def recreate_image(codebook, labels, w, h):\r\n d = codebook.shape[1]\r\n image = np.zeros((w, h, d))\r\n label_idx = 0\r\n for i in range(w):\r\n for j in range(h):\r\n image[i][j] = codebook[labels[label_idx]]\r\n label_idx += 1\r\n return image","def map_loc_to_pixel((x, y), xc = 17.25, yc = 630, run = 17.25):\n xp, yp = xc + x*run, yc - y*run\n return (xp, yp)","def map_property(self, linc):\n sleep(1)\n linc = '{}'.format(linc).zfill(10)\n self.driver.switch_to_frame('fOpts')\n select_box = Select(self.driver.find_element_by_id('Finds_lstFindTypes'))\n select_box.select_by_visible_text('Linc Number')\n linc_box = self.driver.find_element_by_id('Finds_ctlLincNumber_txtLincNumber')\n linc_box.clear()\n linc_box.send_keys(linc)\n self.driver.find_element_by_id('Finds_cmdSubmit').click()\n if self.spatial_count == 0:\n sleep(8)\n sleep(4)\n self.driver.switch_to_default_content()\n if self.spatial_count == 0:\n try:\n e = WebDriverWait(self.driver, 10).until(\n EC.presence_of_element_located((By.ID, 'map'))\n )\n except:\n self.driver.refresh()\n self.driver.switch_to_default_content()\n e = WebDriverWait(self.driver, 60).until(\n EC.presence_of_element_located((By.ID, 'map'))\n )\n hover_target = self.driver.find_element_by_id('map')\n if self.spatial_count == 0:\n sleep(5)\n map_location = hover_target.location\n map_size = hover_target.size\n filename = 'data/sites/{}.png'.format(linc)\n self.driver.save_screenshot(filename)\n x = map_location['x'] + 50\n y = map_location['y']\n width = map_location['x'] + map_size['width'] - 50\n height = map_location['y'] + map_size['height']\n im = Image.open(filename)\n im = im.crop((int(x), int(y), int(width), int(height)))\n im.save(filename)\n if self.spatial_count == 0:\n sleep(5)\n ActionChains(self.driver).move_to_element(hover_target).drag_and_drop_by_offset(hover_target, 1, 1).perform()\n if self.spatial_count == 0:\n sleep(5)\n nad83_raw = self.driver.find_element_by_id('coordinateOutput').text\n nad83 = tuple(re.findall(r\"[0-9\\.\\-]+\", nad83_raw))\n gps = Geography().nad83(nad83, reverse=True)\n gpsr = (gps[1], gps[0])\n self.spatial_count += 1\n return gpsr","def __init__(self, island_map):\n self.island_map = island_map\n self.landscape_dict = {'M': Mountain,\n 'O': Ocean,\n 'J': Jungle,\n 'S': Savannah,\n 'D': Desert}","def map_to_mgi(adata, copy = False):\n from pybiomart import Server\n # connest to the biomart server\n server = Server(host='http://www.ensembl.org')\n\n # retrieve the mouse data set we need\n dataset = (server.marts['ENSEMBL_MART_ENSEMBL']\n .datasets['mmusculus_gene_ensembl'])\n\n # recieve the mapping from ensembl to MGI\n conv_table = dataset.query(attributes=['ensembl_gene_id', 'external_gene_name'])\n\n # we first drop duplicates in the first column\n conv_table = conv_table.drop_duplicates(conv_table.columns.values[0])\n\n # convert the gene names from the adata object to a data frame\n adata_table = pd.DataFrame(adata.var_names)\n\n # give the first column a name\n adata_table.columns = ['Gene stable ID']\n\n # change the gene table so that the ensembl names are now the index\n conv_table = conv_table.set_index('Gene stable ID')\n\n # project the names from the conversion table on the corr. names in the\n # adata var names table\n mapping = adata_table.join(conv_table, on='Gene stable ID')\n\n # how many could we not map\n not_found_mgi = sum(pd.isnull(mapping).iloc[:,1])\n\n # how many ensg symbols did we map several times?\n rep_ensg = len(mapping.iloc[:, 0]) - len(set(mapping.iloc[:, 0]))\n\n # how many mgi symbols did we map several times?\n rep_mgi = len(mapping.iloc[:, 1]) - len(set(mapping.iloc[:, 1]))\n\n # print this information\n print('Genes where no MGI annotations where found: {}\\nENSG repetition: {}\\nMGI repetition: {}'.\\\n format(not_found_mgi, rep_ensg, rep_mgi))\n\n # fill nans in mgi column with corresponding ensembl annotations\n mapping['Gene name'].fillna(mapping['Gene stable ID'], inplace = True)\n\n # add the new gene names to the adata object\n adata.var['mgi_symbols'] = mapping['Gene name'].tolist()","def map(self, lat, long):\r\n rxy = self._r*np.sqrt(1-np.cos(lat))\r\n x = rxy*np.cos(long)\r\n y = rxy*np.sin(long)\r\n return (x, y)","def decode(codes, dictionary):\n c, d = dictionary.shape\n codes = codes.reshape(-1, c)\n \n return np.dot(codes, dictionary)","def map(self,Affine,i):\n map_x = np.zeros([self.num,self.d])\n for k in range(self.num):\n map_x[k,:] = Affine.apply(i,self.pick(k))\n Mapped = Model_Points(map_x)\n return Mapped","def mapping(nside, angs):\n\n\tnpix = hp.nside2npix(nside)\n\tmaph = np.zeros(npix)\n\n\tpix = hp.ang2pix(nside, angs[:, 1], angs[:, 0])\n\tvals, times = np.unique(pix, return_counts=True)\n\n\tmaph[vals] = times\n\tmaph *= float(npix)/len(angs)\n\n\treturn maph","def remap(\n image: Tensor,\n map_x: Tensor,\n map_y: Tensor,\n mode: str = 'bilinear',\n padding_mode: str = 'zeros',\n align_corners: bool | None = None,\n normalized_coordinates: bool = False,\n) -> Tensor:\n KORNIA_CHECK_SHAPE(image, [\"B\", \"C\", \"H\", \"W\"])\n KORNIA_CHECK_SHAPE(map_x, [\"B\", \"H\", \"W\"])\n KORNIA_CHECK_SHAPE(map_y, [\"B\", \"H\", \"W\"])\n\n batch_size, _, height, width = image.shape\n\n # grid_sample need the grid between -1/1\n map_xy: Tensor = stack([map_x, map_y], -1)\n\n # normalize coordinates if not already normalized\n if not normalized_coordinates:\n map_xy = normalize_pixel_coordinates(map_xy, height, width)\n\n # simulate broadcasting since grid_sample does not support it\n map_xy = map_xy.expand(batch_size, -1, -1, -1)\n\n # warp the image tensor and return\n return F.grid_sample(image, map_xy, mode=mode, padding_mode=padding_mode, align_corners=align_corners)","def _interpolate_codes_at_points(\n self, code_grid: tf.Tensor, points: tf.Tensor,\n level: int) -> Tuple[tf.Tensor, tf.Tensor, Dict[str, tf.Tensor]]:\n if self._num_point_dim == 2:\n _, code_grid_h, code_grid_w, _ = code_grid.shape\n _, num_point, _ = points.shape\n\n # Get grid indices of each point.\n grid_indices = grid_utils.get_grid_index(points, self._grid_shape[level],\n self._grid_range_min,\n self._grid_side_length[level],\n self._grid_mode)\n # Tensor with shape [batch_size, num_point, num_point_dim].\n\n # Normalize point coordinates within each grid.\n points_normalize = grid_utils.normalize_point_coord(\n points, self._grid_centers[level], self._grid_side_length[level],\n grid_indices)\n\n # Renormalize point coordinates to the spatial resolution of code grid.\n points_renormalize = grid_utils.normalize_point_coord(\n points, self._grid_centers[0], self._grid_side_length[0],\n tf.zeros_like(grid_indices))\n points_renormalize = points_renormalize * 0.5 + 0.5 # Map to [0, 1].\n points_renormalize = points_renormalize * tf.constant(\n [code_grid_h - 1, code_grid_w - 1], dtype=tf.float32)[None, None, :]\n # Tensor with shape [batch_size, num_point, num_point_dim].\n\n # Interpolate codes from code_grid.\n if code_grid_h == 1 and code_grid_w == 1:\n codes_for_points = tf.tile(code_grid[:, 0, ...], [1, num_point, 1])\n else:\n codes_for_points = tfa_image.interpolate_bilinear(\n code_grid, points_renormalize, indexing='xy')\n # Tensor with shape [batch_size, num_point, code_grid_c].\n\n elif self._num_point_dim == 3:\n _, code_grid_d, code_grid_h, code_grid_w, _ = code_grid.shape\n num_point = tf.shape(points)[1]\n\n if self._grid_shape[level] != [1, 1, 1]:\n raise NotImplementedError('Grid shape must be [1, 1, 1].')\n else:\n points_normalize = points\n\n # Renormalize point coordinates to the spatial resolution of code grid,\n # after which points should be in the range of [-1, 1].\n points_renormalize = points * 0.5 + 0.5 # Map to [0, 1].\n points_renormalize = points_renormalize * tf.constant(\n [code_grid_d - 1, code_grid_h - 1, code_grid_w - 1],\n dtype=tf.float32)[None, None, :]\n\n # Interpolate codes from code_grid. Output tensor is with shape\n # [batch_size, num_point, code_grid_c].\n if code_grid_d == 1 and code_grid_h == 1 and code_grid_w == 1:\n codes_for_points = tf.tile(code_grid[:, 0, 0, ...], [1, num_point, 1])\n else:\n # The dimensions of code_grid should be [batch_size, code_grid_d,\n # code_grid_h, code_grid_w, code_grid_c]. The dimensions of\n # points_renormalize should be [batch_size, num_point, num_point_dim],\n # and the order of coordinates should be (z, y, x).\n codes_for_points = tfg_trilinear.interpolate(code_grid,\n points_renormalize)\n\n debug_data = {}\n debug_data['points_normalize'] = points_normalize\n debug_data['points_renormalize'] = points_renormalize\n debug_data['latent_codes'] = tf.concat(\n [codes_for_points[..., :3], codes_for_points[..., -3:]], axis=-1)\n\n return codes_for_points, points_normalize, debug_data","def geotif_image(self, tile_bounds, image_bounds, imagepath,image_gdal):\n i_srid=3857\n s_srid=\"WGS 84 / Pseudo-Mercator\"\n # i_srid=3395\n # s_srid=\"WGS 84 / World Mercator\"\n # 4326 Wsg84\n # Upper Left ( -8.4375000, 77.1571625) ( 8d26'15.00\"W, 77d 9'25.79\"N)\n # Lower Left ( -8.4375000, 35.4606700) ( 8d26'15.00\"W, 35d27'38.41\"N)\n # Upper Right ( 80.1562500, 77.1571625) ( 80d 9'22.50\"E, 77d 9'25.79\"N)\n # Lower Right ( 80.1562500, 35.4606700) ( 80d 9'22.50\"E, 35d27'38.41\"N)\n # Center ( 35.8593750, 56.3089162) ( 35d51'33.75\"E, 56d18'32.10\"N)\n # 3857 'WGS 84 / Pseudo-Mercator'\n # Upper Left ( -939258.204,13932330.020) ( 8d26'15.00\"W, 77d 9'25.79\"N)\n # Lower Left ( -939258.204, 4226661.916) ( 8d26'15.00\"W, 35d27'38.41\"N)\n # Upper Right ( 8922952.934,13932330.020) ( 80d 9'22.50\"E, 77d 9'25.79\"N)\n # Lower Right ( 8922952.934, 4226661.916) ( 80d 9'22.50\"E, 35d27'38.41\"N)\n # Center ( 3991847.365, 9079495.968) ( 35d51'33.75\"E, 62d54'54.84\"N)\n # 3395 'WGS 84 / World Mercator'\n # Upper Left ( -939258.204,13932330.020) ( 8d26'15.00\"W, 77d14'24.81\"N)\n # Lower Left ( -939258.204, 4226661.916) ( 8d26'15.00\"W, 35d38'33.56\"N)\n # Upper Right ( 8922952.934,13932330.020) ( 80d 9'22.50\"E, 77d14'24.81\"N)\n # Lower Right ( 8922952.934, 4226661.916) ( 80d 9'22.50\"E, 35d38'33.56\"N)\n # Center ( 3991847.365, 9079495.968) ( 35d51'33.75\"E, 63d 4'14.87\"N)\n bounds_west,bounds_south,bounds_east,bounds_north=tile_bounds\n bounds_wsg84=\"bounds_wsg84: %f,%f,%f,%f\"% (bounds_west,bounds_south,bounds_east,bounds_north)\n mercator = GlobalMercator()\n tile_bounds=mercator.BoundsToMeters(tile_bounds)\n mbtiles_name=\"\";\n mbtiles_description=\"\"\n s_TIFFTAG_DOCUMENTNAME=\"\"\n s_TIFFTAG_IMAGEDESCRIPTION=\"\"\n s_TIFFTAG_SOFTWARE=\"\"\n s_TIFFTAG_DATETIME=\"\"\n s_TIFFTAG_ARTIST=\"\"\n s_TIFFTAG_HOSTCOMPUTER=\"\"\n s_TIFFTAG_COPYRIGHT=\"\"\n if self.metadata_input:\n metadata=dict(self.metadata_input)\n mbtiles_name=metadata.get('name','')\n mbtiles_description=metadata.get('description','')\n if self._metadata:\n for metadata_list in self._metadata:\n metadata=dict(metadata_list[0])\n mbtiles_name=metadata.get('name',mbtiles_name)\n mbtiles_description=metadata.get('description',mbtiles_description)\n s_TIFFTAG_DOCUMENTNAME=metadata.get('TIFFTAG_DOCUMENTNAME',mbtiles_name)\n s_TIFFTAG_IMAGEDESCRIPTION=metadata.get('TIFFTAG_IMAGEDESCRIPTION',mbtiles_description)\n s_TIFFTAG_SOFTWARE=metadata.get('TIFFTAG_SOFTWARE','')\n s_TIFFTAG_DATETIME=metadata.get('TIFFTAG_DATETIME','')\n s_TIFFTAG_ARTIST=metadata.get('TIFFTAG_ARTIST','')\n s_TIFFTAG_HOSTCOMPUTER=metadata.get('TIFFTAG_HOSTCOMPUTER','')\n s_TIFFTAG_COPYRIGHT=metadata.get('TIFFTAG_COPYRIGHT','')\n if s_TIFFTAG_DOCUMENTNAME == \"\":\n s_TIFFTAG_DOCUMENTNAME=mbtiles_name\n if s_TIFFTAG_IMAGEDESCRIPTION == \"\":\n s_TIFFTAG_IMAGEDESCRIPTION=mbtiles_description\n tiff_metadata=[]\n if s_TIFFTAG_DOCUMENTNAME != \"\":\n tiff_metadata.append(('TIFFTAG_DOCUMENTNAME',s_TIFFTAG_DOCUMENTNAME))\n if s_TIFFTAG_IMAGEDESCRIPTION != \"\":\n tiff_metadata.append(('TIFFTAG_IMAGEDESCRIPTION',s_TIFFTAG_IMAGEDESCRIPTION))\n if s_TIFFTAG_SOFTWARE != \"\":\n tiff_metadata.append(('TIFFTAG_SOFTWARE',s_TIFFTAG_SOFTWARE))\n else:\n tiff_metadata.append(('TIFFTAG_SOFTWARE',bounds_wsg84))\n if s_TIFFTAG_DATETIME != \"\":\n tiff_metadata.append(('TIFFTAG_DATETIME',s_TIFFTAG_DATETIME))\n if s_TIFFTAG_ARTIST != \"\":\n tiff_metadata.append(('TIFFTAG_ARTIST',s_TIFFTAG_ARTIST))\n if s_TIFFTAG_HOSTCOMPUTER != \"\":\n tiff_metadata.append(('TIFFTAG_HOSTCOMPUTER',s_TIFFTAG_HOSTCOMPUTER))\n if s_TIFFTAG_COPYRIGHT != \"\":\n tiff_metadata.append(('TIFFTAG_COPYRIGHT',s_TIFFTAG_COPYRIGHT))\n # this assumes the projection is Geographic lat/lon WGS 84\n xmin,ymin,xmax,ymax=tile_bounds\n image_width,image_height=image_bounds\n # Upper Left ( 20800.000, 22000.000)\n # Lower Right ( 24000.000, 19600.000)\n # Size is 15118, 11339\n # (24000-20800)/15118 = 3200 = 0,21166821 [xres]\n # (19600-22000)/11339 = 2400 = −0,211658876 [yres]\n # geo_transform = (20800.0, 0.2116682100807, 0.0, 22000.0, 0.0, -0.21165887644413)\n geo_transform = [xmin, (xmax-xmin)/image_width, 0, ymax, 0, (ymin-ymax)/image_height ]\n spatial_projection = osr.SpatialReference()\n spatial_projection.ImportFromEPSG(i_srid)\n logger.info(_(\"-I-> geotif_image: Saving as GeoTiff - image[%s] compression[%s]\") % (imagepath,self.tiff_compression))\n image_dataset = gdal.Open(image_gdal, gdal.GA_Update )\n image_dataset.SetProjection(spatial_projection.ExportToWkt())\n image_dataset.SetGeoTransform(geo_transform)\n driver = gdal.GetDriverByName(\"GTiff\")\n output_dataset = driver.CreateCopy(imagepath,image_dataset, 0, self.tiff_compression )\n if tiff_metadata:\n logger.info(_(\"-I-> geotif_image: tiff_metadata[%s]\") % tiff_metadata)\n output_dataset.SetMetadata(dict(tiff_metadata))\n # Once we're done, close properly the dataset\n output_dataset = None\n image_dataset = None\n os.remove(image_gdal)\n logger.info(_(\"-I-> geotif_image: Saved resulting image to '%s' as GeoTiff- bounds[%s]\") % (imagepath,tile_bounds))","def loadCode(self,code,startNum):\r\n\t\tself.frame.loadCode(code,startNum)","def generate_xmap(x_len, y_len, all_cids, all_xcoords, all_ycoords):\r\n # Determine figure height and width\"\"\"\r\n img_height = x_len * 80\r\n img_width = y_len * 80\r\n\r\n # Write html script which allows for mouseover of labels\r\n xmap = []\r\n for cid, x, y in zip(all_cids, all_xcoords, all_ycoords):\r\n xmap.append(AREA_SRC % (x, img_height - y, cid, cid))\r\n\r\n return xmap, img_height, img_width","def __call__(self, map_in: np.ndarray) -> np.ndarray:\n return hp.map2alm(maps=map_in, lmax=self.n_max, use_weights=self.use_weights, verbose=self.verbose)","def _map_fn(self):\n raise NotImplementedError","def get_lat_long(self, postcodes):\n # Fix evil postcodes\n postcodes = clean_postcodes(postcodes)\n\n postcode_df = self.postcode_df\n postcode_df = postcode_df.fillna('np.nan')\n postcode_df = postcode_df.set_index('Postcode')\n index_data = postcode_df.loc[postcodes]\n lat = np.array(index_data['Latitude']).T\n lng = np.array(index_data['Longitude']).T\n\n return np.vstack((lat, lng)).transpose()","def create_mapping(project, img):\n with BMI(_username, _password, project) as bmi:\n ret = bmi.mount_image(img)\n if ret[constants.STATUS_CODE_KEY] == 200:\n click.echo('Success')\n else:\n click.echo(ret[constants.MESSAGE_KEY])","def forward_code_map(self):\n\n return { c.key:c.value for c in self.codes}","def process_coords():\n split_coords = row[\"map_coord\"].split(',')\n map_x, map_y = [int(i) for i in split_coords]\n map_x_normed = ((map_x*2) / self.MINIMAP_DIM) - 1\n map_y_normed = -(((map_y*2) / self.MINIMAP_DIM) - 1)\n return map_x_normed, map_y_normed","def convert(self, lat, lon):\r\n a = self.a\r\n b = self.b\r\n long0 = self.long0\r\n k0 = self.k0\r\n dx = self.dx\r\n\r\n e = (1 - b ** 2 / a ** 2) ** 0.5\r\n e2 = e ** 2 / (1 - e ** 2)\r\n n = (a - b) / (a + b)\r\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\r\n p = lon - long0\r\n\r\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\r\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\r\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\r\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\r\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\r\n\r\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\r\n\r\n K1 = S * k0\r\n K2 = k0 * nu * sin(2 * lat)/4.0\r\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\r\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\r\n\r\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\r\n\r\n K4 = k0 * nu * cos(lat)\r\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\r\n\r\n x = K4 * p + K5 * (p ** 3) + dx\r\n return x, y","def pintarIMAGENENMAPA(self, pos):\n # Agrego al vector que controla las images\n k = (pos[0], pos[1], \"img\"+str(self.idIMG))\n # Si deseo pintar una silla\n if self.queIMGAgregar == 1:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgSilla, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar una mesa\n if self.queIMGAgregar == 2:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgMesa, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Se deseo pintar una nevera\n if self.queIMGAgregar == 3:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgNevera, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar una cama\n if self.queIMGAgregar == 4:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgCama, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar un sofa\n if self.queIMGAgregar == 5:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgSofa, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar tv\n if self.queIMGAgregar == 6:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgTV, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar lampara\n if self.queIMGAgregar == 7:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgLampara, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar planta\n if self.queIMGAgregar == 8:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgPlanta, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar sanitario\n if self.queIMGAgregar == 9:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgSanitario, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar lavamanos\n if self.queIMGAgregar == 10:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgLavamanos, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1\n\n # Si deseo pintar la ducha\n if self.queIMGAgregar == 11:\n self.telaMAPA.create_image(k[0], k[1], image=self.imgDucha, tag=k[2])\n # Como fue agregado un elemento en el mapa procedo a registrarlo\n self.cotroladoraIMGREG.append(k)\n # Como una img fue agregada procedo a aumentar el id\n self.idIMG = self.idIMG + 1","def geo_transform(self):\n pass","def mapPsf(self, locn):\n\n x = (locn[1] - self.output_center) * self.rescale + self.input_center\n y = (locn[0] - self.output_center) * self.rescale + self.input_center\n\n return (y, x)","def map_picture(the_map, p):\n xy = (p.location[0] - 2, p.location[1] + 2)\n map_coords = []\n for y in range(0, 5):\n row = [(xy[0] + x, xy[1] - y) for x in range(0, 5)]\n map_coords.append(row)\n\n pretty_map = []\n for r in map_coords:\n row = []\n for coordinates in r:\n if coordinates in the_map.keys():\n if p.quest and p.job and p.quest[1] == coordinates and p.job.location == coordinates:\n star = '*$ '\n elif p.quest and p.quest[1] == coordinates:\n star = ' * '\n elif p.job and p.job.location == coordinates:\n star = ' $ '\n else:\n star = ' '\n row.append(\"|{!s:9}{}|\".format(the_map[coordinates].square_type, star))\n else:\n row.append(\"|{!s:12}|\".format(' '))\n pretty_map.append(row)\n for row in pretty_map:\n print(''.join(row))","def map(self, function):\n pass","def apply_remap_values(labels: np.ndarray, label_map: Dict[int, int]) -> np.ndarray:\n for l1, l2 in label_map.items():\n labels[labels == l1] = l2","def make_label_map(path, label_list):\r\n \r\n img = []\r\n for name in path:\r\n now = np.zeros((224,224))\r\n im = cv2.resize(cv2.imread(name), (224,224)).tolist()\r\n for y, i in enumerate(im):\r\n for x, j in enumerate(i):\r\n try:\r\n now[y, x] = label_list.index(j)\r\n\r\n except ValueError:\r\n now[y, x] = 0\r\n\r\n img.append(now)\r\n return img","def lensedImage(self, source, scale, xl=8., yl=4., gamma=0.):\n image, magMap = lens(self.ltype, self.dist, source, self.x01, self.x02, xl, yl, gamma)\n\n return image, magMap","def terrainEncoded(self, request, result):\n pass","def setreferencecode(self, *args, **kwargs):\n return _coordsys.coordsys_setreferencecode(self, *args, **kwargs)","def convertLatLongToPixels(mapImg, leftLongitude, rightLongitude, topLatitude, bottomLatitude, latLong):\n latitude = min(max(latLong[0], bottomLatitude), topLatitude)\n longitude = min(max(latLong[1], leftLongitude), rightLongitude)\n\n diffLat = topLatitude - bottomLatitude\n diffLong = rightLongitude - leftLongitude\n\n pixelX = (longitude - leftLongitude)/diffLong*mapImg.size[0]\n pixelX = max(min(pixelX, mapImg.size[0] - 1), 0)\n pixelY = mapImg.size[1] - (latitude - bottomLatitude)/diffLat*mapImg.size[1]\n pixelY = max(min(pixelY, mapImg.size[1] - 1), 0)\n return (pixelX, pixelY)","def transform_images(img1,img2):","def ds_map(n_caps, n_refs, n_codes, differential=False):\n\n p_map = pipe_map(n_caps, n_refs, differential)\n return adjust_map(p_map, n_codes)","def map(z):\n pass","def create_map(width, height, pixels):\n\n\n\n\n def index_to_xy(i, width, height):\n \"\"\" Takes 0 based index going line wise from top\n left to bottom right, returns x, y coordinates so\n that 0,0 is on bottom left corner\n \"\"\"\n x = i % width\n y = i // width\n y*= -1\n y+= height - 1\n return (x,y)\n\n def place_terrain(type, i):\n \"\"\"This won't return anything, just do side effects\n\n The object \"gameLogic\" is used to place the object\n initially. It doesn't matter where this object is,\n as long as it exists. There must be an easier way,\n but this works.\n \"\"\"\n x,y = index_to_xy(i, width, height)\n\n object_name = terrain_types.get(type, \"water\")\n\n if ob[\"fast_create\"] > 0 and not (x%ob[\"fast_create\"] == 0 and y%ob[\"fast_create\"] == 0):\n return\n\n if object_name != \"water\":\n object = scene.addObject(object_name, \"gameLogic\")\n object.worldPosition = (x,y,0)\n\n\n list(map( (lambda tup : place_terrain(tup[1], tup[0])), list(enumerate(pixels)) ))","def map(self, lat, long):\r\n r1 = self._r1\r\n r2 = self._r2\r\n direction = self._direction\r\n\r\n return self.map_aux(lat, long, direction, r1, r2)","def map(self, lat, long):\r\n rxy = self._r*lat/(np.pi/2)\r\n x = rxy*np.cos(long)\r\n y = rxy*np.sin(long)\r\n return (x, y)","def run_genomemap(args):\n genome_map(args)","def pointToWorld( nImageX, nImageY, rDepth, rMaxX = 320, rMaxY = 240, rFieldOfViewX = 60, rFieldOfViewY = 40 ):\n # convert to [-0.5,0.5]\n rCenteredX = ( nImageX / rMaxX ) - 0.5;\n rCenteredY = ( nImageY / rMaxY ) - 0.5;","def flag_regional_indicator(code: List[str]) -> str:\r\n\r\n return \"\".join([chr(ord(c.upper()) + OFFSET) for c in code])","def map_coordinates(self,geometry):\n\t\tg = self.geomatrix\n\t\tdef project_coord(x,y,z=None):\n\t\t\tx = g[0] + g[1] * x + g[2] * y\n\t\t\ty = g[3] + g[4] * x + g[5] * y\n\t\t\tif z is None:\n\t\t\t\treturn x,y\n\t\t\telse:\n\t\t\t\treturn x,y,z\n\t\treturn transform(project_coord, geometry)","def map_image(map_dict):\n import PIL.Image\n\n map_palette = [\n (0, 0, 0), # special-cased to transparent in the code below\n (125, 176, 55),\n (244, 230, 161),\n (197, 197, 197),\n (252, 0, 0),\n (158, 158, 252),\n (165, 165, 165),\n (0, 123, 0),\n (252, 252, 252),\n (162, 166, 182),\n (149, 108, 76),\n (111, 111, 111),\n (63, 63, 252),\n (141, 118, 71),\n (252, 249, 242),\n (213, 125, 50),\n (176, 75, 213),\n (101, 151, 213),\n (226, 226, 50),\n (125, 202, 25),\n (239, 125, 163),\n (75, 75, 75),\n (151, 151, 151),\n (75, 125, 151),\n (125, 62, 176),\n (50, 75, 176),\n (101, 75, 50),\n (101, 125, 50),\n (151, 50, 50),\n (25, 25, 25),\n (247, 235, 76),\n (91, 216, 210),\n (73, 129, 252),\n (0, 214, 57),\n (21, 20, 31),\n (112, 2, 0),\n (127, 85, 48)\n ]\n ret = PIL.Image.new('RGBA', (map_dict['data']['width'], map_dict['data']['height']), color=(0, 0, 0, 0))\n for i, color in enumerate(map_dict['data']['colors']):\n y, x = divmod(i, map_dict['data']['width'])\n base_color, color_variant = divmod(color, 4)\n if base_color == 0:\n continue\n color = tuple(round(palette_color * [180, 220, 255, 135][color_variant] / 255) for palette_color in map_palette[base_color]) + (255,)\n ret.putpixel((x, y), color)\n return ret"],"string":"[\n \"def preprocess(self, latent_codes, **kwargs):\\n raise NotImplementedError(f'Should be implemented in derived class!')\",\n \"def prepare_map(self):\\n for y_coord, row in enumerate(self.contents):\\n for x_coord, tile in enumerate(row):\\n bit_map = self.get_tile_bitmap(tile)\\n self.image[y_coord * TILE_SIZE:(y_coord+1) * TILE_SIZE,\\n x_coord * TILE_SIZE:(x_coord+1) * TILE_SIZE] = bit_map\",\n \"def map():\",\n \"def prepare_map(self):\\n for y, row in enumerate(self.contents):\\n for x, tile in enumerate(row):\\n bm = self.get_tile(tile)\\n self.image[\\n y * TILE_SIZE : (y + 1) * TILE_SIZE,\\n x * TILE_SIZE : (x + 1) * TILE_SIZE,\\n ] = bm\",\n \"def mapped(center_pt, mapping):\\n if center_pt != None:\\n center_pt[0] = int(center_pt[0] * mapping[0] / 512.)\\n center_pt[1] = int(center_pt[1] * mapping[1] / 512.)\\n return [center_pt[1], center_pt[0]]\\n else:\\n return None\",\n \"def apply_tiles(self, code: str) -> 'ImageCollection':\\n\\n process_id = 'apply_tiles'\\n args = {\\n 'imagery':self.graph,\\n 'code':{\\n 'language':'python',\\n 'source':code\\n }\\n }\\n\\n return self.graph_add_process(process_id, args)\",\n \"def apply_tiles(self, code: str) -> 'ImageCollection':\\n\\n process_id = 'apply_tiles'\\n args = {\\n 'imagery':self.graph,\\n 'code':{\\n 'language':'python',\\n 'source':code\\n }\\n }\\n\\n return self.graph_add_process(process_id, args)\",\n \"def adjust_map(map_, n_codes):\\n assert np.size(map_, 1) <= n_codes, \\\"Map does not fit in number of codes\\\"\\n margin = n_codes - np.size(map_, 1)\\n left = margin // 2\\n right = margin - left\\n return np.concatenate((map_[:, 0:1, :],)*left + (map_,) + (map_[:,-1:, :],)*right, axis=1)\",\n \"def _standard_mapping(self):\\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\\n self.camvidMap = mapping_raw['camvidMap'] * 255\\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255\",\n \"def map_constructor(self):\\n self.island_map = self.island_map.split('\\\\n')\\n\\n for n in range(len(self.island_map)):\\n self.island_map[n] = \\\\\\n [character for character in self.island_map[n]]\\n\\n self.construct_map_coordinates()\",\n \"def plotCode(code):\\n # rescale features\\n mincode = np.amin(code)\\n maxcode = np.amax(code)\\n print('Min: ', mincode, 'Max: ', maxcode)\\n code = (code - mincode) / (maxcode - mincode)\\n # create output image\\n sh = np.shape(code)\\n W = sh[0]\\n H = sh[1]\\n out = np.zeros((3*(W+2)-2, 5*(H+2)-2))\\n # copy each feature in out\\n for w in range(0,3):\\n for h in range(0,5):\\n c = w*5 + h\\n out[w*(W+2):w*(W+2)+W, h*(H+2):h*(H+2)+H] = code[:,:,c]\\n return out\",\n \"def img_map(ts):\\n image_map = \\\"\\\"\\n texdata = bpy.data.textures[ts.texture]\\n if ts.mapping == \\\"FLAT\\\":\\n image_map = \\\"map_type 0 \\\"\\n elif ts.mapping == \\\"SPHERE\\\":\\n image_map = \\\"map_type 1 \\\"\\n elif ts.mapping == \\\"TUBE\\\":\\n image_map = \\\"map_type 2 \\\"\\n\\n # map_type 3 and 4 in development (?) (ENV in pov 3.8)\\n # for POV-Ray, currently they just seem to default back to Flat (type 0)\\n # elif ts.mapping==\\\"?\\\":\\n # image_map = \\\" map_type 3 \\\"\\n # elif ts.mapping==\\\"?\\\":\\n # image_map = \\\" map_type 4 \\\"\\n if ts.use_interpolation: # Available if image sampling class reactivated?\\n image_map += \\\" interpolate 2 \\\"\\n if texdata.extension == \\\"CLIP\\\":\\n image_map += \\\" once \\\"\\n # image_map += \\\"}\\\"\\n # if ts.mapping=='CUBE':\\n # image_map+= \\\"warp { cubic } rotate <-90,0,180>\\\"\\n # no direct cube type mapping. Though this should work in POV 3.7\\n # it doesn't give that good results(best suited to environment maps?)\\n # if image_map == \\\"\\\":\\n # print(\\\" No texture image found \\\")\\n return image_map\",\n \"def recreate_image(codebook, labels, w, h):\\n d = codebook.shape[1]\\n image = np.zeros((w, h, d))\\n label_idx = 0 # 第几个原始图像的像素点\\n for i in range(w):\\n for j in range(h):\\n # 获取原始数据像素点对应的类别中心点坐标\\n # 再根据中心点坐标获取对应的像素值\\n image[i][j] = codebook[labels[label_idx]]\\n label_idx += 1\\n return image\",\n \"def _maping(x,y,l,a):\\n newx = (x**2 *(l* ((x**2 + y**2)**(a/2) - 1) + 2) - l * y**2 *((x**2 + y**2)**(a/2) - 1))/(x**2 + y**2) \\n newy = (2 * x* y *(l* ((x**2 + y**2)**(a/2) - 1) + 1))/(x**2 + y**2)\\n return newx, newy\",\n \"def map(inputs, e0,e1,k):\\r\\n codebook = tf.cast(inputs[0][0:2 ** k], tf.float32)\\r\\n soft_map = tf.TensorArray(tf.float32, size=0, dynamic_size=True)\\r\\n for y in inputs[1]:\\r\\n Pxy_map = pyx(y, codebook, e0, e1)\\r\\n soft_map = soft_map.write(soft_map.size(), Pxy_map)\\r\\n\\r\\n soft_map = soft_map.stack()\\r\\n return soft_map\",\n \"def _gather_latent_codes(self,\\n latent_code_type: str = 'train'\\n ) -> Sequence[tf.Tensor]:\\n if latent_code_type == 'train':\\n codes_use = self.codes_train_data\\n elif latent_code_type == 'test':\\n codes_use = self.codes_test_data\\n\\n if (self._mode == 'fully_multi_level' and\\n self._encoder_mode == 'input_enc+f2c'):\\n if self._latent_optim_target == 'code_grid_enc':\\n codes_each_level = []\\n for i in range(len(codes_use)):\\n codes_each_level.append(\\n tf.reshape(codes_use[i](0), [1, *self.code_grid_enc_shape[i]]))\\n\\n return codes_each_level\",\n \"def relabel_with_map_array(image, label_list, measurement_list):\\n from skimage.util import map_array\\n return map_array(np.asarray(image), np.asarray(label_list), np.array(measurement_list))\",\n \"def img_map_transforms(ts):\\n # XXX TODO: unchecked textures give error of variable referenced before assignment XXX\\n # POV-Ray \\\"scale\\\" is not a number of repetitions factor, but ,its\\n # inverse, a standard scale factor.\\n # 0.5 Offset is needed relatively to scale because center of the\\n # scale is 0.5,0.5 in blender and 0,0 in POV\\n # Strange that the translation factor for scale is not the same as for\\n # translate.\\n # TODO: verify both matches with other blender renderers / internal in previous versions.\\n image_map_transforms = \\\"\\\"\\n image_map_transforms = \\\"scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>\\\" % (\\n ts.scale[0],\\n ts.scale[1],\\n ts.scale[2],\\n ts.offset[0],\\n ts.offset[1],\\n ts.offset[2],\\n )\\n # image_map_transforms = (\\\" translate <-0.5,-0.5,0.0> scale <%.4g,%.4g,%.4g> translate <%.4g,%.4g,%.4g>\\\" % \\\\\\n # ( 1.0 / ts.scale.x,\\n # 1.0 / ts.scale.y,\\n # 1.0 / ts.scale.z,\\n # (0.5 / ts.scale.x) + ts.offset.x,\\n # (0.5 / ts.scale.y) + ts.offset.y,\\n # ts.offset.z))\\n # image_map_transforms = (\\n # \\\"translate <-0.5,-0.5,0> \\\"\\n # \\\"scale <-1,-1,1> * <%.4g,%.4g,%.4g> \\\"\\n # \\\"translate <0.5,0.5,0> + <%.4g,%.4g,%.4g>\\\" % \\\\\\n # (1.0 / ts.scale.x,\\n # 1.0 / ts.scale.y,\\n # 1.0 / ts.scale.z,\\n # ts.offset.x,\\n # ts.offset.y,\\n # ts.offset.z)\\n # )\\n return image_map_transforms\",\n \"def transform(self,image,landmarks,s0=None):\\n if s0 is None:\\n s0 = np.array([[127.6475, 227.8161], [79.1608, 87.0376], [176.8392, 87.0376]], np.float32)\\n idx = [8,36,45] #\\\"\\\"\\\"Anchor points\\\"\\\"\\\"\\n pts = np.float32(landmarks[idx,:])\\n M = cv2.getAffineTransform(pts,s0)\\n dst = cv2.warpAffine(image, M, (256,256))\\n return dst\",\n \"def register_landmarks(fname_src, fname_dest, dof, fname_affine='affine.txt', verbose=1, path_qc='./'):\\n from msct_image import Image\\n # open src label\\n im_src = Image(fname_src)\\n # coord_src = im_src.getNonZeroCoordinates(sorting='value') # landmarks are sorted by value\\n coord_src = im_src.getCoordinatesAveragedByValue() # landmarks are sorted by value\\n # open dest labels\\n im_dest = Image(fname_dest)\\n # coord_dest = im_dest.getNonZeroCoordinates(sorting='value')\\n coord_dest = im_dest.getCoordinatesAveragedByValue()\\n # Reorganize landmarks\\n\\n points_src, points_dest = [], []\\n for coord in coord_src:\\n point_src = im_src.transfo_pix2phys([[coord.x, coord.y, coord.z]])\\n # convert NIFTI to ITK world coordinate\\n # points_src.append([point_src[0][0], point_src[0][1], point_src[0][2]])\\n points_src.append([-point_src[0][0], -point_src[0][1], point_src[0][2]])\\n for coord in coord_dest:\\n point_dest = im_dest.transfo_pix2phys([[coord.x, coord.y, coord.z]])\\n # convert NIFTI to ITK world coordinate\\n # points_dest.append([point_dest[0][0], point_dest[0][1], point_dest[0][2]])\\n points_dest.append([-point_dest[0][0], -point_dest[0][1], point_dest[0][2]])\\n\\n # display\\n sct.printv('Labels src: ' + str(points_src), verbose)\\n sct.printv('Labels dest: ' + str(points_dest), verbose)\\n sct.printv('Degrees of freedom (dof): ' + dof, verbose)\\n\\n if len(coord_src) != len(coord_dest):\\n raise Exception('Error: number of source and destination landmarks are not the same, so landmarks cannot be paired.')\\n\\n # estimate transformation\\n # N.B. points_src and points_dest are inverted below, because ITK uses inverted transformation matrices, i.e., src->dest is defined in dest instead of src.\\n # (rotation_matrix, translation_array, points_moving_reg, points_moving_barycenter) = getRigidTransformFromLandmarks(points_dest, points_src, constraints=dof, verbose=verbose, path_qc=path_qc)\\n (rotation_matrix, translation_array, points_moving_reg, points_moving_barycenter) = getRigidTransformFromLandmarks(points_src, points_dest, constraints=dof, verbose=verbose, path_qc=path_qc)\\n # writing rigid transformation file\\n # N.B. x and y dimensions have a negative sign to ensure compatibility between Python and ITK transfo\\n text_file = open(fname_affine, 'w')\\n text_file.write(\\\"#Insight Transform File V1.0\\\\n\\\")\\n text_file.write(\\\"#Transform 0\\\\n\\\")\\n text_file.write(\\\"Transform: AffineTransform_double_3_3\\\\n\\\")\\n text_file.write(\\\"Parameters: %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f %.9f\\\\n\\\" % (\\n rotation_matrix[0, 0], rotation_matrix[0, 1], rotation_matrix[0, 2],\\n rotation_matrix[1, 0], rotation_matrix[1, 1], rotation_matrix[1, 2],\\n rotation_matrix[2, 0], rotation_matrix[2, 1], rotation_matrix[2, 2],\\n translation_array[0, 0], translation_array[0, 1], translation_array[0, 2]))\\n text_file.write(\\\"FixedParameters: %.9f %.9f %.9f\\\\n\\\" % (points_moving_barycenter[0],\\n points_moving_barycenter[1],\\n points_moving_barycenter[2]))\\n text_file.close()\",\n \"def inv_projmap(self, img, nside=None):\\n pass\",\n \"def generate_latent_points(noise_dim, code_dim, n_samples, available_codes, training_noise_dict):\\r\\n codes = np.array([np.random.choice(available_codes) for i in range(n_samples)])\\r\\n codes = codes.reshape((n_samples, code_dim))\\r\\n z_noise = []\\r\\n for i in range(n_samples):\\r\\n z_noise.append(np.random.choice(training_noise_dict[codes[i][0]]))\\r\\n z_noise = np.array(z_noise).reshape((n_samples, 1))\\r\\n z_input = np.hstack((z_noise, codes))\\r\\n return z_input\",\n \"def _pixel_to_map(coordinates, geotransform):\\n coordinates_map = np.empty(coordinates.shape)\\n coordinates_map[..., 0] = (\\n geotransform[0]\\n + geotransform[1] * coordinates[..., 0]\\n + geotransform[2] * coordinates[..., 1]\\n )\\n coordinates_map[..., 1] = (\\n geotransform[3]\\n + geotransform[4] * coordinates[..., 0]\\n + geotransform[5] * coordinates[..., 1]\\n )\\n return coordinates_map\",\n \"def make_maps_of_2x1_pix_coordinates (sp) : \\n x_rhs = np.arange(sp.colsh)*sp.pixs + sp.pixw - sp.pixsh\\n x_rhs[0] = sp.pixwh # set x-coordinate of the wide pixel \\n x_arr = np.hstack([-x_rhs[::-1],x_rhs])\\n\\n y_arr = np.arange(sp.rows) * sp.pixs\\n y_arr -= y_arr[-1]/2 # move origin to the center of array\\n\\n sp.x_map2x1, sp.y_map2x1 = np.meshgrid(x_arr, y_arr)\",\n \"def gm2code(arr, info):\\n return (arr / info.pboxsize + 0.5)# * 0.999783599\",\n \"def fun_location(self, l1_xpos, l1_xscale):\\n const_1 = self.tik_instance.Tensor(\\\"float32\\\", (8, 8),\\n name=\\\"const_1\\\",\\n scope=tik.scope_ubuf)\\n const_0 = self.tik_instance.Tensor(\\\"float32\\\", (8, 8),\\n name=\\\"const_0\\\",\\n scope=tik.scope_ubuf)\\n index_256 = self.tik_instance.Tensor(\\\"float32\\\", (256, 8),\\n name=\\\"index_256\\\",\\n scope=tik.scope_ubuf)\\n self.tik_instance.vector_dup(MASK, const_1, float(1), 1, 1, 8)\\n self.tik_instance.vector_dup(MASK, const_0, 0, 1, 1, 8)\\n int32_256_ub = self.tik_instance.Tensor(\\\"int32\\\", (256, 8),\\n name=\\\"int32_256_ub\\\",\\n scope=tik.scope_ubuf)\\n scale_512_x = self.tik_instance.Tensor(\\\"float32\\\", (512, 8),\\n name=\\\"scale_512_x\\\",\\n scope=tik.scope_ubuf)\\n const_weight = self.tik_instance.Tensor(\\\"float32\\\", (8, 8),\\n name=\\\"const_weight\\\",\\n scope=tik.scope_ubuf)\\n self.tik_instance.vector_dup(MASK, const_weight, float(self.weight_in), 1, 1, 8)\\n #x zuobiao\\n with self.tik_instance.for_range(0, self.w_in_loop) as w_index:\\n with self.tik_instance.for_range(0, 256) as num_index:\\n self.tik_instance.vector_dup(8, index_256[num_index*8],\\n w_index*256+num_index, 1, 1, 8)\\n if self.half_pixel_centers:\\n self.tik_instance.vadds(MASK, index_256, index_256, float(0.5),\\n 32, 1, 1, 8, 8)\\n self.tik_instance.vmuls(MASK, scale_512_x, index_256, float(self.weight_out),\\n 32, 1, 1, 8, 8)\\n self.tik_instance.vdiv(MASK, scale_512_x, scale_512_x, const_weight,\\n 32, 1, 1, 1, 8, 8, 0)\\n if self.half_pixel_centers:\\n self.tik_instance.vadds(MASK, scale_512_x, scale_512_x, float(-0.5),\\n 32, 1, 1, 8, 8)\\n self.tik_instance.vmax(MASK, scale_512_x[0], scale_512_x[0], const_0[0],\\n 32, 1, 1, 1, 8, 8, 0)\\n self.tik_instance.vconv(MASK, \\\"floor\\\", int32_256_ub[0],\\n scale_512_x[0], 32, 1, 1, 8, 8)\\n self.tik_instance.vconv(MASK, \\\"\\\", scale_512_x[2048],\\n int32_256_ub[0], 32, 1, 1, 8, 8)\\n self.tik_instance.data_move(l1_xpos[w_index*256*8], int32_256_ub[0],\\n 0, 1, 256, 0, 0)\\n self.tik_instance.vsub(MASK, scale_512_x[2048],\\n scale_512_x[0], scale_512_x[2048],\\n 32, 1, 1, 1, 8, 8, 8)\\n self.tik_instance.vsub(MASK, scale_512_x[0],\\n const_1[0], scale_512_x[2048],\\n 32, 1, 1, 1, 8, 0, 8)\\n self.tik_instance.data_move(l1_xscale[w_index*512*8],\\n scale_512_x[0], 0, 1, 512, 0, 0)\",\n \"def applyMapping(self):\\n pass\",\n \"def apply_spherical_map(img_src, mapping, output_res=(360, 640), f_fill=np.mean):\\n (y_map, x_map), (fill_y_l, fill_x_l, nonzeros_l) = mapping\\n\\n transfo_img = np.zeros(output_res) + 128\\n transfo_img[y_map, x_map] = img_src.flatten()\\n\\n for y, x, nonz in zip(fill_y_l, fill_x_l, nonzeros_l):\\n transfo_img[y, x] = f_fill(transfo_img[nonz])\\n return transfo_img\",\n \"def map(self):\\r\\n pass\",\n \"def map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\\n\\n latent_coords = []\\n\\n for batch in data_sample:\\n # run encoder\\n coords = model.encoder(batch)\\n latent_coords.append(coords)\\n\\n # return latent (per jet?)\\n return np.concatenate(latent_coords, axis=0)\",\n \"def easy_synthesize(self, latent_codes, **kwargs):\\n outputs = self.synthesize(latent_codes, **kwargs)\\n if 'image' in outputs:\\n outputs['image'] = self.postprocess(outputs['image'])\\n return outputs\",\n \"def _do_mapping(self):\\n pass\",\n \"def _putCode(self, code):\\n assert(type(code) == int)\\n self.code[self.codeptr] = code\\n self.codeptr += 1\",\n \"def wrapper_map_v2(self, train):\\n\\n def _func(data):\\n img, label = data['image'], data['label']\\n image_bytes = tf.image.encode_jpeg(img)\\n image_1 = imagenet_preprocess_image(\\n image_bytes, is_training=train, image_size=self.image_size)\\n if train:\\n image_2 = imagenet_preprocess_image(\\n image_bytes,\\n is_training=train,\\n image_size=self.image_size,\\n autoaugment_name='v0',\\n use_cutout=True)\\n images = tf.concat(\\n [tf.expand_dims(image_1, 0),\\n tf.expand_dims(image_2, 0)], axis=0)\\n else:\\n images = image_1\\n return images, label\\n\\n return _func\",\n \"def array_to_island(self):\\n\\n array_map = self.string_to_array()\\n array_shape = np.shape(array_map) # type: tuple\\n\\n nested = list(np.zeros(array_shape))\\n for i, e in enumerate(nested):\\n nested[i] = list(e)\\n\\n for i in range(array_shape[0]):\\n for j in range(array_shape[1]):\\n if array_map[i, j] == 'J':\\n nested[i][j] = Jungle()\\n elif array_map[i, j] == 'S':\\n nested[i][j] = Savannah()\\n elif array_map[i, j] == 'D':\\n nested[i][j] = Desert()\\n elif array_map[i, j] == 'O':\\n nested[i][j] = Ocean()\\n elif array_map[i, j] == 'M':\\n nested[i][j] = Mountain()\\n else:\\n raise SyntaxError(\\\"Island geography multi-line string \\\"\\n \\\"must only have these letters: \\\"\\n \\\"'J', 'S', 'D', 'O', 'M'\\\")\\n\\n self.cells = np.array(nested)\",\n \"def geocode(df, col):\\r\\n pass\",\n \"def field_map(ar_field, ar_coorx, ar_coory, X, picture_out, title, flip=0):\\n max_val=max(ar_field)\\n\\n xmin=min(ar_coorx);xmax=max(ar_coorx)\\n ymin=min(ar_coory);ymax=max(ar_coory)\\n step=X\\n nx=(xmax-xmin)/step+1\\n ny=(ymax-ymin)/step+1\\n\\n ar_indx=np.array((ar_coorx-xmin)/step,int)\\n ar_indy=np.array((ar_coory-ymin)/step,int)\\n\\n ar_map=np.ones((ny,nx))*-99.9\\n ar_map[ar_indy,ar_indx]=ar_field\\n\\n if flip==1:\\n ar_map=np.flipud(ar_map)\\n\\n ar_map2 = ma.masked_where(ar_map <0, ar_map)\\n\\n\\n ut.check_file_exist(picture_out)\\n\\n pl.clf()\\n pl.imshow(ar_map2, interpolation='Nearest',\\n origin='lower', vmax=max_val,vmin=0)\\n\\n pl.title(title)\\n pl.colorbar()\\n pl.savefig(picture_out)\",\n \"def uvmap(self, p):\\n pass\",\n \"def __init__(self):\\n DetectLandmarks.__init__(self)\\n self.red_l = 0\\n self.green_l = 0\\n self.blue_l = 0\\n self.red_e = 0\\n self.green_e = 0\\n self.blue_e = 0\\n self.debug = 0\\n self.image = 0\\n self.width = 0\\n self.height = 0\\n self.im_copy = 0\\n self.lip_x = []\\n self.lip_y = []\",\n \"def _mappings(self, inputs):\\n return self.mapbias + tensor.dot(\\n self._factorsX(inputs) * self._factorsY(inputs), self.whf_in.T)\",\n \"def loc_to_coord(codes):\\n def adfilter(codes):\\n return re.findall(\\\"\\\"\\\"[a-zA-Z]+, [A-Z]{2}\\\"\\\"\\\", \\\";\\\".join(codes))\\n\\n api_key = \\\"AIzaSyCxQCjOrHFAf7T-W3vtUYqWkgSFkvMjxN4\\\"\\n\\n g = geocoders.GoogleV3(api_key = api_key)\\n coords = {\\\"lat\\\":[], \\\"long\\\":[]}\\n for code in adfilter(codes):\\n if code != \\\"\\\":\\n try:\\n place = g.geocode(code)\\n if place != None:\\n coords[\\\"lat\\\"].append(place.latitude)\\n coords[\\\"long\\\"].append(place.longitude)\\n except (exc.GeocoderTimedOut, exc.GeocoderQueryError):\\n pass\\n return coords\",\n \"def _set_mapper(self, classification_dict):\\n d = {class_code: class_index for class_index, class_code in enumerate(classification_dict.keys())}\\n # Here we update the dict so that code 65 remains unchanged.\\n # Indeed, 65 is reserved for noise/artefacts points, that will be deleted by transform \\\"DropPointsByClass\\\".\\n d.update({65: 65})\\n self.mapper = np.vectorize(lambda class_code: d.get(class_code))\",\n \"def _makeimap(self):\\n self.map_[\\\"source\\\"] = \\\"nasa\\\"\\n self.map_[\\\"instrument\\\"] = \\\"goes\\\"\\n self.map_[\\\"physobs\\\"] = \\\"irradiance\\\"\\n self.map_[\\\"provider\\\"] = \\\"sdac\\\"\",\n \"def recreate_image(codebook, labels, w, h, d):\\r\\n image = np.zeros((w, h, d))\\r\\n label_idx = 0\\r\\n for i in range(w):\\r\\n for j in range(h):\\r\\n image[i][j] = codebook[labels[label_idx]]\\r\\n label_idx += 1\\r\\n return image\",\n \"def data_mapping(image, statistics, method):\\n if method == \\\"normalize\\\":\\n image = transforms.Normalize( statistics[\\\"mapped_mean\\\"] , \\n statistics[\\\"mapped_std\\\"] )(image) \\n elif method == \\\"map_zero_one\\\":\\n for ch in range(image.shape[0]):\\n a = statistics[\\\"lower_bound\\\"][ch]\\n b = statistics[\\\"upper_bound\\\"][ch]\\n image[ch,:,:] = map_zero_one(image[ch,:,:], a, b)\\n elif method == \\\"map_minus_one_to_one\\\":\\n for ch in range(image.shape[0]):\\n a = statistics[\\\"lower_bound\\\"][ch]\\n b = statistics[\\\"upper_bound\\\"][ch]\\n image[ch,:,:] = map_minus_one_to_one(image[ch,:,:], a, b)\\n else:\\n raise Exception('Wrong mapping function')\\n return image\",\n \"def __init__(self, island_map):\\n self.map = island_map\\n self.cells = None\\n self.array_to_island()\\n self.herbivores_on_island = None\\n self.carnivores_on_island = None\",\n \"def _makeimap(self):\\n self.map_['source'] = 'GOES'\\n self.map_['provider'] = 'NOAA'\\n self.map_['instrument'] = 'SUVI'\\n self.map_['physobs'] = 'flux'\",\n \"def encode_labelmap(colour_img, colourlabelmap):\\n colour_img = colour_img.astype(int)\\n labels = np.zeros((colour_img.shape[0], colour_img.shape[1]), dtype=np.int16)\\n for label_id, colour in enumerate(colourlabelmap):\\n labels[np.where(np.all(colour == colour_img, axis=-1))] = label_id\\n\\n return labels\",\n \"def recreate_image(codebook, labels, w, h):\\n d = codebook.shape[1]\\n image = np.zeros((w, h, d))\\n label_idx = 0\\n for i in range(w):\\n for j in range(h):\\n image[i][j] = codebook[labels[label_idx]]\\n label_idx += 1\\n return image\",\n \"def _preprocessing(mask, mapping, image) -> np.ndarray:\\n # TODO: Turn mapping into generic function.\\n processed_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\\n processed_image = cv.remap(processed_image, *mapping, cv.INTER_LINEAR)\\n processed_image[~mask] = 255\\n return processed_image\",\n \"def _create_naics_map():\\n # Read in list of industry topics.\\n naics_codes = pd.read_excel(\\n \\\"https://www.census.gov/eos/www/naics/2017NAICS/2-6%20digit_2017_Codes.xlsx\\\"\\n )\\n naics_codes = naics_codes.iloc[:, [1, 2]]\\n naics_codes.columns = ['NAICSCode', 'Title']\\n\\n # Replace all ranges with individual rows. E.g. 31-33 -> 31, 32, 33.\\n def range_to_array(read_code):\\n if isinstance(read_code, str) and \\\"-\\\" in read_code:\\n lower, upper = read_code.split(\\\"-\\\")\\n return list(range(int(lower), int(upper) + 1))\\n return read_code\\n\\n naics_codes = naics_codes.dropna()\\n naics_codes['NAICSCode'] = naics_codes['NAICSCode'].apply(range_to_array)\\n naics_codes = naics_codes.explode('NAICSCode')\\n\\n # Add unclassified code which is used in some statistical variables.\\n naics_codes = naics_codes.append(\\n {\\n \\\"NAICSCode\\\": 99,\\n \\\"Title\\\": \\\"Nonclassifiable\\\"\\n }, ignore_index=True)\\n\\n # Query for only two digit codes.\\n short_codes = naics_codes[naics_codes['NAICSCode'] < 100]\\n short_codes = short_codes.set_index(\\\"NAICSCode\\\")\\n short_codes = short_codes['Title'].to_dict()\\n\\n # Read in overview codes.\\n overview_codes = pd.read_csv(\\n \\\"https://data.bls.gov/cew/doc/titles/industry/high_level_industries.csv\\\"\\n )\\n overview_codes.columns = [\\\"NAICSCode\\\", \\\"Title\\\"]\\n overview_codes = overview_codes.set_index(\\\"NAICSCode\\\")\\n overview_codes = overview_codes['Title'].to_dict()\\n\\n # Combine the two sources of codes.\\n NAICS_MAP = {}\\n combined_codes = short_codes\\n combined_codes.update(overview_codes)\\n\\n # Rename industries into Pascal case.\\n for code, orig_name in combined_codes.items():\\n NAICS_MAP[str(code)] = standard_name_remapper(orig_name)\\n\\n # Other edge cases.\\n NAICS_MAP['00'] = 'Unclassified'\\n return NAICS_MAP\",\n \"def recreate_image(codebook, labels, w, h):\\n d = codebook.shape[1]\\n image = np.zeros((w, h, d))\\n label_idx = 0\\n for i in range(w):\\n for j in range(h):\\n image[i][j] = codebook[int(labels[label_idx])]\\n label_idx += 1\\n return image\",\n \"def projLocMap2Glob(loc_map,car_pos_in_loc_map,x,y,heading):\\n c = int((loc_map.shape[0]**2+loc_map.shape[1]**2)**(1/2)) #pytago\\n I = np.zeros((c,c))\\n r1 = (c-loc_map.shape[0])//2\\n c1 = (c-loc_map.shape[1])//2\\n I[r1:r1+loc_map.shape[0],c1:c1+loc_map.shape[1]] = loc_map #place it in the middle\\n\\n car_pos_in_imgR = [c1+c//2,r1+c//2]\\n imgR = rotateImage(loc_map,heading,car_pos_in_imgR)\\n plt.figure()\\n plt.imshow(imgR)\\n plt.show()\\n\\n global obst_map\\n #TODO add it in obst_map\\n return car_pos_in_imgR#np.zeros(obst_map.shape[:2])[x*RES,y*RES]\",\n \"def getLocalMap(dist_compl):\\n sdc=dist_compl*RES\\n #clms are real ;)\\n #rws are imaginary :D #rows\\n map_padd = 1*RES #add a meter\\n rws_ofs = abs(sdc.imag.min())+map_padd #offsetX\\n rws = abs(sdc.imag.max())+(rws_ofs)\\n clms_ofs = abs(sdc.real.min())+map_padd\\n clms = abs(sdc.real.max())+(clms_ofs)\\n M = np.zeros((np.round(rws+map_padd).astype(int),np.round(clms+map_padd).astype(int))).astype(dtype=MAP_D_TYPE)#empty local map\\n Mg = M.copy()\\n points = sdc + np.array([clms_ofs+1j*rws_ofs]) #scale\\n #M[points.imag.astype(int),points.real.astype(int)]=10 \\n for p in points:\\n r=np.round(p.imag).astype(int)\\n c=np.round(p.real).astype(int)\\n try:\\n #draw line in matrix\\n lc = [np.round(rws_ofs).astype(int),np.round(clms_ofs).astype(int),r,c]\\n rr, cc, val = line_aa(*lc) #not really demaning --> 1%\\n M[rr, cc] = np.logical_or(M[rr,cc]>0, val>0) \\n #add gaussian\\n Mg[r-GPoints//2:r+GPoints//2,c-GPoints//2:c+GPoints//2]+=Gau\\n except:\\n print('Error: out of array when calculating the local map',r,c)\\n Mg[Mg>100]=100 #cap the gaussian matrix\\n car_pos_in_loc_mat = np.array([np.round(clms_ofs).astype(int), np.round(rws_ofs).astype(int)])\\n #Mg[car_pos_in_loc_mat[1],car_pos_in_loc_mat[0]]=300 #add car pos\\n return M*(-100)+Mg, car_pos_in_loc_mat\",\n \"def recreate_image(codebook, labels, w, h):\\n d = codebook.shape[1]\\n image = np.zeros((w, h, d))\\n label_idx = 0\\n for i in range(w):\\n for j in range(h):\\n image[i][j] = codebook[labels[label_idx]]\\n label_idx += 1\\n return image\",\n \"def __scale_and_shift(self, image, landmarks, scale_range, output_size):\\n (x1, y1, x2, y2), new_size, need_pad, (p_x, p_y, p_w, p_h) = self.get_bbox_of_landmarks(\\n image, landmarks, scale_range, shift_rate=0.3)\\n box_image = image[y1:y2, x1:x2]\\n if need_pad:\\n box_image = np.lib.pad(box_image, ((p_y, p_h), (p_x, p_w), (0, 0)), 'constant')\\n box_image = cv2.resize(box_image, (output_size, output_size))\\n landmarks = (landmarks - (x1 - p_x, y1 - p_y)) / (new_size, new_size)\\n return box_image, landmarks\",\n \"def align(img, landmarks, d_size=(400, 400), normalized=False, show=False):\\n assert len(landmarks) == 10\\n assert isinstance(img, np.ndarray)\\n landmarks = np.array(landmarks).reshape(5, 2)\\n dw, dh = d_size\\n\\n keypoints = landmarks.copy().astype(np.float64)\\n if normalized:\\n keypoints[:, 0] *= img.shape[1]\\n keypoints[:, 1] *= img.shape[0]\\n\\n keypoints_ref = np.zeros((5, 2), dtype=np.float64)\\n keypoints_ref[:, 0] = FivePointsAligner.ref_landmarks[:, 0] * dw\\n keypoints_ref[:, 1] = FivePointsAligner.ref_landmarks[:, 1] * dh\\n\\n transform_matrix = transformation_from_points(keypoints_ref, keypoints)\\n output_im = cv.warpAffine(img, transform_matrix, d_size, flags=cv.WARP_INVERSE_MAP)\\n\\n if show:\\n tmp_output = output_im.copy()\\n for point in keypoints_ref:\\n cv.circle(tmp_output, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\\n for point in keypoints:\\n cv.circle(img, (int(point[0]), int(point[1])), 5, (255, 0, 0), -1)\\n img = cv.resize(img, d_size)\\n cv.imshow('source/warped', np.hstack((img, tmp_output)))\\n cv.waitKey()\\n\\n return output_im\",\n \"def process_map_img(self, map, height, width, dtype=np.int8):\\n img_in = np.array(map, dtype=np.uint8).reshape(height, width)\\n img = img_in.copy()\\n\\n # NOTE(CH3): We might not need to do this conversion...\\n img[(img_in == self.free_ros)] = self.free_img\\n img[(img_in == self.unknown_ros)] = self.unknown_img\\n img[(img_in == self.obstacle_ros)] = self.obstacle_img\\n\\n # Isolate layers\\n free_mask = cv2.inRange(img, self.free_img, self.free_img)\\n unknown_mask = cv2.inRange(img, self.unknown_img, self.unknown_img)\\n obstacle_mask = cv2.inRange(img, self.obstacle_img, self.obstacle_img)\\n\\n # Process free layer\\n if self.process_free:\\n free_mask = cv2.erode(free_mask, self.kernel, iterations=self.iters)\\n free_mask = cv2.dilate(free_mask, self.kernel, iterations=self.iters)\\n\\n # if True: # erode_free\\n # free_mask = cv2.erode(free_mask, self.kernel, iterations=3)\\n\\n # Construct new map img\\n new_img = make_img(img.shape, (self.unknown_ros), dtype=dtype)\\n new_img[(free_mask != 0)] = self.free_ros\\n new_img[(obstacle_mask != 0)] = self.obstacle_ros\\n\\n return new_img\",\n \"def recreate_image(codebook, labels, w, h):\\r\\n d = codebook.shape[1]\\r\\n image = np.zeros((w, h, d))\\r\\n label_idx = 0\\r\\n for i in range(w):\\r\\n for j in range(h):\\r\\n image[i][j] = codebook[labels[label_idx]]\\r\\n label_idx += 1\\r\\n return image\",\n \"def map_loc_to_pixel((x, y), xc = 17.25, yc = 630, run = 17.25):\\n xp, yp = xc + x*run, yc - y*run\\n return (xp, yp)\",\n \"def map_property(self, linc):\\n sleep(1)\\n linc = '{}'.format(linc).zfill(10)\\n self.driver.switch_to_frame('fOpts')\\n select_box = Select(self.driver.find_element_by_id('Finds_lstFindTypes'))\\n select_box.select_by_visible_text('Linc Number')\\n linc_box = self.driver.find_element_by_id('Finds_ctlLincNumber_txtLincNumber')\\n linc_box.clear()\\n linc_box.send_keys(linc)\\n self.driver.find_element_by_id('Finds_cmdSubmit').click()\\n if self.spatial_count == 0:\\n sleep(8)\\n sleep(4)\\n self.driver.switch_to_default_content()\\n if self.spatial_count == 0:\\n try:\\n e = WebDriverWait(self.driver, 10).until(\\n EC.presence_of_element_located((By.ID, 'map'))\\n )\\n except:\\n self.driver.refresh()\\n self.driver.switch_to_default_content()\\n e = WebDriverWait(self.driver, 60).until(\\n EC.presence_of_element_located((By.ID, 'map'))\\n )\\n hover_target = self.driver.find_element_by_id('map')\\n if self.spatial_count == 0:\\n sleep(5)\\n map_location = hover_target.location\\n map_size = hover_target.size\\n filename = 'data/sites/{}.png'.format(linc)\\n self.driver.save_screenshot(filename)\\n x = map_location['x'] + 50\\n y = map_location['y']\\n width = map_location['x'] + map_size['width'] - 50\\n height = map_location['y'] + map_size['height']\\n im = Image.open(filename)\\n im = im.crop((int(x), int(y), int(width), int(height)))\\n im.save(filename)\\n if self.spatial_count == 0:\\n sleep(5)\\n ActionChains(self.driver).move_to_element(hover_target).drag_and_drop_by_offset(hover_target, 1, 1).perform()\\n if self.spatial_count == 0:\\n sleep(5)\\n nad83_raw = self.driver.find_element_by_id('coordinateOutput').text\\n nad83 = tuple(re.findall(r\\\"[0-9\\\\.\\\\-]+\\\", nad83_raw))\\n gps = Geography().nad83(nad83, reverse=True)\\n gpsr = (gps[1], gps[0])\\n self.spatial_count += 1\\n return gpsr\",\n \"def __init__(self, island_map):\\n self.island_map = island_map\\n self.landscape_dict = {'M': Mountain,\\n 'O': Ocean,\\n 'J': Jungle,\\n 'S': Savannah,\\n 'D': Desert}\",\n \"def map_to_mgi(adata, copy = False):\\n from pybiomart import Server\\n # connest to the biomart server\\n server = Server(host='http://www.ensembl.org')\\n\\n # retrieve the mouse data set we need\\n dataset = (server.marts['ENSEMBL_MART_ENSEMBL']\\n .datasets['mmusculus_gene_ensembl'])\\n\\n # recieve the mapping from ensembl to MGI\\n conv_table = dataset.query(attributes=['ensembl_gene_id', 'external_gene_name'])\\n\\n # we first drop duplicates in the first column\\n conv_table = conv_table.drop_duplicates(conv_table.columns.values[0])\\n\\n # convert the gene names from the adata object to a data frame\\n adata_table = pd.DataFrame(adata.var_names)\\n\\n # give the first column a name\\n adata_table.columns = ['Gene stable ID']\\n\\n # change the gene table so that the ensembl names are now the index\\n conv_table = conv_table.set_index('Gene stable ID')\\n\\n # project the names from the conversion table on the corr. names in the\\n # adata var names table\\n mapping = adata_table.join(conv_table, on='Gene stable ID')\\n\\n # how many could we not map\\n not_found_mgi = sum(pd.isnull(mapping).iloc[:,1])\\n\\n # how many ensg symbols did we map several times?\\n rep_ensg = len(mapping.iloc[:, 0]) - len(set(mapping.iloc[:, 0]))\\n\\n # how many mgi symbols did we map several times?\\n rep_mgi = len(mapping.iloc[:, 1]) - len(set(mapping.iloc[:, 1]))\\n\\n # print this information\\n print('Genes where no MGI annotations where found: {}\\\\nENSG repetition: {}\\\\nMGI repetition: {}'.\\\\\\n format(not_found_mgi, rep_ensg, rep_mgi))\\n\\n # fill nans in mgi column with corresponding ensembl annotations\\n mapping['Gene name'].fillna(mapping['Gene stable ID'], inplace = True)\\n\\n # add the new gene names to the adata object\\n adata.var['mgi_symbols'] = mapping['Gene name'].tolist()\",\n \"def map(self, lat, long):\\r\\n rxy = self._r*np.sqrt(1-np.cos(lat))\\r\\n x = rxy*np.cos(long)\\r\\n y = rxy*np.sin(long)\\r\\n return (x, y)\",\n \"def decode(codes, dictionary):\\n c, d = dictionary.shape\\n codes = codes.reshape(-1, c)\\n \\n return np.dot(codes, dictionary)\",\n \"def map(self,Affine,i):\\n map_x = np.zeros([self.num,self.d])\\n for k in range(self.num):\\n map_x[k,:] = Affine.apply(i,self.pick(k))\\n Mapped = Model_Points(map_x)\\n return Mapped\",\n \"def mapping(nside, angs):\\n\\n\\tnpix = hp.nside2npix(nside)\\n\\tmaph = np.zeros(npix)\\n\\n\\tpix = hp.ang2pix(nside, angs[:, 1], angs[:, 0])\\n\\tvals, times = np.unique(pix, return_counts=True)\\n\\n\\tmaph[vals] = times\\n\\tmaph *= float(npix)/len(angs)\\n\\n\\treturn maph\",\n \"def remap(\\n image: Tensor,\\n map_x: Tensor,\\n map_y: Tensor,\\n mode: str = 'bilinear',\\n padding_mode: str = 'zeros',\\n align_corners: bool | None = None,\\n normalized_coordinates: bool = False,\\n) -> Tensor:\\n KORNIA_CHECK_SHAPE(image, [\\\"B\\\", \\\"C\\\", \\\"H\\\", \\\"W\\\"])\\n KORNIA_CHECK_SHAPE(map_x, [\\\"B\\\", \\\"H\\\", \\\"W\\\"])\\n KORNIA_CHECK_SHAPE(map_y, [\\\"B\\\", \\\"H\\\", \\\"W\\\"])\\n\\n batch_size, _, height, width = image.shape\\n\\n # grid_sample need the grid between -1/1\\n map_xy: Tensor = stack([map_x, map_y], -1)\\n\\n # normalize coordinates if not already normalized\\n if not normalized_coordinates:\\n map_xy = normalize_pixel_coordinates(map_xy, height, width)\\n\\n # simulate broadcasting since grid_sample does not support it\\n map_xy = map_xy.expand(batch_size, -1, -1, -1)\\n\\n # warp the image tensor and return\\n return F.grid_sample(image, map_xy, mode=mode, padding_mode=padding_mode, align_corners=align_corners)\",\n \"def _interpolate_codes_at_points(\\n self, code_grid: tf.Tensor, points: tf.Tensor,\\n level: int) -> Tuple[tf.Tensor, tf.Tensor, Dict[str, tf.Tensor]]:\\n if self._num_point_dim == 2:\\n _, code_grid_h, code_grid_w, _ = code_grid.shape\\n _, num_point, _ = points.shape\\n\\n # Get grid indices of each point.\\n grid_indices = grid_utils.get_grid_index(points, self._grid_shape[level],\\n self._grid_range_min,\\n self._grid_side_length[level],\\n self._grid_mode)\\n # Tensor with shape [batch_size, num_point, num_point_dim].\\n\\n # Normalize point coordinates within each grid.\\n points_normalize = grid_utils.normalize_point_coord(\\n points, self._grid_centers[level], self._grid_side_length[level],\\n grid_indices)\\n\\n # Renormalize point coordinates to the spatial resolution of code grid.\\n points_renormalize = grid_utils.normalize_point_coord(\\n points, self._grid_centers[0], self._grid_side_length[0],\\n tf.zeros_like(grid_indices))\\n points_renormalize = points_renormalize * 0.5 + 0.5 # Map to [0, 1].\\n points_renormalize = points_renormalize * tf.constant(\\n [code_grid_h - 1, code_grid_w - 1], dtype=tf.float32)[None, None, :]\\n # Tensor with shape [batch_size, num_point, num_point_dim].\\n\\n # Interpolate codes from code_grid.\\n if code_grid_h == 1 and code_grid_w == 1:\\n codes_for_points = tf.tile(code_grid[:, 0, ...], [1, num_point, 1])\\n else:\\n codes_for_points = tfa_image.interpolate_bilinear(\\n code_grid, points_renormalize, indexing='xy')\\n # Tensor with shape [batch_size, num_point, code_grid_c].\\n\\n elif self._num_point_dim == 3:\\n _, code_grid_d, code_grid_h, code_grid_w, _ = code_grid.shape\\n num_point = tf.shape(points)[1]\\n\\n if self._grid_shape[level] != [1, 1, 1]:\\n raise NotImplementedError('Grid shape must be [1, 1, 1].')\\n else:\\n points_normalize = points\\n\\n # Renormalize point coordinates to the spatial resolution of code grid,\\n # after which points should be in the range of [-1, 1].\\n points_renormalize = points * 0.5 + 0.5 # Map to [0, 1].\\n points_renormalize = points_renormalize * tf.constant(\\n [code_grid_d - 1, code_grid_h - 1, code_grid_w - 1],\\n dtype=tf.float32)[None, None, :]\\n\\n # Interpolate codes from code_grid. Output tensor is with shape\\n # [batch_size, num_point, code_grid_c].\\n if code_grid_d == 1 and code_grid_h == 1 and code_grid_w == 1:\\n codes_for_points = tf.tile(code_grid[:, 0, 0, ...], [1, num_point, 1])\\n else:\\n # The dimensions of code_grid should be [batch_size, code_grid_d,\\n # code_grid_h, code_grid_w, code_grid_c]. The dimensions of\\n # points_renormalize should be [batch_size, num_point, num_point_dim],\\n # and the order of coordinates should be (z, y, x).\\n codes_for_points = tfg_trilinear.interpolate(code_grid,\\n points_renormalize)\\n\\n debug_data = {}\\n debug_data['points_normalize'] = points_normalize\\n debug_data['points_renormalize'] = points_renormalize\\n debug_data['latent_codes'] = tf.concat(\\n [codes_for_points[..., :3], codes_for_points[..., -3:]], axis=-1)\\n\\n return codes_for_points, points_normalize, debug_data\",\n \"def geotif_image(self, tile_bounds, image_bounds, imagepath,image_gdal):\\n i_srid=3857\\n s_srid=\\\"WGS 84 / Pseudo-Mercator\\\"\\n # i_srid=3395\\n # s_srid=\\\"WGS 84 / World Mercator\\\"\\n # 4326 Wsg84\\n # Upper Left ( -8.4375000, 77.1571625) ( 8d26'15.00\\\"W, 77d 9'25.79\\\"N)\\n # Lower Left ( -8.4375000, 35.4606700) ( 8d26'15.00\\\"W, 35d27'38.41\\\"N)\\n # Upper Right ( 80.1562500, 77.1571625) ( 80d 9'22.50\\\"E, 77d 9'25.79\\\"N)\\n # Lower Right ( 80.1562500, 35.4606700) ( 80d 9'22.50\\\"E, 35d27'38.41\\\"N)\\n # Center ( 35.8593750, 56.3089162) ( 35d51'33.75\\\"E, 56d18'32.10\\\"N)\\n # 3857 'WGS 84 / Pseudo-Mercator'\\n # Upper Left ( -939258.204,13932330.020) ( 8d26'15.00\\\"W, 77d 9'25.79\\\"N)\\n # Lower Left ( -939258.204, 4226661.916) ( 8d26'15.00\\\"W, 35d27'38.41\\\"N)\\n # Upper Right ( 8922952.934,13932330.020) ( 80d 9'22.50\\\"E, 77d 9'25.79\\\"N)\\n # Lower Right ( 8922952.934, 4226661.916) ( 80d 9'22.50\\\"E, 35d27'38.41\\\"N)\\n # Center ( 3991847.365, 9079495.968) ( 35d51'33.75\\\"E, 62d54'54.84\\\"N)\\n # 3395 'WGS 84 / World Mercator'\\n # Upper Left ( -939258.204,13932330.020) ( 8d26'15.00\\\"W, 77d14'24.81\\\"N)\\n # Lower Left ( -939258.204, 4226661.916) ( 8d26'15.00\\\"W, 35d38'33.56\\\"N)\\n # Upper Right ( 8922952.934,13932330.020) ( 80d 9'22.50\\\"E, 77d14'24.81\\\"N)\\n # Lower Right ( 8922952.934, 4226661.916) ( 80d 9'22.50\\\"E, 35d38'33.56\\\"N)\\n # Center ( 3991847.365, 9079495.968) ( 35d51'33.75\\\"E, 63d 4'14.87\\\"N)\\n bounds_west,bounds_south,bounds_east,bounds_north=tile_bounds\\n bounds_wsg84=\\\"bounds_wsg84: %f,%f,%f,%f\\\"% (bounds_west,bounds_south,bounds_east,bounds_north)\\n mercator = GlobalMercator()\\n tile_bounds=mercator.BoundsToMeters(tile_bounds)\\n mbtiles_name=\\\"\\\";\\n mbtiles_description=\\\"\\\"\\n s_TIFFTAG_DOCUMENTNAME=\\\"\\\"\\n s_TIFFTAG_IMAGEDESCRIPTION=\\\"\\\"\\n s_TIFFTAG_SOFTWARE=\\\"\\\"\\n s_TIFFTAG_DATETIME=\\\"\\\"\\n s_TIFFTAG_ARTIST=\\\"\\\"\\n s_TIFFTAG_HOSTCOMPUTER=\\\"\\\"\\n s_TIFFTAG_COPYRIGHT=\\\"\\\"\\n if self.metadata_input:\\n metadata=dict(self.metadata_input)\\n mbtiles_name=metadata.get('name','')\\n mbtiles_description=metadata.get('description','')\\n if self._metadata:\\n for metadata_list in self._metadata:\\n metadata=dict(metadata_list[0])\\n mbtiles_name=metadata.get('name',mbtiles_name)\\n mbtiles_description=metadata.get('description',mbtiles_description)\\n s_TIFFTAG_DOCUMENTNAME=metadata.get('TIFFTAG_DOCUMENTNAME',mbtiles_name)\\n s_TIFFTAG_IMAGEDESCRIPTION=metadata.get('TIFFTAG_IMAGEDESCRIPTION',mbtiles_description)\\n s_TIFFTAG_SOFTWARE=metadata.get('TIFFTAG_SOFTWARE','')\\n s_TIFFTAG_DATETIME=metadata.get('TIFFTAG_DATETIME','')\\n s_TIFFTAG_ARTIST=metadata.get('TIFFTAG_ARTIST','')\\n s_TIFFTAG_HOSTCOMPUTER=metadata.get('TIFFTAG_HOSTCOMPUTER','')\\n s_TIFFTAG_COPYRIGHT=metadata.get('TIFFTAG_COPYRIGHT','')\\n if s_TIFFTAG_DOCUMENTNAME == \\\"\\\":\\n s_TIFFTAG_DOCUMENTNAME=mbtiles_name\\n if s_TIFFTAG_IMAGEDESCRIPTION == \\\"\\\":\\n s_TIFFTAG_IMAGEDESCRIPTION=mbtiles_description\\n tiff_metadata=[]\\n if s_TIFFTAG_DOCUMENTNAME != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_DOCUMENTNAME',s_TIFFTAG_DOCUMENTNAME))\\n if s_TIFFTAG_IMAGEDESCRIPTION != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_IMAGEDESCRIPTION',s_TIFFTAG_IMAGEDESCRIPTION))\\n if s_TIFFTAG_SOFTWARE != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_SOFTWARE',s_TIFFTAG_SOFTWARE))\\n else:\\n tiff_metadata.append(('TIFFTAG_SOFTWARE',bounds_wsg84))\\n if s_TIFFTAG_DATETIME != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_DATETIME',s_TIFFTAG_DATETIME))\\n if s_TIFFTAG_ARTIST != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_ARTIST',s_TIFFTAG_ARTIST))\\n if s_TIFFTAG_HOSTCOMPUTER != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_HOSTCOMPUTER',s_TIFFTAG_HOSTCOMPUTER))\\n if s_TIFFTAG_COPYRIGHT != \\\"\\\":\\n tiff_metadata.append(('TIFFTAG_COPYRIGHT',s_TIFFTAG_COPYRIGHT))\\n # this assumes the projection is Geographic lat/lon WGS 84\\n xmin,ymin,xmax,ymax=tile_bounds\\n image_width,image_height=image_bounds\\n # Upper Left ( 20800.000, 22000.000)\\n # Lower Right ( 24000.000, 19600.000)\\n # Size is 15118, 11339\\n # (24000-20800)/15118 = 3200 = 0,21166821 [xres]\\n # (19600-22000)/11339 = 2400 = −0,211658876 [yres]\\n # geo_transform = (20800.0, 0.2116682100807, 0.0, 22000.0, 0.0, -0.21165887644413)\\n geo_transform = [xmin, (xmax-xmin)/image_width, 0, ymax, 0, (ymin-ymax)/image_height ]\\n spatial_projection = osr.SpatialReference()\\n spatial_projection.ImportFromEPSG(i_srid)\\n logger.info(_(\\\"-I-> geotif_image: Saving as GeoTiff - image[%s] compression[%s]\\\") % (imagepath,self.tiff_compression))\\n image_dataset = gdal.Open(image_gdal, gdal.GA_Update )\\n image_dataset.SetProjection(spatial_projection.ExportToWkt())\\n image_dataset.SetGeoTransform(geo_transform)\\n driver = gdal.GetDriverByName(\\\"GTiff\\\")\\n output_dataset = driver.CreateCopy(imagepath,image_dataset, 0, self.tiff_compression )\\n if tiff_metadata:\\n logger.info(_(\\\"-I-> geotif_image: tiff_metadata[%s]\\\") % tiff_metadata)\\n output_dataset.SetMetadata(dict(tiff_metadata))\\n # Once we're done, close properly the dataset\\n output_dataset = None\\n image_dataset = None\\n os.remove(image_gdal)\\n logger.info(_(\\\"-I-> geotif_image: Saved resulting image to '%s' as GeoTiff- bounds[%s]\\\") % (imagepath,tile_bounds))\",\n \"def loadCode(self,code,startNum):\\r\\n\\t\\tself.frame.loadCode(code,startNum)\",\n \"def generate_xmap(x_len, y_len, all_cids, all_xcoords, all_ycoords):\\r\\n # Determine figure height and width\\\"\\\"\\\"\\r\\n img_height = x_len * 80\\r\\n img_width = y_len * 80\\r\\n\\r\\n # Write html script which allows for mouseover of labels\\r\\n xmap = []\\r\\n for cid, x, y in zip(all_cids, all_xcoords, all_ycoords):\\r\\n xmap.append(AREA_SRC % (x, img_height - y, cid, cid))\\r\\n\\r\\n return xmap, img_height, img_width\",\n \"def __call__(self, map_in: np.ndarray) -> np.ndarray:\\n return hp.map2alm(maps=map_in, lmax=self.n_max, use_weights=self.use_weights, verbose=self.verbose)\",\n \"def _map_fn(self):\\n raise NotImplementedError\",\n \"def get_lat_long(self, postcodes):\\n # Fix evil postcodes\\n postcodes = clean_postcodes(postcodes)\\n\\n postcode_df = self.postcode_df\\n postcode_df = postcode_df.fillna('np.nan')\\n postcode_df = postcode_df.set_index('Postcode')\\n index_data = postcode_df.loc[postcodes]\\n lat = np.array(index_data['Latitude']).T\\n lng = np.array(index_data['Longitude']).T\\n\\n return np.vstack((lat, lng)).transpose()\",\n \"def create_mapping(project, img):\\n with BMI(_username, _password, project) as bmi:\\n ret = bmi.mount_image(img)\\n if ret[constants.STATUS_CODE_KEY] == 200:\\n click.echo('Success')\\n else:\\n click.echo(ret[constants.MESSAGE_KEY])\",\n \"def forward_code_map(self):\\n\\n return { c.key:c.value for c in self.codes}\",\n \"def process_coords():\\n split_coords = row[\\\"map_coord\\\"].split(',')\\n map_x, map_y = [int(i) for i in split_coords]\\n map_x_normed = ((map_x*2) / self.MINIMAP_DIM) - 1\\n map_y_normed = -(((map_y*2) / self.MINIMAP_DIM) - 1)\\n return map_x_normed, map_y_normed\",\n \"def convert(self, lat, lon):\\r\\n a = self.a\\r\\n b = self.b\\r\\n long0 = self.long0\\r\\n k0 = self.k0\\r\\n dx = self.dx\\r\\n\\r\\n e = (1 - b ** 2 / a ** 2) ** 0.5\\r\\n e2 = e ** 2 / (1 - e ** 2)\\r\\n n = (a - b) / (a + b)\\r\\n nu = a / (1 - (e ** 2) * (sin(lat) ** 2)) ** 0.5\\r\\n p = lon - long0\\r\\n\\r\\n A = a * (1 - n + (5 / 4.0) * (n ** 2 - n ** 3) + (81 / 64.0)*(n ** 4 - n ** 5))\\r\\n B = (3 * a * n / 2.0) * (1 - n + (7 / 8.0) * (n ** 2 - n ** 3) + (55 / 64.0) * (n ** 4 - n ** 5))\\r\\n C = (15 * a * (n ** 2) / 16.0) * (1 - n + (3 / 4.0) * (n ** 2 - n ** 3))\\r\\n D = (35 * a * (n ** 3) / 48.0) * (1 - n + (11 / 16.0) * (n ** 2 - n ** 3))\\r\\n E = (315 * a * (n ** 4) / 51.0) * (1 - n)\\r\\n\\r\\n S = A * lat - B * sin(2 * lat) + C * sin(4 * lat) - D * sin(6 * lat) + E * sin(8 * lat)\\r\\n\\r\\n K1 = S * k0\\r\\n K2 = k0 * nu * sin(2 * lat)/4.0\\r\\n K3 = (k0 * nu * sin(lat) * (cos(lat) ** 3) / 24.0) * \\\\\\r\\n (5 - tan(lat) ** 2 + 9 * e2 * (cos(lat) ** 2) + 4 * (e2 ** 2) * (cos(lat) ** 4))\\r\\n\\r\\n y = K1 + K2 * (p ** 2) + K3 * (p ** 4)\\r\\n\\r\\n K4 = k0 * nu * cos(lat)\\r\\n K5 = (k0 * nu * (cos(lat) ** 3) / 6.0) * (1 - tan(lat) ** 2 + e2 * (cos(lat) ** 2))\\r\\n\\r\\n x = K4 * p + K5 * (p ** 3) + dx\\r\\n return x, y\",\n \"def pintarIMAGENENMAPA(self, pos):\\n # Agrego al vector que controla las images\\n k = (pos[0], pos[1], \\\"img\\\"+str(self.idIMG))\\n # Si deseo pintar una silla\\n if self.queIMGAgregar == 1:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgSilla, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar una mesa\\n if self.queIMGAgregar == 2:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgMesa, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Se deseo pintar una nevera\\n if self.queIMGAgregar == 3:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgNevera, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar una cama\\n if self.queIMGAgregar == 4:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgCama, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar un sofa\\n if self.queIMGAgregar == 5:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgSofa, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar tv\\n if self.queIMGAgregar == 6:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgTV, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar lampara\\n if self.queIMGAgregar == 7:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgLampara, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar planta\\n if self.queIMGAgregar == 8:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgPlanta, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar sanitario\\n if self.queIMGAgregar == 9:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgSanitario, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar lavamanos\\n if self.queIMGAgregar == 10:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgLavamanos, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\\n\\n # Si deseo pintar la ducha\\n if self.queIMGAgregar == 11:\\n self.telaMAPA.create_image(k[0], k[1], image=self.imgDucha, tag=k[2])\\n # Como fue agregado un elemento en el mapa procedo a registrarlo\\n self.cotroladoraIMGREG.append(k)\\n # Como una img fue agregada procedo a aumentar el id\\n self.idIMG = self.idIMG + 1\",\n \"def geo_transform(self):\\n pass\",\n \"def mapPsf(self, locn):\\n\\n x = (locn[1] - self.output_center) * self.rescale + self.input_center\\n y = (locn[0] - self.output_center) * self.rescale + self.input_center\\n\\n return (y, x)\",\n \"def map_picture(the_map, p):\\n xy = (p.location[0] - 2, p.location[1] + 2)\\n map_coords = []\\n for y in range(0, 5):\\n row = [(xy[0] + x, xy[1] - y) for x in range(0, 5)]\\n map_coords.append(row)\\n\\n pretty_map = []\\n for r in map_coords:\\n row = []\\n for coordinates in r:\\n if coordinates in the_map.keys():\\n if p.quest and p.job and p.quest[1] == coordinates and p.job.location == coordinates:\\n star = '*$ '\\n elif p.quest and p.quest[1] == coordinates:\\n star = ' * '\\n elif p.job and p.job.location == coordinates:\\n star = ' $ '\\n else:\\n star = ' '\\n row.append(\\\"|{!s:9}{}|\\\".format(the_map[coordinates].square_type, star))\\n else:\\n row.append(\\\"|{!s:12}|\\\".format(' '))\\n pretty_map.append(row)\\n for row in pretty_map:\\n print(''.join(row))\",\n \"def map(self, function):\\n pass\",\n \"def apply_remap_values(labels: np.ndarray, label_map: Dict[int, int]) -> np.ndarray:\\n for l1, l2 in label_map.items():\\n labels[labels == l1] = l2\",\n \"def make_label_map(path, label_list):\\r\\n \\r\\n img = []\\r\\n for name in path:\\r\\n now = np.zeros((224,224))\\r\\n im = cv2.resize(cv2.imread(name), (224,224)).tolist()\\r\\n for y, i in enumerate(im):\\r\\n for x, j in enumerate(i):\\r\\n try:\\r\\n now[y, x] = label_list.index(j)\\r\\n\\r\\n except ValueError:\\r\\n now[y, x] = 0\\r\\n\\r\\n img.append(now)\\r\\n return img\",\n \"def lensedImage(self, source, scale, xl=8., yl=4., gamma=0.):\\n image, magMap = lens(self.ltype, self.dist, source, self.x01, self.x02, xl, yl, gamma)\\n\\n return image, magMap\",\n \"def terrainEncoded(self, request, result):\\n pass\",\n \"def setreferencecode(self, *args, **kwargs):\\n return _coordsys.coordsys_setreferencecode(self, *args, **kwargs)\",\n \"def convertLatLongToPixels(mapImg, leftLongitude, rightLongitude, topLatitude, bottomLatitude, latLong):\\n latitude = min(max(latLong[0], bottomLatitude), topLatitude)\\n longitude = min(max(latLong[1], leftLongitude), rightLongitude)\\n\\n diffLat = topLatitude - bottomLatitude\\n diffLong = rightLongitude - leftLongitude\\n\\n pixelX = (longitude - leftLongitude)/diffLong*mapImg.size[0]\\n pixelX = max(min(pixelX, mapImg.size[0] - 1), 0)\\n pixelY = mapImg.size[1] - (latitude - bottomLatitude)/diffLat*mapImg.size[1]\\n pixelY = max(min(pixelY, mapImg.size[1] - 1), 0)\\n return (pixelX, pixelY)\",\n \"def transform_images(img1,img2):\",\n \"def ds_map(n_caps, n_refs, n_codes, differential=False):\\n\\n p_map = pipe_map(n_caps, n_refs, differential)\\n return adjust_map(p_map, n_codes)\",\n \"def map(z):\\n pass\",\n \"def create_map(width, height, pixels):\\n\\n\\n\\n\\n def index_to_xy(i, width, height):\\n \\\"\\\"\\\" Takes 0 based index going line wise from top\\n left to bottom right, returns x, y coordinates so\\n that 0,0 is on bottom left corner\\n \\\"\\\"\\\"\\n x = i % width\\n y = i // width\\n y*= -1\\n y+= height - 1\\n return (x,y)\\n\\n def place_terrain(type, i):\\n \\\"\\\"\\\"This won't return anything, just do side effects\\n\\n The object \\\"gameLogic\\\" is used to place the object\\n initially. It doesn't matter where this object is,\\n as long as it exists. There must be an easier way,\\n but this works.\\n \\\"\\\"\\\"\\n x,y = index_to_xy(i, width, height)\\n\\n object_name = terrain_types.get(type, \\\"water\\\")\\n\\n if ob[\\\"fast_create\\\"] > 0 and not (x%ob[\\\"fast_create\\\"] == 0 and y%ob[\\\"fast_create\\\"] == 0):\\n return\\n\\n if object_name != \\\"water\\\":\\n object = scene.addObject(object_name, \\\"gameLogic\\\")\\n object.worldPosition = (x,y,0)\\n\\n\\n list(map( (lambda tup : place_terrain(tup[1], tup[0])), list(enumerate(pixels)) ))\",\n \"def map(self, lat, long):\\r\\n r1 = self._r1\\r\\n r2 = self._r2\\r\\n direction = self._direction\\r\\n\\r\\n return self.map_aux(lat, long, direction, r1, r2)\",\n \"def map(self, lat, long):\\r\\n rxy = self._r*lat/(np.pi/2)\\r\\n x = rxy*np.cos(long)\\r\\n y = rxy*np.sin(long)\\r\\n return (x, y)\",\n \"def run_genomemap(args):\\n genome_map(args)\",\n \"def pointToWorld( nImageX, nImageY, rDepth, rMaxX = 320, rMaxY = 240, rFieldOfViewX = 60, rFieldOfViewY = 40 ):\\n # convert to [-0.5,0.5]\\n rCenteredX = ( nImageX / rMaxX ) - 0.5;\\n rCenteredY = ( nImageY / rMaxY ) - 0.5;\",\n \"def flag_regional_indicator(code: List[str]) -> str:\\r\\n\\r\\n return \\\"\\\".join([chr(ord(c.upper()) + OFFSET) for c in code])\",\n \"def map_coordinates(self,geometry):\\n\\t\\tg = self.geomatrix\\n\\t\\tdef project_coord(x,y,z=None):\\n\\t\\t\\tx = g[0] + g[1] * x + g[2] * y\\n\\t\\t\\ty = g[3] + g[4] * x + g[5] * y\\n\\t\\t\\tif z is None:\\n\\t\\t\\t\\treturn x,y\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn x,y,z\\n\\t\\treturn transform(project_coord, geometry)\",\n \"def map_image(map_dict):\\n import PIL.Image\\n\\n map_palette = [\\n (0, 0, 0), # special-cased to transparent in the code below\\n (125, 176, 55),\\n (244, 230, 161),\\n (197, 197, 197),\\n (252, 0, 0),\\n (158, 158, 252),\\n (165, 165, 165),\\n (0, 123, 0),\\n (252, 252, 252),\\n (162, 166, 182),\\n (149, 108, 76),\\n (111, 111, 111),\\n (63, 63, 252),\\n (141, 118, 71),\\n (252, 249, 242),\\n (213, 125, 50),\\n (176, 75, 213),\\n (101, 151, 213),\\n (226, 226, 50),\\n (125, 202, 25),\\n (239, 125, 163),\\n (75, 75, 75),\\n (151, 151, 151),\\n (75, 125, 151),\\n (125, 62, 176),\\n (50, 75, 176),\\n (101, 75, 50),\\n (101, 125, 50),\\n (151, 50, 50),\\n (25, 25, 25),\\n (247, 235, 76),\\n (91, 216, 210),\\n (73, 129, 252),\\n (0, 214, 57),\\n (21, 20, 31),\\n (112, 2, 0),\\n (127, 85, 48)\\n ]\\n ret = PIL.Image.new('RGBA', (map_dict['data']['width'], map_dict['data']['height']), color=(0, 0, 0, 0))\\n for i, color in enumerate(map_dict['data']['colors']):\\n y, x = divmod(i, map_dict['data']['width'])\\n base_color, color_variant = divmod(color, 4)\\n if base_color == 0:\\n continue\\n color = tuple(round(palette_color * [180, 220, 255, 135][color_variant] / 255) for palette_color in map_palette[base_color]) + (255,)\\n ret.putpixel((x, y), color)\\n return ret\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6005514","0.5933257","0.5838075","0.5818631","0.5656862","0.56560636","0.56560636","0.56314653","0.5581515","0.55739915","0.55533266","0.55513483","0.55221444","0.54776543","0.5458927","0.5432332","0.5427928","0.53670174","0.5355888","0.53041667","0.5300272","0.5293322","0.5281089","0.5276837","0.5251064","0.522472","0.52151346","0.52063245","0.51726246","0.5160775","0.5154253","0.51406497","0.51405257","0.513201","0.5124828","0.51192945","0.5117335","0.5102387","0.5100346","0.5077067","0.50599694","0.5044547","0.5041143","0.50409204","0.50370777","0.50329024","0.50316614","0.50281286","0.50281006","0.50243926","0.5023208","0.5022837","0.50084573","0.4997794","0.49939606","0.4990994","0.49908912","0.4979153","0.49750498","0.49649248","0.4962149","0.49618247","0.49613112","0.49545896","0.4949442","0.49489698","0.4941743","0.4941573","0.49327222","0.49260885","0.4915618","0.49097025","0.49003363","0.48994252","0.48985666","0.48976874","0.48976123","0.4891939","0.48901013","0.48828587","0.4879338","0.48747703","0.48712623","0.48690504","0.48678458","0.48667696","0.48658055","0.48632565","0.48624814","0.4859983","0.48595476","0.4853408","0.485117","0.4850533","0.48424494","0.48423806","0.48348865","0.48314586","0.48245698","0.4822128","0.4818185"],"string":"[\n \"0.6005514\",\n \"0.5933257\",\n \"0.5838075\",\n \"0.5818631\",\n \"0.5656862\",\n \"0.56560636\",\n \"0.56560636\",\n \"0.56314653\",\n \"0.5581515\",\n \"0.55739915\",\n \"0.55533266\",\n \"0.55513483\",\n \"0.55221444\",\n \"0.54776543\",\n \"0.5458927\",\n \"0.5432332\",\n \"0.5427928\",\n \"0.53670174\",\n \"0.5355888\",\n \"0.53041667\",\n \"0.5300272\",\n \"0.5293322\",\n \"0.5281089\",\n \"0.5276837\",\n \"0.5251064\",\n \"0.522472\",\n \"0.52151346\",\n \"0.52063245\",\n \"0.51726246\",\n \"0.5160775\",\n \"0.5154253\",\n \"0.51406497\",\n \"0.51405257\",\n \"0.513201\",\n \"0.5124828\",\n \"0.51192945\",\n \"0.5117335\",\n \"0.5102387\",\n \"0.5100346\",\n \"0.5077067\",\n \"0.50599694\",\n \"0.5044547\",\n \"0.5041143\",\n \"0.50409204\",\n \"0.50370777\",\n \"0.50329024\",\n \"0.50316614\",\n \"0.50281286\",\n \"0.50281006\",\n \"0.50243926\",\n \"0.5023208\",\n \"0.5022837\",\n \"0.50084573\",\n \"0.4997794\",\n \"0.49939606\",\n \"0.4990994\",\n \"0.49908912\",\n \"0.4979153\",\n \"0.49750498\",\n \"0.49649248\",\n \"0.4962149\",\n \"0.49618247\",\n \"0.49613112\",\n \"0.49545896\",\n \"0.4949442\",\n \"0.49489698\",\n \"0.4941743\",\n \"0.4941573\",\n \"0.49327222\",\n \"0.49260885\",\n \"0.4915618\",\n \"0.49097025\",\n \"0.49003363\",\n \"0.48994252\",\n \"0.48985666\",\n \"0.48976874\",\n \"0.48976123\",\n \"0.4891939\",\n \"0.48901013\",\n \"0.48828587\",\n \"0.4879338\",\n \"0.48747703\",\n \"0.48712623\",\n \"0.48690504\",\n \"0.48678458\",\n \"0.48667696\",\n \"0.48658055\",\n \"0.48632565\",\n \"0.48624814\",\n \"0.4859983\",\n \"0.48595476\",\n \"0.4853408\",\n \"0.485117\",\n \"0.4850533\",\n \"0.48424494\",\n \"0.48423806\",\n \"0.48348865\",\n \"0.48314586\",\n \"0.48245698\",\n \"0.4822128\",\n \"0.4818185\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88360,"cells":{"query":{"kind":"string","value":"r\"\"\"Reparameterization trick to sample from N(mu, var) from N(0,1)."},"document":{"kind":"string","value":"def reparameterize(self, mu, log_var):\n std = torch.exp(0.5 * log_var)\n eps = torch.randn_like(std)\n return eps * std + mu"},"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 _reparameterized_sample(self, mean, std):\n eps = torch.zeros(std.size(), device=self.device, dtype=torch.float32).normal_()\n eps = eps.requires_grad_()\n return eps.mul(std).add_(mean)","def sample_low_rank(self, n_samples, mu, logvar, F):\n #F = torch.unsqueeze(F, dim=1).repeat(1, n_samples, 1, 1) # [self.batch_size, n_samples, self.Y_dim, self.rank]\n F = F.repeat(n_samples, 1, 1) # [self.batch_size*n_samples, self.Y_dim, self.rank]\n mu = mu.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\n logvar = logvar.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\n eps_low_rank = torch.randn(self.batch_size*n_samples, self.rank, 1)\n eps_diag = torch.randn(self.batch_size*n_samples, self.Y_dim)\n half_var = torch.exp(0.5*logvar) # [self.batch_size*n_samples, self.Y_dim]\n samples = torch.bmm(F, eps_low_rank).squeeze() + mu + half_var*eps_diag\n samples = samples.reshape(n_samples, self.batch_size, self.Y_dim)\n samples = samples.transpose(0, 1)\n samples = self.unwhiten_back(samples)\n samples = samples.data.cpu().numpy()\n return samples","def sample_uniform(instance, params):\n subpop = np.random.randint(params['N'])\n return sample_from_subpop(instance, params, subpop)","def lhsample(N, bounds):\n \n D = len(bounds)\n sample = vstack(arange(a,b,(b-a)/N) for (a,b) in bounds).T + rand(N,D) / N \n for d in xrange(D): \n shuffle(sample[:,d])\n return sample","def reparameterize(self, mu, logvar):\n std = torch.exp(0.5 * logvar)\n eps = torch.randn_like(std)\n return eps * std + mu","def reparameterize(self, mu, logvar):\n std = torch.exp(0.5 * logvar)\n eps = torch.randn_like(std)\n return eps * std + mu","def sampling(args):\r\n z_mean,z_log_var = args\r\n batch = K.shape(z_mean)[0]\r\n dim = K.shape(z_mean)[1]\r\n epsilon = K.random_normal(shape=(batch,dim),\r\n mean=0.0,stddev=1.0)\r\n std_epsilon = 1e-4\r\n return z_mean + (z_log_var + std_epsilon) * epsilon","def sampling(args: tuple):\n\n # unpack the input tuple\n z_mean, z_log_var = args\n\n # mini-batch size\n mb_size = K.shape(z_mean)[0]\n\n # latent space size\n dim = K.int_shape(z_mean)[1]\n\n # random normal vector with mean=0 and std=1.0\n epsilon = K.random_normal(shape=(mb_size, dim))\n\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:\n std = torch.exp(0.5*logvar)\n # eps=N(0,I), where the I is an identity matrix of same size as std\n eps = torch.randn_like(std)\n return mu + std*eps","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.shape(z_mean)[1]\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sample(self, n):\n unparameterized = [\n v for v in self._weights.keys() if v not in self._weights_p.keys()\n ]\n if len(unparameterized) > 0:\n raise ValueError(\n \"The following variables must be numerically parameterized before sampling: {0}\".format(\n unparameterized\n )\n )\n mu, cov = self.parameterized_mean_cov()\n cov = np.asarray(cov).astype(np.float64)\n mu = np.asarray(mu).astype(np.float64)\n return np.random.multivariate_normal(mu.ravel(), cov, size=n)","def posterior_sampler(self, nsamples, seed=0, verbose=True):\n\n import random\n\n random.seed(seed)\n sample = self.get_chain()[-self.get_tune:]\n sample = sample.reshape(-1, sample.shape[-1])\n sample = random.choices(sample, k=nsamples)\n\n return sample","def sampling(args):\r\n\r\n z_mean, z_log_var = args\r\n batch = K.shape(z_mean)[0]\r\n dim = K.int_shape(z_mean)[1]\r\n # by default, random_normal has mean=0 and std=1.0\r\n epsilon = K.random_normal(shape=(batch, dim))\r\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(-0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean=0 and std=1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean = 0 and std = 1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def reparameterize(self, mu, logvar):\n eps = torch.randn_like(mu)\n return mu + eps*torch.exp(0.5 * logvar)","def reparameterize(self, mu, logvar):\n eps = torch.randn_like(mu)\n return mu + eps*torch.exp(0.5 * logvar)","def reparameterize(self, mu, logvar):\n eps = torch.randn_like(mu)\n return mu + eps*torch.exp(0.5 * logvar)","def reparameterize(self, mu, logvar):\n eps = torch.randn_like(mu)\n return mu + eps*torch.exp(0.5 * logvar)","def normal_sample(mu, sigma):\n return mu + sigma * torch.randn_like(sigma)","def latent_sample(self, mu, logvar):\n\n # the reparameterization trick\n std = logvar.mul(0.5).exp_()\n eps = torch.empty_like(std).normal_()\n return eps.mul(std).add_(mu)","def sampling(args):\r\n z_mean, z_log_var = args\r\n # K is the keras backend\r\n batch = K.shape(z_mean)[0]\r\n dim = K.int_shape(z_mean)[1]\r\n # by default, random_normal has mean=0 and std=1.0\r\n epsilon = K.random_normal(shape=(batch, dim))\r\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\r\n z_mean, z_log_var = args\r\n # K is the keras backend\r\n batch = K.shape(z_mean)[0]\r\n dim = K.int_shape(z_mean)[1]\r\n # by default, random_normal has mean=0 and std=1.0\r\n epsilon = K.random_normal(shape=(batch, dim))\r\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sample_from_prior(self, n_samples):\n pass","def reparametrize(self, mu, logvar):\n std = logvar.div(2).exp()\n eps = torch.Tensor(std.data.new(std.size()).normal_())\n return mu + std * eps","def sample_prior(size):\n return torch.randn(size)","def sampling(self, args):\n self.z_mean, self.z_log_var = args\n batch = K.shape(self.z_mean)[0]\n dim = K.int_shape(self.z_mean)[1]\n epsilon = K.random_uniform(shape=(batch, dim))\n \n return self.z_mean + K.exp(0.5 * self.z_log_var) * epsilon","def _sampling_normal(self, args):\n z_mean, z_log_var = args\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))","def _sampling_normal(self, args):\n z_mean, z_log_var = args\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))","def _sampling_normal(self, args):\n z_mean, z_log_var = args\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))","def _sampling_normal(self, args):\n z_mean, z_log_var = args\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))","def _sampling_normal(self, args):\n z_mean, z_log_var = args\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))","def sample_uniform():\n global samples_uniform, isample_uniform\n\n # sample of U(0, 1)\n u = samples_uniform[isample_uniform]\n\n # moving to next index of samples global array\n isample_uniform += 1\n if isample_uniform >= len(samples_uniform):\n # exhausted all samples -> re-drawing samples from U(0, 1)\n samples_uniform = np.random.uniform(size=SIZE_SAMPLES_UNIFORM)\n isample_uniform = 0\n\n return u","def reparametrize(self, mu, log_var):\n eps = to_var(torch.randn(mu.size(0), mu.size(1)))\n z = mu + eps * torch.exp(0.5 * log_var) # 0.5 to convert var to std\n return z","def reparameterize(self, mean, logvar):\n if self.training:\n std = torch.exp(0.5 * logvar)\n # std = torch.zeros_like(mean) + 0.25\n eps = torch.randn_like(std)\n return mean + std * eps\n else:\n return mean","def sampling(self, args):\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.shape(z_mean)[1]\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def sampling(args):\n t_mean, t_log_var = args\n # YOUR CODE HERE\n epsilon = K.random_normal(t_mean.shape)\n z = epsilon * K.exp(0.5 * t_log_var) + t_mean\n return z","def reset(self, var=0.1):\n\n self.P = 1 / (self.nx * self.ny) # uniform value\n if var != 0:\n self.P *= (1 + var * utils.rand_mat(self.ny, self.nx, 2))\n self.P = self.P / self.P.sum() # PD over all positions","def initial_samples(lb, ub, method, numSamp):\r\n if not len(lb) == len(ub):\r\n raise AssertionError('Lower and upper bounds have different #s of design variables in initial_samples function.')\r\n assert method == 'random' or method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr' or method == 'lhc' or method == 'rand-wor', 'An invalid method was specified for the initial_samples.'\r\n assert (method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr') and len(ub) >= 2 and len(ub) <= 29, 'The Phase space dimensions are outside of the bounds for initial_samples.'\r\n for case in Switch(method):\r\n if case('random'):\r\n s = np.zeros((numSamp, len(lb)))\r\n for i in range(0, numSamp, 1):\r\n s[i, :] = lb + (ub - lb) * rand(len(lb))\r\n\r\n break\r\n if case('rand-wor'):\r\n s = np.zeros((numSamp, len(lb)))\r\n for i in range(0, numSamp, 1):\r\n s[i, :] = choice(len(ub), size=len(ub), replace=False)\r\n\r\n break\r\n if case('nolh'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf = range(q)\r\n if r != 0:\r\n remove = range(dim - r, dim)\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('nolh-rp'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf = random.sample(range(q), q)\r\n if r != 0:\r\n remove = random.sample(range(q - 1), r)\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('nolh-cdr'):\r\n dim = len(ub)\r\n m, q, r = params(dim)\r\n conf, remove = get_cdr_permutations(len(ub))\r\n if remove != []:\r\n nolh = NOLH(conf, remove)\r\n else:\r\n nolh = NOLH(conf)\r\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\r\n ])\r\n break\r\n if case('lhc'):\r\n tmp = lhs(len(lb), samples=numSamp, criterion='center')\r\n s = np.array([ list(lb + (ub - lb) * tmp[i, :]) for i in range(len(tmp[:, 0]))\r\n ])\r\n break\r\n if case():\r\n print 'Somehow you evaded my assert statement - good job!',\r\n print ' However, you still need to use a valid method string.'\r\n\r\n return s","def reparameterize(self, mu, logvar):\n\t\tlogvar = torch.exp(logvar/2)\n\t\tif self.cuda_flag:\n\t\t\tepsilon = torch.randn((mu.size())).float().cuda()\n\t\telse:\n\t\t\tepsilon = torch.randn((mu.size())).float()\n\t\tlatent_vector = torch.mul(epsilon, logvar) + mu \n\t\treturn latent_vector","def sample_from_simplex(rng, dim):\n alpha = [1] * dim\n return rng.dirichlet(alpha)","def reparameterize(self, mean, logvar):\n if self.training:\n std = torch.exp(0.5 * logvar)\n eps = torch.randn_like(std)\n return mean + std * eps\n else:\n # Reconstruction mode\n return mean","def _sample_without_replacement(logits, n_samples):\n z = -K.log(-K.log(K.random_uniform(K.shape(logits))))\n return K.tf.nn.top_k(logits+z, k=n_samples)[1]","def generate_samples(self,n_samples=100):\n rnd_input=torch.randn((n_samples,self._reparam_nodes[1]))\n zeta=rnd_input \n # rnd_input=torch.where((rnd_input>0.5),torch.ones(rnd_input.size()),torch.zeros(rnd_input.size()))\n # print(rnd_input) \n # output, mu, logvar, zeta=self.forward(rnd_input)\n # mu = self._reparam_layers['mu'](rnd_input)\n # logvar = self._reparam_layers['var'](rnd_input)\n # zeta = self.reparameterize(mu, logvar)\n output = self.decoder.decode(zeta)\n return output","def easy_sample(self, num, **kwargs):\n return self.preprocess(self.sample(num, **kwargs), **kwargs)","def rvs(self, mu,size=None, nsample=1e3, **kwargs):\n # faster than resample\n xrange = self._xrange_nonzero_(mu)\n x = np.linspace(xrange[0], xrange[1], int(nsample))\n return np.random.choice(x, p= self.pdf(x, mu) / self.pdf(x, mu).sum(), size=size)","def sample_from_prior(self, n_samples):\n\n p0 = self.min + self.rng.rand(n_samples) * (self.max - self.min)\n return p0[:, np.newaxis]","def randomize(self, rand_gen=None, *args, **kwargs):\n if rand_gen is None:\n rand_gen = np.random.normal\n # first take care of all parameters (from N(0,1))\n x = rand_gen(size=self._size_transformed(), *args, **kwargs)\n updates = self.update_model()\n self.update_model(False) # Switch off the updates\n self.optimizer_array = x # makes sure all of the tied parameters get the same init (since there's only one prior object...)\n # now draw from prior where possible\n x = self.param_array.copy()\n #Py3 fix\n #[np.put(x, ind, p.rvs(ind.size)) for p, ind in self.priors.iteritems() if not p is None]\n [np.put(x, ind, p.rvs(ind.size)) for p, ind in self.priors.items() if not p is None]\n unfixlist = np.ones((self.size,),dtype=np.bool)\n unfixlist[self.constraints[__fixed__]] = False\n self.param_array.flat[unfixlist] = x.view(np.ndarray).ravel()[unfixlist]\n self.update_model(updates)","def sample_from(space):\n distrs = {\n 'choice': choice,\n 'randint': randint,\n 'uniform': uniform,\n 'normal': normal,\n }\n s = space[0]\n\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\n\n log = s.startswith('log_')\n s = s[len('log_'):] if log else s\n\n quantized = s.startswith('q')\n s = s[1:] if quantized else s\n\n distr = distrs[s]\n if s == 'choice':\n return distr(space[1])\n samp = distr(space[1], space[2])\n if log:\n samp = np.exp(samp)\n if quantized:\n samp = round((samp / space[3]) * space[3])\n return samp","def bootstrap_resample(X, n=None):\r\n if n == None:\r\n n = len(X)\r\n \r\n resample_i = np.floor(np.random.rand(n)*len(X)).astype(int)\r\n X_resample = X[resample_i]\r\n return X_resample","def sample_GP_prior(x_test, mean_func, cov_func, kernel_params, \n\t\t\t\t\tseed=42, n_samples=5):\n m = mean_func(x_test)\n k = cov_func(x_test, x_test, *kernel_params)\n prng = np.random.RandomState(int(seed))\n sample = prng.multivariate_normal(m, k, n_samples)\n return sample","def sample(read_sampler, n, array, res=1.0, prng = np.random.RandomState()):\n for read in read_sampler.pull_reads(n, prng):\n map_read(array, read, res)","def _generate(self, **kwargs):\n N = self.parameter_schema['N']\n parameter_count = len(self._parameter_names)\n common_override_kwargs = {}\n override_kwargs = self._sampler_overrides(common_override_kwargs)\n if kwargs:\n kwargs.update(override_kwargs)\n else:\n kwargs = override_kwargs\n __import__(\"SALib.sample\", fromlist=[self.sampler_class])\n sampler = getattr(SALib.sample, self.sampler_class)\n problem = self.parameter_schema[\"problem\"]\n self._samples = sampler.sample(problem, N, **kwargs)\n self._samples = numpy.unique(self._samples, axis=0)\n super()._generate()","def _sample_with_replacement(logits, n_samples):\n if hasattr(K.tf, \"random\") and hasattr(K.tf.random, \"categorical\"):\n return K.tf.random.categorical(logits, n_samples, dtype=\"int32\")\n else:\n return K.tf.multinomial(logits, n_samples, output_dtype=\"int32\")","def under_sample(pos_nids, neg_nids, scale=1):\n index = np.arange(neg_nids.shape[0])\n index = np.random.RandomState().permutation(index)\n N = min(int(pos_nids.shape[0] * scale), neg_nids.shape[0])\n index = index[0: N]\n neg_sampled = neg_nids[index]\n sampled_nids = torch.cat((pos_nids, neg_sampled))\n\n return sampled_nids","def sample_posterior(self):\n \n# print (\"SAMPLING FROM LINEAR SIMILARITY VB\")\n if (self.posterior_mean == False):\n self.weight = Vil.sample_posterior(self.mu_weight, Vil.softplus(self.rho_weight))\n self.bias = Vil.sample_posterior(self.mu_bias, Vil.softplus(self.rho_bias))\n# print (self.bias)\n else:\n self.weight.data = self.mu_weight.data\n self.bias.data = self.mu_bias.data","def sample(self, n_samples, sample_seed):\n self.seed_samples(sample_seed)\n eps = torch.randn(self.batch_size, n_samples, self.Y_dim)\n samples = eps*torch.exp(0.5*self.logvar.unsqueeze(1)) + self.mu.unsqueeze(1)\n samples = self.unwhiten_back(samples)\n samples = samples.data.cpu().numpy()\n return samples","def sample(self, mean, std, n_samples, sample_seed):\n self.seed_samples(sample_seed)\n self.Y_mean = mean\n self.Y_std = std\n eps = torch.randn(self.batch_size, n_samples, self.Y_dim)\n samples = eps*torch.exp(0.5*self.logvar.unsqueeze(1)) + self.mu.unsqueeze(1)\n samples = self.unwhiten_back(samples)\n samples = samples.data.cpu().numpy()\n return samples","def sample_parameters_prior(self, n_samples, random_seed=None):\n\n if random_seed is not None:\n np.random.seed(random_seed)\n samples = []\n samples.append(self.var_noise.sample_from_prior(n_samples))\n samples.append(self.mean.sample_from_prior(n_samples))\n samples.append(self.kernel.sample_parameters(n_samples))\n\n return np.concatenate(samples, 1)","def sample_from_prior(self, n_samples):\n\n p0 = self.rng.normal(loc=self.mean, scale=self.sigma, size=n_samples)\n return p0[:, np.newaxis]","def sample_mean_var_unbiased(x):\n n = len(x)\n assert(n > 0)\n if n == 1:\n return x[0], float('Inf')\n mean, v = sample_mean_var_ml(x)\n var = v*n/(n-1)\n return mean, var","def sampler(QU, qu, x_mean, x_err, mask, data_mean,\\\n Nside=256, Niter=10000, R_Pp=None):\n \n print(data_mean)\n print(x_mean, np.shape(x_mean))\n print(x_err)\n N = len(mask)\n QU_model = np.full((2, hp.nside2npix(Nside)), np.nan)\n QU_star = np.full((2, hp.nside2npix(Nside)), np.nan)\n model_err = np.full((3, hp.nside2npix(Nside)), np.nan)\n star_err = np.full((3, hp.nside2npix(Nside)), np.nan)\n burnin = int(Niter/2)\n \n t0 = time.time()\n # Initialize function:\n log_like = partial(logLike, data=QU[:,mask])\n log_prior = partial(logPrior, mu=data_mean, sigma=x_err)\n func = partial(QU_func, qu=qu[:,mask])\n print(np.mean(data_mean[N:-1])) \n print(log_like(func(data_mean)))\n cov0 = Cov(x_mean)\n #print(cov0)\n\n # Initialize:\n params0, model0, loglike0, logprior0 = Initialize(log_like,\\\n log_prior,\\\n func, x_mean,\\\n cov0)\n #sys.exit()\n # Metropolis Hastrings:\n params_maxL, params = MH(log_like, log_prior, func, params0,\\\n model0, loglike0, logprior0, x_mean,\\\n cov0, burnin, Niter)\n\n t1 = time.time()\n print('Sampling time: {} s'.format(t1-t0))\n print(params_maxL[:len(mask)], params_maxL[len(mask):-1], params_maxL[-1])\n print_params(params_maxL, int((len(x_mean)-1)/2))\n \n #print(np.std(params[burnin:,:], axis=0))\n #print(np.shape(params))\n QU_model[:,mask] = QU_func(params_maxL, qu[:,mask])\n QU_star[:,mask] = QU_func(params_maxL, qu[:,mask], star=True)\n bkgr_model = background(params_maxL[len(mask):])\n sample_err = Error_estimation(params[burnin:, :], par=True) #!\n model_err[:,mask], star_err[:,mask], bkgr_err\\\n = Error_estimation(params[burnin:,:], qu[:,mask])\n\n mod0 = QU_func(data_mean, qu[:,mask])\n plt.figure()\n plt.plot(qu[0,mask], QU[0,mask], '.k')\n plt.plot(qu[1,mask], QU[1,mask], '.b')\n plt.scatter(qu[0,mask], QU_model[0,mask], marker='x', c='gray')\n plt.scatter(qu[1,mask], QU_model[1,mask], marker='x', c='skyblue')\n #plt.scatter(qu[0,mask], mod0[0,:], marker='^', c='orange')\n #plt.scatter(qu[1,mask], mod0[1,:], marker='^', c='g')\n #\"\"\"\n x = np.linspace(np.min(qu), np.max(qu), 10)\n b = np.mean(bkgr_model, axis=1)\n print(b, np.shape(model_err), '<-----------')\n print(np.corrcoef(params_maxL, data_mean))\n\n plt.plot(x, -np.mean(params_maxL[:N])*x, '-r')\n plt.plot(x, -np.mean(params_maxL[:N])*x + b[0], '-k')\n plt.plot(x, -np.mean(params_maxL[:N])*x + b[1], '-b')\n plt.grid(True)\n #\"\"\"\n \n compare_params(params_maxL, data_mean, N)\n \n plot_params(params_maxL, xlab='hei', ylab='hopp')\n #plot_params(data_mean, xlab='hei', ylab='hopp')\n plot_params(params[:,:], xlab='hei', ylab='hopp')\n #plot_params(params[burnin:,:], hist=True, xlab='hei', ylab='hopp')\n print(np.std(params[burnin:,:], axis=0))\n #plt.show()\n #sys.exit()\n return([QU_model, QU_star, bkgr_model, params_maxL, params[burnin:,:]],\\\n [model_err, star_err, bkgr_err, sample_err])\n # end","def initial_sampling(self, params):\n i = params\n theta_star = self.priors_sample()\n model = self.simz( theta_star )\n rho = test_dist(self.data, model)\n while rho > self.eps0: \n theta_star = self.priors_sample()\n model = self.simz( theta_star )\n rho = test_dist(self.data, model)\n data_list = [np.int(i)]\n\n for i_param in xrange(self.n_params): \n data_list.append(theta_star[i_param])\n data_list.append(1./np.float(self.N))\n data_list.append(rho)\n\treturn np.array(data_list)","def posterior_sample_parameter(self, parameter):\n pass","def sample (self, n):\n y = self.bins\n x = np.r_[0, self.values.cumsum ()] / self.sum\n # interpolate inverse CDF\n out = np.interp (np.random.random (n), x, y)\n if n == 1:\n return out[0]\n else:\n return out.reshape ((n,))","def bootstrap_resample(X, n=None):\r\n if n == None:\r\n n = len(X)\r\n\r\n resample_i = N.floor(N.random.rand(n)*len(X)).astype(int)\r\n X_resample = X[resample_i]\r\n return X_resample","def _sample_likelihood_params(self):\r\n self._sample_omega()\r\n self._sample_beta()\r\n self._sample_r()","def Sample(n=6):\n t = [random.normalvariate(0.0, 1.0) for i in range(n)]\n t.sort()\n return t","def _choose_sample(self):\n\n \t #periodically generate a new reconstruction for the purposes of sampling","def sample(self, n):\n raise NotImplementedError","def gen_noise(sample_size, latent):\r\n\treturn Variable(torch.randn(sample_size, latent))","def sampling(args):\n z_mean, z_log_sigma = args\n epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim), mean = 0., stddev=0.1)\n return z_mean + K.exp(z_log_sigma) * epsilon","def __sample(self, data, los, n: Optional[int], random: bool):\n if n is None:\n n = len(data)\n else:\n n = min(len(data), n)\n # Uniform random sampling from our data array\n indices = list(range(len(data)))\n if random:\n np.random.shuffle(indices)\n indices = indices[:n]\n data = torch.Tensor(data[indices])\n los = torch.Tensor(los[indices])\n if self.device != 'cpu' and 'cuda' in self.device.type:\n data = data.cuda()\n los = los.cuda()\n return data, los","def sample_full_rank(self, n_samples, mu, tril_elements, as_numpy=True):\n samples = torch.zeros([self.batch_size, n_samples, self.Y_dim])\n for b in range(self.batch_size):\n tril = torch.zeros([self.Y_dim, self.Y_dim], device=self.device, dtype=None)\n tril[self.tril_idx[0], self.tril_idx[1]] = tril_elements[b, :]\n log_diag_tril = torch.diagonal(tril, offset=0, dim1=0, dim2=1)\n tril[torch.eye(self.Y_dim, dtype=bool)] = torch.exp(log_diag_tril)\n prec_mat = torch.mm(tril, tril.T) # [Y_dim, Y_dim]\n mvn = torch.distributions.multivariate_normal.MultivariateNormal(loc=mu[b, :], precision_matrix=prec_mat)\n sample_b = mvn.sample([n_samples,])\n samples[b, :, :] = sample_b\n samples = self.unwhiten_back(samples)\n if as_numpy:\n return samples.cpu().numpy()\n else:\n return samples","def uniform_sample(x):\n return np.random.choice(x)","def simple_sampler(fun, start, sigma, iterations, verbose=False):\n mean = np.zeros(len(start))\n cov = np.eye(len(start)) * sigma\n\n if isinstance(start, np.ndarray):\n previous = start\n else:\n previous = np.array(start)\n\n f_previous = fun(previous)\n\n samples = np.zeros((iterations, len(start)))\n acceptance = 0\n for i in range(iterations):\n proposal = previous + np.random.multivariate_normal(mean=mean, cov=cov)\n f_proposal = fun(proposal)\n fun(previous)\n if (np.log(np.random.rand())) < (f_proposal - f_previous):\n previous = proposal\n acceptance += 1\n samples[i] = np.array(previous)\n\n if verbose:\n print('sampler acceptance = {0:.3f}'.format(acceptance / iterations))\n\n return samples","def sample_from_prior(self, *args, **kwargs):\n pass","def sample_noise(batch_size, dim):\n\n return tf.random_uniform([batch_size, dim], minval=-1, maxval=1)","def sample_from_distribution(n, param_dict, seed=None):\n\n parametric_family = param_dict['parametric_family']\n true_parameters = param_dict['true_parameters']\n\n eval_str = 'scipy.stats.' + str(parametric_family) + \\\n '.rvs(' + str(true_parameters)[1:-1] + ',size=n, random_state=seed)'\n\n eval_str = eval_str.replace(\"'\", \"\").replace(\":\", \"=\")\n output_vec = eval(eval_str)\n return np.reshape(output_vec, (len(output_vec), 1))","def sample_parameters(self, n_samples, start_point=None, random_seed=None):\n\n if random_seed is not None:\n np.random.seed(random_seed)\n\n samples = []\n\n if start_point is None:\n start_point = self.samples_parameters[-1]\n\n\n n_samples *= (self.thinning + 1)\n n_samples = int(n_samples)\n\n if len(self.slice_samplers) == 1:\n for sample in xrange(n_samples):\n start_point_ = None\n n_try = 0\n points = separate_vector(start_point, self.length_scale_indexes)\n while start_point_ is None and n_try < 10:\n try:\n start_point_ = \\\n self.slice_samplers[0].slice_sample(points[0], points[1], *(self, ))\n except Exception as e:\n n_try += 1\n start_point_ = None\n if start_point_ is None:\n logger.info('program failed to compute a sample of the parameters')\n sys.exit(1)\n start_point = combine_vectors(start_point_, points[1], self.length_scale_indexes)\n # start_point = start_point_\n samples.append(start_point)\n return samples[::self.thinning + 1]\n\n for sample in xrange(n_samples):\n points = separate_vector(start_point, self.length_scale_indexes)\n for index, slice in enumerate(self.slice_samplers):\n new_point_ = None\n n_try = 0\n while new_point_ is None and n_try < 10:\n try:\n new_point_ = \\\n slice.slice_sample(points[1 - index], points[index], *(self, ))\n except Exception as e:\n n_try += 1\n new_point_ = None\n if new_point_ is None:\n logger.info('program failed to compute a sample of the parameters')\n sys.exit(1)\n points[1 - index] = new_point_\n start_point = combine_vectors(points[0], points[1], self.length_scale_indexes)\n samples.append(start_point)\n samples_return = samples[::self.thinning + 1]\n self.samples_parameters += samples_return\n\n return samples_return","def sample_from_prior(self):\n raise NotImplementedError","def sample_noise(batch_size, dim):\n temp = torch.rand(batch_size, dim) + torch.rand(batch_size, dim)*(-1)\n\n return temp","def sample_from_posterior(self,\n system: tf.Tensor,\n n_batch: tf.Tensor) -> tf.Tensor:\n gaussian_noise = tf.random_normal(shape=[self.dimensionality *\n self.n_points,\n n_batch],\n dtype=tf.float64)\n mu = self.compute_posterior_mean(system)\n f_var = self.compute_posterior_variance()\n chol_var = tf.cholesky(f_var)\n noise_samples = tf.matmul(chol_var, gaussian_noise)\n samples = tf.reshape(mu, [-1, 1]) + noise_samples\n return tf.reshape(tf.transpose(samples),\n [n_batch, self.dimensionality, self.n_points])","def sampler(self, mean, log_var):\n eps = torch.randn_like(mean).to(self.device)\n z = torch.exp(0.5*log_var) * eps + mean\n return z","def randomize(self):\r\n # first take care of all parameters (from N(0,1))\r\n x = self._get_params_transformed()\r\n x = np.random.randn(x.size)\r\n self._set_params_transformed(x)\r\n # now draw from prior where possible\r\n x = self._get_params()\r\n if self.priors is not None:\r\n [np.put(x, i, p.rvs(1)) for i, p in enumerate(self.priors) if not p is None]\r\n self._set_params(x)\r\n self._set_params_transformed(self._get_params_transformed()) # makes sure all of the tied parameters get the same init (since there's only one prior object...)\r","def init_with_uniform(n, p, param_init):\n if p.dim() == 1:\n nn.init.constant_(p, 0.0)\n logger.info('Initialize %s with %s / %.3f' % (n, 'constant', 0.0))\n elif p.dim() in [2, 3, 4]:\n nn.init.uniform_(p, a=-param_init, b=param_init)\n logger.info('Initialize %s with %s / %.3f' % (n, 'uniform', param_init))\n else:\n raise ValueError(n)","def rand_rate_uni( N, tmin, tmax, **kwargs):\n return np.random.uniform( tmin, tmax, size = N)","def randomize(self):\n #first take care of all parameters (from N(0,1))\n x = self._get_params_transformed()\n x = np.random.randn(x.size)\n self._set_params_transformed(x)\n #now draw from prior where possible\n x = self._get_params()\n [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]\n self._set_params(x)\n self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)","def myTakeStep2(x):\n s = 0.5\n x += np.random.uniform(-s, s, np.shape(x))\n return x","def sample_noise(batch_size, dim):\n noise = torch.rand(batch_size, dim) * 2 - 1\n return noise.view(batch_size, dim, 1, 1)","def random(N, D, rng):\n samples = rng.randn(N, D)\n norm = np.sqrt(np.sum(samples*samples, axis=1))\n return samples/norm[:,None]","def sample(self, n=1):\n raise NotImplementedError","def sample_X(self, m, n):\n return np.random.permutation(m)[:n]","def sample(self, n=1):\n return np.random.vonmises(self.__mu, self.__kappa, n) if n > 1 else np.random.vonmises(self.__mu, self.__kappa)","def generate_samples(self, n_samples):"],"string":"[\n \"def _reparameterized_sample(self, mean, std):\\n eps = torch.zeros(std.size(), device=self.device, dtype=torch.float32).normal_()\\n eps = eps.requires_grad_()\\n return eps.mul(std).add_(mean)\",\n \"def sample_low_rank(self, n_samples, mu, logvar, F):\\n #F = torch.unsqueeze(F, dim=1).repeat(1, n_samples, 1, 1) # [self.batch_size, n_samples, self.Y_dim, self.rank]\\n F = F.repeat(n_samples, 1, 1) # [self.batch_size*n_samples, self.Y_dim, self.rank]\\n mu = mu.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\\n logvar = logvar.repeat(n_samples, 1) # [self.batch_size*n_samples, self.Y_dim]\\n eps_low_rank = torch.randn(self.batch_size*n_samples, self.rank, 1)\\n eps_diag = torch.randn(self.batch_size*n_samples, self.Y_dim)\\n half_var = torch.exp(0.5*logvar) # [self.batch_size*n_samples, self.Y_dim]\\n samples = torch.bmm(F, eps_low_rank).squeeze() + mu + half_var*eps_diag\\n samples = samples.reshape(n_samples, self.batch_size, self.Y_dim)\\n samples = samples.transpose(0, 1)\\n samples = self.unwhiten_back(samples)\\n samples = samples.data.cpu().numpy()\\n return samples\",\n \"def sample_uniform(instance, params):\\n subpop = np.random.randint(params['N'])\\n return sample_from_subpop(instance, params, subpop)\",\n \"def lhsample(N, bounds):\\n \\n D = len(bounds)\\n sample = vstack(arange(a,b,(b-a)/N) for (a,b) in bounds).T + rand(N,D) / N \\n for d in xrange(D): \\n shuffle(sample[:,d])\\n return sample\",\n \"def reparameterize(self, mu, logvar):\\n std = torch.exp(0.5 * logvar)\\n eps = torch.randn_like(std)\\n return eps * std + mu\",\n \"def reparameterize(self, mu, logvar):\\n std = torch.exp(0.5 * logvar)\\n eps = torch.randn_like(std)\\n return eps * std + mu\",\n \"def sampling(args):\\r\\n z_mean,z_log_var = args\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.shape(z_mean)[1]\\r\\n epsilon = K.random_normal(shape=(batch,dim),\\r\\n mean=0.0,stddev=1.0)\\r\\n std_epsilon = 1e-4\\r\\n return z_mean + (z_log_var + std_epsilon) * epsilon\",\n \"def sampling(args: tuple):\\n\\n # unpack the input tuple\\n z_mean, z_log_var = args\\n\\n # mini-batch size\\n mb_size = K.shape(z_mean)[0]\\n\\n # latent space size\\n dim = K.int_shape(z_mean)[1]\\n\\n # random normal vector with mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(mb_size, dim))\\n\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def reparameterize(self, mu: torch.Tensor, logvar: torch.Tensor) -> torch.Tensor:\\n std = torch.exp(0.5*logvar)\\n # eps=N(0,I), where the I is an identity matrix of same size as std\\n eps = torch.randn_like(std)\\n return mu + std*eps\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.shape(z_mean)[1]\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sample(self, n):\\n unparameterized = [\\n v for v in self._weights.keys() if v not in self._weights_p.keys()\\n ]\\n if len(unparameterized) > 0:\\n raise ValueError(\\n \\\"The following variables must be numerically parameterized before sampling: {0}\\\".format(\\n unparameterized\\n )\\n )\\n mu, cov = self.parameterized_mean_cov()\\n cov = np.asarray(cov).astype(np.float64)\\n mu = np.asarray(mu).astype(np.float64)\\n return np.random.multivariate_normal(mu.ravel(), cov, size=n)\",\n \"def posterior_sampler(self, nsamples, seed=0, verbose=True):\\n\\n import random\\n\\n random.seed(seed)\\n sample = self.get_chain()[-self.get_tune:]\\n sample = sample.reshape(-1, sample.shape[-1])\\n sample = random.choices(sample, k=nsamples)\\n\\n return sample\",\n \"def sampling(args):\\r\\n\\r\\n z_mean, z_log_var = args\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.int_shape(z_mean)[1]\\r\\n # by default, random_normal has mean=0 and std=1.0\\r\\n epsilon = K.random_normal(shape=(batch, dim))\\r\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(-0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean=0 and std=1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean = 0 and std = 1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def reparameterize(self, mu, logvar):\\n eps = torch.randn_like(mu)\\n return mu + eps*torch.exp(0.5 * logvar)\",\n \"def reparameterize(self, mu, logvar):\\n eps = torch.randn_like(mu)\\n return mu + eps*torch.exp(0.5 * logvar)\",\n \"def reparameterize(self, mu, logvar):\\n eps = torch.randn_like(mu)\\n return mu + eps*torch.exp(0.5 * logvar)\",\n \"def reparameterize(self, mu, logvar):\\n eps = torch.randn_like(mu)\\n return mu + eps*torch.exp(0.5 * logvar)\",\n \"def normal_sample(mu, sigma):\\n return mu + sigma * torch.randn_like(sigma)\",\n \"def latent_sample(self, mu, logvar):\\n\\n # the reparameterization trick\\n std = logvar.mul(0.5).exp_()\\n eps = torch.empty_like(std).normal_()\\n return eps.mul(std).add_(mu)\",\n \"def sampling(args):\\r\\n z_mean, z_log_var = args\\r\\n # K is the keras backend\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.int_shape(z_mean)[1]\\r\\n # by default, random_normal has mean=0 and std=1.0\\r\\n epsilon = K.random_normal(shape=(batch, dim))\\r\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\r\\n z_mean, z_log_var = args\\r\\n # K is the keras backend\\r\\n batch = K.shape(z_mean)[0]\\r\\n dim = K.int_shape(z_mean)[1]\\r\\n # by default, random_normal has mean=0 and std=1.0\\r\\n epsilon = K.random_normal(shape=(batch, dim))\\r\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sample_from_prior(self, n_samples):\\n pass\",\n \"def reparametrize(self, mu, logvar):\\n std = logvar.div(2).exp()\\n eps = torch.Tensor(std.data.new(std.size()).normal_())\\n return mu + std * eps\",\n \"def sample_prior(size):\\n return torch.randn(size)\",\n \"def sampling(self, args):\\n self.z_mean, self.z_log_var = args\\n batch = K.shape(self.z_mean)[0]\\n dim = K.int_shape(self.z_mean)[1]\\n epsilon = K.random_uniform(shape=(batch, dim))\\n \\n return self.z_mean + K.exp(0.5 * self.z_log_var) * epsilon\",\n \"def _sampling_normal(self, args):\\n z_mean, z_log_var = args\\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))\",\n \"def _sampling_normal(self, args):\\n z_mean, z_log_var = args\\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))\",\n \"def _sampling_normal(self, args):\\n z_mean, z_log_var = args\\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))\",\n \"def _sampling_normal(self, args):\\n z_mean, z_log_var = args\\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))\",\n \"def _sampling_normal(self, args):\\n z_mean, z_log_var = args\\n return sampling_normal(z_mean, z_log_var, (None, self.latent_dim))\",\n \"def sample_uniform():\\n global samples_uniform, isample_uniform\\n\\n # sample of U(0, 1)\\n u = samples_uniform[isample_uniform]\\n\\n # moving to next index of samples global array\\n isample_uniform += 1\\n if isample_uniform >= len(samples_uniform):\\n # exhausted all samples -> re-drawing samples from U(0, 1)\\n samples_uniform = np.random.uniform(size=SIZE_SAMPLES_UNIFORM)\\n isample_uniform = 0\\n\\n return u\",\n \"def reparametrize(self, mu, log_var):\\n eps = to_var(torch.randn(mu.size(0), mu.size(1)))\\n z = mu + eps * torch.exp(0.5 * log_var) # 0.5 to convert var to std\\n return z\",\n \"def reparameterize(self, mean, logvar):\\n if self.training:\\n std = torch.exp(0.5 * logvar)\\n # std = torch.zeros_like(mean) + 0.25\\n eps = torch.randn_like(std)\\n return mean + std * eps\\n else:\\n return mean\",\n \"def sampling(self, args):\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.shape(z_mean)[1]\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def sampling(args):\\n t_mean, t_log_var = args\\n # YOUR CODE HERE\\n epsilon = K.random_normal(t_mean.shape)\\n z = epsilon * K.exp(0.5 * t_log_var) + t_mean\\n return z\",\n \"def reset(self, var=0.1):\\n\\n self.P = 1 / (self.nx * self.ny) # uniform value\\n if var != 0:\\n self.P *= (1 + var * utils.rand_mat(self.ny, self.nx, 2))\\n self.P = self.P / self.P.sum() # PD over all positions\",\n \"def initial_samples(lb, ub, method, numSamp):\\r\\n if not len(lb) == len(ub):\\r\\n raise AssertionError('Lower and upper bounds have different #s of design variables in initial_samples function.')\\r\\n assert method == 'random' or method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr' or method == 'lhc' or method == 'rand-wor', 'An invalid method was specified for the initial_samples.'\\r\\n assert (method == 'nolh' or method == 'nolh-rp' or method == 'nolh-cdr') and len(ub) >= 2 and len(ub) <= 29, 'The Phase space dimensions are outside of the bounds for initial_samples.'\\r\\n for case in Switch(method):\\r\\n if case('random'):\\r\\n s = np.zeros((numSamp, len(lb)))\\r\\n for i in range(0, numSamp, 1):\\r\\n s[i, :] = lb + (ub - lb) * rand(len(lb))\\r\\n\\r\\n break\\r\\n if case('rand-wor'):\\r\\n s = np.zeros((numSamp, len(lb)))\\r\\n for i in range(0, numSamp, 1):\\r\\n s[i, :] = choice(len(ub), size=len(ub), replace=False)\\r\\n\\r\\n break\\r\\n if case('nolh'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf = range(q)\\r\\n if r != 0:\\r\\n remove = range(dim - r, dim)\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('nolh-rp'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf = random.sample(range(q), q)\\r\\n if r != 0:\\r\\n remove = random.sample(range(q - 1), r)\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('nolh-cdr'):\\r\\n dim = len(ub)\\r\\n m, q, r = params(dim)\\r\\n conf, remove = get_cdr_permutations(len(ub))\\r\\n if remove != []:\\r\\n nolh = NOLH(conf, remove)\\r\\n else:\\r\\n nolh = NOLH(conf)\\r\\n s = np.array([ list(lb + (ub - lb) * nolh[i, :]) for i in range(len(nolh[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case('lhc'):\\r\\n tmp = lhs(len(lb), samples=numSamp, criterion='center')\\r\\n s = np.array([ list(lb + (ub - lb) * tmp[i, :]) for i in range(len(tmp[:, 0]))\\r\\n ])\\r\\n break\\r\\n if case():\\r\\n print 'Somehow you evaded my assert statement - good job!',\\r\\n print ' However, you still need to use a valid method string.'\\r\\n\\r\\n return s\",\n \"def reparameterize(self, mu, logvar):\\n\\t\\tlogvar = torch.exp(logvar/2)\\n\\t\\tif self.cuda_flag:\\n\\t\\t\\tepsilon = torch.randn((mu.size())).float().cuda()\\n\\t\\telse:\\n\\t\\t\\tepsilon = torch.randn((mu.size())).float()\\n\\t\\tlatent_vector = torch.mul(epsilon, logvar) + mu \\n\\t\\treturn latent_vector\",\n \"def sample_from_simplex(rng, dim):\\n alpha = [1] * dim\\n return rng.dirichlet(alpha)\",\n \"def reparameterize(self, mean, logvar):\\n if self.training:\\n std = torch.exp(0.5 * logvar)\\n eps = torch.randn_like(std)\\n return mean + std * eps\\n else:\\n # Reconstruction mode\\n return mean\",\n \"def _sample_without_replacement(logits, n_samples):\\n z = -K.log(-K.log(K.random_uniform(K.shape(logits))))\\n return K.tf.nn.top_k(logits+z, k=n_samples)[1]\",\n \"def generate_samples(self,n_samples=100):\\n rnd_input=torch.randn((n_samples,self._reparam_nodes[1]))\\n zeta=rnd_input \\n # rnd_input=torch.where((rnd_input>0.5),torch.ones(rnd_input.size()),torch.zeros(rnd_input.size()))\\n # print(rnd_input) \\n # output, mu, logvar, zeta=self.forward(rnd_input)\\n # mu = self._reparam_layers['mu'](rnd_input)\\n # logvar = self._reparam_layers['var'](rnd_input)\\n # zeta = self.reparameterize(mu, logvar)\\n output = self.decoder.decode(zeta)\\n return output\",\n \"def easy_sample(self, num, **kwargs):\\n return self.preprocess(self.sample(num, **kwargs), **kwargs)\",\n \"def rvs(self, mu,size=None, nsample=1e3, **kwargs):\\n # faster than resample\\n xrange = self._xrange_nonzero_(mu)\\n x = np.linspace(xrange[0], xrange[1], int(nsample))\\n return np.random.choice(x, p= self.pdf(x, mu) / self.pdf(x, mu).sum(), size=size)\",\n \"def sample_from_prior(self, n_samples):\\n\\n p0 = self.min + self.rng.rand(n_samples) * (self.max - self.min)\\n return p0[:, np.newaxis]\",\n \"def randomize(self, rand_gen=None, *args, **kwargs):\\n if rand_gen is None:\\n rand_gen = np.random.normal\\n # first take care of all parameters (from N(0,1))\\n x = rand_gen(size=self._size_transformed(), *args, **kwargs)\\n updates = self.update_model()\\n self.update_model(False) # Switch off the updates\\n self.optimizer_array = x # makes sure all of the tied parameters get the same init (since there's only one prior object...)\\n # now draw from prior where possible\\n x = self.param_array.copy()\\n #Py3 fix\\n #[np.put(x, ind, p.rvs(ind.size)) for p, ind in self.priors.iteritems() if not p is None]\\n [np.put(x, ind, p.rvs(ind.size)) for p, ind in self.priors.items() if not p is None]\\n unfixlist = np.ones((self.size,),dtype=np.bool)\\n unfixlist[self.constraints[__fixed__]] = False\\n self.param_array.flat[unfixlist] = x.view(np.ndarray).ravel()[unfixlist]\\n self.update_model(updates)\",\n \"def sample_from(space):\\n distrs = {\\n 'choice': choice,\\n 'randint': randint,\\n 'uniform': uniform,\\n 'normal': normal,\\n }\\n s = space[0]\\n\\n np.random.seed(int(time.time() + np.random.randint(0, 300)))\\n\\n log = s.startswith('log_')\\n s = s[len('log_'):] if log else s\\n\\n quantized = s.startswith('q')\\n s = s[1:] if quantized else s\\n\\n distr = distrs[s]\\n if s == 'choice':\\n return distr(space[1])\\n samp = distr(space[1], space[2])\\n if log:\\n samp = np.exp(samp)\\n if quantized:\\n samp = round((samp / space[3]) * space[3])\\n return samp\",\n \"def bootstrap_resample(X, n=None):\\r\\n if n == None:\\r\\n n = len(X)\\r\\n \\r\\n resample_i = np.floor(np.random.rand(n)*len(X)).astype(int)\\r\\n X_resample = X[resample_i]\\r\\n return X_resample\",\n \"def sample_GP_prior(x_test, mean_func, cov_func, kernel_params, \\n\\t\\t\\t\\t\\tseed=42, n_samples=5):\\n m = mean_func(x_test)\\n k = cov_func(x_test, x_test, *kernel_params)\\n prng = np.random.RandomState(int(seed))\\n sample = prng.multivariate_normal(m, k, n_samples)\\n return sample\",\n \"def sample(read_sampler, n, array, res=1.0, prng = np.random.RandomState()):\\n for read in read_sampler.pull_reads(n, prng):\\n map_read(array, read, res)\",\n \"def _generate(self, **kwargs):\\n N = self.parameter_schema['N']\\n parameter_count = len(self._parameter_names)\\n common_override_kwargs = {}\\n override_kwargs = self._sampler_overrides(common_override_kwargs)\\n if kwargs:\\n kwargs.update(override_kwargs)\\n else:\\n kwargs = override_kwargs\\n __import__(\\\"SALib.sample\\\", fromlist=[self.sampler_class])\\n sampler = getattr(SALib.sample, self.sampler_class)\\n problem = self.parameter_schema[\\\"problem\\\"]\\n self._samples = sampler.sample(problem, N, **kwargs)\\n self._samples = numpy.unique(self._samples, axis=0)\\n super()._generate()\",\n \"def _sample_with_replacement(logits, n_samples):\\n if hasattr(K.tf, \\\"random\\\") and hasattr(K.tf.random, \\\"categorical\\\"):\\n return K.tf.random.categorical(logits, n_samples, dtype=\\\"int32\\\")\\n else:\\n return K.tf.multinomial(logits, n_samples, output_dtype=\\\"int32\\\")\",\n \"def under_sample(pos_nids, neg_nids, scale=1):\\n index = np.arange(neg_nids.shape[0])\\n index = np.random.RandomState().permutation(index)\\n N = min(int(pos_nids.shape[0] * scale), neg_nids.shape[0])\\n index = index[0: N]\\n neg_sampled = neg_nids[index]\\n sampled_nids = torch.cat((pos_nids, neg_sampled))\\n\\n return sampled_nids\",\n \"def sample_posterior(self):\\n \\n# print (\\\"SAMPLING FROM LINEAR SIMILARITY VB\\\")\\n if (self.posterior_mean == False):\\n self.weight = Vil.sample_posterior(self.mu_weight, Vil.softplus(self.rho_weight))\\n self.bias = Vil.sample_posterior(self.mu_bias, Vil.softplus(self.rho_bias))\\n# print (self.bias)\\n else:\\n self.weight.data = self.mu_weight.data\\n self.bias.data = self.mu_bias.data\",\n \"def sample(self, n_samples, sample_seed):\\n self.seed_samples(sample_seed)\\n eps = torch.randn(self.batch_size, n_samples, self.Y_dim)\\n samples = eps*torch.exp(0.5*self.logvar.unsqueeze(1)) + self.mu.unsqueeze(1)\\n samples = self.unwhiten_back(samples)\\n samples = samples.data.cpu().numpy()\\n return samples\",\n \"def sample(self, mean, std, n_samples, sample_seed):\\n self.seed_samples(sample_seed)\\n self.Y_mean = mean\\n self.Y_std = std\\n eps = torch.randn(self.batch_size, n_samples, self.Y_dim)\\n samples = eps*torch.exp(0.5*self.logvar.unsqueeze(1)) + self.mu.unsqueeze(1)\\n samples = self.unwhiten_back(samples)\\n samples = samples.data.cpu().numpy()\\n return samples\",\n \"def sample_parameters_prior(self, n_samples, random_seed=None):\\n\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n samples = []\\n samples.append(self.var_noise.sample_from_prior(n_samples))\\n samples.append(self.mean.sample_from_prior(n_samples))\\n samples.append(self.kernel.sample_parameters(n_samples))\\n\\n return np.concatenate(samples, 1)\",\n \"def sample_from_prior(self, n_samples):\\n\\n p0 = self.rng.normal(loc=self.mean, scale=self.sigma, size=n_samples)\\n return p0[:, np.newaxis]\",\n \"def sample_mean_var_unbiased(x):\\n n = len(x)\\n assert(n > 0)\\n if n == 1:\\n return x[0], float('Inf')\\n mean, v = sample_mean_var_ml(x)\\n var = v*n/(n-1)\\n return mean, var\",\n \"def sampler(QU, qu, x_mean, x_err, mask, data_mean,\\\\\\n Nside=256, Niter=10000, R_Pp=None):\\n \\n print(data_mean)\\n print(x_mean, np.shape(x_mean))\\n print(x_err)\\n N = len(mask)\\n QU_model = np.full((2, hp.nside2npix(Nside)), np.nan)\\n QU_star = np.full((2, hp.nside2npix(Nside)), np.nan)\\n model_err = np.full((3, hp.nside2npix(Nside)), np.nan)\\n star_err = np.full((3, hp.nside2npix(Nside)), np.nan)\\n burnin = int(Niter/2)\\n \\n t0 = time.time()\\n # Initialize function:\\n log_like = partial(logLike, data=QU[:,mask])\\n log_prior = partial(logPrior, mu=data_mean, sigma=x_err)\\n func = partial(QU_func, qu=qu[:,mask])\\n print(np.mean(data_mean[N:-1])) \\n print(log_like(func(data_mean)))\\n cov0 = Cov(x_mean)\\n #print(cov0)\\n\\n # Initialize:\\n params0, model0, loglike0, logprior0 = Initialize(log_like,\\\\\\n log_prior,\\\\\\n func, x_mean,\\\\\\n cov0)\\n #sys.exit()\\n # Metropolis Hastrings:\\n params_maxL, params = MH(log_like, log_prior, func, params0,\\\\\\n model0, loglike0, logprior0, x_mean,\\\\\\n cov0, burnin, Niter)\\n\\n t1 = time.time()\\n print('Sampling time: {} s'.format(t1-t0))\\n print(params_maxL[:len(mask)], params_maxL[len(mask):-1], params_maxL[-1])\\n print_params(params_maxL, int((len(x_mean)-1)/2))\\n \\n #print(np.std(params[burnin:,:], axis=0))\\n #print(np.shape(params))\\n QU_model[:,mask] = QU_func(params_maxL, qu[:,mask])\\n QU_star[:,mask] = QU_func(params_maxL, qu[:,mask], star=True)\\n bkgr_model = background(params_maxL[len(mask):])\\n sample_err = Error_estimation(params[burnin:, :], par=True) #!\\n model_err[:,mask], star_err[:,mask], bkgr_err\\\\\\n = Error_estimation(params[burnin:,:], qu[:,mask])\\n\\n mod0 = QU_func(data_mean, qu[:,mask])\\n plt.figure()\\n plt.plot(qu[0,mask], QU[0,mask], '.k')\\n plt.plot(qu[1,mask], QU[1,mask], '.b')\\n plt.scatter(qu[0,mask], QU_model[0,mask], marker='x', c='gray')\\n plt.scatter(qu[1,mask], QU_model[1,mask], marker='x', c='skyblue')\\n #plt.scatter(qu[0,mask], mod0[0,:], marker='^', c='orange')\\n #plt.scatter(qu[1,mask], mod0[1,:], marker='^', c='g')\\n #\\\"\\\"\\\"\\n x = np.linspace(np.min(qu), np.max(qu), 10)\\n b = np.mean(bkgr_model, axis=1)\\n print(b, np.shape(model_err), '<-----------')\\n print(np.corrcoef(params_maxL, data_mean))\\n\\n plt.plot(x, -np.mean(params_maxL[:N])*x, '-r')\\n plt.plot(x, -np.mean(params_maxL[:N])*x + b[0], '-k')\\n plt.plot(x, -np.mean(params_maxL[:N])*x + b[1], '-b')\\n plt.grid(True)\\n #\\\"\\\"\\\"\\n \\n compare_params(params_maxL, data_mean, N)\\n \\n plot_params(params_maxL, xlab='hei', ylab='hopp')\\n #plot_params(data_mean, xlab='hei', ylab='hopp')\\n plot_params(params[:,:], xlab='hei', ylab='hopp')\\n #plot_params(params[burnin:,:], hist=True, xlab='hei', ylab='hopp')\\n print(np.std(params[burnin:,:], axis=0))\\n #plt.show()\\n #sys.exit()\\n return([QU_model, QU_star, bkgr_model, params_maxL, params[burnin:,:]],\\\\\\n [model_err, star_err, bkgr_err, sample_err])\\n # end\",\n \"def initial_sampling(self, params):\\n i = params\\n theta_star = self.priors_sample()\\n model = self.simz( theta_star )\\n rho = test_dist(self.data, model)\\n while rho > self.eps0: \\n theta_star = self.priors_sample()\\n model = self.simz( theta_star )\\n rho = test_dist(self.data, model)\\n data_list = [np.int(i)]\\n\\n for i_param in xrange(self.n_params): \\n data_list.append(theta_star[i_param])\\n data_list.append(1./np.float(self.N))\\n data_list.append(rho)\\n\\treturn np.array(data_list)\",\n \"def posterior_sample_parameter(self, parameter):\\n pass\",\n \"def sample (self, n):\\n y = self.bins\\n x = np.r_[0, self.values.cumsum ()] / self.sum\\n # interpolate inverse CDF\\n out = np.interp (np.random.random (n), x, y)\\n if n == 1:\\n return out[0]\\n else:\\n return out.reshape ((n,))\",\n \"def bootstrap_resample(X, n=None):\\r\\n if n == None:\\r\\n n = len(X)\\r\\n\\r\\n resample_i = N.floor(N.random.rand(n)*len(X)).astype(int)\\r\\n X_resample = X[resample_i]\\r\\n return X_resample\",\n \"def _sample_likelihood_params(self):\\r\\n self._sample_omega()\\r\\n self._sample_beta()\\r\\n self._sample_r()\",\n \"def Sample(n=6):\\n t = [random.normalvariate(0.0, 1.0) for i in range(n)]\\n t.sort()\\n return t\",\n \"def _choose_sample(self):\\n\\n \\t #periodically generate a new reconstruction for the purposes of sampling\",\n \"def sample(self, n):\\n raise NotImplementedError\",\n \"def gen_noise(sample_size, latent):\\r\\n\\treturn Variable(torch.randn(sample_size, latent))\",\n \"def sampling(args):\\n z_mean, z_log_sigma = args\\n epsilon = K.random_normal(shape=(K.shape(z_mean)[0], latent_dim), mean = 0., stddev=0.1)\\n return z_mean + K.exp(z_log_sigma) * epsilon\",\n \"def __sample(self, data, los, n: Optional[int], random: bool):\\n if n is None:\\n n = len(data)\\n else:\\n n = min(len(data), n)\\n # Uniform random sampling from our data array\\n indices = list(range(len(data)))\\n if random:\\n np.random.shuffle(indices)\\n indices = indices[:n]\\n data = torch.Tensor(data[indices])\\n los = torch.Tensor(los[indices])\\n if self.device != 'cpu' and 'cuda' in self.device.type:\\n data = data.cuda()\\n los = los.cuda()\\n return data, los\",\n \"def sample_full_rank(self, n_samples, mu, tril_elements, as_numpy=True):\\n samples = torch.zeros([self.batch_size, n_samples, self.Y_dim])\\n for b in range(self.batch_size):\\n tril = torch.zeros([self.Y_dim, self.Y_dim], device=self.device, dtype=None)\\n tril[self.tril_idx[0], self.tril_idx[1]] = tril_elements[b, :]\\n log_diag_tril = torch.diagonal(tril, offset=0, dim1=0, dim2=1)\\n tril[torch.eye(self.Y_dim, dtype=bool)] = torch.exp(log_diag_tril)\\n prec_mat = torch.mm(tril, tril.T) # [Y_dim, Y_dim]\\n mvn = torch.distributions.multivariate_normal.MultivariateNormal(loc=mu[b, :], precision_matrix=prec_mat)\\n sample_b = mvn.sample([n_samples,])\\n samples[b, :, :] = sample_b\\n samples = self.unwhiten_back(samples)\\n if as_numpy:\\n return samples.cpu().numpy()\\n else:\\n return samples\",\n \"def uniform_sample(x):\\n return np.random.choice(x)\",\n \"def simple_sampler(fun, start, sigma, iterations, verbose=False):\\n mean = np.zeros(len(start))\\n cov = np.eye(len(start)) * sigma\\n\\n if isinstance(start, np.ndarray):\\n previous = start\\n else:\\n previous = np.array(start)\\n\\n f_previous = fun(previous)\\n\\n samples = np.zeros((iterations, len(start)))\\n acceptance = 0\\n for i in range(iterations):\\n proposal = previous + np.random.multivariate_normal(mean=mean, cov=cov)\\n f_proposal = fun(proposal)\\n fun(previous)\\n if (np.log(np.random.rand())) < (f_proposal - f_previous):\\n previous = proposal\\n acceptance += 1\\n samples[i] = np.array(previous)\\n\\n if verbose:\\n print('sampler acceptance = {0:.3f}'.format(acceptance / iterations))\\n\\n return samples\",\n \"def sample_from_prior(self, *args, **kwargs):\\n pass\",\n \"def sample_noise(batch_size, dim):\\n\\n return tf.random_uniform([batch_size, dim], minval=-1, maxval=1)\",\n \"def sample_from_distribution(n, param_dict, seed=None):\\n\\n parametric_family = param_dict['parametric_family']\\n true_parameters = param_dict['true_parameters']\\n\\n eval_str = 'scipy.stats.' + str(parametric_family) + \\\\\\n '.rvs(' + str(true_parameters)[1:-1] + ',size=n, random_state=seed)'\\n\\n eval_str = eval_str.replace(\\\"'\\\", \\\"\\\").replace(\\\":\\\", \\\"=\\\")\\n output_vec = eval(eval_str)\\n return np.reshape(output_vec, (len(output_vec), 1))\",\n \"def sample_parameters(self, n_samples, start_point=None, random_seed=None):\\n\\n if random_seed is not None:\\n np.random.seed(random_seed)\\n\\n samples = []\\n\\n if start_point is None:\\n start_point = self.samples_parameters[-1]\\n\\n\\n n_samples *= (self.thinning + 1)\\n n_samples = int(n_samples)\\n\\n if len(self.slice_samplers) == 1:\\n for sample in xrange(n_samples):\\n start_point_ = None\\n n_try = 0\\n points = separate_vector(start_point, self.length_scale_indexes)\\n while start_point_ is None and n_try < 10:\\n try:\\n start_point_ = \\\\\\n self.slice_samplers[0].slice_sample(points[0], points[1], *(self, ))\\n except Exception as e:\\n n_try += 1\\n start_point_ = None\\n if start_point_ is None:\\n logger.info('program failed to compute a sample of the parameters')\\n sys.exit(1)\\n start_point = combine_vectors(start_point_, points[1], self.length_scale_indexes)\\n # start_point = start_point_\\n samples.append(start_point)\\n return samples[::self.thinning + 1]\\n\\n for sample in xrange(n_samples):\\n points = separate_vector(start_point, self.length_scale_indexes)\\n for index, slice in enumerate(self.slice_samplers):\\n new_point_ = None\\n n_try = 0\\n while new_point_ is None and n_try < 10:\\n try:\\n new_point_ = \\\\\\n slice.slice_sample(points[1 - index], points[index], *(self, ))\\n except Exception as e:\\n n_try += 1\\n new_point_ = None\\n if new_point_ is None:\\n logger.info('program failed to compute a sample of the parameters')\\n sys.exit(1)\\n points[1 - index] = new_point_\\n start_point = combine_vectors(points[0], points[1], self.length_scale_indexes)\\n samples.append(start_point)\\n samples_return = samples[::self.thinning + 1]\\n self.samples_parameters += samples_return\\n\\n return samples_return\",\n \"def sample_from_prior(self):\\n raise NotImplementedError\",\n \"def sample_noise(batch_size, dim):\\n temp = torch.rand(batch_size, dim) + torch.rand(batch_size, dim)*(-1)\\n\\n return temp\",\n \"def sample_from_posterior(self,\\n system: tf.Tensor,\\n n_batch: tf.Tensor) -> tf.Tensor:\\n gaussian_noise = tf.random_normal(shape=[self.dimensionality *\\n self.n_points,\\n n_batch],\\n dtype=tf.float64)\\n mu = self.compute_posterior_mean(system)\\n f_var = self.compute_posterior_variance()\\n chol_var = tf.cholesky(f_var)\\n noise_samples = tf.matmul(chol_var, gaussian_noise)\\n samples = tf.reshape(mu, [-1, 1]) + noise_samples\\n return tf.reshape(tf.transpose(samples),\\n [n_batch, self.dimensionality, self.n_points])\",\n \"def sampler(self, mean, log_var):\\n eps = torch.randn_like(mean).to(self.device)\\n z = torch.exp(0.5*log_var) * eps + mean\\n return z\",\n \"def randomize(self):\\r\\n # first take care of all parameters (from N(0,1))\\r\\n x = self._get_params_transformed()\\r\\n x = np.random.randn(x.size)\\r\\n self._set_params_transformed(x)\\r\\n # now draw from prior where possible\\r\\n x = self._get_params()\\r\\n if self.priors is not None:\\r\\n [np.put(x, i, p.rvs(1)) for i, p in enumerate(self.priors) if not p is None]\\r\\n self._set_params(x)\\r\\n self._set_params_transformed(self._get_params_transformed()) # makes sure all of the tied parameters get the same init (since there's only one prior object...)\\r\",\n \"def init_with_uniform(n, p, param_init):\\n if p.dim() == 1:\\n nn.init.constant_(p, 0.0)\\n logger.info('Initialize %s with %s / %.3f' % (n, 'constant', 0.0))\\n elif p.dim() in [2, 3, 4]:\\n nn.init.uniform_(p, a=-param_init, b=param_init)\\n logger.info('Initialize %s with %s / %.3f' % (n, 'uniform', param_init))\\n else:\\n raise ValueError(n)\",\n \"def rand_rate_uni( N, tmin, tmax, **kwargs):\\n return np.random.uniform( tmin, tmax, size = N)\",\n \"def randomize(self):\\n #first take care of all parameters (from N(0,1))\\n x = self._get_params_transformed()\\n x = np.random.randn(x.size)\\n self._set_params_transformed(x)\\n #now draw from prior where possible\\n x = self._get_params()\\n [np.put(x,i,p.rvs(1)) for i,p in enumerate(self.priors) if not p is None]\\n self._set_params(x)\\n self._set_params_transformed(self._get_params_transformed())#makes sure all of the tied parameters get the same init (since there's only one prior object...)\",\n \"def myTakeStep2(x):\\n s = 0.5\\n x += np.random.uniform(-s, s, np.shape(x))\\n return x\",\n \"def sample_noise(batch_size, dim):\\n noise = torch.rand(batch_size, dim) * 2 - 1\\n return noise.view(batch_size, dim, 1, 1)\",\n \"def random(N, D, rng):\\n samples = rng.randn(N, D)\\n norm = np.sqrt(np.sum(samples*samples, axis=1))\\n return samples/norm[:,None]\",\n \"def sample(self, n=1):\\n raise NotImplementedError\",\n \"def sample_X(self, m, n):\\n return np.random.permutation(m)[:n]\",\n \"def sample(self, n=1):\\n return np.random.vonmises(self.__mu, self.__kappa, n) if n > 1 else np.random.vonmises(self.__mu, self.__kappa)\",\n \"def generate_samples(self, n_samples):\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6662356","0.65233475","0.65074307","0.644771","0.6394351","0.6394351","0.6386821","0.63468987","0.6301969","0.6298426","0.62799734","0.62720144","0.6258597","0.6256825","0.6253637","0.6253637","0.6253637","0.6253637","0.6253637","0.6240244","0.62155056","0.62155056","0.62155056","0.62155056","0.6205217","0.6189588","0.6165993","0.6165993","0.60726684","0.60644567","0.6057126","0.6022626","0.59841156","0.59841156","0.59841156","0.59841156","0.59841156","0.59710485","0.5969166","0.5956959","0.593751","0.5916619","0.5870072","0.58308935","0.5819348","0.5816325","0.5815927","0.5810334","0.57995266","0.5784051","0.57681155","0.5750154","0.57449466","0.571608","0.5707575","0.57025117","0.56942093","0.56929463","0.5676956","0.56717014","0.5668874","0.56671613","0.5661346","0.5656487","0.56525046","0.5649863","0.5644453","0.5631966","0.561744","0.56097996","0.56063","0.56026983","0.5599889","0.5598833","0.55968165","0.55934525","0.55856365","0.55806243","0.55797","0.55750906","0.5569856","0.5564721","0.55529237","0.55351657","0.5532589","0.5530637","0.55276644","0.5522085","0.5519782","0.5515311","0.55129045","0.5512326","0.55105585","0.5503727","0.5498227","0.549706","0.5494895","0.54930073","0.54875356","0.54816014"],"string":"[\n \"0.6662356\",\n \"0.65233475\",\n \"0.65074307\",\n \"0.644771\",\n \"0.6394351\",\n \"0.6394351\",\n \"0.6386821\",\n \"0.63468987\",\n \"0.6301969\",\n \"0.6298426\",\n \"0.62799734\",\n \"0.62720144\",\n \"0.6258597\",\n \"0.6256825\",\n \"0.6253637\",\n \"0.6253637\",\n \"0.6253637\",\n \"0.6253637\",\n \"0.6253637\",\n \"0.6240244\",\n \"0.62155056\",\n \"0.62155056\",\n \"0.62155056\",\n \"0.62155056\",\n \"0.6205217\",\n \"0.6189588\",\n \"0.6165993\",\n \"0.6165993\",\n \"0.60726684\",\n \"0.60644567\",\n \"0.6057126\",\n \"0.6022626\",\n \"0.59841156\",\n \"0.59841156\",\n \"0.59841156\",\n \"0.59841156\",\n \"0.59841156\",\n \"0.59710485\",\n \"0.5969166\",\n \"0.5956959\",\n \"0.593751\",\n \"0.5916619\",\n \"0.5870072\",\n \"0.58308935\",\n \"0.5819348\",\n \"0.5816325\",\n \"0.5815927\",\n \"0.5810334\",\n \"0.57995266\",\n \"0.5784051\",\n \"0.57681155\",\n \"0.5750154\",\n \"0.57449466\",\n \"0.571608\",\n \"0.5707575\",\n \"0.57025117\",\n \"0.56942093\",\n \"0.56929463\",\n \"0.5676956\",\n \"0.56717014\",\n \"0.5668874\",\n \"0.56671613\",\n \"0.5661346\",\n \"0.5656487\",\n \"0.56525046\",\n \"0.5649863\",\n \"0.5644453\",\n \"0.5631966\",\n \"0.561744\",\n \"0.56097996\",\n \"0.56063\",\n \"0.56026983\",\n \"0.5599889\",\n \"0.5598833\",\n \"0.55968165\",\n \"0.55934525\",\n \"0.55856365\",\n \"0.55806243\",\n \"0.55797\",\n \"0.55750906\",\n \"0.5569856\",\n \"0.5564721\",\n \"0.55529237\",\n \"0.55351657\",\n \"0.5532589\",\n \"0.5530637\",\n \"0.55276644\",\n \"0.5522085\",\n \"0.5519782\",\n \"0.5515311\",\n \"0.55129045\",\n \"0.5512326\",\n \"0.55105585\",\n \"0.5503727\",\n \"0.5498227\",\n \"0.549706\",\n \"0.5494895\",\n \"0.54930073\",\n \"0.54875356\",\n \"0.54816014\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6309882"},"document_rank":{"kind":"string","value":"8"}}},{"rowIdx":88361,"cells":{"query":{"kind":"string","value":"r\"\"\"Computes the VAE loss function. KL(N(\\mu, \\sigma), N(0, 1)) = \\log \\frac{1}{\\sigma} + \\frac{\\sigma^2 + \\mu^2}{2} \\frac{1}{2}"},"document":{"kind":"string","value":"def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\n recons_loss = F.mse_loss(recons, inputs)\n# recons_loss = F.binary_cross_entropy(recons, inputs)\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\n loss = recons_loss - KLD\n return loss, recons_loss, KLD"},"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 vae_loss(recon_x, x, mu_logvar):\n mu = mu_logvar[:, 0:int(mu_logvar.size()[1]/2)]\n logvar = mu_logvar[:, int(mu_logvar.size()[1]/2):]\n# KLD = -0.5 * torch.sum(1 + 2 * logvar - mu.pow(2) - (2 * logvar).exp())\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n# BCE = F.binary_cross_entropy(recon_x.squeeze(), x.squeeze(), reduction='sum')\n MSE = F.mse_loss(recon_x.squeeze(), x.squeeze(), reduction='sum')\n return {'loss': KLD + MSE,\n 'mse': MSE}","def kl_loss(mean, variance):\n kld_value = mean.pow(2).add_(variance.exp()).mul_(-1).add_(1).add_(variance)\n kld = torch.mean(kld_value).mul_(-0.5)\n return kld","def vae_loss(self, inputs, outputs, z_mean, z_log):\n\n reconstruction_loss = self.loss(inputs, outputs)\n reconstruction_loss *= self.n_features_\n kl_loss = 1 + z_log - K.square(z_mean) - K.exp(z_log)\n kl_loss = -0.5 * K.sum(kl_loss, axis=-1)\n kl_loss = self.gamma * K.abs(kl_loss - self.capacity)\n\n return K.mean(reconstruction_loss + kl_loss)","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def kl_divergence(self) -> Tensor:\n return self.variational_strategy.kl_divergence().sum(dim=1).mean()","def kullbackLeibler(mu, log_sigma):\n # (tf.Tensor, tf.Tensor) -> tf.Tensor\n # = -0.5 * (1 + log(sigma**2) - mu**2 - sigma**2)\n return -0.5 * tf.reduce_sum(1 + 2 * log_sigma - mu**2 - tf.exp(2 * log_sigma), 1)","def loss_function(recon_x, x, mu, logvar, input_size):\n BCE = F.binary_cross_entropy(recon_x, x.view(-1, input_size), size_average=False)\n\n # see Appendix B from VAE paper:\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n # https://arxiv.org/abs/1312.6114\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n\n return BCE + KLD","def kl_loss(self):\n return sum([p.kl_loss() for p in self.parameters])","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n\n return reconstruction_loss + kl_normal_loss","def kl_loss(self, simulation, c1 = 1.0, ndims = 2, ehigh = 1e5, emax = 1e10):\n loss = KLLoss(c1, simulation, ndims, ehigh, emax)\n return loss.lossFunction","def VAE_losses(t_logits, t_truncate, mu_logvar0, mu_logvar1, tiny=1e-8):\n # NEW ONE! with different strategy of calculating loss for censoring, adding \\sum p_b, not \\sum w_b*p_b\n # Reconstruction loss\n t_dist = tf.nn.softmax(t_logits)\n reconstruction = -tf.log(tf.reduce_sum(t_dist*t_truncate, axis=1))\n\n # KL divergence\n mu0, logvar0 = tf.split(mu_logvar0, num_or_size_splits=2, axis=1)\n mu1, logvar1 = tf.split(mu_logvar1, num_or_size_splits=2, axis=1)\n\n kl_d = 0.5 * tf.reduce_sum(tf.exp(logvar1-logvar0)\\\n + tf.divide(tf.square(mu0-mu1),tf.exp(logvar0)+tiny) \\\n + logvar0 - logvar1 -1.0, \\\n 1)\n\n # Total loss for event\n loss = tf.reduce_mean(reconstruction + kl_d) \n \n return reconstruction, kl_d, loss","def vq_vae_loss(args, x_prime, x, vq_loss, model):\n # Use Discretized Logistic as an alternative to MSE, see [1]\n log_pxz = utils.discretized_logistic(x_prime, model.dec_log_stdv,\n sample=x).mean()\n\n # recon_error = torch.mean((data_recon - data)**2)/args.data_variance\n # loss = recon_error + vq_loss\n\n loss = -1 * (log_pxz / args.num_pixels) + args.commitment_cost * vq_loss\n elbo = - (args.KL - log_pxz) / args.num_pixels\n bpd = elbo / np.log(2.)\n\n return loss, log_pxz, bpd","def get_KL_divergence(self):\n KL_loss = 0\n if(self.Bayesian):\n for i in range(self.num_layers):\n KL_loss += getattr(self, 'LSTMCell%i'%(i+1)).get_KL_divergence()\n \n return KL_loss","def kl_gaussian_gaussian_analytic(mu_q, logvar_q, mu_p, logvar_p):\n # init\n batch_size = mu_q.size(0)\n input_size = mu_q.size(1)\n mu_q = mu_q.view(batch_size, -1)\n logvar_q = logvar_q.view(batch_size, -1)\n mu_p = mu_p.view(batch_size, -1)\n logvar_p = logvar_p.view(batch_size, -1) \n\n # kld\n cov_q = torch.exp(logvar_q)\n cov_p = torch.exp(logvar_p)\n cov_p_inverse = 1 / cov_p\n mu_diff = mu_p - mu_q\n log_det_cov_p = torch.sum(logvar_p, dim=1)\n log_det_cov_q = torch.sum(logvar_q, dim=1)\n trace_det = torch.sum(cov_p_inverse * cov_q, dim=1)\n fourth_term = torch.sum(mu_diff * cov_p_inverse * mu_diff, dim=1)\n kl_div = 0.5 * (log_det_cov_p - log_det_cov_q - input_size + trace_det + fourth_term)\n return kl_div","def compute_K(alpha: torch.FloatTensor,\n beta: torch.FloatTensor) -> torch.FloatTensor:\n return torch.exp(compute_log_K(alpha, beta))","def loss_with_kl_constraint(avg_probs, current_log_probs,\n model, original_loss, delta, optimizer, args):\n\n # Compute g: a direction to minimize the original loss\n optimizer.zero_grad()\n original_loss.backward(retain_graph=True)\n g = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\n\n # Compute k: a direction to increase KL div.\n optimizer.zero_grad()\n kl = kl_div(avg_probs, current_log_probs, args)\n (-kl).backward(retain_graph=True)\n k = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\n\n optimizer.zero_grad()\n\n kg_dot = sum(torch.sum(k_p * g_p) for k_p, g_p in zip(k, g))\n kk_dot = sum(torch.sum(k_p ** 2) for k_p in k)\n\n if kk_dot.data.numpy()[0] > 0:\n k_factor = torch.clamp((kg_dot-delta)/kk_dot, min=0)\n else:\n k_factor = Variable(torch.zeros(1))\n\n z = [gp - k_factor.expand_as(kp) * kp for kp, gp in zip(k, g)]\n loss = 0\n\n for p, zp in zip(model.parameters(), z):\n if p.size() == zp.size():\n loss += torch.sum(p * zp)\n return loss, kl.data","def vae_loss(gen_images, input_images, mu_sigmas):\n # List to aggregate binary cross-entropy reconstruction losses\n # from all of the image outputs:\n BCEs = []\n # List to aggregate KL divergence losses from each of the mu/sigma\n # projections:\n KLDs = []\n\n # TODO Your code goes here.\n\n return BCEs, KLDs","def kl(self):\n weights_logvar = self.weights_logvar\n kld_weights = self.prior_stdv.log() - weights_logvar.mul(0.5) + \\\n (weights_logvar.exp() + (self.weights.pow(2) - self.prior_mean)) / (\n 2 * self.prior_stdv.pow(2)) - 0.5\n kld_bias = self.prior_bias_stdv.log() - self.bias_logvar.mul(0.5) + \\\n (self.bias_logvar.exp() + (self.bias.pow(2) - self.prior_bias_mean)) / (\n 2 * self.prior_bias_stdv.pow(2)) \\\n - 0.5\n return kld_weights.sum() + kld_bias.sum()","def normal_kl(mean1, logvar1, mean2, logvar2):\n return 0.5 * (-1.0 + logvar2 - logvar1 + torch.exp(logvar1 - logvar2) + (mean1 - mean2) ** 2 * torch.exp(-logvar2))","def approximate_loss(self, x, x_recon, v_dist, eps=1e-3):\n log_alpha = v_dist.logits\n bce = F.binary_cross_entropy(x_recon, x.view(-1, 784), reduction='sum')\n num_class = torch.tensor(self.latent_dim).float()\n probs = torch.softmax(log_alpha, dim=-1) # alpha_i / alpha_sum\n kl = torch.sum(probs * (num_class * (probs + eps)).log(), dim=-1).sum()\n return bce, kl","def compute_loss(self):\n def calc_loss(inputs, outputs):\n reconstruction_loss = tf.metrics.binary_crossentropy(\n tf_flat(inputs), tf_flat(outputs))\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\n self.mu) - tf.exp(self.log_sigma), 1)\n return tf.reduce_mean(reconstruction_loss + kl_loss)\n return calc_loss","def get_KL_divergence(self):\n KL_loss_W = Vil.get_KL_divergence_Samples(self.mu_weight, Vil.softplus(self.rho_weight), self.weight, self.prior)\n KL_loss_b = 0\n if self.bias is not None:\n KL_loss_b = Vil.get_KL_divergence_Samples(self.mu_bias, Vil.softplus(self.rho_bias), self.bias, self.prior)\n \n KL_loss = KL_loss_W + KL_loss_b\n \n return KL_loss","def kl_from_q_to_standard_normal(args):\n mean, log_var = args\n return -0.5 * K.sum(log_var - K.exp(log_var) - K.square(mean) + 1, axis=-1)","def variance_kl(var: base.Array, pred_log_var: base.Array) -> base.Array:\n log_var = jnp.log(var)\n pred_var = jnp.exp(pred_log_var)\n return 0.5 * (pred_log_var - log_var + var / pred_var - 1)","def kl_latent_space(network, *args):\n\n z, log_det_J = network(*args)\n loss = tf.reduce_mean(0.5 * tf.square(tf.norm(z, axis=-1)) - log_det_J)\n return loss","def get_vlb(self):\n vlb = 0\n\n # First term\n # E[LN p(g | \\gamma)]\n E_ln_g = self.expected_log_g()\n vlb += Dirichlet(self.gamma[None, None, :]).negentropy(E_ln_g=E_ln_g).sum()\n\n # Second term\n # E[LN q(g | \\tilde{gamma})]\n vlb -= Dirichlet(self.mf_gamma).negentropy().sum()\n\n return vlb","def kl_divergence(self) -> Tensor:\n return torch.tensor(0.0)","def PoissonGaussianLoss(mu_kl, log_var_kl) :\n def pgl(x, lambdas) :\n N = K.int_shape(lambdas)[1]\n recon = -1.*K.sum(x*lambdas - K.exp(lambdas), axis=1)\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\n return recon + dkl\n return pgl","def global_loss(bce_loss, mu, log_var):\n kl_divergence = 0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())\n return bce_loss - kl_divergence","def loss_fn(input_d, reconstructed, mean, logvar, beta=1, batch_size=1, input_size=1):\n\n # mse_criterion = nn.MSELoss() # reduction=sum ?\n # mse_loss = mse_criterion(input_d, reconstructed)\n\n # bce_criterion = nn.BCELoss(size_average=False) # reduction=sum ?\n bce_criterion = nn.BCELoss() # reduction=sum ?\n bce_loss = bce_criterion(input_d, reconstructed)\n\n # see Appendix B from VAE paper:\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n # https://arxiv.org/abs/1312.6114\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n\n # for gaussian distribution when\n # generated data passed to the encorder is z~ N(0,1) and generated data is x~N(m,var)\n\n kl_loss = -0.5 * torch.sum(1 + logvar - mean.pow(2) - logvar.exp())\n\n normalized_kl_loss = kl_loss / (batch_size * input_size)\n scaled_kl_loss = beta*normalized_kl_loss\n # scaled_kl_loss = beta*kl_loss\n\n # return bce_loss + kl_loss, bce_loss, kl_loss\n return bce_loss + scaled_kl_loss, bce_loss, normalized_kl_loss\n # return mse_loss + scaled_kl_loss, mse_loss, kl_loss","def get_vlb(self):\n raise NotImplementedError()\n vlb = 0\n\n # First term\n # E[LN p(g | \\gamma)]\n E_ln_g = self.expected_log_g()\n vlb += Dirichlet(self.gamma[None, None, :]).negentropy(E_ln_g=E_ln_g).sum()\n\n # Second term\n # E[LN q(g | \\tilde{gamma})]\n vlb -= Dirichlet(self.mf_gamma).negentropy().sum()\n\n return vlb","def kl_unit_gaussian(mu, log_sigma, sigma):\n with tf.name_scope('kl_unit_gaussian') as scope:\n return -0.5 * (1 + 2 * log_sigma - mu**2 - sigma**2)","def loss_function(self, x, p_x_given_z_logits, mu, log_sigma):\n rec_loss = nn.functional.binary_cross_entropy_with_logits(p_x_given_z_logits, x, reduction=\"none\").sum(dim=1)\n kl_loss = 0.5 * torch.sum(torch.exp(log_sigma) + mu**2 - log_sigma - 1., dim=1)\n\n return torch.mean(rec_loss + kl_loss), rec_loss.mean(), kl_loss.mean()","def kl_divergence(mu, logvar):\n klds = -0.5*(1 + logvar - mu.pow(2) - logvar.exp())\n total_kld = klds.sum(1).mean(0, True)\n dimension_wise_kld = klds.mean(0)\n mean_kld = klds.mean(1).mean(0, True)\n\n return total_kld, dimension_wise_kld, mean_kld","def compute_log_K(alpha: torch.FloatTensor,\n beta: torch.FloatTensor) -> torch.FloatTensor:\n return mask * (-C + alpha.unsqueeze(dim=-1) + beta.unsqueeze(dim=-2)) / epsilon","def _get_vae_loss(self, x, x_bar):\n log_softmax_var = tf.nn.log_softmax(x_bar)\n self.neg_ll = -tf.reduce_mean(\n input_tensor=tf.reduce_sum(input_tensor=log_softmax_var * x, axis=-1)\n )\n a = tf.keras.backend.print_tensor(self.neg_ll) # noqa: F841\n # calculate positive Kullback–Leibler divergence divergence term\n kl_loss = K.mean(\n 0.5\n * K.sum(\n -1 - self.z_log_var + K.square(self.z_mean) + K.exp(self.z_log_var),\n axis=-1,\n )\n )\n\n # obtain negative ELBO\n neg_ELBO = self.neg_ll + self.beta * kl_loss\n\n return neg_ELBO","def compute_kl(mu1, mu2, sigma1, sigma2):\n k = len(mu1)\n try:\n term1 = np.trace(np.matmul(np.linalg.inv(sigma2), sigma1))\n term2 = np.matmul(np.matmul((mu2 - mu1).T,\n np.linalg.inv(sigma2)),\n (mu2 - mu1))\n det_sigma1 = compute_determinant(sigma1)\n det_sigma2 = compute_determinant(sigma2)\n # term3 = np.log(np.linalg.det(sigma2)/np.linalg.det(sigma1))\n term3 = np.log(det_sigma2)\n term4 = np.log(det_sigma1)\n kl = (term1 + term2 - k + term3 - term4)/2.\n return kl\n except np.linalg.LinAlgError:\n return np.nan","def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\n kl_cost = torch.mean(kl_cost, 0)\n return torch.sum(kl_cost)","def vae_criterion(self, predicted, target, mu, logvar, loss_type=\"huber\"):\n\n KLD = -0.5 * torch.sum(1 + logvar - mu ** 2 - logvar.exp())\n\n if loss_type == \"huber\":\n loss = self.huber_loss(predicted, target) + KLD\n elif loss_type == \"manhattan\":\n loss = self.manhattan_loss(predicted, target) + KLD\n elif loss_type == \"mse\":\n loss = self.mse_loss(predicted, target) + KLD\n elif loss_type == \"huber_ae\":\n loss = self.huber_loss(predicted, target)\n elif loss_type == \"manhattan_ae\":\n loss = self.manhattan_loss(predicted, target)\n elif loss_type == \"mse_ae\":\n loss = self.mse_loss(predicted, target)\n else:\n raise Exception(\"Loss type '{}' is unknown!\".format(loss_type))\n return loss","def loss_function(self, x, x_hat_logit, mu, log_sigma):\n rec_loss = nn.functional.binary_cross_entropy_with_logits(x_hat_logit, x, size_average=False)\n kl_loss = -0.5 * torch.sum(1 + log_sigma - mu.pow(2) - log_sigma.exp())\n\n return rec_loss + (kl_loss), rec_loss, kl_loss","def loss_function(recon_x, x, mu, logvar, cl, target, natural):\n\tglobal decoder_nat_loss, decoder_syn_loss, KLD_syn_loss, KLD_nat_loss, regressor_nat, regressor_syn\n\t#decoder_loss = F.binary_cross_entropy(recon_x, x.view(-1, 1, img_size, img_size), reduction='sum') * decoder_l_factor\n\tdecoder_loss = F.mse_loss(recon_x, x) * decoder_l_factor\n\n\t# see Appendix B from VAE paper: Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n\t# https://arxiv.org/abs/1312.6114\n\t# 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n\tbeta = 1 / (batch_size * boundary_dim) # disentanglement factor#extremely small\n\tKLD = -0.5 * beta * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) * KLD_l_factor\n\n\tregressor_loss = F.mse_loss(cl, target.view(-1, 1)) * regressor_l_factor\n\tif epoch < regressor_start:\n\t\tregressor_loss *= 0\n\n\tif natural:\n\t\tdecoder_nat_loss += decoder_loss\n\t\tKLD_nat_loss += KLD\n\t\tregressor_nat += regressor_loss\n\telse:\n\t\tdecoder_syn_loss += decoder_loss\n\t\tKLD_syn_loss += KLD\n\t\tregressor_syn += regressor_loss\n\n\tif KLD > 1e10:\n\t\tplaySound()\n\t\tsys.exit('KLD diverged')\n\n\treturn decoder_loss + KLD + regressor_loss, KLD, regressor_loss","def grad_KL_mu(self):\n return np.multiply(np.exp(self.q_S),\n - kron_mvp(self.K_invs, self.mu - self.q_mu))","def encoder_kl_loss(latent_dist):\n zeros = tf.zeros_like(latent_dist.mean())\n batch_size = tf.cast(tf.shape(zeros)[0], zeros.dtype)\n prior = tf.distributions.Normal(loc=zeros, scale=(zeros + 1))\n total_kl = tf.reduce_sum(tf.distributions.kl_divergence(latent_dist, prior))\n mean_kl = total_kl / batch_size\n return mean_kl","def TCVAE_loss_function(input, recons, mu, log_var, z, dataset_size, batch_iter, \n anneal_steps=200., alpha=1., beta=6., gamma=1., train=True):\n weight = 1 # Account for the minibatch samples from the dataset\n batch_size, z_dim = z.shape\n \n recons_loss = F.mse_loss(recons, input, reduction='sum')/(19*batch_size)\n\n log_q_zx = log_density_gaussian(z, mu, log_var).sum(dim = 1)\n\n zeros = torch.zeros_like(z)\n log_p_z = log_density_gaussian(z, zeros, zeros).sum(dim = 1)\n\n mat_log_q_z = log_density_gaussian( z.view(batch_size, 1, z_dim),\n mu.view(1, batch_size, z_dim),\n log_var.view(1, batch_size, z_dim))\n\n # Reference\n # [1] https://github.com/YannDubs/disentangling-vae/blob/535bbd2e9aeb5a200663a4f82f1d34e084c4ba8d/disvae/utils/math.py#L54\n strat_weight = (dataset_size - batch_size + 1) / (dataset_size * (batch_size - 1))\n importance_weights = torch.Tensor(batch_size, batch_size).fill_(1 / (batch_size -1)).to(input.device)\n importance_weights.view(-1)[::batch_size] = 1 / dataset_size\n importance_weights.view(-1)[1::batch_size] = strat_weight\n importance_weights[batch_size - 2, 0] = strat_weight\n log_importance_weights = importance_weights.log()\n\n mat_log_q_z += log_importance_weights.view(batch_size, batch_size, 1)\n\n log_q_z = torch.logsumexp(mat_log_q_z.sum(2), dim=1, keepdim=False)\n log_prod_q_z = torch.logsumexp(mat_log_q_z, dim=1, keepdim=False).sum(1)\n\n mi_loss = (log_q_zx - log_q_z).mean()/19\n tc_loss = (log_q_z - log_prod_q_z).mean()/19\n kld_loss = (log_prod_q_z - log_p_z).mean()/19\n\n if train:\n batch_iter += 1\n anneal_rate = min(0 + 1 * batch_iter / anneal_steps, 1)\n else:\n anneal_rate = 1.\n\n loss = recons_loss + alpha*mi_loss + weight*(beta*tc_loss + \n anneal_rate*gamma*kld_loss)\n \n return loss, recons_loss, kld_loss, tc_loss, mi_loss","def get_ELBO(self, length):\n # KL divergence between posterior and N(0,1) prior\n\n KL_div = (0.5 * (tf.reduce_sum(tf.sqrt(tf.reduce_sum(self.batch_mu**2,\n axis=1))) + tf.reduce_sum(self.batch_Tr_C) -\n tf.reduce_sum(self.batch_ld_C) - length))\n weight_reg = ((0.5 / self.k) *\n tf.sqrt(tf.reduce_sum(self.W**2)) *\n tf.sqrt(tf.reduce_sum(self.G**2)))\n return -(weight_reg + KL_div)","def kullback_leibler_gaussian(z_mean, z_logvar, beta=1., **args):\n \n loss = 1 + z_logvar - tf.square(z_mean) - tf.exp(z_logvar)\n loss = -0.5 * tf.reduce_sum(input_tensor=loss, axis=-1)\n return beta * tf.reduce_mean(input_tensor=loss)","def GaussianGaussianLoss(mu_kl, log_var_kl, const_var=None) :\n if const_var is None : # Heteroscedastic\n def ggl(x, mu_log_var) :\n N = K.int_shape(mu_log_var)[1]\n mu = mu_log_var[:,:,0]\n log_var = mu_log_var[:,:,1]\n mu = mu[:,:,np.newaxis]\n log_var = log_var[:,:,np.newaxis]\n recon = -1.*K.sum(-0.5*log_var - 0.5*K.exp(-1.*log_var)*K.square(x - mu), axis=1)\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\n return dkl\n return ggl\n else : # Homoscedastic\n const_var = float(const_var)\n def ggl(x, mu) :\n recon = -1.*K.sum(-0.5*const_var - 0.5*K.exp(-1.*const_var)*K.square(x - mu), axis=1)\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\n return dkl + recon\n return ggl","def log_likelihood(self) -> tf.Tensor:\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\n l_post = self._k_inv_post.cholesky\n num_data = self.observations_index.shape[0]\n\n # Hμ [..., num_transitions + 1, output_dim]\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\n marginal = self._drop_batch_shape(marginal)\n\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\n disp = self.observations - marginal\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\n\n # cst is the constant term for a gaussian log likelihood\n cst = (\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\n )\n\n term1 = -0.5 * tf.reduce_sum(\n input_tensor=tf.einsum(\"...op,...p,...o->...o\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\n )\n\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\n obs_proj = self._back_project_y_to_state(disp)\n\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\n term2 = 0.5 * tf.reduce_sum(\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\n )\n\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\n term3 = (\n 0.5 * self.prior_ssm.log_det_precision()\n - l_post.abs_log_det()\n + 0.5 * self._log_det_observation_precision\n )\n\n return tf.reduce_sum(cst + term1 + term2 + term3)","def KD(T=8):\n\n def KD_loss(input, teacher_logits):\n return nn.KLDivLoss()(F.log_softmax(input / T, dim=1), F.softmax(teacher_logits / T, dim=1))\n\n return KD_loss","def vae_loss(x, t_decoded):\r\n return K.mean(reconstruction_loss(x, t_decoded))","def kullback_leibler_gaussian(z_mean, z_logvar, beta=1.):\n \n loss = 1 + z_logvar - tf.square(z_mean) - tf.exp(z_logvar)\n loss = -0.5 * tf.reduce_sum(loss, axis=-1)\n return beta * tf.reduce_mean(loss)","def kl_divergence(eta_q, eta_p):\n return ev_t(eta_q) @ (eta_q - eta_p) - a(eta_q) + a(eta_p)","def K(self, u, v):\n return (self.L(u, v) * self.N(u, v) - np.square(self.M(u, v))) / \\\n (self.E(u, v) * self.G(u, v) - np.square(self.F(u, v)))","def matern_kernel(x_1, x_2, l, v):\n\n\tassert l > 0 and v > 0, \"The hyperparameters l and v must be > 0\"\n\tdist = euclidean_distances(x_1.reshape(-1,1), x_2.reshape(-1,1))\n\tdist[dist == 0.0] += 1e-10\n\tz = np.sqrt(2*v) * dist / l\n\treturn (2**(1-v)/gamma(v)) * (z**v) * kv(v, z)","def KL_bound2(k_var, k_ls, sigma_n, N, p_sd, p_success, M):\n a = 1. / (4 * np.square(p_sd))\n b = 1. / (2 * np.square(k_ls))\n c = np.sqrt(np.square(a) + 2 * a * b)\n A = a + b + c\n B = b / A\n delta = 1 - p_success\n delta_sn_sq = delta * np.square(sigma_n)\n eigenvalues_sum = k_var * np.sqrt(2 * a / A) * np.power(B, M) / (1 - B)\n return (M+1) * N * eigenvalues_sum / delta_sn_sq","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def kld(mu, log_var):\n return (mu + log_var).sum() # TODO Your code goes here.","def kl2(mu1, mu2, sigma1, sigma2):\n return np.log(sigma2/sigma1) + 0.5 * (sigma1**2/sigma2**2 + (mu2-mu1)**2/sigma2**2 - 1)","def kl2(mu1, mu2, sigma1, sigma2):\n return np.log(sigma2/sigma1) + 0.5 * (sigma1**2/sigma2**2 + (mu2-mu1)**2/sigma2**2 - 1)","def calculate_kl(self, old_policy, new_policy, obs):\n # _, logp0 = old_policy(obs, act)\n # logp0 = logp0.detach()\n # _, logp1 = new_policy(obs, act)\n\n p0 = old_policy._distribution(obs).probs.detach() + 1e-8\n p1 = new_policy._distribution(obs).probs\n # pi_new = Categorical(old_policy.logits_net(obs))\n # act_new = pi_new.sample()\n # logp0 = old_policy._log_prob_from_distribution(pi_old, act_old)\n # logp1 = new_policy._log_prob_from_distribution(pi_new, act_new)\n\n return torch.sum(p0 * torch.log(p0 / p1), 1).mean()\n # kl = torch.exp(logp1) * (logp1-logp0)\n # return kl.sum(-1, keepdim=True).mean()","def kl_loss(y_true, y_pred):\n #y_true = tf.constant(y_true, dtype=tf.dtypes.float64)\n #y_pred = tf.constant(y_pred, dtype=tf.dtypes.float64)\n #y_true = tf.reshape(y_true, shape=[y_true.shape[0], y_true.shape[1] * y_true.shape[2]])\n #y_pred = tf.reshape(y_pred, shape=[y_pred.shape[0], y_pred.shape[1] * y_pred.shape[2]])\n loss = 0\n if y_true.shape[-1] is None:\n return 0.0\n for i in range(y_true.shape[-1]):\n hist_true = np.histogram(y_true[:,i], bins=10, density=True)\n hist_pred = np.histogram(y_pred[:,i], bins=10, density=True)\n loss += kl(hist_true[0], hist_pred[0])\n return loss","def __init__(self, lam,lrate,latent_dim,loss_fn):\r\n super(VAE, self).__init__()\r\n\r\n self.lrate = lrate\r\n self.lam = lam\r\n self.loss_fn = loss_fn\r\n self.latent_dim = latent_dim\r\n \r\n self.en_fc1 = nn.Linear(2,50)\r\n self.en_fc2 = nn.Linear(50,50)\r\n self.en_fc3 = nn.Linear(50,50)\r\n self.en_mu = nn.Linear(50,latent_dim)\r\n self.en_log = nn.Linear(50,latent_dim)\r\n \r\n self.de_fc1 = nn.Linear(latent_dim,50)\r\n self.de_fc2 = nn.Linear(50,50)\r\n self.de_fc3 = nn.Linear(50,2)\r\n \r\n self.opt = optim.Adam(self.parameters(), lr=self.lrate)","def kl2(mu1, mu2, sigma1, sigma2):\n return np.log(sigma2 / sigma1) + 0.5 * (\n sigma1 ** 2 / sigma2 ** 2 + (mu2 - mu1) ** 2 / sigma2 ** 2 - 1\n )","def L2_func(x):\n return K.expand_dims(K.sqrt(K.sum(K.pow(x,2), axis=1)))","def func_ludwigson(eps,k1,n1,k2,n2,):\n return k1*eps**n1+np.exp(k2+n2*eps)","def ewc_loss(lam, model, dataset, samples):\n optimal_weights = deepcopy(model.trainable_weights)\n fisher_diagonal = fisher_matrix(model, dataset, samples)\n\n def loss_fn(new_model):\n # We're computing:\n # sum [(lambda / 2) * F * (current weights - optimal weights)^2]\n loss = 0\n current = new_model.trainable_weights\n for f, c, o in zip(fisher_diagonal, current, optimal_weights):\n loss += tf.reduce_sum(f * ((c - o) ** 2))\n\n return loss * (lam / 2)\n\n return loss_fn","def getK2(inp):\n\treturn 0.9/(1-math.exp(-getLambda(inp)))","def KL(self):\n\n self.build_cholesky_if_needed()\n\n KL = -0.5 * self.num_inducing * self.num_nodes * self.dim_per_out\n\n for nd in range(self.num_nodes):\n q_sqrt_nd = self.q_sqrt_lst[nd]\n with params_as_tensors_for(q_sqrt_nd, convert=True):\n KL -= 0.5 * tf.reduce_sum(tf.log(tf.matrix_diag_part(q_sqrt_nd) ** 2))\n\n KL += tf.reduce_sum(tf.log(tf.matrix_diag_part(self.Lu[nd]))) * self.dim_per_out\n KL += 0.5 * tf.reduce_sum(\n tf.square(tf.matrix_triangular_solve(self.Lu_tiled_lst[nd], q_sqrt_nd, lower=True)))\n q_mu_nd = self.q_mu[:, nd * self.dim_per_out:(nd + 1) * self.dim_per_out]\n Kinv_m_nd = tf.cholesky_solve(self.Lu[nd], q_mu_nd)\n KL += 0.5 * tf.reduce_sum(q_mu_nd * Kinv_m_nd)\n\n return KL","def kl_normal(qm, qv, pm, pv):\n element_wise = 0.5 * (t.log(pv) - t.log(qv) + qv / pv + (qm - pm).pow(2) / pv - 1)\n kl = element_wise.sum(-1)\n return kl","def BernoulliGaussianLoss(mu_kl, log_var_kl) :\n def bgl(x, p) :\n N = K.int_shape(p)[1]\n recon = N*metrics.binary_crossentropy(x, p)\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\n return dkl + recon\n return bgl","def log_loss(m_true, alpha, alpha0, m_probs, lambd=1.0):\n \n m_probs = tf.clip_by_value(m_probs, 1e-15, 1 - 1e-15)\n loss = -tf.reduce_mean(input_tensor=tf.reduce_sum(input_tensor=m_true * tf.math.log(m_probs), axis=1))\n if lambd > 0:\n kl = kullback_leibler_dirichlet(m_true, alpha)\n loss = loss + lambd * kl\n return loss","def loss_fun(model: GPModel, params: dict) -> float:\n py = model.module.call(params, train_ds['index_points'])\n return -py.log_prob(train_ds['y'])","def PSD_sym_KL(u, v):\n n = len(v)\n j = (1 / n) * (u / v + v / u - 2).sum()\n\n return j","def gaussian_kld(mu_left, logvar_left, mu_right, logvar_right):\n gauss_klds = 0.5 * (logvar_right - logvar_left +\n (tf.exp(logvar_left) / tf.exp(logvar_right)) +\n ((mu_left - mu_right)**2.0 / tf.exp(logvar_right)) - 1.0)\n assert len(gauss_klds.shape) == 2\n return tf.reduce_sum(gauss_klds, axis=1)","def grad_KL_mu(self):\n return kron_mvp(self.K_invs, self.q_mu - self.mu)","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def gnll_loss(y, parameter_vector):\n alpha, mu, sigma = slice_parameter_vectors(\n parameter_vector, components\n ) # Unpack parameter vectors\n\n gm = tfd.MixtureSameFamily(\n mixture_distribution=tfd.Categorical(probs=alpha),\n components_distribution=tfd.Normal(loc=mu, scale=sigma),\n )\n\n log_likelihood = gm.log_prob(tf.transpose(y)) # Evaluate log-probability of y\n\n return -tf.reduce_mean(log_likelihood, axis=-1)","def kl_policy(self):\n r = .5 * (np.trace(np.dot(self.behavior_policy.precision, self.target_policy.noise))\n - self.behavior_policy.dim_A - np.log(np.linalg.det(self.target_policy.noise) / np.linalg.det(self.behavior_policy.noise)))\n\n dtheta = (self.behavior_policy.theta - self.target_policy.theta)\n da = np.dot(dtheta, self.mu.T)\n m = float(np.sum(\n da * np.dot(self.target_policy.precision, da))) / self.mu.shape[0]\n\n r += .5 * m\n return r","def KL(P,Q):\n epsilon = 0.00001\n \n #You may want to instead make copies to avoid changing the np arrays.\n P = P+epsilon\n Q = Q+epsilon\n \n divergence = np.sum(P*np.log(P/Q))\n return divergence","def dot_kf(u, v):\n # TODO: implement the kernel function\n\n counter = 0\n if len(u)==len(v):\n for i in range(len(u)):\n counter = counter + (u[i]*v[i])\n return counter","def logp_loss(self, entropy, beta=0.0):\n def loss(y_true, y_pred):\n return -K.mean((y_pred * y_true) \\\n + (beta * entropy), axis=-1)\n\n return loss","def kl_divergence(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n y_true = backend.clip(y_true, backend.epsilon(), 1)\n y_pred = backend.clip(y_pred, backend.epsilon(), 1)\n return math_ops.reduce_sum(y_true * math_ops.log(y_true / y_pred), axis=-1)","def loss(self,A2,label):\r\n m = label.shape[0]\r\n\r\n log_likelihood = -np.log(A2[label,range(m)])\r\n loss = np.sum(log_likelihood) / m\r\n return loss","def KD_CE(alpha=0.5, T=8):\n\n def KD_loss(input, teacher_logits):\n return nn.KLDivLoss()(F.log_softmax(input / T, dim=1),\n F.softmax(teacher_logits / T, dim=1))\n\n def CE_loss(input,target):\n return nn.CrossEntropyLoss()(input.squeeze(), target)\n\n def KD_CE_loss(input, teacher_logits, target):\n\n return CE_loss(input,target) * alpha * T * T + KD_loss(input, teacher_logits) * (1 - alpha)\n\n return KD_CE_loss","def NLL(sample, params):\n mu = params[:,:,0]\n logsigma = params[:,:,1]\n \n c = normalization.to(mu.device)\n inv_sigma = torch.exp(-logsigma)\n tmp = (sample - mu) * inv_sigma\n return torch.mean(0.5 * (tmp * tmp + 2 * logsigma + c))","def KL_function_gaussian(self, H, data):\n\t\t#Initialize stuff\n\t\tn_data = float(len(data))\n\t\tn_dim = float(len(H))\n\t\t\n\t\t#Calculate the KL function by iterating\n\t\tKL_func = 0.\n\t\tfor i in xrange(int(n_data)):\n\t\t\tKL_func += np.log10( -0.9999999999999999 + np.sum( np.exp(-0.5 * np.sum( ((data[i,:] - data[:,:])/H[:])**2., axis=-1)), axis=-1) )\n\t\tKL_func /= n_data\n\t\tKL_func -= np.log10( (n_data-1.) * np.sqrt( (2.*np.pi)**n_dim * np.prod(H[:])**2.) )\n\n\t\treturn KL_func","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def nllfun(x):\n mu = x[0]\n logsigma = x[1]\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)","def KL_bound(k_var, k_ls, sigma_n, N, p_sd, p_success, bound_y, M):\n a = 1. / (4 * np.square(p_sd))\n b = 1. / (2 * np.square(k_ls))\n c = np.sqrt(np.square(a) + 2 * a * b)\n A = a + b + c\n B = b / A\n delta = 1 - p_success\n eigenvalues_sum = k_var * np.sqrt(2 * a / A) * np.power(B, M) / (1 - B)\n two_delta_sn_sq = 2 * delta * np.square(sigma_n)\n first_term = (M+1) * N * eigenvalues_sum / two_delta_sn_sq\n second_term = 1 + bound_y / np.square(sigma_n)\n return first_term * second_term","def VAE_sampling(args):\n\n z_mean, z_log_var = args\n batch = K.shape(z_mean)[0]\n dim = K.int_shape(z_mean)[1]\n # by default, random_normal has mean = 0 and std = 1.0\n epsilon = K.random_normal(shape=(batch, dim))\n return z_mean + K.exp(0.5 * z_log_var) * epsilon","def vbe_step(self):\n\n digam_alpha = digamma(np.sum(self.alpha_k))\n for k in range(self.k):\n\n # compute estimate over ln det(lamb)\n tmp = sum(digamma((self.nu_k[k] + 1 - j) / 2) for j in range(self.dim))\n\n det = np.linalg.det(self.w_k[k])\n self.log_lamb[k] = tmp + self.dim * np.log(2) + np.log(det)\n\n # compute estimate for ln pi\n self.log_pi[k] = digamma(self.alpha_k[k]) - digam_alpha\n\n for n in range(self.n):\n tmp = self.x[n] - self.m_k[k]\n # compute estimate over mu and lambda\n self.estimate[n, k] = self.dim * (1 / self.beta_k[k]) + self.nu_k[k] * (tmp.T @ self.w_k[k] @ tmp)","def kl_gaussian_gaussian_mc(mu_q, logvar_q, mu_p, logvar_p, num_samples=1):\n # init\n batch_size = mu_q.size(0)\n input_size = np.prod(mu_q.size()[1:])\n mu_q = mu_q.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\n logvar_q = logvar_q.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\n mu_p = mu_p.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\n logvar_p = logvar_p.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\n\n # kld\n sigma_q = torch.sqrt(torch.exp(logvar_q))\n sigma_p = torch.sqrt(torch.exp(logvar_p))\n q_dist = torch.distributions.normal.Normal(mu_q, sigma_q)\n p_dist = torch.distributions.normal.Normal(mu_p, sigma_p)\n z = q_dist.rsample()\n q_z = q_dist.log_prob(z)\n p_z = p_dist.log_prob(z)\n kld = torch.mean(q_z - p_z, dim=(1, 2))\n return kld","def gaussian_kl_np(mu0, log_std0, mu1, log_std1):\n var0, var1 = np.exp(2 * log_std0), np.exp(2 * log_std1)\n pre_sum = 0.5*(((mu1- mu0)**2 + var0)/(var1+EPS) - 1) + log_std1 - log_std0\n all_kls = pre_sum\n #all_kls = np.mean(all_kls)\n all_kls = np.clip(all_kls, 0, 1/EPS) ### for stability\n return all_kls","def K(self, X, Xstar):\n r = l2norm_(X, Xstar)\n bessel = kv(self.v, np.sqrt(2 * self.v) * r / self.l)\n f = 2 ** (1 - self.v) / gamma(self.v) * (np.sqrt(2 * self.v) * r / self.l) ** self.v\n res = f * bessel\n res[np.isnan(res)] = 1\n res = self.sigmaf * res + self.sigman * kronDelta(X, Xstar)\n return (res)","def gaussian_kl_div(mean_0, cov_0, mean_1, cov_1, dim):\n mean_diff = mean_1 - mean_0\n cov_1_inv = tf.reciprocal(cov_1)\n log_cov_1_det = tf.reduce_sum(tf.log(cov_1), axis=[1])\n log_cov_0_det = tf.reduce_sum(tf.log(cov_0), axis=[1])\n log_term = log_cov_1_det - log_cov_0_det\n trace_term = tf.reduce_sum(cov_1_inv * cov_0, axis=[1])\n square_term = tf.reduce_sum(mean_diff * cov_1_inv * mean_diff, axis=[1])\n kl_div = 0.5 * (trace_term + square_term - dim + log_term)\n return kl_div","def e_step(self):\n # update VMF probabilities (Equation (3))\n logP = np.dot(self.features, self.mu.T)*self.kappa + np.log(self.pi).reshape(1,-1) # n by k\n logP_norm = logP - logsumexp(logP, axis=1).reshape(-1,1)\n self.p = np.exp(logP_norm)\n self.mllk = np.mean(logsumexp(logP, axis=1))","def log_bessel_kve(v, z, name=None):\n with tf.name_scope(name or 'log_bessel_kve'):\n dtype = dtype_util.common_dtype([v, z], tf.float32)\n v = tf.convert_to_tensor(v, dtype=dtype)\n z = tf.convert_to_tensor(z, dtype=dtype)\n return _log_bessel_kve_custom_gradient(v, z)"],"string":"[\n \"def vae_loss(recon_x, x, mu_logvar):\\n mu = mu_logvar[:, 0:int(mu_logvar.size()[1]/2)]\\n logvar = mu_logvar[:, int(mu_logvar.size()[1]/2):]\\n# KLD = -0.5 * torch.sum(1 + 2 * logvar - mu.pow(2) - (2 * logvar).exp())\\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\\n# BCE = F.binary_cross_entropy(recon_x.squeeze(), x.squeeze(), reduction='sum')\\n MSE = F.mse_loss(recon_x.squeeze(), x.squeeze(), reduction='sum')\\n return {'loss': KLD + MSE,\\n 'mse': MSE}\",\n \"def kl_loss(mean, variance):\\n kld_value = mean.pow(2).add_(variance.exp()).mul_(-1).add_(1).add_(variance)\\n kld = torch.mean(kld_value).mul_(-0.5)\\n return kld\",\n \"def vae_loss(self, inputs, outputs, z_mean, z_log):\\n\\n reconstruction_loss = self.loss(inputs, outputs)\\n reconstruction_loss *= self.n_features_\\n kl_loss = 1 + z_log - K.square(z_mean) - K.exp(z_log)\\n kl_loss = -0.5 * K.sum(kl_loss, axis=-1)\\n kl_loss = self.gamma * K.abs(kl_loss - self.capacity)\\n\\n return K.mean(reconstruction_loss + kl_loss)\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def kl_divergence(self) -> Tensor:\\n return self.variational_strategy.kl_divergence().sum(dim=1).mean()\",\n \"def kullbackLeibler(mu, log_sigma):\\n # (tf.Tensor, tf.Tensor) -> tf.Tensor\\n # = -0.5 * (1 + log(sigma**2) - mu**2 - sigma**2)\\n return -0.5 * tf.reduce_sum(1 + 2 * log_sigma - mu**2 - tf.exp(2 * log_sigma), 1)\",\n \"def loss_function(recon_x, x, mu, logvar, input_size):\\n BCE = F.binary_cross_entropy(recon_x, x.view(-1, input_size), size_average=False)\\n\\n # see Appendix B from VAE paper:\\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\\n # https://arxiv.org/abs/1312.6114\\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\\n\\n return BCE + KLD\",\n \"def kl_loss(self):\\n return sum([p.kl_loss() for p in self.parameters])\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n\\n return reconstruction_loss + kl_normal_loss\",\n \"def kl_loss(self, simulation, c1 = 1.0, ndims = 2, ehigh = 1e5, emax = 1e10):\\n loss = KLLoss(c1, simulation, ndims, ehigh, emax)\\n return loss.lossFunction\",\n \"def VAE_losses(t_logits, t_truncate, mu_logvar0, mu_logvar1, tiny=1e-8):\\n # NEW ONE! with different strategy of calculating loss for censoring, adding \\\\sum p_b, not \\\\sum w_b*p_b\\n # Reconstruction loss\\n t_dist = tf.nn.softmax(t_logits)\\n reconstruction = -tf.log(tf.reduce_sum(t_dist*t_truncate, axis=1))\\n\\n # KL divergence\\n mu0, logvar0 = tf.split(mu_logvar0, num_or_size_splits=2, axis=1)\\n mu1, logvar1 = tf.split(mu_logvar1, num_or_size_splits=2, axis=1)\\n\\n kl_d = 0.5 * tf.reduce_sum(tf.exp(logvar1-logvar0)\\\\\\n + tf.divide(tf.square(mu0-mu1),tf.exp(logvar0)+tiny) \\\\\\n + logvar0 - logvar1 -1.0, \\\\\\n 1)\\n\\n # Total loss for event\\n loss = tf.reduce_mean(reconstruction + kl_d) \\n \\n return reconstruction, kl_d, loss\",\n \"def vq_vae_loss(args, x_prime, x, vq_loss, model):\\n # Use Discretized Logistic as an alternative to MSE, see [1]\\n log_pxz = utils.discretized_logistic(x_prime, model.dec_log_stdv,\\n sample=x).mean()\\n\\n # recon_error = torch.mean((data_recon - data)**2)/args.data_variance\\n # loss = recon_error + vq_loss\\n\\n loss = -1 * (log_pxz / args.num_pixels) + args.commitment_cost * vq_loss\\n elbo = - (args.KL - log_pxz) / args.num_pixels\\n bpd = elbo / np.log(2.)\\n\\n return loss, log_pxz, bpd\",\n \"def get_KL_divergence(self):\\n KL_loss = 0\\n if(self.Bayesian):\\n for i in range(self.num_layers):\\n KL_loss += getattr(self, 'LSTMCell%i'%(i+1)).get_KL_divergence()\\n \\n return KL_loss\",\n \"def kl_gaussian_gaussian_analytic(mu_q, logvar_q, mu_p, logvar_p):\\n # init\\n batch_size = mu_q.size(0)\\n input_size = mu_q.size(1)\\n mu_q = mu_q.view(batch_size, -1)\\n logvar_q = logvar_q.view(batch_size, -1)\\n mu_p = mu_p.view(batch_size, -1)\\n logvar_p = logvar_p.view(batch_size, -1) \\n\\n # kld\\n cov_q = torch.exp(logvar_q)\\n cov_p = torch.exp(logvar_p)\\n cov_p_inverse = 1 / cov_p\\n mu_diff = mu_p - mu_q\\n log_det_cov_p = torch.sum(logvar_p, dim=1)\\n log_det_cov_q = torch.sum(logvar_q, dim=1)\\n trace_det = torch.sum(cov_p_inverse * cov_q, dim=1)\\n fourth_term = torch.sum(mu_diff * cov_p_inverse * mu_diff, dim=1)\\n kl_div = 0.5 * (log_det_cov_p - log_det_cov_q - input_size + trace_det + fourth_term)\\n return kl_div\",\n \"def compute_K(alpha: torch.FloatTensor,\\n beta: torch.FloatTensor) -> torch.FloatTensor:\\n return torch.exp(compute_log_K(alpha, beta))\",\n \"def loss_with_kl_constraint(avg_probs, current_log_probs,\\n model, original_loss, delta, optimizer, args):\\n\\n # Compute g: a direction to minimize the original loss\\n optimizer.zero_grad()\\n original_loss.backward(retain_graph=True)\\n g = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\\n\\n # Compute k: a direction to increase KL div.\\n optimizer.zero_grad()\\n kl = kl_div(avg_probs, current_log_probs, args)\\n (-kl).backward(retain_graph=True)\\n k = [Variable(p.grad.data.clone()) if p.grad is not None else Variable(torch.zeros(1)) for p in model.parameters()]\\n\\n optimizer.zero_grad()\\n\\n kg_dot = sum(torch.sum(k_p * g_p) for k_p, g_p in zip(k, g))\\n kk_dot = sum(torch.sum(k_p ** 2) for k_p in k)\\n\\n if kk_dot.data.numpy()[0] > 0:\\n k_factor = torch.clamp((kg_dot-delta)/kk_dot, min=0)\\n else:\\n k_factor = Variable(torch.zeros(1))\\n\\n z = [gp - k_factor.expand_as(kp) * kp for kp, gp in zip(k, g)]\\n loss = 0\\n\\n for p, zp in zip(model.parameters(), z):\\n if p.size() == zp.size():\\n loss += torch.sum(p * zp)\\n return loss, kl.data\",\n \"def vae_loss(gen_images, input_images, mu_sigmas):\\n # List to aggregate binary cross-entropy reconstruction losses\\n # from all of the image outputs:\\n BCEs = []\\n # List to aggregate KL divergence losses from each of the mu/sigma\\n # projections:\\n KLDs = []\\n\\n # TODO Your code goes here.\\n\\n return BCEs, KLDs\",\n \"def kl(self):\\n weights_logvar = self.weights_logvar\\n kld_weights = self.prior_stdv.log() - weights_logvar.mul(0.5) + \\\\\\n (weights_logvar.exp() + (self.weights.pow(2) - self.prior_mean)) / (\\n 2 * self.prior_stdv.pow(2)) - 0.5\\n kld_bias = self.prior_bias_stdv.log() - self.bias_logvar.mul(0.5) + \\\\\\n (self.bias_logvar.exp() + (self.bias.pow(2) - self.prior_bias_mean)) / (\\n 2 * self.prior_bias_stdv.pow(2)) \\\\\\n - 0.5\\n return kld_weights.sum() + kld_bias.sum()\",\n \"def normal_kl(mean1, logvar1, mean2, logvar2):\\n return 0.5 * (-1.0 + logvar2 - logvar1 + torch.exp(logvar1 - logvar2) + (mean1 - mean2) ** 2 * torch.exp(-logvar2))\",\n \"def approximate_loss(self, x, x_recon, v_dist, eps=1e-3):\\n log_alpha = v_dist.logits\\n bce = F.binary_cross_entropy(x_recon, x.view(-1, 784), reduction='sum')\\n num_class = torch.tensor(self.latent_dim).float()\\n probs = torch.softmax(log_alpha, dim=-1) # alpha_i / alpha_sum\\n kl = torch.sum(probs * (num_class * (probs + eps)).log(), dim=-1).sum()\\n return bce, kl\",\n \"def compute_loss(self):\\n def calc_loss(inputs, outputs):\\n reconstruction_loss = tf.metrics.binary_crossentropy(\\n tf_flat(inputs), tf_flat(outputs))\\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\\n self.mu) - tf.exp(self.log_sigma), 1)\\n return tf.reduce_mean(reconstruction_loss + kl_loss)\\n return calc_loss\",\n \"def get_KL_divergence(self):\\n KL_loss_W = Vil.get_KL_divergence_Samples(self.mu_weight, Vil.softplus(self.rho_weight), self.weight, self.prior)\\n KL_loss_b = 0\\n if self.bias is not None:\\n KL_loss_b = Vil.get_KL_divergence_Samples(self.mu_bias, Vil.softplus(self.rho_bias), self.bias, self.prior)\\n \\n KL_loss = KL_loss_W + KL_loss_b\\n \\n return KL_loss\",\n \"def kl_from_q_to_standard_normal(args):\\n mean, log_var = args\\n return -0.5 * K.sum(log_var - K.exp(log_var) - K.square(mean) + 1, axis=-1)\",\n \"def variance_kl(var: base.Array, pred_log_var: base.Array) -> base.Array:\\n log_var = jnp.log(var)\\n pred_var = jnp.exp(pred_log_var)\\n return 0.5 * (pred_log_var - log_var + var / pred_var - 1)\",\n \"def kl_latent_space(network, *args):\\n\\n z, log_det_J = network(*args)\\n loss = tf.reduce_mean(0.5 * tf.square(tf.norm(z, axis=-1)) - log_det_J)\\n return loss\",\n \"def get_vlb(self):\\n vlb = 0\\n\\n # First term\\n # E[LN p(g | \\\\gamma)]\\n E_ln_g = self.expected_log_g()\\n vlb += Dirichlet(self.gamma[None, None, :]).negentropy(E_ln_g=E_ln_g).sum()\\n\\n # Second term\\n # E[LN q(g | \\\\tilde{gamma})]\\n vlb -= Dirichlet(self.mf_gamma).negentropy().sum()\\n\\n return vlb\",\n \"def kl_divergence(self) -> Tensor:\\n return torch.tensor(0.0)\",\n \"def PoissonGaussianLoss(mu_kl, log_var_kl) :\\n def pgl(x, lambdas) :\\n N = K.int_shape(lambdas)[1]\\n recon = -1.*K.sum(x*lambdas - K.exp(lambdas), axis=1)\\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\\n return recon + dkl\\n return pgl\",\n \"def global_loss(bce_loss, mu, log_var):\\n kl_divergence = 0.5 * torch.sum(1 + log_var - mu.pow(2) - log_var.exp())\\n return bce_loss - kl_divergence\",\n \"def loss_fn(input_d, reconstructed, mean, logvar, beta=1, batch_size=1, input_size=1):\\n\\n # mse_criterion = nn.MSELoss() # reduction=sum ?\\n # mse_loss = mse_criterion(input_d, reconstructed)\\n\\n # bce_criterion = nn.BCELoss(size_average=False) # reduction=sum ?\\n bce_criterion = nn.BCELoss() # reduction=sum ?\\n bce_loss = bce_criterion(input_d, reconstructed)\\n\\n # see Appendix B from VAE paper:\\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\\n # https://arxiv.org/abs/1312.6114\\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\\n\\n # for gaussian distribution when\\n # generated data passed to the encorder is z~ N(0,1) and generated data is x~N(m,var)\\n\\n kl_loss = -0.5 * torch.sum(1 + logvar - mean.pow(2) - logvar.exp())\\n\\n normalized_kl_loss = kl_loss / (batch_size * input_size)\\n scaled_kl_loss = beta*normalized_kl_loss\\n # scaled_kl_loss = beta*kl_loss\\n\\n # return bce_loss + kl_loss, bce_loss, kl_loss\\n return bce_loss + scaled_kl_loss, bce_loss, normalized_kl_loss\\n # return mse_loss + scaled_kl_loss, mse_loss, kl_loss\",\n \"def get_vlb(self):\\n raise NotImplementedError()\\n vlb = 0\\n\\n # First term\\n # E[LN p(g | \\\\gamma)]\\n E_ln_g = self.expected_log_g()\\n vlb += Dirichlet(self.gamma[None, None, :]).negentropy(E_ln_g=E_ln_g).sum()\\n\\n # Second term\\n # E[LN q(g | \\\\tilde{gamma})]\\n vlb -= Dirichlet(self.mf_gamma).negentropy().sum()\\n\\n return vlb\",\n \"def kl_unit_gaussian(mu, log_sigma, sigma):\\n with tf.name_scope('kl_unit_gaussian') as scope:\\n return -0.5 * (1 + 2 * log_sigma - mu**2 - sigma**2)\",\n \"def loss_function(self, x, p_x_given_z_logits, mu, log_sigma):\\n rec_loss = nn.functional.binary_cross_entropy_with_logits(p_x_given_z_logits, x, reduction=\\\"none\\\").sum(dim=1)\\n kl_loss = 0.5 * torch.sum(torch.exp(log_sigma) + mu**2 - log_sigma - 1., dim=1)\\n\\n return torch.mean(rec_loss + kl_loss), rec_loss.mean(), kl_loss.mean()\",\n \"def kl_divergence(mu, logvar):\\n klds = -0.5*(1 + logvar - mu.pow(2) - logvar.exp())\\n total_kld = klds.sum(1).mean(0, True)\\n dimension_wise_kld = klds.mean(0)\\n mean_kld = klds.mean(1).mean(0, True)\\n\\n return total_kld, dimension_wise_kld, mean_kld\",\n \"def compute_log_K(alpha: torch.FloatTensor,\\n beta: torch.FloatTensor) -> torch.FloatTensor:\\n return mask * (-C + alpha.unsqueeze(dim=-1) + beta.unsqueeze(dim=-2)) / epsilon\",\n \"def _get_vae_loss(self, x, x_bar):\\n log_softmax_var = tf.nn.log_softmax(x_bar)\\n self.neg_ll = -tf.reduce_mean(\\n input_tensor=tf.reduce_sum(input_tensor=log_softmax_var * x, axis=-1)\\n )\\n a = tf.keras.backend.print_tensor(self.neg_ll) # noqa: F841\\n # calculate positive Kullback–Leibler divergence divergence term\\n kl_loss = K.mean(\\n 0.5\\n * K.sum(\\n -1 - self.z_log_var + K.square(self.z_mean) + K.exp(self.z_log_var),\\n axis=-1,\\n )\\n )\\n\\n # obtain negative ELBO\\n neg_ELBO = self.neg_ll + self.beta * kl_loss\\n\\n return neg_ELBO\",\n \"def compute_kl(mu1, mu2, sigma1, sigma2):\\n k = len(mu1)\\n try:\\n term1 = np.trace(np.matmul(np.linalg.inv(sigma2), sigma1))\\n term2 = np.matmul(np.matmul((mu2 - mu1).T,\\n np.linalg.inv(sigma2)),\\n (mu2 - mu1))\\n det_sigma1 = compute_determinant(sigma1)\\n det_sigma2 = compute_determinant(sigma2)\\n # term3 = np.log(np.linalg.det(sigma2)/np.linalg.det(sigma1))\\n term3 = np.log(det_sigma2)\\n term4 = np.log(det_sigma1)\\n kl = (term1 + term2 - k + term3 - term4)/2.\\n return kl\\n except np.linalg.LinAlgError:\\n return np.nan\",\n \"def kl_divergence(means: Tensor, logvars: Tensor) ->Tensor:\\n kl_cost = -0.5 * (logvars - means ** 2 - torch.exp(logvars) + 1.0)\\n kl_cost = torch.mean(kl_cost, 0)\\n return torch.sum(kl_cost)\",\n \"def vae_criterion(self, predicted, target, mu, logvar, loss_type=\\\"huber\\\"):\\n\\n KLD = -0.5 * torch.sum(1 + logvar - mu ** 2 - logvar.exp())\\n\\n if loss_type == \\\"huber\\\":\\n loss = self.huber_loss(predicted, target) + KLD\\n elif loss_type == \\\"manhattan\\\":\\n loss = self.manhattan_loss(predicted, target) + KLD\\n elif loss_type == \\\"mse\\\":\\n loss = self.mse_loss(predicted, target) + KLD\\n elif loss_type == \\\"huber_ae\\\":\\n loss = self.huber_loss(predicted, target)\\n elif loss_type == \\\"manhattan_ae\\\":\\n loss = self.manhattan_loss(predicted, target)\\n elif loss_type == \\\"mse_ae\\\":\\n loss = self.mse_loss(predicted, target)\\n else:\\n raise Exception(\\\"Loss type '{}' is unknown!\\\".format(loss_type))\\n return loss\",\n \"def loss_function(self, x, x_hat_logit, mu, log_sigma):\\n rec_loss = nn.functional.binary_cross_entropy_with_logits(x_hat_logit, x, size_average=False)\\n kl_loss = -0.5 * torch.sum(1 + log_sigma - mu.pow(2) - log_sigma.exp())\\n\\n return rec_loss + (kl_loss), rec_loss, kl_loss\",\n \"def loss_function(recon_x, x, mu, logvar, cl, target, natural):\\n\\tglobal decoder_nat_loss, decoder_syn_loss, KLD_syn_loss, KLD_nat_loss, regressor_nat, regressor_syn\\n\\t#decoder_loss = F.binary_cross_entropy(recon_x, x.view(-1, 1, img_size, img_size), reduction='sum') * decoder_l_factor\\n\\tdecoder_loss = F.mse_loss(recon_x, x) * decoder_l_factor\\n\\n\\t# see Appendix B from VAE paper: Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\\n\\t# https://arxiv.org/abs/1312.6114\\n\\t# 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\\n\\tbeta = 1 / (batch_size * boundary_dim) # disentanglement factor#extremely small\\n\\tKLD = -0.5 * beta * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) * KLD_l_factor\\n\\n\\tregressor_loss = F.mse_loss(cl, target.view(-1, 1)) * regressor_l_factor\\n\\tif epoch < regressor_start:\\n\\t\\tregressor_loss *= 0\\n\\n\\tif natural:\\n\\t\\tdecoder_nat_loss += decoder_loss\\n\\t\\tKLD_nat_loss += KLD\\n\\t\\tregressor_nat += regressor_loss\\n\\telse:\\n\\t\\tdecoder_syn_loss += decoder_loss\\n\\t\\tKLD_syn_loss += KLD\\n\\t\\tregressor_syn += regressor_loss\\n\\n\\tif KLD > 1e10:\\n\\t\\tplaySound()\\n\\t\\tsys.exit('KLD diverged')\\n\\n\\treturn decoder_loss + KLD + regressor_loss, KLD, regressor_loss\",\n \"def grad_KL_mu(self):\\n return np.multiply(np.exp(self.q_S),\\n - kron_mvp(self.K_invs, self.mu - self.q_mu))\",\n \"def encoder_kl_loss(latent_dist):\\n zeros = tf.zeros_like(latent_dist.mean())\\n batch_size = tf.cast(tf.shape(zeros)[0], zeros.dtype)\\n prior = tf.distributions.Normal(loc=zeros, scale=(zeros + 1))\\n total_kl = tf.reduce_sum(tf.distributions.kl_divergence(latent_dist, prior))\\n mean_kl = total_kl / batch_size\\n return mean_kl\",\n \"def TCVAE_loss_function(input, recons, mu, log_var, z, dataset_size, batch_iter, \\n anneal_steps=200., alpha=1., beta=6., gamma=1., train=True):\\n weight = 1 # Account for the minibatch samples from the dataset\\n batch_size, z_dim = z.shape\\n \\n recons_loss = F.mse_loss(recons, input, reduction='sum')/(19*batch_size)\\n\\n log_q_zx = log_density_gaussian(z, mu, log_var).sum(dim = 1)\\n\\n zeros = torch.zeros_like(z)\\n log_p_z = log_density_gaussian(z, zeros, zeros).sum(dim = 1)\\n\\n mat_log_q_z = log_density_gaussian( z.view(batch_size, 1, z_dim),\\n mu.view(1, batch_size, z_dim),\\n log_var.view(1, batch_size, z_dim))\\n\\n # Reference\\n # [1] https://github.com/YannDubs/disentangling-vae/blob/535bbd2e9aeb5a200663a4f82f1d34e084c4ba8d/disvae/utils/math.py#L54\\n strat_weight = (dataset_size - batch_size + 1) / (dataset_size * (batch_size - 1))\\n importance_weights = torch.Tensor(batch_size, batch_size).fill_(1 / (batch_size -1)).to(input.device)\\n importance_weights.view(-1)[::batch_size] = 1 / dataset_size\\n importance_weights.view(-1)[1::batch_size] = strat_weight\\n importance_weights[batch_size - 2, 0] = strat_weight\\n log_importance_weights = importance_weights.log()\\n\\n mat_log_q_z += log_importance_weights.view(batch_size, batch_size, 1)\\n\\n log_q_z = torch.logsumexp(mat_log_q_z.sum(2), dim=1, keepdim=False)\\n log_prod_q_z = torch.logsumexp(mat_log_q_z, dim=1, keepdim=False).sum(1)\\n\\n mi_loss = (log_q_zx - log_q_z).mean()/19\\n tc_loss = (log_q_z - log_prod_q_z).mean()/19\\n kld_loss = (log_prod_q_z - log_p_z).mean()/19\\n\\n if train:\\n batch_iter += 1\\n anneal_rate = min(0 + 1 * batch_iter / anneal_steps, 1)\\n else:\\n anneal_rate = 1.\\n\\n loss = recons_loss + alpha*mi_loss + weight*(beta*tc_loss + \\n anneal_rate*gamma*kld_loss)\\n \\n return loss, recons_loss, kld_loss, tc_loss, mi_loss\",\n \"def get_ELBO(self, length):\\n # KL divergence between posterior and N(0,1) prior\\n\\n KL_div = (0.5 * (tf.reduce_sum(tf.sqrt(tf.reduce_sum(self.batch_mu**2,\\n axis=1))) + tf.reduce_sum(self.batch_Tr_C) -\\n tf.reduce_sum(self.batch_ld_C) - length))\\n weight_reg = ((0.5 / self.k) *\\n tf.sqrt(tf.reduce_sum(self.W**2)) *\\n tf.sqrt(tf.reduce_sum(self.G**2)))\\n return -(weight_reg + KL_div)\",\n \"def kullback_leibler_gaussian(z_mean, z_logvar, beta=1., **args):\\n \\n loss = 1 + z_logvar - tf.square(z_mean) - tf.exp(z_logvar)\\n loss = -0.5 * tf.reduce_sum(input_tensor=loss, axis=-1)\\n return beta * tf.reduce_mean(input_tensor=loss)\",\n \"def GaussianGaussianLoss(mu_kl, log_var_kl, const_var=None) :\\n if const_var is None : # Heteroscedastic\\n def ggl(x, mu_log_var) :\\n N = K.int_shape(mu_log_var)[1]\\n mu = mu_log_var[:,:,0]\\n log_var = mu_log_var[:,:,1]\\n mu = mu[:,:,np.newaxis]\\n log_var = log_var[:,:,np.newaxis]\\n recon = -1.*K.sum(-0.5*log_var - 0.5*K.exp(-1.*log_var)*K.square(x - mu), axis=1)\\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\\n return dkl\\n return ggl\\n else : # Homoscedastic\\n const_var = float(const_var)\\n def ggl(x, mu) :\\n recon = -1.*K.sum(-0.5*const_var - 0.5*K.exp(-1.*const_var)*K.square(x - mu), axis=1)\\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\\n return dkl + recon\\n return ggl\",\n \"def log_likelihood(self) -> tf.Tensor:\\n # K⁻¹ + GᵀΣ⁻¹G = LLᵀ.\\n l_post = self._k_inv_post.cholesky\\n num_data = self.observations_index.shape[0]\\n\\n # Hμ [..., num_transitions + 1, output_dim]\\n marginal = self.emission.project_state_to_f(self.prior_ssm.marginal_means)\\n marginal = self._drop_batch_shape(marginal)\\n\\n # y = obs - Hμ [..., num_transitions + 1, output_dim]\\n disp = self.observations - marginal\\n disp_data = self.sparse_observations - self.dense_to_sparse(marginal)\\n\\n # cst is the constant term for a gaussian log likelihood\\n cst = (\\n -0.5 * np.log(2 * np.pi) * tf.cast(self.emission.output_dim * num_data, default_float())\\n )\\n\\n term1 = -0.5 * tf.reduce_sum(\\n input_tensor=tf.einsum(\\\"...op,...p,...o->...o\\\", self._r_inv_data, disp_data, disp_data), axis=[-1, -2]\\n )\\n\\n # term 2 is: ½|L⁻¹(GᵀΣ⁻¹)y|²\\n # (GᵀΣ⁻¹)y [..., num_transitions + 1, state_dim]\\n obs_proj = self._back_project_y_to_state(disp)\\n\\n # ½|L⁻¹(GᵀΣ⁻¹)y|² [...]\\n term2 = 0.5 * tf.reduce_sum(\\n input_tensor=tf.square(l_post.solve(obs_proj, transpose_left=False)), axis=[-1, -2]\\n )\\n\\n ## term 3 is: ½log |K⁻¹| - log |L| + ½ log |Σ⁻¹|\\n # where log |Σ⁻¹| = num_data * log|R⁻¹|\\n term3 = (\\n 0.5 * self.prior_ssm.log_det_precision()\\n - l_post.abs_log_det()\\n + 0.5 * self._log_det_observation_precision\\n )\\n\\n return tf.reduce_sum(cst + term1 + term2 + term3)\",\n \"def KD(T=8):\\n\\n def KD_loss(input, teacher_logits):\\n return nn.KLDivLoss()(F.log_softmax(input / T, dim=1), F.softmax(teacher_logits / T, dim=1))\\n\\n return KD_loss\",\n \"def vae_loss(x, t_decoded):\\r\\n return K.mean(reconstruction_loss(x, t_decoded))\",\n \"def kullback_leibler_gaussian(z_mean, z_logvar, beta=1.):\\n \\n loss = 1 + z_logvar - tf.square(z_mean) - tf.exp(z_logvar)\\n loss = -0.5 * tf.reduce_sum(loss, axis=-1)\\n return beta * tf.reduce_mean(loss)\",\n \"def kl_divergence(eta_q, eta_p):\\n return ev_t(eta_q) @ (eta_q - eta_p) - a(eta_q) + a(eta_p)\",\n \"def K(self, u, v):\\n return (self.L(u, v) * self.N(u, v) - np.square(self.M(u, v))) / \\\\\\n (self.E(u, v) * self.G(u, v) - np.square(self.F(u, v)))\",\n \"def matern_kernel(x_1, x_2, l, v):\\n\\n\\tassert l > 0 and v > 0, \\\"The hyperparameters l and v must be > 0\\\"\\n\\tdist = euclidean_distances(x_1.reshape(-1,1), x_2.reshape(-1,1))\\n\\tdist[dist == 0.0] += 1e-10\\n\\tz = np.sqrt(2*v) * dist / l\\n\\treturn (2**(1-v)/gamma(v)) * (z**v) * kv(v, z)\",\n \"def KL_bound2(k_var, k_ls, sigma_n, N, p_sd, p_success, M):\\n a = 1. / (4 * np.square(p_sd))\\n b = 1. / (2 * np.square(k_ls))\\n c = np.sqrt(np.square(a) + 2 * a * b)\\n A = a + b + c\\n B = b / A\\n delta = 1 - p_success\\n delta_sn_sq = delta * np.square(sigma_n)\\n eigenvalues_sum = k_var * np.sqrt(2 * a / A) * np.power(B, M) / (1 - B)\\n return (M+1) * N * eigenvalues_sum / delta_sn_sq\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def kld(mu, log_var):\\n return (mu + log_var).sum() # TODO Your code goes here.\",\n \"def kl2(mu1, mu2, sigma1, sigma2):\\n return np.log(sigma2/sigma1) + 0.5 * (sigma1**2/sigma2**2 + (mu2-mu1)**2/sigma2**2 - 1)\",\n \"def kl2(mu1, mu2, sigma1, sigma2):\\n return np.log(sigma2/sigma1) + 0.5 * (sigma1**2/sigma2**2 + (mu2-mu1)**2/sigma2**2 - 1)\",\n \"def calculate_kl(self, old_policy, new_policy, obs):\\n # _, logp0 = old_policy(obs, act)\\n # logp0 = logp0.detach()\\n # _, logp1 = new_policy(obs, act)\\n\\n p0 = old_policy._distribution(obs).probs.detach() + 1e-8\\n p1 = new_policy._distribution(obs).probs\\n # pi_new = Categorical(old_policy.logits_net(obs))\\n # act_new = pi_new.sample()\\n # logp0 = old_policy._log_prob_from_distribution(pi_old, act_old)\\n # logp1 = new_policy._log_prob_from_distribution(pi_new, act_new)\\n\\n return torch.sum(p0 * torch.log(p0 / p1), 1).mean()\\n # kl = torch.exp(logp1) * (logp1-logp0)\\n # return kl.sum(-1, keepdim=True).mean()\",\n \"def kl_loss(y_true, y_pred):\\n #y_true = tf.constant(y_true, dtype=tf.dtypes.float64)\\n #y_pred = tf.constant(y_pred, dtype=tf.dtypes.float64)\\n #y_true = tf.reshape(y_true, shape=[y_true.shape[0], y_true.shape[1] * y_true.shape[2]])\\n #y_pred = tf.reshape(y_pred, shape=[y_pred.shape[0], y_pred.shape[1] * y_pred.shape[2]])\\n loss = 0\\n if y_true.shape[-1] is None:\\n return 0.0\\n for i in range(y_true.shape[-1]):\\n hist_true = np.histogram(y_true[:,i], bins=10, density=True)\\n hist_pred = np.histogram(y_pred[:,i], bins=10, density=True)\\n loss += kl(hist_true[0], hist_pred[0])\\n return loss\",\n \"def __init__(self, lam,lrate,latent_dim,loss_fn):\\r\\n super(VAE, self).__init__()\\r\\n\\r\\n self.lrate = lrate\\r\\n self.lam = lam\\r\\n self.loss_fn = loss_fn\\r\\n self.latent_dim = latent_dim\\r\\n \\r\\n self.en_fc1 = nn.Linear(2,50)\\r\\n self.en_fc2 = nn.Linear(50,50)\\r\\n self.en_fc3 = nn.Linear(50,50)\\r\\n self.en_mu = nn.Linear(50,latent_dim)\\r\\n self.en_log = nn.Linear(50,latent_dim)\\r\\n \\r\\n self.de_fc1 = nn.Linear(latent_dim,50)\\r\\n self.de_fc2 = nn.Linear(50,50)\\r\\n self.de_fc3 = nn.Linear(50,2)\\r\\n \\r\\n self.opt = optim.Adam(self.parameters(), lr=self.lrate)\",\n \"def kl2(mu1, mu2, sigma1, sigma2):\\n return np.log(sigma2 / sigma1) + 0.5 * (\\n sigma1 ** 2 / sigma2 ** 2 + (mu2 - mu1) ** 2 / sigma2 ** 2 - 1\\n )\",\n \"def L2_func(x):\\n return K.expand_dims(K.sqrt(K.sum(K.pow(x,2), axis=1)))\",\n \"def func_ludwigson(eps,k1,n1,k2,n2,):\\n return k1*eps**n1+np.exp(k2+n2*eps)\",\n \"def ewc_loss(lam, model, dataset, samples):\\n optimal_weights = deepcopy(model.trainable_weights)\\n fisher_diagonal = fisher_matrix(model, dataset, samples)\\n\\n def loss_fn(new_model):\\n # We're computing:\\n # sum [(lambda / 2) * F * (current weights - optimal weights)^2]\\n loss = 0\\n current = new_model.trainable_weights\\n for f, c, o in zip(fisher_diagonal, current, optimal_weights):\\n loss += tf.reduce_sum(f * ((c - o) ** 2))\\n\\n return loss * (lam / 2)\\n\\n return loss_fn\",\n \"def getK2(inp):\\n\\treturn 0.9/(1-math.exp(-getLambda(inp)))\",\n \"def KL(self):\\n\\n self.build_cholesky_if_needed()\\n\\n KL = -0.5 * self.num_inducing * self.num_nodes * self.dim_per_out\\n\\n for nd in range(self.num_nodes):\\n q_sqrt_nd = self.q_sqrt_lst[nd]\\n with params_as_tensors_for(q_sqrt_nd, convert=True):\\n KL -= 0.5 * tf.reduce_sum(tf.log(tf.matrix_diag_part(q_sqrt_nd) ** 2))\\n\\n KL += tf.reduce_sum(tf.log(tf.matrix_diag_part(self.Lu[nd]))) * self.dim_per_out\\n KL += 0.5 * tf.reduce_sum(\\n tf.square(tf.matrix_triangular_solve(self.Lu_tiled_lst[nd], q_sqrt_nd, lower=True)))\\n q_mu_nd = self.q_mu[:, nd * self.dim_per_out:(nd + 1) * self.dim_per_out]\\n Kinv_m_nd = tf.cholesky_solve(self.Lu[nd], q_mu_nd)\\n KL += 0.5 * tf.reduce_sum(q_mu_nd * Kinv_m_nd)\\n\\n return KL\",\n \"def kl_normal(qm, qv, pm, pv):\\n element_wise = 0.5 * (t.log(pv) - t.log(qv) + qv / pv + (qm - pm).pow(2) / pv - 1)\\n kl = element_wise.sum(-1)\\n return kl\",\n \"def BernoulliGaussianLoss(mu_kl, log_var_kl) :\\n def bgl(x, p) :\\n N = K.int_shape(p)[1]\\n recon = N*metrics.binary_crossentropy(x, p)\\n dkl = -0.5 * K.sum(-K.exp(log_var_kl) - K.square(mu_kl) + 1. + log_var_kl, axis=-1)\\n return dkl + recon\\n return bgl\",\n \"def log_loss(m_true, alpha, alpha0, m_probs, lambd=1.0):\\n \\n m_probs = tf.clip_by_value(m_probs, 1e-15, 1 - 1e-15)\\n loss = -tf.reduce_mean(input_tensor=tf.reduce_sum(input_tensor=m_true * tf.math.log(m_probs), axis=1))\\n if lambd > 0:\\n kl = kullback_leibler_dirichlet(m_true, alpha)\\n loss = loss + lambd * kl\\n return loss\",\n \"def loss_fun(model: GPModel, params: dict) -> float:\\n py = model.module.call(params, train_ds['index_points'])\\n return -py.log_prob(train_ds['y'])\",\n \"def PSD_sym_KL(u, v):\\n n = len(v)\\n j = (1 / n) * (u / v + v / u - 2).sum()\\n\\n return j\",\n \"def gaussian_kld(mu_left, logvar_left, mu_right, logvar_right):\\n gauss_klds = 0.5 * (logvar_right - logvar_left +\\n (tf.exp(logvar_left) / tf.exp(logvar_right)) +\\n ((mu_left - mu_right)**2.0 / tf.exp(logvar_right)) - 1.0)\\n assert len(gauss_klds.shape) == 2\\n return tf.reduce_sum(gauss_klds, axis=1)\",\n \"def grad_KL_mu(self):\\n return kron_mvp(self.K_invs, self.q_mu - self.mu)\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def gnll_loss(y, parameter_vector):\\n alpha, mu, sigma = slice_parameter_vectors(\\n parameter_vector, components\\n ) # Unpack parameter vectors\\n\\n gm = tfd.MixtureSameFamily(\\n mixture_distribution=tfd.Categorical(probs=alpha),\\n components_distribution=tfd.Normal(loc=mu, scale=sigma),\\n )\\n\\n log_likelihood = gm.log_prob(tf.transpose(y)) # Evaluate log-probability of y\\n\\n return -tf.reduce_mean(log_likelihood, axis=-1)\",\n \"def kl_policy(self):\\n r = .5 * (np.trace(np.dot(self.behavior_policy.precision, self.target_policy.noise))\\n - self.behavior_policy.dim_A - np.log(np.linalg.det(self.target_policy.noise) / np.linalg.det(self.behavior_policy.noise)))\\n\\n dtheta = (self.behavior_policy.theta - self.target_policy.theta)\\n da = np.dot(dtheta, self.mu.T)\\n m = float(np.sum(\\n da * np.dot(self.target_policy.precision, da))) / self.mu.shape[0]\\n\\n r += .5 * m\\n return r\",\n \"def KL(P,Q):\\n epsilon = 0.00001\\n \\n #You may want to instead make copies to avoid changing the np arrays.\\n P = P+epsilon\\n Q = Q+epsilon\\n \\n divergence = np.sum(P*np.log(P/Q))\\n return divergence\",\n \"def dot_kf(u, v):\\n # TODO: implement the kernel function\\n\\n counter = 0\\n if len(u)==len(v):\\n for i in range(len(u)):\\n counter = counter + (u[i]*v[i])\\n return counter\",\n \"def logp_loss(self, entropy, beta=0.0):\\n def loss(y_true, y_pred):\\n return -K.mean((y_pred * y_true) \\\\\\n + (beta * entropy), axis=-1)\\n\\n return loss\",\n \"def kl_divergence(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n y_true = backend.clip(y_true, backend.epsilon(), 1)\\n y_pred = backend.clip(y_pred, backend.epsilon(), 1)\\n return math_ops.reduce_sum(y_true * math_ops.log(y_true / y_pred), axis=-1)\",\n \"def loss(self,A2,label):\\r\\n m = label.shape[0]\\r\\n\\r\\n log_likelihood = -np.log(A2[label,range(m)])\\r\\n loss = np.sum(log_likelihood) / m\\r\\n return loss\",\n \"def KD_CE(alpha=0.5, T=8):\\n\\n def KD_loss(input, teacher_logits):\\n return nn.KLDivLoss()(F.log_softmax(input / T, dim=1),\\n F.softmax(teacher_logits / T, dim=1))\\n\\n def CE_loss(input,target):\\n return nn.CrossEntropyLoss()(input.squeeze(), target)\\n\\n def KD_CE_loss(input, teacher_logits, target):\\n\\n return CE_loss(input,target) * alpha * T * T + KD_loss(input, teacher_logits) * (1 - alpha)\\n\\n return KD_CE_loss\",\n \"def NLL(sample, params):\\n mu = params[:,:,0]\\n logsigma = params[:,:,1]\\n \\n c = normalization.to(mu.device)\\n inv_sigma = torch.exp(-logsigma)\\n tmp = (sample - mu) * inv_sigma\\n return torch.mean(0.5 * (tmp * tmp + 2 * logsigma + c))\",\n \"def KL_function_gaussian(self, H, data):\\n\\t\\t#Initialize stuff\\n\\t\\tn_data = float(len(data))\\n\\t\\tn_dim = float(len(H))\\n\\t\\t\\n\\t\\t#Calculate the KL function by iterating\\n\\t\\tKL_func = 0.\\n\\t\\tfor i in xrange(int(n_data)):\\n\\t\\t\\tKL_func += np.log10( -0.9999999999999999 + np.sum( np.exp(-0.5 * np.sum( ((data[i,:] - data[:,:])/H[:])**2., axis=-1)), axis=-1) )\\n\\t\\tKL_func /= n_data\\n\\t\\tKL_func -= np.log10( (n_data-1.) * np.sqrt( (2.*np.pi)**n_dim * np.prod(H[:])**2.) )\\n\\n\\t\\treturn KL_func\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def nllfun(x):\\n mu = x[0]\\n logsigma = x[1]\\n return logsigma + 0.5*np.sum((mu/(np.exp(logsigma) + 0.01))**2) + 0.1/np.exp(logsigma)\",\n \"def KL_bound(k_var, k_ls, sigma_n, N, p_sd, p_success, bound_y, M):\\n a = 1. / (4 * np.square(p_sd))\\n b = 1. / (2 * np.square(k_ls))\\n c = np.sqrt(np.square(a) + 2 * a * b)\\n A = a + b + c\\n B = b / A\\n delta = 1 - p_success\\n eigenvalues_sum = k_var * np.sqrt(2 * a / A) * np.power(B, M) / (1 - B)\\n two_delta_sn_sq = 2 * delta * np.square(sigma_n)\\n first_term = (M+1) * N * eigenvalues_sum / two_delta_sn_sq\\n second_term = 1 + bound_y / np.square(sigma_n)\\n return first_term * second_term\",\n \"def VAE_sampling(args):\\n\\n z_mean, z_log_var = args\\n batch = K.shape(z_mean)[0]\\n dim = K.int_shape(z_mean)[1]\\n # by default, random_normal has mean = 0 and std = 1.0\\n epsilon = K.random_normal(shape=(batch, dim))\\n return z_mean + K.exp(0.5 * z_log_var) * epsilon\",\n \"def vbe_step(self):\\n\\n digam_alpha = digamma(np.sum(self.alpha_k))\\n for k in range(self.k):\\n\\n # compute estimate over ln det(lamb)\\n tmp = sum(digamma((self.nu_k[k] + 1 - j) / 2) for j in range(self.dim))\\n\\n det = np.linalg.det(self.w_k[k])\\n self.log_lamb[k] = tmp + self.dim * np.log(2) + np.log(det)\\n\\n # compute estimate for ln pi\\n self.log_pi[k] = digamma(self.alpha_k[k]) - digam_alpha\\n\\n for n in range(self.n):\\n tmp = self.x[n] - self.m_k[k]\\n # compute estimate over mu and lambda\\n self.estimate[n, k] = self.dim * (1 / self.beta_k[k]) + self.nu_k[k] * (tmp.T @ self.w_k[k] @ tmp)\",\n \"def kl_gaussian_gaussian_mc(mu_q, logvar_q, mu_p, logvar_p, num_samples=1):\\n # init\\n batch_size = mu_q.size(0)\\n input_size = np.prod(mu_q.size()[1:])\\n mu_q = mu_q.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\\n logvar_q = logvar_q.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\\n mu_p = mu_p.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\\n logvar_p = logvar_p.view(batch_size, -1).unsqueeze(1).expand(batch_size, num_samples, input_size)\\n\\n # kld\\n sigma_q = torch.sqrt(torch.exp(logvar_q))\\n sigma_p = torch.sqrt(torch.exp(logvar_p))\\n q_dist = torch.distributions.normal.Normal(mu_q, sigma_q)\\n p_dist = torch.distributions.normal.Normal(mu_p, sigma_p)\\n z = q_dist.rsample()\\n q_z = q_dist.log_prob(z)\\n p_z = p_dist.log_prob(z)\\n kld = torch.mean(q_z - p_z, dim=(1, 2))\\n return kld\",\n \"def gaussian_kl_np(mu0, log_std0, mu1, log_std1):\\n var0, var1 = np.exp(2 * log_std0), np.exp(2 * log_std1)\\n pre_sum = 0.5*(((mu1- mu0)**2 + var0)/(var1+EPS) - 1) + log_std1 - log_std0\\n all_kls = pre_sum\\n #all_kls = np.mean(all_kls)\\n all_kls = np.clip(all_kls, 0, 1/EPS) ### for stability\\n return all_kls\",\n \"def K(self, X, Xstar):\\n r = l2norm_(X, Xstar)\\n bessel = kv(self.v, np.sqrt(2 * self.v) * r / self.l)\\n f = 2 ** (1 - self.v) / gamma(self.v) * (np.sqrt(2 * self.v) * r / self.l) ** self.v\\n res = f * bessel\\n res[np.isnan(res)] = 1\\n res = self.sigmaf * res + self.sigman * kronDelta(X, Xstar)\\n return (res)\",\n \"def gaussian_kl_div(mean_0, cov_0, mean_1, cov_1, dim):\\n mean_diff = mean_1 - mean_0\\n cov_1_inv = tf.reciprocal(cov_1)\\n log_cov_1_det = tf.reduce_sum(tf.log(cov_1), axis=[1])\\n log_cov_0_det = tf.reduce_sum(tf.log(cov_0), axis=[1])\\n log_term = log_cov_1_det - log_cov_0_det\\n trace_term = tf.reduce_sum(cov_1_inv * cov_0, axis=[1])\\n square_term = tf.reduce_sum(mean_diff * cov_1_inv * mean_diff, axis=[1])\\n kl_div = 0.5 * (trace_term + square_term - dim + log_term)\\n return kl_div\",\n \"def e_step(self):\\n # update VMF probabilities (Equation (3))\\n logP = np.dot(self.features, self.mu.T)*self.kappa + np.log(self.pi).reshape(1,-1) # n by k\\n logP_norm = logP - logsumexp(logP, axis=1).reshape(-1,1)\\n self.p = np.exp(logP_norm)\\n self.mllk = np.mean(logsumexp(logP, axis=1))\",\n \"def log_bessel_kve(v, z, name=None):\\n with tf.name_scope(name or 'log_bessel_kve'):\\n dtype = dtype_util.common_dtype([v, z], tf.float32)\\n v = tf.convert_to_tensor(v, dtype=dtype)\\n z = tf.convert_to_tensor(z, dtype=dtype)\\n return _log_bessel_kve_custom_gradient(v, z)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71050805","0.6940623","0.6602319","0.6597178","0.6597178","0.6597178","0.6597178","0.6519826","0.6477681","0.64758873","0.64575756","0.64531076","0.64357793","0.63821673","0.63579816","0.631307","0.6311189","0.6289294","0.62851536","0.6265628","0.6253081","0.62478447","0.62462914","0.623995","0.62310165","0.6226509","0.6208754","0.6197905","0.6188672","0.6162639","0.61499536","0.6143951","0.61113286","0.6107778","0.61012","0.60963356","0.60453266","0.60428786","0.60416716","0.6035038","0.60260355","0.60236996","0.60086405","0.6006908","0.6006352","0.5998904","0.59907323","0.59588844","0.59535587","0.5950454","0.59461504","0.59399575","0.59385055","0.5930904","0.5926817","0.59220314","0.5906876","0.5905057","0.5898847","0.58891666","0.58886784","0.58886784","0.58878136","0.5885841","0.5853942","0.5848705","0.5830775","0.5830119","0.58267975","0.5823916","0.58146226","0.5801668","0.57998663","0.57958174","0.5793737","0.5786456","0.5786409","0.57847667","0.57815194","0.5780096","0.57738084","0.57509726","0.5741011","0.5735899","0.57124174","0.57081985","0.570776","0.5702025","0.5701305","0.5700804","0.5700804","0.56982154","0.56973785","0.56630844","0.5661864","0.56473076","0.5644699","0.5635154","0.56271964","0.5622784"],"string":"[\n \"0.71050805\",\n \"0.6940623\",\n \"0.6602319\",\n \"0.6597178\",\n \"0.6597178\",\n \"0.6597178\",\n \"0.6597178\",\n \"0.6519826\",\n \"0.6477681\",\n \"0.64758873\",\n \"0.64575756\",\n \"0.64531076\",\n \"0.64357793\",\n \"0.63821673\",\n \"0.63579816\",\n \"0.631307\",\n \"0.6311189\",\n \"0.6289294\",\n \"0.62851536\",\n \"0.6265628\",\n \"0.6253081\",\n \"0.62478447\",\n \"0.62462914\",\n \"0.623995\",\n \"0.62310165\",\n \"0.6226509\",\n \"0.6208754\",\n \"0.6197905\",\n \"0.6188672\",\n \"0.6162639\",\n \"0.61499536\",\n \"0.6143951\",\n \"0.61113286\",\n \"0.6107778\",\n \"0.61012\",\n \"0.60963356\",\n \"0.60453266\",\n \"0.60428786\",\n \"0.60416716\",\n \"0.6035038\",\n \"0.60260355\",\n \"0.60236996\",\n \"0.60086405\",\n \"0.6006908\",\n \"0.6006352\",\n \"0.5998904\",\n \"0.59907323\",\n \"0.59588844\",\n \"0.59535587\",\n \"0.5950454\",\n \"0.59461504\",\n \"0.59399575\",\n \"0.59385055\",\n \"0.5930904\",\n \"0.5926817\",\n \"0.59220314\",\n \"0.5906876\",\n \"0.5905057\",\n \"0.5898847\",\n \"0.58891666\",\n \"0.58886784\",\n \"0.58886784\",\n \"0.58878136\",\n \"0.5885841\",\n \"0.5853942\",\n \"0.5848705\",\n \"0.5830775\",\n \"0.5830119\",\n \"0.58267975\",\n \"0.5823916\",\n \"0.58146226\",\n \"0.5801668\",\n \"0.57998663\",\n \"0.57958174\",\n \"0.5793737\",\n \"0.5786456\",\n \"0.5786409\",\n \"0.57847667\",\n \"0.57815194\",\n \"0.5780096\",\n \"0.57738084\",\n \"0.57509726\",\n \"0.5741011\",\n \"0.5735899\",\n \"0.57124174\",\n \"0.57081985\",\n \"0.570776\",\n \"0.5702025\",\n \"0.5701305\",\n \"0.5700804\",\n \"0.5700804\",\n \"0.56982154\",\n \"0.56973785\",\n \"0.56630844\",\n \"0.5661864\",\n \"0.56473076\",\n \"0.5644699\",\n \"0.5635154\",\n \"0.56271964\",\n \"0.5622784\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6408748"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":88362,"cells":{"query":{"kind":"string","value":"r\"\"\"Samples from the latent space and return the corresponding image space map."},"document":{"kind":"string","value":"def sample(self, num_samples, current_device, **kwargs):\n z = torch.randn(num_samples, self.latent_dim)\n z = z.to(current_device)\n samples = self.decode(z)\n\n return samples"},"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 map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\n\n latent_coords = []\n\n for batch in data_sample:\n # run encoder\n coords = model.encoder(batch)\n latent_coords.append(coords)\n\n # return latent (per jet?)\n return np.concatenate(latent_coords, axis=0)","def sampling():\n # make directory for street images\n streetImageOutputFolder = CONFIG[\"sampling\"][\"streetImageOutputFolder\"]\n makeDirectory(streetImageOutputFolder)\n\n # Get preprocessed point data\n intersectionPointFile = CONFIG[\"shapefile\"][\"intersectoinPointFile\"]\n pointInfoFile = CONFIG[\"shapefile\"][\"pointInfoFilename\"]\n\n pointInfo = readPointFile(pointInfoFile)\n intersectionPointInfo = readIntersectionPointInfo(intersectionPointFile)\n\n # Filter point data that has street images taken within the specified period.\n maxYear = CONFIG[\"gmap\"][\"streetImageMaxYear\"]\n minYear = CONFIG[\"gmap\"][\"streetImageMinYear\"]\n filteredPoints = filterPointByYear(pointInfo, maxYear, minYear)\n\n IMG_NAME_COL_NUM = 5\n LAT_LNG_COL_NUM = 2\n\n # Sample street images, the return is list of sample info\n sampleNum = CONFIG[\"sampling\"][\"sampleNum\"]\n initImageNumber = CONFIG[\"sampling\"][\"initImageNumber\"]\n sampleData = sampleAndDownloadStreetImage(filteredPoints, sampleNum, initImageNumber, initImageNumber, streetImageOutputFolder, intersectionPointInfo)\n imageNames = [streetImageOutputFolder + \"/\" + data[IMG_NAME_COL_NUM] for data in sampleData]\n links = GDriveUpload(imageNames, \"Sampled_Image\")\n\n for i in xrange(len(sampleData)):\n imageName = streetImageOutputFolder + \"/\" + sampleData[i][IMG_NAME_COL_NUM]\n sampleData[i].append(links[imageName])\n\n columnTitle = [\"Sample Number\", \"Sampled Point Number\", \"Latitude + Longitude\", \"Heading\", \"Date\", \"Image Name\", \"Road Types\", \"Web Link\"]\n sampleData.insert(0, columnTitle)\n\n # output to csv file\n outputCSV(sampleData, CONFIG[\"sampling\"][\"csvFilename\"])\n\n # plot images map\n sampledPoints = set([divideGPS(d[LAT_LNG_COL_NUM]) for d in sampleData[1:]])\n plotSampledPointMap(list(sampledPoints), CONFIG[\"sampling\"][\"sampledPointsMapFilename\"])","def sample(self, num_samples, current_device):\n z = torch.randn(num_samples, self.latent_dim).to(current_device)\n samples = self.decode(z)\n return samples","def __call__(self, sample):\n img, landmarks = sample['image'], sample['landmarks']\n p = random.random()\n if p <= 1:\n h, w, c = img.shape\n for i in range(w//2):\n img[:, i, :], img[:, w-1-i, :] = img[:, w-1-i, :], img[:, i, :]\n for i in range(0, len(landmarks[0]), 2):\n x = landmarks[0][i]\n landmarks[0][i] = w-1-x\n return {'image': img,\n 'landmarks': landmarks}","def subsample_maps(net):\n\n # start with uniform probability that each map is selected for inclusion in a connection;\n # reduce probability of selecting a given map again whenever it is selected\n probability_reduction = .01\n interarea_probabilities = []\n interlaminar_probabilities = []\n for layer in net.layers:\n interarea_probabilities.append(np.ones(layer.m))\n interlaminar_probabilities.append(np.ones(layer.m))\n\n subsample_indices = []\n for connection in net.connections:\n n_maps = int(round(connection.pre.m * connection.c))\n pre_index = net.find_layer_index(connection.pre.name)\n\n pre_cortical_area = connection.pre.name.split('_')[0]\n post_cortical_area = connection.post.name.split('_')[0]\n if pre_cortical_area == post_cortical_area: # interlaminar\n p = interlaminar_probabilities[pre_index]\n else:\n p = interarea_probabilities[pre_index]\n\n indices = np.random.choice(range(int(connection.pre.m)), n_maps, replace=False, p=p/np.sum(p))\n for i in indices:\n p[i] = p[i]*probability_reduction\n subsample_indices.append(indices)\n\n return subsample_indices","def sample_region(data, pt_dict, n_frames,):\n dimensions = list(pt_dict.keys())\n d_data = [i[:, dimensions] for i in data]\n\n tree = KDTree(d_data)\n pt = [pt_dict[i] for i in dimensions]\n dis, ind = tree.query(pt, n_frames)\n return ind","def __sample(self):\n # xvals are \"east\" vals and yvals are \"north\" vals on the map\n xvals = np.random.uniform(self._xmin, self._xmax, self._num_samples)\n yvals = np.random.uniform(self._ymin, self._ymax, self._num_samples)\n if self._target_altitude is None:\n zvals = np.random.uniform(self._zmin, self._zmax, self._num_samples)\n else:\n zvals = np.full(self._num_samples, self._target_altitude, dtype=float)\n \n samples = list(zip(xvals, yvals, zvals))\n\n pts = []\n for s in samples:\n in_collision = False\n idxs = list(self._obstacles_tree.query_radius(\n np.array([s[0], s[1]]).reshape(1, -1), r=self._max_poly_xy)[0])\n \n if len(idxs) > 0:\n for ind in idxs: \n p = self._polygons[int(ind)]\n if p.contains(s) and p.height >= s[2]:\n in_collision = True\n\n if not in_collision:\n pts.append(s)\n \n return pts","def sample_latent(self, x):\n latent_dist = self.encoder(x)\n latent_sample = self.reparameterize(*latent_dist)\n return latent_sample","def sample(self, verbose=False):\n\t\tfor i in range(self.nsamp): self.subsample(verbose)\n\t\treturn self.amps, self.pos, self.irads","def make_map(self, sampling=None, size=None):\n if sampling is None and self.sampling is None:\n self.sampling = self.minimum_sampling()\n elif sampling is not None:\n self.sampling = sampling\n \n if size is None and self.size is None:\n self.size = self.minimum_size()\n elif size is not None:\n self.size = size\n\n # Build the on-sky source distribution\n self.seeing.make_map(sampling=self.sampling, size=self.size)\n self.x = self.seeing.x\n self.X = self.seeing.X\n self.y = self.seeing.y\n self.Y = self.seeing.Y\n try:\n # Construct the intrinsic map of the source\n self.intrinsic.make_map(sampling=self.sampling, size=self.size)\n # Convolve with the seeing distribution, conserving the\n # integral of the intrinsic source\n self.data = signal.fftconvolve(self.intrinsic.data,\n self.seeing.data * numpy.square(self.sampling),\n mode='same')\n except AttributeError:\n # Renormalize the unity-integral seeing kernal for to\n # represent a point source\n self.data = self.intrinsic*self.seeing.data\n\n # Get the integral\n try:\n # After convolving with the seeing kernel, the total\n # integral should be the same, up to some tolerance\n self.integral = self.intrinsic.integral\n tolerance = 1e-3\n diff = numpy.absolute(self.integral - numpy.square(self.sampling)*numpy.sum(self.data))\n if diff > tolerance:\n warnings.warn('Map and analytic integrals are discrepant by {0} ({1} %)'.format(\n diff, 100*diff/self.integral))\n except AttributeError:\n self.integral = numpy.square(self.sampling) * numpy.sum(self.data)\n\n # Prep for interpolation\n self.interp = interpolate.interp2d(self.x, self.y, self.data, bounds_error=True)","def _get_sample(self):\n return [layer._get_sample() for layer in self.layers]","def latents(self):\n self.assert_sampled()\n return self._representations","def sample(self):\n ndim = len(self.lower_bounds)\n pts = numpy.zeros(ndim)\n for j in range(ndim):\n lb = self.lower_bounds[j]\n ub = self.upper_bounds[j]\n pts[j] = numpy.random.uniform(lb, ub)\n return pts","def uniform_samples(self):\n if self._uniform_samples is None:\n if self.is_from_directory:\n uniform_sample_path = f'{self._directory_root}/uniform_points.sdf'\n uniform_samples = gaps_util.read_pts_file(uniform_sample_path)\n # log.info(f'The uniform points have shape {uniform_samples.shape}')\n else:\n uniform_samples = self._archive['uniform_samples']\n self._uniform_samples = np.reshape(uniform_samples,\n [100000, 4]).astype(np.float32)\n return self._uniform_samples","def get_initial_latents(self, height, width, num_channels_latents, batch_size):\n\n image_latents = torch.randn((batch_size, num_channels_latents, height, width)).to(self.device)\n # scale the initial noise by the standard deviation required by the scheduler\n image_latents = image_latents * self.scheduler.init_noise_sigma\n return image_latents","def get_sample(self, n, side_len):\n self.side_len = side_len\n side_len_scaled = self.side_len * self.resolution_scaler\n\n print(self.side_len, side_len_scaled, self.resolution_scaler)\n tiles = []\n center_coords = []\n\n # get random starting positions \n rand_rows = np.random.randint(self.src.shape[0]-side_len_scaled , size=(n,))\n rand_cols = np.random.randint(self.src.shape[1]-side_len_scaled, size=(n,))\n\n for row_idx, col_idx in zip(rand_rows, rand_cols):\n # get clip\n clip = self.get_window(row_idx, col_idx, side_len_scaled)\n\n # handle non-square clips\n if clip.shape[1] != side_len_scaled or clip.shape[2] != side_len_scaled:\n pad = np.full((3, side_len_scaled, side_len_scaled), self.pad_val)\n pad[:, 0:clip.shape[1], 0:clip.shape[2]] = clip\n clip = pad.copy()\n\n if self.resolution_scaler != 1:\n # note that we use the unscaled side length to ensure numpy arrays\n # have the same dimensionality\n clip = resize(clip, (3, self.side_len, self.side_len))\n \n print(clip.shape)\n\n tiles.append(clip)\n\n # get center lat/lon\n lat, lon = self.get_latlon_point(row_idx + side_len_scaled // 2, col_idx + side_len_scaled // 2)\n center_coords.append([lat, lon])\n\n return tiles, center_coords","def subsample_image(input_image, zoom_box_coords):\n start_x, start_y = zoom_box_coords[0:2]\n return input_image[start_y:start_y+zoom_box_coords[3], start_x:start_x+zoom_box_coords[2]]","def samples(self):\n pass","def mapillary_sample():\n return \"tests/data/mapillary/training/\"","def sample(self):\n ndim = len(self.lower_bounds)\n pts = numpy.zeros(ndim)\n for j in range(ndim):\n lb = self.lower_bounds[j]\n ub = self.upper_bounds[j]\n pts[j] = (ub - lb) / 2.0 + lb\n return pts","def samples(self):\n return self._norm_samples * self._scaling","def get_map(self):\n return self.get_raw_ys()","def __call__(self, sample):\n image, landmarks = sample['image'], sample['landmarks']\n choices = ((0, 1, 2), (0, 2, 1), (1, 0, 2),\n (1, 2, 0), (2, 1, 0), (2, 0, 1))\n p = random.random()\n if p <= 0.5:\n idx = random.randint(0, 5)\n swap = choices[idx]\n image = image[:, :, swap]\n return {'image': image,\n 'landmarks': landmarks}","def surface_samples(self):\n if self._surface_samples is None:\n self._surface_samples = self.get_surface_samples(10000)\n return self._surface_samples","def positions(self, tileID, numSamples):","def sample_mapped_keys(mapping, min_coverage=50):\r\n if min_coverage == 0:\r\n return {}\r\n sample_keys = {}\r\n for key in mapping.keys():\r\n if (min_coverage > 1):\r\n sample_keys[key] = sample(mapping[key],\r\n min(min_coverage - 1, len(mapping[key])))\r\n else:\r\n sample_keys[key] = []\r\n sample_keys[key].append(key) # always include the centroid\r\n return sample_keys","def samples(self, gp):\r\n raise NotImplementedError","def near_surface_samples(self):\n if self._near_surface_samples is None:\n if self.is_from_directory:\n nss_sample_path = f'{self._directory_root}/nss_points.sdf'\n nss = gaps_util.read_pts_file(nss_sample_path)\n # log.info(f'The points have shape {nss.shape}')\n else:\n nss = self._archive['axis_samples']\n self._near_surface_samples = np.reshape(nss,\n [100000, 4]).astype(np.float32)\n return self._near_surface_samples","def sample_spherical(self):\n vec = np.random.randn(self.dims, self.arms)\n vec /= np.linalg.norm(vec, axis=0)\n self.contexts = vec.T","def mapillary_raw_sample():\n return \"tests/data/mapillary/sample/\"","def _standard_mapping(self):\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\n self.camvidMap = mapping_raw['camvidMap'] * 255\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255","def create_single_map(self,tod,x,y,x0,y0):\n maps = {'map':np.zeros((self.Nx*self.Ny)),\n 'cov':np.zeros((self.Nx*self.Ny))}\n\n\n pixels,xp,yp,r_x, r_y = self.get_pixel_positions(x,y,x0,y0,0,invertx=True)\n mask = np.ones(pixels.size,dtype=int)\n\n mask[(pixels == -1) | np.isnan(tod) | np.isinf(tod)] = 0\n rms = stats.AutoRMS(tod)\n weights = {'map':tod.astype(np.float64)/rms**2,\n 'cov':np.ones(tod.size)/rms**2}\n for k in maps.keys():\n binFuncs.binValues(maps[k],\n pixels,\n weights=weights[k],mask=mask)\n maps[k] = np.reshape(maps[k],(self.Ny,self.Nx))\n return maps","def init_locations():\n player, door, monster = sample(CELLS, k=3)\n\n return player, door, monster","def cartesian_sampler(data):\n data = np.asarray(data)\n ny, nx = data.shape[0:2]\n\n if ny * 2 != nx:\n raise ValueError(\"Map must be twice as wide as it is tall\")\n\n def vec2pix(l, b):\n l = (l + np.pi) % (2 * np.pi)\n l[l < 0] += 2 * np.pi\n l = nx * (1 - l / (2 * np.pi))\n l = np.clip(l.astype(np.int), 0, nx - 1)\n b = ny * (1 - (b + np.pi / 2) / np.pi)\n b = np.clip(b.astype(np.int), 0, ny - 1)\n return data[b, l]\n\n return vec2pix","def _compute_samples(self, samples):\n return samples","def sample(self, n_samples):\n\n eps = torch.randn((n_samples, self.z_dim)).to(self.device)\n sampled_ims = self.decoder(eps)\n im_means = sampled_ims.mean(dim=0)\n\n shape = (-1, 1, 28, 28)\n sampled_ims, im_means = sampled_ims.view(shape), im_means.view(shape)\n\n return sampled_ims, im_means","def get_real_samples(self):\n # Define the camera poses\n if not self.opt.same_view:\n if self.opt.full_sphere_sampling:\n self.cam_pos = uniform_sample_sphere(\n radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\n axis=None, angle=self.opt.angle,\n theta_range=np.deg2rad(self.opt.theta), phi_range=np.deg2rad(self.opt.phi))\n else:\n self.cam_pos = uniform_sample_sphere(\n radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\n axis=None, angle=self.opt.angle,\n theta_range=np.deg2rad(self.opt.theta),\n phi_range=np.deg2rad(self.opt.phi))\n if self.opt.full_sphere_sampling_light:\n self.light_pos1 = uniform_sample_sphere(\n radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\n axis=None, angle=self.opt.angle,\n theta_range=np.deg2rad(self.opt.theta),\n phi_range=np.deg2rad(self.opt.phi))\n # self.light_pos2 = uniform_sample_sphere(radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\n # axis=self.opt.axis, angle=np.deg2rad(40),\n # theta_range=self.opt.theta, phi_range=self.opt.phi)\n else:\n print(\"inbox\")\n light_eps = 0.15\n self.light_pos1 = np.random.rand(self.opt.batchSize,3)*self.opt.cam_dist + light_eps\n self.light_pos2 = np.random.rand(self.opt.batchSize,3)*self.opt.cam_dist + light_eps\n\n # TODO: deg2rad in all the angles????\n\n # Create a splats rendering scene\n large_scene = create_scene(self.opt.width, self.opt.height,\n self.opt.fovy, self.opt.focal_length,\n self.opt.n_splats)\n lookat = self.opt.at if self.opt.at is not None else [0.0, 0.0, 0.0, 1.0]\n large_scene['camera']['at'] = tch_var_f(lookat)\n\n # Render scenes\n data, data_depth, data_normal, data_cond = [], [], [], []\n inpath = self.opt.vis_images + '/'\n for idx in range(self.opt.batchSize):\n # Save the splats into the rendering scene\n if self.opt.use_mesh:\n if 'sphere' in large_scene['objects']:\n del large_scene['objects']['sphere']\n if 'disk' in large_scene['objects']:\n del large_scene['objects']['disk']\n if 'triangle' not in large_scene['objects']:\n large_scene['objects'] = {\n 'triangle': {'face': None, 'normal': None,\n 'material_idx': None}}\n samples = self.get_samples()\n\n large_scene['objects']['triangle']['material_idx'] = tch_var_l(\n np.zeros(samples['mesh']['face'][0].shape[0],\n dtype=int).tolist())\n large_scene['objects']['triangle']['face'] = Variable(\n samples['mesh']['face'][0].cuda(), requires_grad=False)\n large_scene['objects']['triangle']['normal'] = Variable(\n samples['mesh']['normal'][0].cuda(),\n requires_grad=False)\n else:\n if 'sphere' in large_scene['objects']:\n del large_scene['objects']['sphere']\n if 'triangle' in large_scene['objects']:\n del large_scene['objects']['triangle']\n if 'disk' not in large_scene['objects']:\n large_scene['objects'] = {\n 'disk': {'pos': None,\n 'normal': None,\n 'material_idx': None}}\n large_scene['objects']['disk']['radius'] = tch_var_f(\n np.ones(self.opt.n_splats) * self.opt.splats_radius)\n large_scene['objects']['disk']['material_idx'] = tch_var_l(\n np.zeros(self.opt.n_splats, dtype=int).tolist())\n large_scene['objects']['disk']['pos'] = Variable(\n samples['splats']['pos'][idx].cuda(),\n requires_grad=False)\n large_scene['objects']['disk']['normal'] = Variable(\n samples['splats']['normal'][idx].cuda(),\n requires_grad=False)\n\n # Set camera position\n if not self.opt.same_view:\n large_scene['camera']['eye'] = tch_var_f(self.cam_pos[idx])\n else:\n large_scene['camera']['eye'] = tch_var_f(self.cam_pos[0])\n\n large_scene['lights']['pos'][0,:3]=tch_var_f(self.light_pos1[idx])\n #large_scene['lights']['pos'][1,:3]=tch_var_f(self.light_pos2[idx])\n\n # Render scene\n res = render(large_scene,\n norm_depth_image_only=self.opt.norm_depth_image_only,\n double_sided=True, use_quartic=self.opt.use_quartic)\n\n # Get rendered output\n if self.opt.render_img_nc == 1:\n depth = res['depth']\n im_d = depth.unsqueeze(0)\n else:\n depth = res['depth']\n im_d = depth.unsqueeze(0)\n im = res['image'].permute(2, 0, 1)\n target_normal_ = get_data(res['normal'])\n target_normalmap_img_ = get_normalmap_image(target_normal_)\n im_n = tch_var_f(\n target_normalmap_img_).view(im.shape[1], im.shape[2],\n 3).permute(2, 0, 1)\n\n # Add depth image to the output structure\n if self.iteration_no % self.opt.save_image_interval == 0:\n imsave((inpath + str(self.iteration_no) +\n 'real_normalmap_{:05d}.png'.format(idx)),\n target_normalmap_img_)\n imsave((inpath + str(self.iteration_no) +\n 'real_depth_{:05d}.png'.format(idx)), get_data(depth))\n # imsave(inpath + str(self.iteration_no) + 'real_depthmap_{:05d}.png'.format(idx), im_d)\n # imsave(inpath + str(self.iteration_no) + 'world_normalmap_{:05d}.png'.format(idx), target_worldnormalmap_img_)\n data.append(im)\n data_depth.append(im_d)\n data_normal.append(im_n)\n data_cond.append(large_scene['camera']['eye'])\n # Stack real samples\n real_samples = torch.stack(data)\n real_samples_depth = torch.stack(data_depth)\n real_samples_normal = torch.stack(data_normal)\n real_samples_cond = torch.stack(data_cond)\n self.batch_size = real_samples.size(0)\n if not self.opt.no_cuda:\n real_samples = real_samples.cuda()\n real_samples_depth = real_samples_depth.cuda()\n real_samples_normal = real_samples_normal.cuda()\n real_samples_cond = real_samples_cond.cuda()\n\n # Set input/output variables\n\n self.input.resize_as_(real_samples.data).copy_(real_samples.data)\n self.input_depth.resize_as_(real_samples_depth.data).copy_(real_samples_depth.data)\n self.input_normal.resize_as_(real_samples_normal.data).copy_(real_samples_normal.data)\n self.input_cond.resize_as_(real_samples_cond.data).copy_(real_samples_cond.data)\n self.label.resize_(self.batch_size).fill_(self.real_label)\n # TODO: Remove Variables\n self.inputv = Variable(self.input)\n self.inputv_depth = Variable(self.input_depth)\n self.inputv_normal = Variable(self.input_normal)\n self.inputv_cond = Variable(self.input_cond)\n self.labelv = Variable(self.label)","def generate_map():\n o = []\n note_group_size = GAN_PARAMS[\"note_group_size\"]\n pos = [np.random.randint(100, 412), np.random.randint(80, 304)]\n models = make_models()\n\n print(\"# of groups: {}\".format(timestamps.shape[0] // note_group_size))\n for i in range(timestamps.shape[0] // note_group_size):\n z = generate_set(models, begin=i * note_group_size, start_pos=pos, length_multiplier=dist_multiplier,\n group_id=i, plot_map=False)[:, :6] * np.array([512, 384, 1, 1, 512, 384])\n pos = z[-1, 0:2]\n o.append(z)\n a = np.concatenate(o, axis=0)\n return a","def synthetic_gen(self):\r\n logging.debug('generating synthetic map...')\r\n data = self.realData\r\n unit = Params.unitGrid\r\n x_min = np.floor(Params.LOW[0] / unit) * unit\r\n x_max = np.ceil(Params.HIGH[0] / unit) * unit\r\n y_min = np.floor(Params.LOW[1] / unit) * unit\r\n y_max = np.ceil(Params.HIGH[1] / unit) * unit\r\n\r\n x_CELL = int(np.rint((x_max - x_min) / unit))\r\n y_CELL = int(np.rint((y_max - y_min) / unit))\r\n\r\n self.root.n_box = np.array([[x_min, y_min], [x_max, y_max]])\r\n\r\n self.mapp = np.zeros((x_CELL, y_CELL)) - 1 # ## initialize every cell with -1\r\n for i in range(Params.NDATA): # ## populate the map\r\n point = data[:, i]\r\n cell_x = int(np.floor((point[0] - x_min) / unit))\r\n cell_y = int(np.floor((point[1] - y_min) / unit))\r\n if self.mapp[cell_x, cell_y] != -1:\r\n self.mapp[cell_x, cell_y] += 1\r\n else:\r\n self.mapp[cell_x, cell_y] = 1\r\n\r\n for i in range(x_CELL): # ## perturb the counts\r\n for j in range(y_CELL):\r\n if self.mapp[i, j] != -1:\r\n self.mapp[i, j] += np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\r\n else:\r\n self.mapp[i, j] = np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\r\n # if noisy count is negative, ignore the noise and generate no points\r\n if self.mapp[i, j] < 0:\r\n self.mapp[i, j] = 0","def get_pixel_sample_coords(upperLeftTup, lowerRightTup, pixPerSample=20):\n ulx, uly = upperLeftTup\n lrx, lry = lowerRightTup\n\n width = lrx - ulx\n height = lry - uly\n\n pixels = width * height\n nSamples = (pixels/pixPerSample)\n\n x, y = (0, 0)\n i = 0\n while i < nSamples:\n yield (x + ulx, y + uly)\n x = (x + pixPerSample) % width\n y += int((x + pixPerSample) / width)\n i += 1","def make_map(self, sampling=None, size=None):\n if sampling is None and self.sampling is None:\n self.sampling = self.minimum_sampling()\n elif sampling is not None:\n self.sampling = sampling\n \n if size is None and self.size is None:\n self.size = self.minimum_size()\n elif size is not None:\n self.size = size\n\n # Set the number of pixels that spans the full size requested\n pixsize = numpy.ceil(self.size/self.sampling).astype(int)\n # Force the pixel size to be odd\n if pixsize % 2 == 0:\n pixsize += 1\n # Adjust the size to be an integer number of pixels\n _size = pixsize*self.sampling\n if _size - self.size > 0.1*self.sampling:\n warnings.warn('Size reset to an integer number of pixels: '\n ' {0} -> {1} arcsec'.format(self.size, _size))\n self.size = _size\n self.y = (pixsize-1)*numpy.linspace(-0.5,0.5,pixsize)*self.sampling\n self.x = self.y.copy()[::-1]\n\n # Sample it\n self.X, self.Y = numpy.meshgrid(self.x, self.y)\n self.data = self.__call__(self.X, self.Y)","def make_pnts(start_point, end_point, path, cellsize):\n pnts = misc.generateSamples(tran = [start_point, end_point], path = path)\n \n #Only do sampling at DEM with >3m resolution \n if cellsize[0] >= 5:\n pnts = misc.selectSamplePts([start_point, end_point], pnts, cellsize[0])\n return pnts","def surface_samples_from_dodeca(self):\n if not hasattr(self, '_surface_samples_from_dodeca'):\n depth_ims = self.depth_images.copy() / 1000.0\n is_valid = depth_ims != 0.0\n is_valid = np.reshape(is_valid, [20, 224, 224])\n world_xyz = self.world_xyz_images_from_dodeca.copy()\n world_n = self.world_normal_images.copy()\n world_xyzn = np.concatenate([world_xyz, world_n], axis=-1)\n world_xyzn = world_xyzn[is_valid, :]\n world_xyzn = np.reshape(world_xyzn, [-1, 6])\n np.random.shuffle(world_xyzn)\n assert world_xyzn.shape[0] > 1\n while world_xyzn.shape[0] < self.surface_sample_count:\n log.verbose(f'Tiling samples from {world_xyzn.shape[0]} to'\n f' {2*world_xyzn.shape[0]}')\n world_xyzn = np.tile(world_xyzn, [2, 1])\n self._surface_samples_from_dodeca = world_xyzn[:self\n .surface_sample_count, :]\n return self._surface_samples_from_dodeca","def sample(self):\n return gc.rand_state.uniform(low=self.bounds[0], high=self.bounds[1])","def sample_location(key: jnp.ndarray) -> s2.LatLng:\n lat_key, lng_key = jax.random.split(key, num=2)\n\n # NOTE(scandido): If we sample from the sphere we will need to seriously\n # skew the distribution (likely via rejection sampling) to retrieve enough\n # times when station keeping is possible. We temporarily (permanently?) work\n # around this by just sampling the equatorial region. Given the lower\n # latitudes have significantly lower skew we don't bother making sure each\n # lat/lng has equal chance (e.g., sample from sphere and rejection sample\n # points with latitude beyond the equatorial region). All this as\n # justification for lazy GIS work. 🤷♂️\n lat: float = jax.random.uniform(lat_key, (), minval=-10.0, maxval=10.0).item()\n # NOTE(scandido): We avoid sampling near the international date line so we\n # don't have to worry about wrapping the grid. This is a meteorologically\n # sound trick to save a few lines of code. 🤠\n lng: float = jax.random.uniform(\n lng_key, (), minval=-175.0, maxval=175.0).item()\n return s2.LatLng.from_degrees(lat, lng)","def sample_from_boundary(bounds_dict):\n area = 0 if np.random.random() < 0.5 else 1 #area 0 is half the center table, area 1 is the whole right table\n\n x = np.random.random() * bounds_dict['x_r'][area] + min(bounds_dict['x'][area])\n y = np.random.random() * bounds_dict['y_r'][area] + min(bounds_dict['y'][area])\n\n z = np.random.random() * 0.15 + 0.24\n return([x, y, z])","def sampleFromShakeMap(shakefile, layer, xypoints):\n\n shakegrid = ShakeGrid.load(shakefile, fixFileGeoDict='corner')\n return sampleFromMultiGrid(shakegrid, layer, xypoints)","def __getitem__(self, idx):\n # stored image have binary and shape (H x W) so multiply by 255 to get pixel\n # values + add dimension\n sample = np.expand_dims(self.imgs[idx] * 255, axis=-1)\n\n # ToTensor transforms numpy.ndarray (H x W x C) in the range\n # [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]\n sample = self.transforms(sample)\n\n lat_value = self.lat_values[idx]\n return sample, lat_value","def test_sample_from_extra_bounds_good(self):\n dim = Real(\"yolo\", \"norm\", 0, 2, low=-5, high=+5, shape=(4, 4))\n for _ in range(8):\n samples = dim.sample(8)\n for sample in samples:\n assert sample in dim","def samplePositions(self):\n samples = []\n for i in range(self.sampleIter):\n x = random.randint(-self.sampleRange, self.sampleRange)\n y = random.randint(-self.sampleRange, self.sampleRange)\n x += self.currentPosition[0]\n y += self.currentPosition[1]\n if (x, y) in self.graph.keys():\n if self.graph[(x, y)] == 0:\n samples.append((x, y))\n return samples","def sample(self, nsamples):\n return self.dist.sample(nsamples)","def get_samples(self, min_samples):\n raise NotImplementedError","def get_data():\r\n spatial_expmat = np.load('/home/anniegao/spatial_magan/data/spatial_pca_with_coords.npz')['arr_0']\r\n spatial_expmat[:,100:] *= 5\r\n rna_expmat = np.load('/home/anniegao/spatial_magan/data/rna_pca_sampled.npz')['arr_0']\r\n spatial_pca_components = np.load('/home/anniegao/spatial_magan/data/spatial_pca_100components.npz')['arr_0']\r\n rna_pca_components = np.load('/home/anniegao/spatial_magan/data/rna_pca_100components.npz')['arr_0']\r\n spatial_cluster_labels = np.load('/home/anniegao/spatial_magan/data/spatial_cluster_3_labels_phate.npz')['arr_0']\r\n rna_cluster_labels = np.load('/home/anniegao/spatial_magan/data/rna_cluster_5_labels_sampled.npz')['arr_0']\r\n return spatial_expmat, rna_expmat, spatial_pca_components, rna_pca_components, spatial_cluster_labels, rna_cluster_labels","def sampling_latent(self):\n \n self.z = gaussian_sample(self.qz_m, self.qz_v)\n if self.scalings:\n self.library = gaussian_sample(self.ql_m, self.ql_v)","def get_sample_mask(self):","def make_maps_of_2x1_pix_coordinates (sp) : \n x_rhs = np.arange(sp.colsh)*sp.pixs + sp.pixw - sp.pixsh\n x_rhs[0] = sp.pixwh # set x-coordinate of the wide pixel \n x_arr = np.hstack([-x_rhs[::-1],x_rhs])\n\n y_arr = np.arange(sp.rows) * sp.pixs\n y_arr -= y_arr[-1]/2 # move origin to the center of array\n\n sp.x_map2x1, sp.y_map2x1 = np.meshgrid(x_arr, y_arr)","def example():\n sampler = DoomSampler()\n # Current architecture works on batches of 32 levels\n # Noise shape is (batch_size, 100)\n noise_shape = [32, 100]\n # Input Feature vector shape is (batch_size, 7) - Refer to DoomLevelsGAN/network_architecture.py\n feat_shape = [32, 7]\n\n # Generating random noise and input features as example\n noise = np.random.random(size=noise_shape)\n input_features = np.random.random(size=feat_shape)\n out_features = sampler.get_features_of(noise, input_features)\n\n # Retrieving samples\n levels = sampler.last_generated_samples\n\n # Printing feature values\n for f_name, f_list in out_features.items():\n print(\"Feature: {} \\n {}\".format(f_name, f_list))","def sample(src, coords):\n b, h, w, c = src.size()\n h_sample, w_sample = coords.shape[:2]\n max_coord = [h - 1, w - 1]\n coords = np.clip(coords, 0, max_coord)\n indices = mapping_to_indices(coords, b)\n\n sampled = src[indices].reshape((h_sample, w_sample))\n\n return sampled","def get_surface_samples_from_single_dodeca_image(self, idx):\n depth_im = self.depth_images[0, idx, ...]\n is_valid = depth_im != 0.0\n is_valid = np.reshape(is_valid, [224, 224])\n world_xyz = self.world_xyz_images_from_dodeca.copy()[idx, ...]\n world_n = self.world_normal_images.copy()[idx, ...]\n world_xyzn = np.concatenate([world_xyz, world_n], axis=-1)\n world_xyzn = world_xyzn[is_valid, :]\n world_xyzn = np.reshape(world_xyzn, [-1, 6])\n np.random.shuffle(world_xyzn)\n point_count = world_xyzn.shape[0]\n assert point_count > 0\n log.info('The number of valid samples for idx %i is: %i' %\n (idx, point_count))\n while point_count < 10000:\n world_xyzn = np.tile(world_xyzn, [2, 1])\n point_count = world_xyzn.shape[0]\n return world_xyzn[:10000, :]","def test_ndc_to_grid_sample_coords(self):\n\n # square image tests\n image_size_square = [100, 100]\n xy_ndc_gs_square = torch.FloatTensor(\n [\n # 4 corners\n [[-1.0, -1.0], [1.0, 1.0]],\n [[1.0, 1.0], [-1.0, -1.0]],\n [[1.0, -1.0], [-1.0, 1.0]],\n [[1.0, 1.0], [-1.0, -1.0]],\n # center\n [[0.0, 0.0], [0.0, 0.0]],\n ]\n )\n\n # non-batched version\n for xy_ndc, xy_gs in xy_ndc_gs_square:\n xy_gs_predicted = ndc_to_grid_sample_coords(\n xy_ndc,\n image_size_square,\n )\n self.assertClose(xy_gs_predicted, xy_gs)\n\n # batched version\n xy_ndc, xy_gs = xy_ndc_gs_square[:, 0], xy_ndc_gs_square[:, 1]\n xy_gs_predicted = ndc_to_grid_sample_coords(\n xy_ndc,\n image_size_square,\n )\n self.assertClose(xy_gs_predicted, xy_gs)\n\n # non-square image tests\n image_size = [100, 200]\n xy_ndc_gs = torch.FloatTensor(\n [\n # 4 corners\n [[-2.0, -1.0], [1.0, 1.0]],\n [[2.0, -1.0], [-1.0, 1.0]],\n [[-2.0, 1.0], [1.0, -1.0]],\n [[2.0, 1.0], [-1.0, -1.0]],\n # center\n [[0.0, 0.0], [0.0, 0.0]],\n # non-corner points\n [[4.0, 0.5], [-2.0, -0.5]],\n [[1.0, -0.5], [-0.5, 0.5]],\n ]\n )\n\n # check both H > W and W > H\n for flip_axes in [False, True]:\n\n # non-batched version\n for xy_ndc, xy_gs in xy_ndc_gs:\n xy_gs_predicted = ndc_to_grid_sample_coords(\n xy_ndc.flip(dims=(-1,)) if flip_axes else xy_ndc,\n list(reversed(image_size)) if flip_axes else image_size,\n )\n self.assertClose(\n xy_gs_predicted,\n xy_gs.flip(dims=(-1,)) if flip_axes else xy_gs,\n )\n\n # batched version\n xy_ndc, xy_gs = xy_ndc_gs[:, 0], xy_ndc_gs[:, 1]\n xy_gs_predicted = ndc_to_grid_sample_coords(\n xy_ndc.flip(dims=(-1,)) if flip_axes else xy_ndc,\n list(reversed(image_size)) if flip_axes else image_size,\n )\n self.assertClose(\n xy_gs_predicted,\n xy_gs.flip(dims=(-1,)) if flip_axes else xy_gs,\n )","def sample_data_grid8(num_samples=0):\n db, imsize = utils.load_grid8()\n\n return sample_data(db, imsize, num_samples)","def generate_samples(self, latent_vec=None, num=None):\n num = self.batch_size if num is None else num\n latent_vec = self.noise_fn(num) if latent_vec is None else latent_vec\n with torch.no_grad():\n samples = self.generator(latent_vec)\n samples = samples.cpu() # move images to cpu\n return samples","def sample(self):\n # Convert year from number to string (i.e. -1200 to 1200BC)\n year = self.world.year()\n if year < 0:\n year = str(year)[1:] + 'BC'\n elif year == 0:\n year = '0'\n elif year > 0:\n year = str(year) + 'AD'\n # Only sample when we are at a valid year\n if year not in self.years:\n return\n\n # retrieve list of occupied tile coordinates\n occupied = self.occupied[year]\n\n # Sum the number of polities in the historical extent of the empire,\n # and their sizes\n included_polities = []\n n_polities = 0\n polity_sizes = []\n for coordinates in occupied:\n tile = self.world.index(coordinates[0], coordinates[1])\n # Skip desert tiles included in the extent of the empire\n if not tile.terrain.polity_forming:\n continue\n polity = tile.polity\n # Ensure polities are not doubly counted if they possess more than\n # one community in the extent of the empire\n if polity in included_polities:\n continue\n included_polities.append(polity)\n n_polities += 1\n polity_sizes.append(polity.size())\n\n self.n_polities[year] = n_polities\n self.polity_sizes[year] = polity_sizes","def sample_damaging(image):\r\n return crease_image(blotch_image(image, 100, True), 10, False)","def _get_random_sample(self):\n p=np.zeros(len(self.dim_ranges))\n for i in range(len(self.dim_ranges)):\n temp=np.linspace(self.dim_ranges[i][0],self.dim_ranges[i][1],1000)\n p[i]=np.random.choice(temp,1,True,None)\n\n return p","def get_spherical_map(screen_pos, input_res=(281, 500), output_res=(360, 640), k_side=2, filling_pol=\"nonzero\"):\n assert filling_pol in [\"nonzero\", \"closest\"]\n\n screen_interp = interpolate_screen_pos(screen_pos, np.linspace(0,16, input_res[1], endpoint=True),\n np.linspace(0, 9, input_res[0], endpoint=True))\n y_inres, x_inres = input_res\n y_res, x_res = output_res\n xnew = np.linspace(screen_interp[:,:,1].min(), screen_interp[:,:,1].max(), x_res)\n ynew = np.linspace(screen_interp[:,:,0].min(), screen_interp[:,:,0].max(), y_res)\n map_img = np.zeros((y_res, x_res))\n\n y_map, x_map = np.empty(y_inres*x_inres, dtype=int), np.empty(y_inres*x_inres, dtype=int)\n for i, (y, x) in enumerate(zip(screen_interp[:,::-1,0].flatten(), screen_interp[:,::-1,1].flatten())):\n y_map[i] = np.argmin(ynew<y)\n x_map[i] = np.argmin(xnew<x)\n map_img[y_map, x_map] = 1\n\n y_nonzero, x_nonzero = np.nonzero(map_img==0) #Finds where the image is still zero\n fill_x_l, fill_y_l, nonzeros_l = [], [], []\n for y, x in zip(y_nonzero, x_nonzero):\n # Sets the limits to where to look for nonzeros pixels\n ylow, xlow = max(0, y-k_side), max(0, x-k_side)\n yhig, xhig = min(y+k_side+1, y_res), min(x+k_side+1, x_res)\n area = map_img[ylow:yhig, xlow:xhig]\n\n if np.any(area): #If there are pixels around\n fill_x_l.append(x)\n fill_y_l.append(y)\n nonz_y, nonz_x = np.nonzero(area)\n if filling_pol==\"nonzero\":\n nonzeros_l.append((nonz_y+ylow, nonz_x+xlow)) #store the nonzero slicing for later filling\n elif filling_pol==\"closest\":\n xx, yy = np.meshgrid(np.arange(xlow,xhig), np.arange(ylow,yhig))\n distances = np.sqrt((yy-y)**2+(xx-x)**2)\n idx_min = np.argmin(distances[nonz_y, nonz_x])\n nonzeros_l.append(([nonz_y[idx_min]+ylow], [nonz_x[idx_min]+xlow]))\n\n return (y_map, x_map), (fill_y_l, fill_x_l, nonzeros_l)","def create_band_maps(self):\n band_maps = []\n source_band_index = 1\n target_band_index = self.starting_target_band\n for band in self.image['bands']:\n band_maps.append({\n 'source': source_band_index,\n 'target': target_band_index\n })\n source_band_index += 1\n target_band_index += 1\n return band_maps","def lhs_start(hyperbounds, n_samples, rng=None):\n low_bounds = []\n high_bounds = []\n for bound in hyperbounds:\n low_bounds.append(bound[0])\n high_bounds.append(bound[1])\n\n low_bounds = np.array(low_bounds, dtype=object)\n high_bounds = np.array(high_bounds, dtype=object)\n\n samples = sample_latin_hypercube(low_bounds, high_bounds, n_samples, rng=rng)\n samples = samples.tolist()\n return samples","def test_sample_mapped_keys(self):\r\n\r\n # With num_coverage=1 only the keys will be sampled\r\n actual = sample_mapped_keys(self.test_map, 1)\r\n self.assertEqual(actual, {'1': ['1'], '2': ['2']})\r\n\r\n actual = sample_mapped_keys(self.test_map, 3)\r\n for key in actual.keys():\r\n # check number of sampled keys\r\n self.assertEqual(3, len(actual[key]))\r\n for x in actual[key]:\r\n # check that sampled key is in the full list\r\n correct = list(self.test_map[key])\r\n correct.append(key)\r\n self.assertTrue(x in correct)","def sample(self):\n return [agent_observation_space.sample() for agent_observation_space in self._agents_observation_space]","def point_sample(img_meta,\n img_features,\n points,\n proj_mat,\n coord_type,\n img_scale_factor,\n img_crop_offset,\n img_flip,\n img_pad_shape,\n img_shape,\n aligned=True,\n padding_mode='zeros',\n align_corners=True):\n\n # apply transformation based on info in img_meta\n points = apply_3d_transformation(\n points, coord_type, img_meta, reverse=True)\n\n # project points to camera coordinate\n pts_2d = points_cam2img(points, proj_mat)\n\n # img transformation: scale -> crop -> flip\n # the image is resized by img_scale_factor\n img_coors = pts_2d[:, 0:2] * img_scale_factor # Nx2\n img_coors -= img_crop_offset\n\n # grid sample, the valid grid range should be in [-1,1]\n coor_x, coor_y = torch.split(img_coors, 1, dim=1) # each is Nx1\n\n if img_flip:\n # by default we take it as horizontal flip\n # use img_shape before padding for flip\n orig_h, orig_w = img_shape\n coor_x = orig_w - coor_x\n\n h, w = img_pad_shape\n coor_y = coor_y / h * 2 - 1\n coor_x = coor_x / w * 2 - 1\n grid = torch.cat([coor_x, coor_y],\n dim=1).unsqueeze(0).unsqueeze(0) # Nx2 -> 1x1xNx2\n\n # align_corner=True provides higher performance\n mode = 'bilinear' if aligned else 'nearest'\n point_features = F.grid_sample(\n img_features,\n grid,\n mode=mode,\n padding_mode=padding_mode,\n align_corners=align_corners) # 1xCx1xN feats\n\n return point_features.squeeze().t()","def plot_latent_images(model, n, digit_size=28, latent_dim=2):\n\n norm = tfp.distributions.Normal(0, 1)\n# grid_x = norm.quantile(np.linspace(0.05, 0.95, n))\n grid_x = norm.sample(n)\n grid_x = tf.reshape(grid_x, [grid_x.shape[0], 1])\n grid_x = tf.broadcast_to(grid_x, [grid_x.shape[0], \n tf.dtypes.cast(latent_dim, dtype=tf.uint32)])\n# grid_y = norm.quantile(np.linspace(0.05, 0.95, n))\n grid_y = norm.sample(n)\n grid_y = tf.reshape(grid_y, [grid_y.shape[0], 1])\n grid_y = tf.broadcast_to(grid_y, [grid_y.shape[0],\n tf.dtypes.cast(latent_dim, dtype=tf.uint32)])\n image_width = digit_size*n\n image_height = image_width\n image = np.zeros((image_height, image_width))\n\n for i in range(len(grid_x)):\n for j in range(len(grid_y)):\n z = np.array([grid_x[i, : ], grid_y[j, : ]])\n# z = tf.reshape(z, [-1])\n x_decoded = model.sample(z)\n# print (\"shape:\", x_decoded.shape)\n digit = tf.reshape(x_decoded[0], (digit_size, digit_size))\n image[i * digit_size: (i + 1) * digit_size,\n j * digit_size: (j + 1) * digit_size] = digit.numpy()\n \n plt.figure(figsize=(10, 10))\n plt.imshow(image, cmap='Greys_r')\n plt.axis('Off')\n plt.show()\n plt.savefig('image_manifold.png')","def sample(self, rng_key: jnp.ndarray) -> jnp.ndarray:\n pass","def map_to_slit(fname, clip=0.0, gamma=1.0):\n ia = taskinit.iatool()\n ia.open(fname)\n imshape = ia.shape()\n pix = ia.getchunk().squeeze() # this should now be a numpy pix[ix][iy] map\n pixmax = pix.max()\n pixrms = pix.std()\n if False:\n pix1 = pix.flatten()\n rpix = stats.robust(pix1)\n logging.debug(\"stats: mean: %g %g\" % (pix1.mean(), rpix.mean()))\n logging.debug(\"stats: rms: %g %g\" % (pix1.std(), rpix.std()))\n logging.debug(\"stats: max: %g %g\" % (pix1.max(), rpix.max()))\n logging.debug('shape: %s %s %s' % (str(pix.shape),str(pix1.shape),str(imshape)))\n ia.close()\n nx = pix.shape[0]\n ny = pix.shape[1]\n x=np.arange(pix.shape[0]).reshape( (nx,1) )\n y=np.arange(pix.shape[1]).reshape( (1,ny) )\n if clip > 0.0:\n nmax = nx*ny\n clip = clip * pixrms\n logging.debug(\"Using initial clip=%g for rms=%g\" % (clip,pixrms))\n m=ma.masked_less(pix,clip)\n while m.count() == 0:\n clip = 0.5 * clip\n logging.debug(\"no masking...trying lower clip=%g\" % clip)\n m=ma.masked_less(pix,clip)\n else:\n logging.debug(\"Clip=%g now found %d/%d points\" % (clip,m.count(),nmax))\n \n else:\n #@ todo sigma-clipping with iterations? see also astropy.stats.sigma_clip()\n rpix = stats.robust(pix.flatten())\n r_mean = rpix.mean()\n r_std = rpix.std()\n logging.info(\"ROBUST MAP mean/std: %f %f\" % (r_mean,r_std))\n m=ma.masked_less(pix,-clip*r_std)\n logging.debug(\"Found > clip=%g : %g\" % (clip,m.count()))\n if m.count() == 0:\n logging.warning(\"Returning a dummy slit, no points above clip %g\" % clip)\n edge = 3.0\n #slit = [edge,0.5*ny,nx-1.0-edge,0.5*ny] # @todo file a bug, this failed\n # RuntimeError: (/var/rpmbuild/BUILD/casa-test/casa-test-4.5.7/code/imageanalysis/ImageAnalysis/PVGenerator.cc : 334) Failed AlwaysAssert abs( (endPixRot[0] - startPixRot[0]) - sqrt(xdiff*xdiff + ydiff*ydiff) ) < 1e-6\n slit = [edge,0.5*ny-0.1,nx-1.0-edge,0.5*ny+0.1]\n else:\n slit = convert_to_slit(m,x,y,nx,ny,gamma)\n return (slit,clip)","def sample(self, seg_logit, seg_label):","def sample(self):\n return random.sample(self.memory, k=self.batch_size)","def mapping(nside, angs):\n\n\tnpix = hp.nside2npix(nside)\n\tmaph = np.zeros(npix)\n\n\tpix = hp.ang2pix(nside, angs[:, 1], angs[:, 0])\n\tvals, times = np.unique(pix, return_counts=True)\n\n\tmaph[vals] = times\n\tmaph *= float(npix)/len(angs)\n\n\treturn maph","def sample(self, n_samples=1):\n\n\t\tsamples = np.random.random((n_samples, self.__ndims))*self.__range + self.__low\n\t\treturn samples","def sampleAndDownloadStreetImage(endPoints, sampleNum, picNum, ptrNum, targetDirectory, intersectionPointInfo):\n print \"downloading street images...\"\n sampledPoints = random.sample(endPoints, sampleNum) if sampleNum < len(endPoints) else endPoints\n sampleData = [] # store (picture number, file name, lat and lng)\n progress = Progress(10)\n headings = CONFIG[\"gmap\"][\"headings\"]\n sampleNumDelta = len(headings)\n for point in sampledPoints:\n progress.printProgress()\n result = downloadSurroundingStreetView(point, targetDirectory, picNum, ptrNum, intersectionPointInfo)\n sampleData += result\n picNum += sampleNumDelta\n ptrNum += 1\n print \"\"\n return sampleData","def sample(self):\n # For each row: round(random .* (max - min) + min, 0)\n random_array = prng.np_random.rand(self.num_discrete_space)\n return [int(x) for x in np.floor(np.multiply((self.high - self.low + 1.), random_array) + self.low)]","def _calculate_leading_dim_map():\n small_matrixes = [(value, value+64) for value in range(256, 40192+512, 512)]\n large_matrixes = [(value, value+1088) for value in range(1024, 39936+1024, 1024)]\n return dict(small_matrixes + large_matrixes)","def sample_from_latent_dist(self, latent_dist, num_particles):\n return latent_dist.sample((num_particles,))","def GetSamples(self):\n samples = []\n metadata = self.GetResourceMetadata()\n for image_name, build_time in self.local_build_times.items():\n metadata.update({\n 'build_type': 'local',\n 'image': image_name,\n })\n samples.append(\n sample.Sample('Image Build Time', build_time, 'seconds', metadata))\n for image_name, build_time in self.remote_build_times.items():\n metadata.update({\n 'build_type': 'remote',\n 'image': image_name,\n })\n samples.append(\n sample.Sample('Image Build Time', build_time, 'seconds', metadata))\n return samples","def sample_data(db, imsize, num_samples=0):\n # load data\n im_data = db['im_data']\n value_data = db['value_data']\n states = db['state_xy_data']\n label_data = db['label_data']\n\n # created a sampler\n grid_sampler = GridDataSampler(im_data, value_data, imsize,\n states, label_data)\n print (\"[MESSAGE] Create a sampler\")\n\n data_collector = []\n value_collector = []\n start_pos_collector = []\n pos_traj_collector = []\n goal_pos_collector = []\n\n idx = 0\n while grid_sampler.grid_available and idx < num_samples:\n grid, value, start_pos_list, pos_traj, goal_pos = grid_sampler.next()\n if len(start_pos_list) < 8:\n print (\"[MESSAGE] THE %i-TH GRID SAMPLED. %i PATH FOUND.\" %\n (idx, len(start_pos_list)))\n data_collector.append(grid)\n value_collector.append(value)\n start_pos_collector.append(start_pos_list)\n pos_traj_collector.append(pos_traj)\n goal_pos_collector.append(goal_pos)\n idx += 1\n\n data_collector = np.asarray(data_collector, dtype=np.uint8)\n value_collector = np.asarray(value_collector, dtype=np.uint8)\n\n if idx < num_samples:\n print (\"[MESSAGE] %i samples collected.\" % (idx+1))\n return (data_collector, value_collector, start_pos_collector,\n pos_traj_collector, goal_pos_collector)","def get_Smaps(k_space, img_shape, samples=None, mode='Gridding'):\n if samples is None:\n mode = 'FFT'\n\n M, L = k_space.shape\n Smaps_shape = (img_shape[0], img_shape[1], L)\n Smaps = np.zeros(Smaps_shape).astype('complex128')\n if mode == 'FFT':\n if not M == img_shape[0]*img_shape[1]:\n raise ValueError(['The number of samples in the k-space must be',\n 'equal to the (image size, the number of coils)'\n ])\n k_space = k_space.reshape(Smaps_shape)\n for l in range(Smaps_shape[2]):\n Smaps[:, :, l] = pfft.ifftshift(pfft.ifft2(k_space[:, :, l]))\n elif mode == 'NFFT':\n raise ValueError('NotImplemented yet')\n else:\n xi = np.linspace(0, img_shape[0], endpoint=False)\n yi = np.linspace(0, img_shape[1], endpoint=False)\n gridx, gridy = np.meshgrid(xi, yi)\n for l in range(L):\n Smaps[:, :, l] = pfft.ifftshift(\n pfft.ifft2(griddata(\n samples,\n k_space[:, l],\n (gridx, gridy),\n method='linear',\n fill_value=0)))\n\n SOS = np.sqrt(np.sum(np.abs(Smaps)**2, axis=2))\n for r in range(L):\n Smaps[:, :, r] /= SOS\n return Smaps, SOS","def prepare_map(self):\n for y_coord, row in enumerate(self.contents):\n for x_coord, tile in enumerate(row):\n bit_map = self.get_tile_bitmap(tile)\n self.image[y_coord * TILE_SIZE:(y_coord+1) * TILE_SIZE,\n x_coord * TILE_SIZE:(x_coord+1) * TILE_SIZE] = bit_map","def get_features_of(self, input_noise, input_features, benchmark=False, thread_count=cpu_count()):\n assert input_noise.shape == (self.gan.config.batch_size, self.gan.config.z_dim), \\\n \"Input Noise must have shape (batch_size, z_dim), which is ({},{})\".format(\n self.gan.config.batch_size, self.gan.config.z_dim)\n if self.gan.use_features:\n assert input_features.shape == (self.gan.config.batch_size, len(self.gan.features)), \\\n \"Input Features must have shape (batch_size, n_features), which is ({},{})\".format(self.gan.config.batch_size, len(self.gan.features))\n\n out_features = dict()\n\n\n # Associating map names to sample indices\n fm_idx = self.gan.maps.index(\"floormap\")\n wm_idx = self.gan.maps.index(\"wallmap\")\n tm_idx = self.gan.maps.index(\"thingsmap\")\n\n\n time_gen_start = time.time() if benchmark else None\n self.last_generated_samples = self.gan.sample(mode='direct', y_batch=input_features, z_override=input_noise, postprocess=True).astype(np.uint8)\n print(\"Generation of {} samples took {} seconds\".format(self.gan.config.batch_size, time.time()-time_gen_start)) if benchmark else None\n if thread_count > 1:\n # This function takes the list of samples that has to be processed for each single thread (len=2 if 32 samples and 16 threads)\n def extraction(sample_list):\n feature_list = list()\n for s in sample_list:\n # This manages errors in feature computation due to degenerate levels\n feature = None\n try:\n feature = self.extractor.extract_features_from_maps(s[:, ..., fm_idx], s[:, ..., wm_idx], s[:, ..., tm_idx])\n except:\n print(\"Cannot compute features for a requested map\")\n feature_list.append(feature)\n return feature_list\n\n time_feat_start = time.time() if benchmark else None\n pool = ThreadPool()\n temp_features = pool.map(extraction, np.array_split(self.last_generated_samples, thread_count, axis=0))\n pool.close()\n pool.join()\n print(\"Feature calculation of {} samples took {} seconds with {} threads\".format(self.gan.config.batch_size,\n time.time() - time_feat_start, thread_count)) if benchmark else None\n # Now temp_features has dimensions (n_threads, samples_per_thread, n_features)\n # merging the first two dimensions to obtain (n_samples, n_features)\n temp_features = np.concatenate(temp_features, axis=0)\n else:\n temp_features = list()\n for s in self.last_generated_samples[:, ...]:\n # This manages errors in feature computation due to degenerate levels\n feature = None\n try:\n feature = self.extractor.extract_features_from_maps(s[:, ..., fm_idx], s[:, ..., wm_idx], s[:, ..., tm_idx])\n except:\n print(\"Cannot compute features for a requested map\")\n temp_features.append(feature)\n # Converting list of dicts to dict of lists\n # Finding the representative dict from which to extract the columns\n repr = None\n for dic in temp_features:\n if dic is not None:\n repr = dic\n if repr is None:\n return None\n for feature in repr:\n out_features[feature] = []\n for sample_dict in temp_features:\n if sample_dict is not None:\n out_features[feature].append(sample_dict[feature])\n else:\n out_features[feature].append(None)\n return out_features","def img_map(ts):\n image_map = \"\"\n texdata = bpy.data.textures[ts.texture]\n if ts.mapping == \"FLAT\":\n image_map = \"map_type 0 \"\n elif ts.mapping == \"SPHERE\":\n image_map = \"map_type 1 \"\n elif ts.mapping == \"TUBE\":\n image_map = \"map_type 2 \"\n\n # map_type 3 and 4 in development (?) (ENV in pov 3.8)\n # for POV-Ray, currently they just seem to default back to Flat (type 0)\n # elif ts.mapping==\"?\":\n # image_map = \" map_type 3 \"\n # elif ts.mapping==\"?\":\n # image_map = \" map_type 4 \"\n if ts.use_interpolation: # Available if image sampling class reactivated?\n image_map += \" interpolate 2 \"\n if texdata.extension == \"CLIP\":\n image_map += \" once \"\n # image_map += \"}\"\n # if ts.mapping=='CUBE':\n # image_map+= \"warp { cubic } rotate <-90,0,180>\"\n # no direct cube type mapping. Though this should work in POV 3.7\n # it doesn't give that good results(best suited to environment maps?)\n # if image_map == \"\":\n # print(\" No texture image found \")\n return image_map","def _get_sample(self):\n mu = self._get_mean().reshape((1, self.out_dim))\n sigma = self.variables[\"s\"]\n sample = self.random.normal(mu, sigma)\n sample = sample.reshape(self.out_dim)\n return sample","def _sample_single(self):\n ss = super(SuperResolutions, self)._sample_single()\n image = ss['data']\n # Down sample\n max_down_sample = max(self.data_down_sample, self.label_down_sample)\n if self.is_down_sample:\n images = []\n images.append(image)\n for i in range(max_down_sample):\n image = self.downsample(image)\n images.append(image)\n data = images[self.data_down_sample]\n label = images[self.label_down_sample]\n return {'data': data, 'label': label}","def lensedImage(self, source, scale, xl=8., yl=4., gamma=0.):\n image, magMap = lens(self.ltype, self.dist, source, self.x01, self.x02, xl, yl, gamma)\n\n return image, magMap","def random_sample(grid_size):\r\n g = grid_size\r\n x_range = g[1] - g[0]\r\n\r\n y_range = g[3] - g[2]\r\n\r\n x_off = g[0]\r\n y_off = g[2]\r\n (x,y) = (x_range*np.random.ranf()+x_off,y_range*np.random.ranf()+y_off) \r\n return (x,y)","def getLocalMap(dist_compl):\n sdc=dist_compl*RES\n #clms are real ;)\n #rws are imaginary :D #rows\n map_padd = 1*RES #add a meter\n rws_ofs = abs(sdc.imag.min())+map_padd #offsetX\n rws = abs(sdc.imag.max())+(rws_ofs)\n clms_ofs = abs(sdc.real.min())+map_padd\n clms = abs(sdc.real.max())+(clms_ofs)\n M = np.zeros((np.round(rws+map_padd).astype(int),np.round(clms+map_padd).astype(int))).astype(dtype=MAP_D_TYPE)#empty local map\n Mg = M.copy()\n points = sdc + np.array([clms_ofs+1j*rws_ofs]) #scale\n #M[points.imag.astype(int),points.real.astype(int)]=10 \n for p in points:\n r=np.round(p.imag).astype(int)\n c=np.round(p.real).astype(int)\n try:\n #draw line in matrix\n lc = [np.round(rws_ofs).astype(int),np.round(clms_ofs).astype(int),r,c]\n rr, cc, val = line_aa(*lc) #not really demaning --> 1%\n M[rr, cc] = np.logical_or(M[rr,cc]>0, val>0) \n #add gaussian\n Mg[r-GPoints//2:r+GPoints//2,c-GPoints//2:c+GPoints//2]+=Gau\n except:\n print('Error: out of array when calculating the local map',r,c)\n Mg[Mg>100]=100 #cap the gaussian matrix\n car_pos_in_loc_mat = np.array([np.round(clms_ofs).astype(int), np.round(rws_ofs).astype(int)])\n #Mg[car_pos_in_loc_mat[1],car_pos_in_loc_mat[0]]=300 #add car pos\n return M*(-100)+Mg, car_pos_in_loc_mat","def generate_samples(self, n_samples):","def generate_samples(self, n_samples):","def _sample(self, points: Iterable[float]) -> np.array:\n pass","def sample_trajectories(self):\n minibatch = []\n for i in range(self.num_avg_gradient):\n trajectory = self.replay_buffer[random.randint(0, len(self.replay_buffer) - 1)]\n trajectory = trajectory[random.randint(0, len(trajectory) - 1):]\n minibatch.append(trajectory)\n return minibatch","def fully_sample_sky(region = \"allsky\", limitregion = False, adaptivep0 = True, useprior = \"RHTPrior\", velrangestring = \"-10_10\", \n gausssmooth_prior = False, tol=1E-5, sampletype = \"mean_bayes\", mcmc=False, deltafuncprior=False, testpsiproj=False, \n testthetas=False, save=True, baseprioramp = 1E-8, smoothprior=False, sig=30, fixwidth=False):\n \n print(\"Fully sampling sky with options: region = {}, limitregion = {}, useprior = {}, velrangestring = {}, gausssmooth_prior = {}, deltafuncprior = {}, testpsiproj = {}, testthetas = {}\".format(region, limitregion, useprior, velrangestring, gausssmooth_prior, deltafuncprior, testpsiproj, testthetas))\n\n out_root = \"/disks/jansky/a/users/goldston/susan/Wide_maps/\"\n\n # Get ids of all pixels that contain RHT data\n rht_cursor, tablename = get_rht_cursor(region = region, velrangestring = velrangestring)\n print(\"table name is\", tablename)\n all_ids = get_all_rht_ids(rht_cursor, tablename)\n \n if limitregion is True:\n print(\"Loading all allsky data points that are in the SC_241 region\")\n # Get all ids that are in both allsky data and SC_241\n all_ids_SC = pickle.load(open(\"SC_241_healpix_ids.p\", \"rb\"))\n all_ids = list(set(all_ids).intersection(all_ids_SC))\n \n print(\"beginning creation of all posteriors\")\n \n if testthetas is False:\n # Create and sample posteriors for all pixels\n if useprior is \"RHTPrior\":\n all_pMB, all_psiMB = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, baseprioramp=baseprioramp)\n elif useprior is \"ThetaRHT\":\n all_pMB, all_psiMB = sample_all_rht_points_ThetaRHTPrior(all_ids, adaptivep0 = adaptivep0, region = region, useprior = useprior, local = False, tol=tol, smoothprior=smoothprior, sig=sig, fixwidth=fixwidth)\n \n # Place into healpix map\n hp_psiMB = make_hp_map(all_psiMB, all_ids, Nside = 2048, nest = True)\n hp_pMB = make_hp_map(all_pMB, all_ids, Nside = 2048, nest = True)\n \n if limitregion is False:\n psiMB_out_fn = \"psiMB_allsky_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\".fits\"\n pMB_out_fn = \"pMB_allsky_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\".fits\"\n elif limitregion is True:\n if mcmc is True:\n psiMB_out_fn = \"psiMB_DR2_SC_241_mcmc_50_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n pMB_out_fn = \"pMB_DR2_SC_241_mcmc_50_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n else:\n if sampletype is \"mean_bayes\":\n print(\"saving mean bayes sampled planck+rht data\")\n #psiMB_out_fn = \"psiMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n #pMB_out_fn = \"pMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_tol_{}.fits\".format(tol)\n #psiMB_out_fn = \"psiMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_fixedpsi0_reverseRHT.fits\"\n #pMB_out_fn = \"pMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_fixedpsi0_reverseRHT.fits\"\n if useprior is \"RHTPrior\":\n psiMB_out_fn = \"psiMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n pMB_out_fn = \"pMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n elif useprior is \"ThetaRHT\":\n psiMB_out_fn = \"psiMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(smoothprior)+\"_sig_\"+str(sig)+\"_adaptivep0_\"+str(adaptivep0)+\"_fixwidth_\"+str(fixwidth)+\".fits\"\n pMB_out_fn = \"pMB_DR2_SC_241_prior_\"+useprior+\"_\"+velrangestring+\"_smoothprior_\"+str(smoothprior)+\"_sig_\"+str(sig)+\"_adaptivep0_\"+str(adaptivep0)+\"_fixwidth_\"+str(fixwidth)+\".fits\"\n \n \n elif sampletype is \"MAP\":\n psiMB_out_fn = \"psiMB_MAP_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n pMB_out_fn = \"pMB_MAP_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_baseprioramp_\"+str(baseprioramp)+\".fits\"\n \n if testpsiproj is True:\n psiMB_out_fn = \"psiMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_testpsiproj_\"+str(testpsiproj)+\"_smalloffset.fits\"\n pMB_out_fn = \"pMB_DR2_SC_241_\"+velrangestring+\"_smoothprior_\"+str(gausssmooth_prior)+\"_adaptivep0_\"+str(adaptivep0)+\"_deltafuncprior_\"+str(deltafuncprior)+\"_testpsiproj_\"+str(testpsiproj)+\"_smalloffset.fits\"\n \n if save:\n hp.fitsfunc.write_map(out_root + psiMB_out_fn, hp_psiMB, coord = \"G\", nest = True) \n hp.fitsfunc.write_map(out_root + pMB_out_fn, hp_pMB, coord = \"G\", nest = True) \n else:\n all_maxrhts, zzz = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, testthetas=testthetas)\n maxrhts = make_hp_map(all_maxrhts, all_ids, Nside = 2048, nest = True)\n hp.fitsfunc.write_map(out_root + \"vel_\" + velrangestring +\"_maxrht.fits\", maxrhts, coord = \"G\", nest = True)","def sampleFromGrid(grid, xypoints, method='nearest'):\n samples = []\n for lon, lat in xypoints:\n sample = grid.getValue(lat, lon, method=method)\n samples.append(sample)\n\n return np.array(samples)","def get_surface_samples_from_single_r2n2_depth_image(self, idx):\n depth_im = self.r2n2_depth_images[idx, ...]\n is_valid = depth_im != 0.0\n is_valid = np.reshape(is_valid, [224, 224])\n world_xyz = self.r2n2_xyz_images.copy()[idx, ...]\n world_n = self.r2n2_normal_world_images.copy()[idx, ...]\n world_xyzn = np.concatenate([world_xyz, world_n], axis=-1)\n world_xyzn = world_xyzn[is_valid, :]\n world_xyzn = np.reshape(world_xyzn, [-1, 6])\n np.random.shuffle(world_xyzn)\n point_count = world_xyzn.shape[0]\n assert point_count > 0\n log.info('The number of valid samples for idx %i is: %i' %\n (idx, point_count))\n while point_count < 10000:\n world_xyzn = np.tile(world_xyzn, [2, 1])\n point_count = world_xyzn.shape[0]\n return world_xyzn[:10000, :]"],"string":"[\n \"def map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\\n\\n latent_coords = []\\n\\n for batch in data_sample:\\n # run encoder\\n coords = model.encoder(batch)\\n latent_coords.append(coords)\\n\\n # return latent (per jet?)\\n return np.concatenate(latent_coords, axis=0)\",\n \"def sampling():\\n # make directory for street images\\n streetImageOutputFolder = CONFIG[\\\"sampling\\\"][\\\"streetImageOutputFolder\\\"]\\n makeDirectory(streetImageOutputFolder)\\n\\n # Get preprocessed point data\\n intersectionPointFile = CONFIG[\\\"shapefile\\\"][\\\"intersectoinPointFile\\\"]\\n pointInfoFile = CONFIG[\\\"shapefile\\\"][\\\"pointInfoFilename\\\"]\\n\\n pointInfo = readPointFile(pointInfoFile)\\n intersectionPointInfo = readIntersectionPointInfo(intersectionPointFile)\\n\\n # Filter point data that has street images taken within the specified period.\\n maxYear = CONFIG[\\\"gmap\\\"][\\\"streetImageMaxYear\\\"]\\n minYear = CONFIG[\\\"gmap\\\"][\\\"streetImageMinYear\\\"]\\n filteredPoints = filterPointByYear(pointInfo, maxYear, minYear)\\n\\n IMG_NAME_COL_NUM = 5\\n LAT_LNG_COL_NUM = 2\\n\\n # Sample street images, the return is list of sample info\\n sampleNum = CONFIG[\\\"sampling\\\"][\\\"sampleNum\\\"]\\n initImageNumber = CONFIG[\\\"sampling\\\"][\\\"initImageNumber\\\"]\\n sampleData = sampleAndDownloadStreetImage(filteredPoints, sampleNum, initImageNumber, initImageNumber, streetImageOutputFolder, intersectionPointInfo)\\n imageNames = [streetImageOutputFolder + \\\"/\\\" + data[IMG_NAME_COL_NUM] for data in sampleData]\\n links = GDriveUpload(imageNames, \\\"Sampled_Image\\\")\\n\\n for i in xrange(len(sampleData)):\\n imageName = streetImageOutputFolder + \\\"/\\\" + sampleData[i][IMG_NAME_COL_NUM]\\n sampleData[i].append(links[imageName])\\n\\n columnTitle = [\\\"Sample Number\\\", \\\"Sampled Point Number\\\", \\\"Latitude + Longitude\\\", \\\"Heading\\\", \\\"Date\\\", \\\"Image Name\\\", \\\"Road Types\\\", \\\"Web Link\\\"]\\n sampleData.insert(0, columnTitle)\\n\\n # output to csv file\\n outputCSV(sampleData, CONFIG[\\\"sampling\\\"][\\\"csvFilename\\\"])\\n\\n # plot images map\\n sampledPoints = set([divideGPS(d[LAT_LNG_COL_NUM]) for d in sampleData[1:]])\\n plotSampledPointMap(list(sampledPoints), CONFIG[\\\"sampling\\\"][\\\"sampledPointsMapFilename\\\"])\",\n \"def sample(self, num_samples, current_device):\\n z = torch.randn(num_samples, self.latent_dim).to(current_device)\\n samples = self.decode(z)\\n return samples\",\n \"def __call__(self, sample):\\n img, landmarks = sample['image'], sample['landmarks']\\n p = random.random()\\n if p <= 1:\\n h, w, c = img.shape\\n for i in range(w//2):\\n img[:, i, :], img[:, w-1-i, :] = img[:, w-1-i, :], img[:, i, :]\\n for i in range(0, len(landmarks[0]), 2):\\n x = landmarks[0][i]\\n landmarks[0][i] = w-1-x\\n return {'image': img,\\n 'landmarks': landmarks}\",\n \"def subsample_maps(net):\\n\\n # start with uniform probability that each map is selected for inclusion in a connection;\\n # reduce probability of selecting a given map again whenever it is selected\\n probability_reduction = .01\\n interarea_probabilities = []\\n interlaminar_probabilities = []\\n for layer in net.layers:\\n interarea_probabilities.append(np.ones(layer.m))\\n interlaminar_probabilities.append(np.ones(layer.m))\\n\\n subsample_indices = []\\n for connection in net.connections:\\n n_maps = int(round(connection.pre.m * connection.c))\\n pre_index = net.find_layer_index(connection.pre.name)\\n\\n pre_cortical_area = connection.pre.name.split('_')[0]\\n post_cortical_area = connection.post.name.split('_')[0]\\n if pre_cortical_area == post_cortical_area: # interlaminar\\n p = interlaminar_probabilities[pre_index]\\n else:\\n p = interarea_probabilities[pre_index]\\n\\n indices = np.random.choice(range(int(connection.pre.m)), n_maps, replace=False, p=p/np.sum(p))\\n for i in indices:\\n p[i] = p[i]*probability_reduction\\n subsample_indices.append(indices)\\n\\n return subsample_indices\",\n \"def sample_region(data, pt_dict, n_frames,):\\n dimensions = list(pt_dict.keys())\\n d_data = [i[:, dimensions] for i in data]\\n\\n tree = KDTree(d_data)\\n pt = [pt_dict[i] for i in dimensions]\\n dis, ind = tree.query(pt, n_frames)\\n return ind\",\n \"def __sample(self):\\n # xvals are \\\"east\\\" vals and yvals are \\\"north\\\" vals on the map\\n xvals = np.random.uniform(self._xmin, self._xmax, self._num_samples)\\n yvals = np.random.uniform(self._ymin, self._ymax, self._num_samples)\\n if self._target_altitude is None:\\n zvals = np.random.uniform(self._zmin, self._zmax, self._num_samples)\\n else:\\n zvals = np.full(self._num_samples, self._target_altitude, dtype=float)\\n \\n samples = list(zip(xvals, yvals, zvals))\\n\\n pts = []\\n for s in samples:\\n in_collision = False\\n idxs = list(self._obstacles_tree.query_radius(\\n np.array([s[0], s[1]]).reshape(1, -1), r=self._max_poly_xy)[0])\\n \\n if len(idxs) > 0:\\n for ind in idxs: \\n p = self._polygons[int(ind)]\\n if p.contains(s) and p.height >= s[2]:\\n in_collision = True\\n\\n if not in_collision:\\n pts.append(s)\\n \\n return pts\",\n \"def sample_latent(self, x):\\n latent_dist = self.encoder(x)\\n latent_sample = self.reparameterize(*latent_dist)\\n return latent_sample\",\n \"def sample(self, verbose=False):\\n\\t\\tfor i in range(self.nsamp): self.subsample(verbose)\\n\\t\\treturn self.amps, self.pos, self.irads\",\n \"def make_map(self, sampling=None, size=None):\\n if sampling is None and self.sampling is None:\\n self.sampling = self.minimum_sampling()\\n elif sampling is not None:\\n self.sampling = sampling\\n \\n if size is None and self.size is None:\\n self.size = self.minimum_size()\\n elif size is not None:\\n self.size = size\\n\\n # Build the on-sky source distribution\\n self.seeing.make_map(sampling=self.sampling, size=self.size)\\n self.x = self.seeing.x\\n self.X = self.seeing.X\\n self.y = self.seeing.y\\n self.Y = self.seeing.Y\\n try:\\n # Construct the intrinsic map of the source\\n self.intrinsic.make_map(sampling=self.sampling, size=self.size)\\n # Convolve with the seeing distribution, conserving the\\n # integral of the intrinsic source\\n self.data = signal.fftconvolve(self.intrinsic.data,\\n self.seeing.data * numpy.square(self.sampling),\\n mode='same')\\n except AttributeError:\\n # Renormalize the unity-integral seeing kernal for to\\n # represent a point source\\n self.data = self.intrinsic*self.seeing.data\\n\\n # Get the integral\\n try:\\n # After convolving with the seeing kernel, the total\\n # integral should be the same, up to some tolerance\\n self.integral = self.intrinsic.integral\\n tolerance = 1e-3\\n diff = numpy.absolute(self.integral - numpy.square(self.sampling)*numpy.sum(self.data))\\n if diff > tolerance:\\n warnings.warn('Map and analytic integrals are discrepant by {0} ({1} %)'.format(\\n diff, 100*diff/self.integral))\\n except AttributeError:\\n self.integral = numpy.square(self.sampling) * numpy.sum(self.data)\\n\\n # Prep for interpolation\\n self.interp = interpolate.interp2d(self.x, self.y, self.data, bounds_error=True)\",\n \"def _get_sample(self):\\n return [layer._get_sample() for layer in self.layers]\",\n \"def latents(self):\\n self.assert_sampled()\\n return self._representations\",\n \"def sample(self):\\n ndim = len(self.lower_bounds)\\n pts = numpy.zeros(ndim)\\n for j in range(ndim):\\n lb = self.lower_bounds[j]\\n ub = self.upper_bounds[j]\\n pts[j] = numpy.random.uniform(lb, ub)\\n return pts\",\n \"def uniform_samples(self):\\n if self._uniform_samples is None:\\n if self.is_from_directory:\\n uniform_sample_path = f'{self._directory_root}/uniform_points.sdf'\\n uniform_samples = gaps_util.read_pts_file(uniform_sample_path)\\n # log.info(f'The uniform points have shape {uniform_samples.shape}')\\n else:\\n uniform_samples = self._archive['uniform_samples']\\n self._uniform_samples = np.reshape(uniform_samples,\\n [100000, 4]).astype(np.float32)\\n return self._uniform_samples\",\n \"def get_initial_latents(self, height, width, num_channels_latents, batch_size):\\n\\n image_latents = torch.randn((batch_size, num_channels_latents, height, width)).to(self.device)\\n # scale the initial noise by the standard deviation required by the scheduler\\n image_latents = image_latents * self.scheduler.init_noise_sigma\\n return image_latents\",\n \"def get_sample(self, n, side_len):\\n self.side_len = side_len\\n side_len_scaled = self.side_len * self.resolution_scaler\\n\\n print(self.side_len, side_len_scaled, self.resolution_scaler)\\n tiles = []\\n center_coords = []\\n\\n # get random starting positions \\n rand_rows = np.random.randint(self.src.shape[0]-side_len_scaled , size=(n,))\\n rand_cols = np.random.randint(self.src.shape[1]-side_len_scaled, size=(n,))\\n\\n for row_idx, col_idx in zip(rand_rows, rand_cols):\\n # get clip\\n clip = self.get_window(row_idx, col_idx, side_len_scaled)\\n\\n # handle non-square clips\\n if clip.shape[1] != side_len_scaled or clip.shape[2] != side_len_scaled:\\n pad = np.full((3, side_len_scaled, side_len_scaled), self.pad_val)\\n pad[:, 0:clip.shape[1], 0:clip.shape[2]] = clip\\n clip = pad.copy()\\n\\n if self.resolution_scaler != 1:\\n # note that we use the unscaled side length to ensure numpy arrays\\n # have the same dimensionality\\n clip = resize(clip, (3, self.side_len, self.side_len))\\n \\n print(clip.shape)\\n\\n tiles.append(clip)\\n\\n # get center lat/lon\\n lat, lon = self.get_latlon_point(row_idx + side_len_scaled // 2, col_idx + side_len_scaled // 2)\\n center_coords.append([lat, lon])\\n\\n return tiles, center_coords\",\n \"def subsample_image(input_image, zoom_box_coords):\\n start_x, start_y = zoom_box_coords[0:2]\\n return input_image[start_y:start_y+zoom_box_coords[3], start_x:start_x+zoom_box_coords[2]]\",\n \"def samples(self):\\n pass\",\n \"def mapillary_sample():\\n return \\\"tests/data/mapillary/training/\\\"\",\n \"def sample(self):\\n ndim = len(self.lower_bounds)\\n pts = numpy.zeros(ndim)\\n for j in range(ndim):\\n lb = self.lower_bounds[j]\\n ub = self.upper_bounds[j]\\n pts[j] = (ub - lb) / 2.0 + lb\\n return pts\",\n \"def samples(self):\\n return self._norm_samples * self._scaling\",\n \"def get_map(self):\\n return self.get_raw_ys()\",\n \"def __call__(self, sample):\\n image, landmarks = sample['image'], sample['landmarks']\\n choices = ((0, 1, 2), (0, 2, 1), (1, 0, 2),\\n (1, 2, 0), (2, 1, 0), (2, 0, 1))\\n p = random.random()\\n if p <= 0.5:\\n idx = random.randint(0, 5)\\n swap = choices[idx]\\n image = image[:, :, swap]\\n return {'image': image,\\n 'landmarks': landmarks}\",\n \"def surface_samples(self):\\n if self._surface_samples is None:\\n self._surface_samples = self.get_surface_samples(10000)\\n return self._surface_samples\",\n \"def positions(self, tileID, numSamples):\",\n \"def sample_mapped_keys(mapping, min_coverage=50):\\r\\n if min_coverage == 0:\\r\\n return {}\\r\\n sample_keys = {}\\r\\n for key in mapping.keys():\\r\\n if (min_coverage > 1):\\r\\n sample_keys[key] = sample(mapping[key],\\r\\n min(min_coverage - 1, len(mapping[key])))\\r\\n else:\\r\\n sample_keys[key] = []\\r\\n sample_keys[key].append(key) # always include the centroid\\r\\n return sample_keys\",\n \"def samples(self, gp):\\r\\n raise NotImplementedError\",\n \"def near_surface_samples(self):\\n if self._near_surface_samples is None:\\n if self.is_from_directory:\\n nss_sample_path = f'{self._directory_root}/nss_points.sdf'\\n nss = gaps_util.read_pts_file(nss_sample_path)\\n # log.info(f'The points have shape {nss.shape}')\\n else:\\n nss = self._archive['axis_samples']\\n self._near_surface_samples = np.reshape(nss,\\n [100000, 4]).astype(np.float32)\\n return self._near_surface_samples\",\n \"def sample_spherical(self):\\n vec = np.random.randn(self.dims, self.arms)\\n vec /= np.linalg.norm(vec, axis=0)\\n self.contexts = vec.T\",\n \"def mapillary_raw_sample():\\n return \\\"tests/data/mapillary/sample/\\\"\",\n \"def _standard_mapping(self):\\n mapping_raw = scipy.io.loadmat(join(self.dataset_dir, 'scripts/mapping.mat'))\\n self.camvidMap = mapping_raw['camvidMap'] * 255\\n self.cityscapesMap = mapping_raw['cityscapesMap'] * 255\",\n \"def create_single_map(self,tod,x,y,x0,y0):\\n maps = {'map':np.zeros((self.Nx*self.Ny)),\\n 'cov':np.zeros((self.Nx*self.Ny))}\\n\\n\\n pixels,xp,yp,r_x, r_y = self.get_pixel_positions(x,y,x0,y0,0,invertx=True)\\n mask = np.ones(pixels.size,dtype=int)\\n\\n mask[(pixels == -1) | np.isnan(tod) | np.isinf(tod)] = 0\\n rms = stats.AutoRMS(tod)\\n weights = {'map':tod.astype(np.float64)/rms**2,\\n 'cov':np.ones(tod.size)/rms**2}\\n for k in maps.keys():\\n binFuncs.binValues(maps[k],\\n pixels,\\n weights=weights[k],mask=mask)\\n maps[k] = np.reshape(maps[k],(self.Ny,self.Nx))\\n return maps\",\n \"def init_locations():\\n player, door, monster = sample(CELLS, k=3)\\n\\n return player, door, monster\",\n \"def cartesian_sampler(data):\\n data = np.asarray(data)\\n ny, nx = data.shape[0:2]\\n\\n if ny * 2 != nx:\\n raise ValueError(\\\"Map must be twice as wide as it is tall\\\")\\n\\n def vec2pix(l, b):\\n l = (l + np.pi) % (2 * np.pi)\\n l[l < 0] += 2 * np.pi\\n l = nx * (1 - l / (2 * np.pi))\\n l = np.clip(l.astype(np.int), 0, nx - 1)\\n b = ny * (1 - (b + np.pi / 2) / np.pi)\\n b = np.clip(b.astype(np.int), 0, ny - 1)\\n return data[b, l]\\n\\n return vec2pix\",\n \"def _compute_samples(self, samples):\\n return samples\",\n \"def sample(self, n_samples):\\n\\n eps = torch.randn((n_samples, self.z_dim)).to(self.device)\\n sampled_ims = self.decoder(eps)\\n im_means = sampled_ims.mean(dim=0)\\n\\n shape = (-1, 1, 28, 28)\\n sampled_ims, im_means = sampled_ims.view(shape), im_means.view(shape)\\n\\n return sampled_ims, im_means\",\n \"def get_real_samples(self):\\n # Define the camera poses\\n if not self.opt.same_view:\\n if self.opt.full_sphere_sampling:\\n self.cam_pos = uniform_sample_sphere(\\n radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\\n axis=None, angle=self.opt.angle,\\n theta_range=np.deg2rad(self.opt.theta), phi_range=np.deg2rad(self.opt.phi))\\n else:\\n self.cam_pos = uniform_sample_sphere(\\n radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\\n axis=None, angle=self.opt.angle,\\n theta_range=np.deg2rad(self.opt.theta),\\n phi_range=np.deg2rad(self.opt.phi))\\n if self.opt.full_sphere_sampling_light:\\n self.light_pos1 = uniform_sample_sphere(\\n radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\\n axis=None, angle=self.opt.angle,\\n theta_range=np.deg2rad(self.opt.theta),\\n phi_range=np.deg2rad(self.opt.phi))\\n # self.light_pos2 = uniform_sample_sphere(radius=self.opt.cam_dist, num_samples=self.opt.batchSize,\\n # axis=self.opt.axis, angle=np.deg2rad(40),\\n # theta_range=self.opt.theta, phi_range=self.opt.phi)\\n else:\\n print(\\\"inbox\\\")\\n light_eps = 0.15\\n self.light_pos1 = np.random.rand(self.opt.batchSize,3)*self.opt.cam_dist + light_eps\\n self.light_pos2 = np.random.rand(self.opt.batchSize,3)*self.opt.cam_dist + light_eps\\n\\n # TODO: deg2rad in all the angles????\\n\\n # Create a splats rendering scene\\n large_scene = create_scene(self.opt.width, self.opt.height,\\n self.opt.fovy, self.opt.focal_length,\\n self.opt.n_splats)\\n lookat = self.opt.at if self.opt.at is not None else [0.0, 0.0, 0.0, 1.0]\\n large_scene['camera']['at'] = tch_var_f(lookat)\\n\\n # Render scenes\\n data, data_depth, data_normal, data_cond = [], [], [], []\\n inpath = self.opt.vis_images + '/'\\n for idx in range(self.opt.batchSize):\\n # Save the splats into the rendering scene\\n if self.opt.use_mesh:\\n if 'sphere' in large_scene['objects']:\\n del large_scene['objects']['sphere']\\n if 'disk' in large_scene['objects']:\\n del large_scene['objects']['disk']\\n if 'triangle' not in large_scene['objects']:\\n large_scene['objects'] = {\\n 'triangle': {'face': None, 'normal': None,\\n 'material_idx': None}}\\n samples = self.get_samples()\\n\\n large_scene['objects']['triangle']['material_idx'] = tch_var_l(\\n np.zeros(samples['mesh']['face'][0].shape[0],\\n dtype=int).tolist())\\n large_scene['objects']['triangle']['face'] = Variable(\\n samples['mesh']['face'][0].cuda(), requires_grad=False)\\n large_scene['objects']['triangle']['normal'] = Variable(\\n samples['mesh']['normal'][0].cuda(),\\n requires_grad=False)\\n else:\\n if 'sphere' in large_scene['objects']:\\n del large_scene['objects']['sphere']\\n if 'triangle' in large_scene['objects']:\\n del large_scene['objects']['triangle']\\n if 'disk' not in large_scene['objects']:\\n large_scene['objects'] = {\\n 'disk': {'pos': None,\\n 'normal': None,\\n 'material_idx': None}}\\n large_scene['objects']['disk']['radius'] = tch_var_f(\\n np.ones(self.opt.n_splats) * self.opt.splats_radius)\\n large_scene['objects']['disk']['material_idx'] = tch_var_l(\\n np.zeros(self.opt.n_splats, dtype=int).tolist())\\n large_scene['objects']['disk']['pos'] = Variable(\\n samples['splats']['pos'][idx].cuda(),\\n requires_grad=False)\\n large_scene['objects']['disk']['normal'] = Variable(\\n samples['splats']['normal'][idx].cuda(),\\n requires_grad=False)\\n\\n # Set camera position\\n if not self.opt.same_view:\\n large_scene['camera']['eye'] = tch_var_f(self.cam_pos[idx])\\n else:\\n large_scene['camera']['eye'] = tch_var_f(self.cam_pos[0])\\n\\n large_scene['lights']['pos'][0,:3]=tch_var_f(self.light_pos1[idx])\\n #large_scene['lights']['pos'][1,:3]=tch_var_f(self.light_pos2[idx])\\n\\n # Render scene\\n res = render(large_scene,\\n norm_depth_image_only=self.opt.norm_depth_image_only,\\n double_sided=True, use_quartic=self.opt.use_quartic)\\n\\n # Get rendered output\\n if self.opt.render_img_nc == 1:\\n depth = res['depth']\\n im_d = depth.unsqueeze(0)\\n else:\\n depth = res['depth']\\n im_d = depth.unsqueeze(0)\\n im = res['image'].permute(2, 0, 1)\\n target_normal_ = get_data(res['normal'])\\n target_normalmap_img_ = get_normalmap_image(target_normal_)\\n im_n = tch_var_f(\\n target_normalmap_img_).view(im.shape[1], im.shape[2],\\n 3).permute(2, 0, 1)\\n\\n # Add depth image to the output structure\\n if self.iteration_no % self.opt.save_image_interval == 0:\\n imsave((inpath + str(self.iteration_no) +\\n 'real_normalmap_{:05d}.png'.format(idx)),\\n target_normalmap_img_)\\n imsave((inpath + str(self.iteration_no) +\\n 'real_depth_{:05d}.png'.format(idx)), get_data(depth))\\n # imsave(inpath + str(self.iteration_no) + 'real_depthmap_{:05d}.png'.format(idx), im_d)\\n # imsave(inpath + str(self.iteration_no) + 'world_normalmap_{:05d}.png'.format(idx), target_worldnormalmap_img_)\\n data.append(im)\\n data_depth.append(im_d)\\n data_normal.append(im_n)\\n data_cond.append(large_scene['camera']['eye'])\\n # Stack real samples\\n real_samples = torch.stack(data)\\n real_samples_depth = torch.stack(data_depth)\\n real_samples_normal = torch.stack(data_normal)\\n real_samples_cond = torch.stack(data_cond)\\n self.batch_size = real_samples.size(0)\\n if not self.opt.no_cuda:\\n real_samples = real_samples.cuda()\\n real_samples_depth = real_samples_depth.cuda()\\n real_samples_normal = real_samples_normal.cuda()\\n real_samples_cond = real_samples_cond.cuda()\\n\\n # Set input/output variables\\n\\n self.input.resize_as_(real_samples.data).copy_(real_samples.data)\\n self.input_depth.resize_as_(real_samples_depth.data).copy_(real_samples_depth.data)\\n self.input_normal.resize_as_(real_samples_normal.data).copy_(real_samples_normal.data)\\n self.input_cond.resize_as_(real_samples_cond.data).copy_(real_samples_cond.data)\\n self.label.resize_(self.batch_size).fill_(self.real_label)\\n # TODO: Remove Variables\\n self.inputv = Variable(self.input)\\n self.inputv_depth = Variable(self.input_depth)\\n self.inputv_normal = Variable(self.input_normal)\\n self.inputv_cond = Variable(self.input_cond)\\n self.labelv = Variable(self.label)\",\n \"def generate_map():\\n o = []\\n note_group_size = GAN_PARAMS[\\\"note_group_size\\\"]\\n pos = [np.random.randint(100, 412), np.random.randint(80, 304)]\\n models = make_models()\\n\\n print(\\\"# of groups: {}\\\".format(timestamps.shape[0] // note_group_size))\\n for i in range(timestamps.shape[0] // note_group_size):\\n z = generate_set(models, begin=i * note_group_size, start_pos=pos, length_multiplier=dist_multiplier,\\n group_id=i, plot_map=False)[:, :6] * np.array([512, 384, 1, 1, 512, 384])\\n pos = z[-1, 0:2]\\n o.append(z)\\n a = np.concatenate(o, axis=0)\\n return a\",\n \"def synthetic_gen(self):\\r\\n logging.debug('generating synthetic map...')\\r\\n data = self.realData\\r\\n unit = Params.unitGrid\\r\\n x_min = np.floor(Params.LOW[0] / unit) * unit\\r\\n x_max = np.ceil(Params.HIGH[0] / unit) * unit\\r\\n y_min = np.floor(Params.LOW[1] / unit) * unit\\r\\n y_max = np.ceil(Params.HIGH[1] / unit) * unit\\r\\n\\r\\n x_CELL = int(np.rint((x_max - x_min) / unit))\\r\\n y_CELL = int(np.rint((y_max - y_min) / unit))\\r\\n\\r\\n self.root.n_box = np.array([[x_min, y_min], [x_max, y_max]])\\r\\n\\r\\n self.mapp = np.zeros((x_CELL, y_CELL)) - 1 # ## initialize every cell with -1\\r\\n for i in range(Params.NDATA): # ## populate the map\\r\\n point = data[:, i]\\r\\n cell_x = int(np.floor((point[0] - x_min) / unit))\\r\\n cell_y = int(np.floor((point[1] - y_min) / unit))\\r\\n if self.mapp[cell_x, cell_y] != -1:\\r\\n self.mapp[cell_x, cell_y] += 1\\r\\n else:\\r\\n self.mapp[cell_x, cell_y] = 1\\r\\n\\r\\n for i in range(x_CELL): # ## perturb the counts\\r\\n for j in range(y_CELL):\\r\\n if self.mapp[i, j] != -1:\\r\\n self.mapp[i, j] += np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\\r\\n else:\\r\\n self.mapp[i, j] = np.rint(self.differ.getNoise(1, 0.5 * self.param.Eps))\\r\\n # if noisy count is negative, ignore the noise and generate no points\\r\\n if self.mapp[i, j] < 0:\\r\\n self.mapp[i, j] = 0\",\n \"def get_pixel_sample_coords(upperLeftTup, lowerRightTup, pixPerSample=20):\\n ulx, uly = upperLeftTup\\n lrx, lry = lowerRightTup\\n\\n width = lrx - ulx\\n height = lry - uly\\n\\n pixels = width * height\\n nSamples = (pixels/pixPerSample)\\n\\n x, y = (0, 0)\\n i = 0\\n while i < nSamples:\\n yield (x + ulx, y + uly)\\n x = (x + pixPerSample) % width\\n y += int((x + pixPerSample) / width)\\n i += 1\",\n \"def make_map(self, sampling=None, size=None):\\n if sampling is None and self.sampling is None:\\n self.sampling = self.minimum_sampling()\\n elif sampling is not None:\\n self.sampling = sampling\\n \\n if size is None and self.size is None:\\n self.size = self.minimum_size()\\n elif size is not None:\\n self.size = size\\n\\n # Set the number of pixels that spans the full size requested\\n pixsize = numpy.ceil(self.size/self.sampling).astype(int)\\n # Force the pixel size to be odd\\n if pixsize % 2 == 0:\\n pixsize += 1\\n # Adjust the size to be an integer number of pixels\\n _size = pixsize*self.sampling\\n if _size - self.size > 0.1*self.sampling:\\n warnings.warn('Size reset to an integer number of pixels: '\\n ' {0} -> {1} arcsec'.format(self.size, _size))\\n self.size = _size\\n self.y = (pixsize-1)*numpy.linspace(-0.5,0.5,pixsize)*self.sampling\\n self.x = self.y.copy()[::-1]\\n\\n # Sample it\\n self.X, self.Y = numpy.meshgrid(self.x, self.y)\\n self.data = self.__call__(self.X, self.Y)\",\n \"def make_pnts(start_point, end_point, path, cellsize):\\n pnts = misc.generateSamples(tran = [start_point, end_point], path = path)\\n \\n #Only do sampling at DEM with >3m resolution \\n if cellsize[0] >= 5:\\n pnts = misc.selectSamplePts([start_point, end_point], pnts, cellsize[0])\\n return pnts\",\n \"def surface_samples_from_dodeca(self):\\n if not hasattr(self, '_surface_samples_from_dodeca'):\\n depth_ims = self.depth_images.copy() / 1000.0\\n is_valid = depth_ims != 0.0\\n is_valid = np.reshape(is_valid, [20, 224, 224])\\n world_xyz = self.world_xyz_images_from_dodeca.copy()\\n world_n = self.world_normal_images.copy()\\n world_xyzn = np.concatenate([world_xyz, world_n], axis=-1)\\n world_xyzn = world_xyzn[is_valid, :]\\n world_xyzn = np.reshape(world_xyzn, [-1, 6])\\n np.random.shuffle(world_xyzn)\\n assert world_xyzn.shape[0] > 1\\n while world_xyzn.shape[0] < self.surface_sample_count:\\n log.verbose(f'Tiling samples from {world_xyzn.shape[0]} to'\\n f' {2*world_xyzn.shape[0]}')\\n world_xyzn = np.tile(world_xyzn, [2, 1])\\n self._surface_samples_from_dodeca = world_xyzn[:self\\n .surface_sample_count, :]\\n return self._surface_samples_from_dodeca\",\n \"def sample(self):\\n return gc.rand_state.uniform(low=self.bounds[0], high=self.bounds[1])\",\n \"def sample_location(key: jnp.ndarray) -> s2.LatLng:\\n lat_key, lng_key = jax.random.split(key, num=2)\\n\\n # NOTE(scandido): If we sample from the sphere we will need to seriously\\n # skew the distribution (likely via rejection sampling) to retrieve enough\\n # times when station keeping is possible. We temporarily (permanently?) work\\n # around this by just sampling the equatorial region. Given the lower\\n # latitudes have significantly lower skew we don't bother making sure each\\n # lat/lng has equal chance (e.g., sample from sphere and rejection sample\\n # points with latitude beyond the equatorial region). All this as\\n # justification for lazy GIS work. 🤷♂️\\n lat: float = jax.random.uniform(lat_key, (), minval=-10.0, maxval=10.0).item()\\n # NOTE(scandido): We avoid sampling near the international date line so we\\n # don't have to worry about wrapping the grid. This is a meteorologically\\n # sound trick to save a few lines of code. 🤠\\n lng: float = jax.random.uniform(\\n lng_key, (), minval=-175.0, maxval=175.0).item()\\n return s2.LatLng.from_degrees(lat, lng)\",\n \"def sample_from_boundary(bounds_dict):\\n area = 0 if np.random.random() < 0.5 else 1 #area 0 is half the center table, area 1 is the whole right table\\n\\n x = np.random.random() * bounds_dict['x_r'][area] + min(bounds_dict['x'][area])\\n y = np.random.random() * bounds_dict['y_r'][area] + min(bounds_dict['y'][area])\\n\\n z = np.random.random() * 0.15 + 0.24\\n return([x, y, z])\",\n \"def sampleFromShakeMap(shakefile, layer, xypoints):\\n\\n shakegrid = ShakeGrid.load(shakefile, fixFileGeoDict='corner')\\n return sampleFromMultiGrid(shakegrid, layer, xypoints)\",\n \"def __getitem__(self, idx):\\n # stored image have binary and shape (H x W) so multiply by 255 to get pixel\\n # values + add dimension\\n sample = np.expand_dims(self.imgs[idx] * 255, axis=-1)\\n\\n # ToTensor transforms numpy.ndarray (H x W x C) in the range\\n # [0, 255] to a torch.FloatTensor of shape (C x H x W) in the range [0.0, 1.0]\\n sample = self.transforms(sample)\\n\\n lat_value = self.lat_values[idx]\\n return sample, lat_value\",\n \"def test_sample_from_extra_bounds_good(self):\\n dim = Real(\\\"yolo\\\", \\\"norm\\\", 0, 2, low=-5, high=+5, shape=(4, 4))\\n for _ in range(8):\\n samples = dim.sample(8)\\n for sample in samples:\\n assert sample in dim\",\n \"def samplePositions(self):\\n samples = []\\n for i in range(self.sampleIter):\\n x = random.randint(-self.sampleRange, self.sampleRange)\\n y = random.randint(-self.sampleRange, self.sampleRange)\\n x += self.currentPosition[0]\\n y += self.currentPosition[1]\\n if (x, y) in self.graph.keys():\\n if self.graph[(x, y)] == 0:\\n samples.append((x, y))\\n return samples\",\n \"def sample(self, nsamples):\\n return self.dist.sample(nsamples)\",\n \"def get_samples(self, min_samples):\\n raise NotImplementedError\",\n \"def get_data():\\r\\n spatial_expmat = np.load('/home/anniegao/spatial_magan/data/spatial_pca_with_coords.npz')['arr_0']\\r\\n spatial_expmat[:,100:] *= 5\\r\\n rna_expmat = np.load('/home/anniegao/spatial_magan/data/rna_pca_sampled.npz')['arr_0']\\r\\n spatial_pca_components = np.load('/home/anniegao/spatial_magan/data/spatial_pca_100components.npz')['arr_0']\\r\\n rna_pca_components = np.load('/home/anniegao/spatial_magan/data/rna_pca_100components.npz')['arr_0']\\r\\n spatial_cluster_labels = np.load('/home/anniegao/spatial_magan/data/spatial_cluster_3_labels_phate.npz')['arr_0']\\r\\n rna_cluster_labels = np.load('/home/anniegao/spatial_magan/data/rna_cluster_5_labels_sampled.npz')['arr_0']\\r\\n return spatial_expmat, rna_expmat, spatial_pca_components, rna_pca_components, spatial_cluster_labels, rna_cluster_labels\",\n \"def sampling_latent(self):\\n \\n self.z = gaussian_sample(self.qz_m, self.qz_v)\\n if self.scalings:\\n self.library = gaussian_sample(self.ql_m, self.ql_v)\",\n \"def get_sample_mask(self):\",\n \"def make_maps_of_2x1_pix_coordinates (sp) : \\n x_rhs = np.arange(sp.colsh)*sp.pixs + sp.pixw - sp.pixsh\\n x_rhs[0] = sp.pixwh # set x-coordinate of the wide pixel \\n x_arr = np.hstack([-x_rhs[::-1],x_rhs])\\n\\n y_arr = np.arange(sp.rows) * sp.pixs\\n y_arr -= y_arr[-1]/2 # move origin to the center of array\\n\\n sp.x_map2x1, sp.y_map2x1 = np.meshgrid(x_arr, y_arr)\",\n \"def example():\\n sampler = DoomSampler()\\n # Current architecture works on batches of 32 levels\\n # Noise shape is (batch_size, 100)\\n noise_shape = [32, 100]\\n # Input Feature vector shape is (batch_size, 7) - Refer to DoomLevelsGAN/network_architecture.py\\n feat_shape = [32, 7]\\n\\n # Generating random noise and input features as example\\n noise = np.random.random(size=noise_shape)\\n input_features = np.random.random(size=feat_shape)\\n out_features = sampler.get_features_of(noise, input_features)\\n\\n # Retrieving samples\\n levels = sampler.last_generated_samples\\n\\n # Printing feature values\\n for f_name, f_list in out_features.items():\\n print(\\\"Feature: {} \\\\n {}\\\".format(f_name, f_list))\",\n \"def sample(src, coords):\\n b, h, w, c = src.size()\\n h_sample, w_sample = coords.shape[:2]\\n max_coord = [h - 1, w - 1]\\n coords = np.clip(coords, 0, max_coord)\\n indices = mapping_to_indices(coords, b)\\n\\n sampled = src[indices].reshape((h_sample, w_sample))\\n\\n return sampled\",\n \"def get_surface_samples_from_single_dodeca_image(self, idx):\\n depth_im = self.depth_images[0, idx, ...]\\n is_valid = depth_im != 0.0\\n is_valid = np.reshape(is_valid, [224, 224])\\n world_xyz = self.world_xyz_images_from_dodeca.copy()[idx, ...]\\n world_n = self.world_normal_images.copy()[idx, ...]\\n world_xyzn = np.concatenate([world_xyz, world_n], axis=-1)\\n world_xyzn = world_xyzn[is_valid, :]\\n world_xyzn = np.reshape(world_xyzn, [-1, 6])\\n np.random.shuffle(world_xyzn)\\n point_count = world_xyzn.shape[0]\\n assert point_count > 0\\n log.info('The number of valid samples for idx %i is: %i' %\\n (idx, point_count))\\n while point_count < 10000:\\n world_xyzn = np.tile(world_xyzn, [2, 1])\\n point_count = world_xyzn.shape[0]\\n return world_xyzn[:10000, :]\",\n \"def test_ndc_to_grid_sample_coords(self):\\n\\n # square image tests\\n image_size_square = [100, 100]\\n xy_ndc_gs_square = torch.FloatTensor(\\n [\\n # 4 corners\\n [[-1.0, -1.0], [1.0, 1.0]],\\n [[1.0, 1.0], [-1.0, -1.0]],\\n [[1.0, -1.0], [-1.0, 1.0]],\\n [[1.0, 1.0], [-1.0, -1.0]],\\n # center\\n [[0.0, 0.0], [0.0, 0.0]],\\n ]\\n )\\n\\n # non-batched version\\n for xy_ndc, xy_gs in xy_ndc_gs_square:\\n xy_gs_predicted = ndc_to_grid_sample_coords(\\n xy_ndc,\\n image_size_square,\\n )\\n self.assertClose(xy_gs_predicted, xy_gs)\\n\\n # batched version\\n xy_ndc, xy_gs = xy_ndc_gs_square[:, 0], xy_ndc_gs_square[:, 1]\\n xy_gs_predicted = ndc_to_grid_sample_coords(\\n xy_ndc,\\n image_size_square,\\n )\\n self.assertClose(xy_gs_predicted, xy_gs)\\n\\n # non-square image tests\\n image_size = [100, 200]\\n xy_ndc_gs = torch.FloatTensor(\\n [\\n # 4 corners\\n [[-2.0, -1.0], [1.0, 1.0]],\\n [[2.0, -1.0], [-1.0, 1.0]],\\n [[-2.0, 1.0], [1.0, -1.0]],\\n [[2.0, 1.0], [-1.0, -1.0]],\\n # center\\n [[0.0, 0.0], [0.0, 0.0]],\\n # non-corner points\\n [[4.0, 0.5], [-2.0, -0.5]],\\n [[1.0, -0.5], [-0.5, 0.5]],\\n ]\\n )\\n\\n # check both H > W and W > H\\n for flip_axes in [False, True]:\\n\\n # non-batched version\\n for xy_ndc, xy_gs in xy_ndc_gs:\\n xy_gs_predicted = ndc_to_grid_sample_coords(\\n xy_ndc.flip(dims=(-1,)) if flip_axes else xy_ndc,\\n list(reversed(image_size)) if flip_axes else image_size,\\n )\\n self.assertClose(\\n xy_gs_predicted,\\n xy_gs.flip(dims=(-1,)) if flip_axes else xy_gs,\\n )\\n\\n # batched version\\n xy_ndc, xy_gs = xy_ndc_gs[:, 0], xy_ndc_gs[:, 1]\\n xy_gs_predicted = ndc_to_grid_sample_coords(\\n xy_ndc.flip(dims=(-1,)) if flip_axes else xy_ndc,\\n list(reversed(image_size)) if flip_axes else image_size,\\n )\\n self.assertClose(\\n xy_gs_predicted,\\n xy_gs.flip(dims=(-1,)) if flip_axes else xy_gs,\\n )\",\n \"def sample_data_grid8(num_samples=0):\\n db, imsize = utils.load_grid8()\\n\\n return sample_data(db, imsize, num_samples)\",\n \"def generate_samples(self, latent_vec=None, num=None):\\n num = self.batch_size if num is None else num\\n latent_vec = self.noise_fn(num) if latent_vec is None else latent_vec\\n with torch.no_grad():\\n samples = self.generator(latent_vec)\\n samples = samples.cpu() # move images to cpu\\n return samples\",\n \"def sample(self):\\n # Convert year from number to string (i.e. -1200 to 1200BC)\\n year = self.world.year()\\n if year < 0:\\n year = str(year)[1:] + 'BC'\\n elif year == 0:\\n year = '0'\\n elif year > 0:\\n year = str(year) + 'AD'\\n # Only sample when we are at a valid year\\n if year not in self.years:\\n return\\n\\n # retrieve list of occupied tile coordinates\\n occupied = self.occupied[year]\\n\\n # Sum the number of polities in the historical extent of the empire,\\n # and their sizes\\n included_polities = []\\n n_polities = 0\\n polity_sizes = []\\n for coordinates in occupied:\\n tile = self.world.index(coordinates[0], coordinates[1])\\n # Skip desert tiles included in the extent of the empire\\n if not tile.terrain.polity_forming:\\n continue\\n polity = tile.polity\\n # Ensure polities are not doubly counted if they possess more than\\n # one community in the extent of the empire\\n if polity in included_polities:\\n continue\\n included_polities.append(polity)\\n n_polities += 1\\n polity_sizes.append(polity.size())\\n\\n self.n_polities[year] = n_polities\\n self.polity_sizes[year] = polity_sizes\",\n \"def sample_damaging(image):\\r\\n return crease_image(blotch_image(image, 100, True), 10, False)\",\n \"def _get_random_sample(self):\\n p=np.zeros(len(self.dim_ranges))\\n for i in range(len(self.dim_ranges)):\\n temp=np.linspace(self.dim_ranges[i][0],self.dim_ranges[i][1],1000)\\n p[i]=np.random.choice(temp,1,True,None)\\n\\n return p\",\n \"def get_spherical_map(screen_pos, input_res=(281, 500), output_res=(360, 640), k_side=2, filling_pol=\\\"nonzero\\\"):\\n assert filling_pol in [\\\"nonzero\\\", \\\"closest\\\"]\\n\\n screen_interp = interpolate_screen_pos(screen_pos, np.linspace(0,16, input_res[1], endpoint=True),\\n np.linspace(0, 9, input_res[0], endpoint=True))\\n y_inres, x_inres = input_res\\n y_res, x_res = output_res\\n xnew = np.linspace(screen_interp[:,:,1].min(), screen_interp[:,:,1].max(), x_res)\\n ynew = np.linspace(screen_interp[:,:,0].min(), screen_interp[:,:,0].max(), y_res)\\n map_img = np.zeros((y_res, x_res))\\n\\n y_map, x_map = np.empty(y_inres*x_inres, dtype=int), np.empty(y_inres*x_inres, dtype=int)\\n for i, (y, x) in enumerate(zip(screen_interp[:,::-1,0].flatten(), screen_interp[:,::-1,1].flatten())):\\n y_map[i] = np.argmin(ynew<y)\\n x_map[i] = np.argmin(xnew<x)\\n map_img[y_map, x_map] = 1\\n\\n y_nonzero, x_nonzero = np.nonzero(map_img==0) #Finds where the image is still zero\\n fill_x_l, fill_y_l, nonzeros_l = [], [], []\\n for y, x in zip(y_nonzero, x_nonzero):\\n # Sets the limits to where to look for nonzeros pixels\\n ylow, xlow = max(0, y-k_side), max(0, x-k_side)\\n yhig, xhig = min(y+k_side+1, y_res), min(x+k_side+1, x_res)\\n area = map_img[ylow:yhig, xlow:xhig]\\n\\n if np.any(area): #If there are pixels around\\n fill_x_l.append(x)\\n fill_y_l.append(y)\\n nonz_y, nonz_x = np.nonzero(area)\\n if filling_pol==\\\"nonzero\\\":\\n nonzeros_l.append((nonz_y+ylow, nonz_x+xlow)) #store the nonzero slicing for later filling\\n elif filling_pol==\\\"closest\\\":\\n xx, yy = np.meshgrid(np.arange(xlow,xhig), np.arange(ylow,yhig))\\n distances = np.sqrt((yy-y)**2+(xx-x)**2)\\n idx_min = np.argmin(distances[nonz_y, nonz_x])\\n nonzeros_l.append(([nonz_y[idx_min]+ylow], [nonz_x[idx_min]+xlow]))\\n\\n return (y_map, x_map), (fill_y_l, fill_x_l, nonzeros_l)\",\n \"def create_band_maps(self):\\n band_maps = []\\n source_band_index = 1\\n target_band_index = self.starting_target_band\\n for band in self.image['bands']:\\n band_maps.append({\\n 'source': source_band_index,\\n 'target': target_band_index\\n })\\n source_band_index += 1\\n target_band_index += 1\\n return band_maps\",\n \"def lhs_start(hyperbounds, n_samples, rng=None):\\n low_bounds = []\\n high_bounds = []\\n for bound in hyperbounds:\\n low_bounds.append(bound[0])\\n high_bounds.append(bound[1])\\n\\n low_bounds = np.array(low_bounds, dtype=object)\\n high_bounds = np.array(high_bounds, dtype=object)\\n\\n samples = sample_latin_hypercube(low_bounds, high_bounds, n_samples, rng=rng)\\n samples = samples.tolist()\\n return samples\",\n \"def test_sample_mapped_keys(self):\\r\\n\\r\\n # With num_coverage=1 only the keys will be sampled\\r\\n actual = sample_mapped_keys(self.test_map, 1)\\r\\n self.assertEqual(actual, {'1': ['1'], '2': ['2']})\\r\\n\\r\\n actual = sample_mapped_keys(self.test_map, 3)\\r\\n for key in actual.keys():\\r\\n # check number of sampled keys\\r\\n self.assertEqual(3, len(actual[key]))\\r\\n for x in actual[key]:\\r\\n # check that sampled key is in the full list\\r\\n correct = list(self.test_map[key])\\r\\n correct.append(key)\\r\\n self.assertTrue(x in correct)\",\n \"def sample(self):\\n return [agent_observation_space.sample() for agent_observation_space in self._agents_observation_space]\",\n \"def point_sample(img_meta,\\n img_features,\\n points,\\n proj_mat,\\n coord_type,\\n img_scale_factor,\\n img_crop_offset,\\n img_flip,\\n img_pad_shape,\\n img_shape,\\n aligned=True,\\n padding_mode='zeros',\\n align_corners=True):\\n\\n # apply transformation based on info in img_meta\\n points = apply_3d_transformation(\\n points, coord_type, img_meta, reverse=True)\\n\\n # project points to camera coordinate\\n pts_2d = points_cam2img(points, proj_mat)\\n\\n # img transformation: scale -> crop -> flip\\n # the image is resized by img_scale_factor\\n img_coors = pts_2d[:, 0:2] * img_scale_factor # Nx2\\n img_coors -= img_crop_offset\\n\\n # grid sample, the valid grid range should be in [-1,1]\\n coor_x, coor_y = torch.split(img_coors, 1, dim=1) # each is Nx1\\n\\n if img_flip:\\n # by default we take it as horizontal flip\\n # use img_shape before padding for flip\\n orig_h, orig_w = img_shape\\n coor_x = orig_w - coor_x\\n\\n h, w = img_pad_shape\\n coor_y = coor_y / h * 2 - 1\\n coor_x = coor_x / w * 2 - 1\\n grid = torch.cat([coor_x, coor_y],\\n dim=1).unsqueeze(0).unsqueeze(0) # Nx2 -> 1x1xNx2\\n\\n # align_corner=True provides higher performance\\n mode = 'bilinear' if aligned else 'nearest'\\n point_features = F.grid_sample(\\n img_features,\\n grid,\\n mode=mode,\\n padding_mode=padding_mode,\\n align_corners=align_corners) # 1xCx1xN feats\\n\\n return point_features.squeeze().t()\",\n \"def plot_latent_images(model, n, digit_size=28, latent_dim=2):\\n\\n norm = tfp.distributions.Normal(0, 1)\\n# grid_x = norm.quantile(np.linspace(0.05, 0.95, n))\\n grid_x = norm.sample(n)\\n grid_x = tf.reshape(grid_x, [grid_x.shape[0], 1])\\n grid_x = tf.broadcast_to(grid_x, [grid_x.shape[0], \\n tf.dtypes.cast(latent_dim, dtype=tf.uint32)])\\n# grid_y = norm.quantile(np.linspace(0.05, 0.95, n))\\n grid_y = norm.sample(n)\\n grid_y = tf.reshape(grid_y, [grid_y.shape[0], 1])\\n grid_y = tf.broadcast_to(grid_y, [grid_y.shape[0],\\n tf.dtypes.cast(latent_dim, dtype=tf.uint32)])\\n image_width = digit_size*n\\n image_height = image_width\\n image = np.zeros((image_height, image_width))\\n\\n for i in range(len(grid_x)):\\n for j in range(len(grid_y)):\\n z = np.array([grid_x[i, : ], grid_y[j, : ]])\\n# z = tf.reshape(z, [-1])\\n x_decoded = model.sample(z)\\n# print (\\\"shape:\\\", x_decoded.shape)\\n digit = tf.reshape(x_decoded[0], (digit_size, digit_size))\\n image[i * digit_size: (i + 1) * digit_size,\\n j * digit_size: (j + 1) * digit_size] = digit.numpy()\\n \\n plt.figure(figsize=(10, 10))\\n plt.imshow(image, cmap='Greys_r')\\n plt.axis('Off')\\n plt.show()\\n plt.savefig('image_manifold.png')\",\n \"def sample(self, rng_key: jnp.ndarray) -> jnp.ndarray:\\n pass\",\n \"def map_to_slit(fname, clip=0.0, gamma=1.0):\\n ia = taskinit.iatool()\\n ia.open(fname)\\n imshape = ia.shape()\\n pix = ia.getchunk().squeeze() # this should now be a numpy pix[ix][iy] map\\n pixmax = pix.max()\\n pixrms = pix.std()\\n if False:\\n pix1 = pix.flatten()\\n rpix = stats.robust(pix1)\\n logging.debug(\\\"stats: mean: %g %g\\\" % (pix1.mean(), rpix.mean()))\\n logging.debug(\\\"stats: rms: %g %g\\\" % (pix1.std(), rpix.std()))\\n logging.debug(\\\"stats: max: %g %g\\\" % (pix1.max(), rpix.max()))\\n logging.debug('shape: %s %s %s' % (str(pix.shape),str(pix1.shape),str(imshape)))\\n ia.close()\\n nx = pix.shape[0]\\n ny = pix.shape[1]\\n x=np.arange(pix.shape[0]).reshape( (nx,1) )\\n y=np.arange(pix.shape[1]).reshape( (1,ny) )\\n if clip > 0.0:\\n nmax = nx*ny\\n clip = clip * pixrms\\n logging.debug(\\\"Using initial clip=%g for rms=%g\\\" % (clip,pixrms))\\n m=ma.masked_less(pix,clip)\\n while m.count() == 0:\\n clip = 0.5 * clip\\n logging.debug(\\\"no masking...trying lower clip=%g\\\" % clip)\\n m=ma.masked_less(pix,clip)\\n else:\\n logging.debug(\\\"Clip=%g now found %d/%d points\\\" % (clip,m.count(),nmax))\\n \\n else:\\n #@ todo sigma-clipping with iterations? see also astropy.stats.sigma_clip()\\n rpix = stats.robust(pix.flatten())\\n r_mean = rpix.mean()\\n r_std = rpix.std()\\n logging.info(\\\"ROBUST MAP mean/std: %f %f\\\" % (r_mean,r_std))\\n m=ma.masked_less(pix,-clip*r_std)\\n logging.debug(\\\"Found > clip=%g : %g\\\" % (clip,m.count()))\\n if m.count() == 0:\\n logging.warning(\\\"Returning a dummy slit, no points above clip %g\\\" % clip)\\n edge = 3.0\\n #slit = [edge,0.5*ny,nx-1.0-edge,0.5*ny] # @todo file a bug, this failed\\n # RuntimeError: (/var/rpmbuild/BUILD/casa-test/casa-test-4.5.7/code/imageanalysis/ImageAnalysis/PVGenerator.cc : 334) Failed AlwaysAssert abs( (endPixRot[0] - startPixRot[0]) - sqrt(xdiff*xdiff + ydiff*ydiff) ) < 1e-6\\n slit = [edge,0.5*ny-0.1,nx-1.0-edge,0.5*ny+0.1]\\n else:\\n slit = convert_to_slit(m,x,y,nx,ny,gamma)\\n return (slit,clip)\",\n \"def sample(self, seg_logit, seg_label):\",\n \"def sample(self):\\n return random.sample(self.memory, k=self.batch_size)\",\n \"def mapping(nside, angs):\\n\\n\\tnpix = hp.nside2npix(nside)\\n\\tmaph = np.zeros(npix)\\n\\n\\tpix = hp.ang2pix(nside, angs[:, 1], angs[:, 0])\\n\\tvals, times = np.unique(pix, return_counts=True)\\n\\n\\tmaph[vals] = times\\n\\tmaph *= float(npix)/len(angs)\\n\\n\\treturn maph\",\n \"def sample(self, n_samples=1):\\n\\n\\t\\tsamples = np.random.random((n_samples, self.__ndims))*self.__range + self.__low\\n\\t\\treturn samples\",\n \"def sampleAndDownloadStreetImage(endPoints, sampleNum, picNum, ptrNum, targetDirectory, intersectionPointInfo):\\n print \\\"downloading street images...\\\"\\n sampledPoints = random.sample(endPoints, sampleNum) if sampleNum < len(endPoints) else endPoints\\n sampleData = [] # store (picture number, file name, lat and lng)\\n progress = Progress(10)\\n headings = CONFIG[\\\"gmap\\\"][\\\"headings\\\"]\\n sampleNumDelta = len(headings)\\n for point in sampledPoints:\\n progress.printProgress()\\n result = downloadSurroundingStreetView(point, targetDirectory, picNum, ptrNum, intersectionPointInfo)\\n sampleData += result\\n picNum += sampleNumDelta\\n ptrNum += 1\\n print \\\"\\\"\\n return sampleData\",\n \"def sample(self):\\n # For each row: round(random .* (max - min) + min, 0)\\n random_array = prng.np_random.rand(self.num_discrete_space)\\n return [int(x) for x in np.floor(np.multiply((self.high - self.low + 1.), random_array) + self.low)]\",\n \"def _calculate_leading_dim_map():\\n small_matrixes = [(value, value+64) for value in range(256, 40192+512, 512)]\\n large_matrixes = [(value, value+1088) for value in range(1024, 39936+1024, 1024)]\\n return dict(small_matrixes + large_matrixes)\",\n \"def sample_from_latent_dist(self, latent_dist, num_particles):\\n return latent_dist.sample((num_particles,))\",\n \"def GetSamples(self):\\n samples = []\\n metadata = self.GetResourceMetadata()\\n for image_name, build_time in self.local_build_times.items():\\n metadata.update({\\n 'build_type': 'local',\\n 'image': image_name,\\n })\\n samples.append(\\n sample.Sample('Image Build Time', build_time, 'seconds', metadata))\\n for image_name, build_time in self.remote_build_times.items():\\n metadata.update({\\n 'build_type': 'remote',\\n 'image': image_name,\\n })\\n samples.append(\\n sample.Sample('Image Build Time', build_time, 'seconds', metadata))\\n return samples\",\n \"def sample_data(db, imsize, num_samples=0):\\n # load data\\n im_data = db['im_data']\\n value_data = db['value_data']\\n states = db['state_xy_data']\\n label_data = db['label_data']\\n\\n # created a sampler\\n grid_sampler = GridDataSampler(im_data, value_data, imsize,\\n states, label_data)\\n print (\\\"[MESSAGE] Create a sampler\\\")\\n\\n data_collector = []\\n value_collector = []\\n start_pos_collector = []\\n pos_traj_collector = []\\n goal_pos_collector = []\\n\\n idx = 0\\n while grid_sampler.grid_available and idx < num_samples:\\n grid, value, start_pos_list, pos_traj, goal_pos = grid_sampler.next()\\n if len(start_pos_list) < 8:\\n print (\\\"[MESSAGE] THE %i-TH GRID SAMPLED. %i PATH FOUND.\\\" %\\n (idx, len(start_pos_list)))\\n data_collector.append(grid)\\n value_collector.append(value)\\n start_pos_collector.append(start_pos_list)\\n pos_traj_collector.append(pos_traj)\\n goal_pos_collector.append(goal_pos)\\n idx += 1\\n\\n data_collector = np.asarray(data_collector, dtype=np.uint8)\\n value_collector = np.asarray(value_collector, dtype=np.uint8)\\n\\n if idx < num_samples:\\n print (\\\"[MESSAGE] %i samples collected.\\\" % (idx+1))\\n return (data_collector, value_collector, start_pos_collector,\\n pos_traj_collector, goal_pos_collector)\",\n \"def get_Smaps(k_space, img_shape, samples=None, mode='Gridding'):\\n if samples is None:\\n mode = 'FFT'\\n\\n M, L = k_space.shape\\n Smaps_shape = (img_shape[0], img_shape[1], L)\\n Smaps = np.zeros(Smaps_shape).astype('complex128')\\n if mode == 'FFT':\\n if not M == img_shape[0]*img_shape[1]:\\n raise ValueError(['The number of samples in the k-space must be',\\n 'equal to the (image size, the number of coils)'\\n ])\\n k_space = k_space.reshape(Smaps_shape)\\n for l in range(Smaps_shape[2]):\\n Smaps[:, :, l] = pfft.ifftshift(pfft.ifft2(k_space[:, :, l]))\\n elif mode == 'NFFT':\\n raise ValueError('NotImplemented yet')\\n else:\\n xi = np.linspace(0, img_shape[0], endpoint=False)\\n yi = np.linspace(0, img_shape[1], endpoint=False)\\n gridx, gridy = np.meshgrid(xi, yi)\\n for l in range(L):\\n Smaps[:, :, l] = pfft.ifftshift(\\n pfft.ifft2(griddata(\\n samples,\\n k_space[:, l],\\n (gridx, gridy),\\n method='linear',\\n fill_value=0)))\\n\\n SOS = np.sqrt(np.sum(np.abs(Smaps)**2, axis=2))\\n for r in range(L):\\n Smaps[:, :, r] /= SOS\\n return Smaps, SOS\",\n \"def prepare_map(self):\\n for y_coord, row in enumerate(self.contents):\\n for x_coord, tile in enumerate(row):\\n bit_map = self.get_tile_bitmap(tile)\\n self.image[y_coord * TILE_SIZE:(y_coord+1) * TILE_SIZE,\\n x_coord * TILE_SIZE:(x_coord+1) * TILE_SIZE] = bit_map\",\n \"def get_features_of(self, input_noise, input_features, benchmark=False, thread_count=cpu_count()):\\n assert input_noise.shape == (self.gan.config.batch_size, self.gan.config.z_dim), \\\\\\n \\\"Input Noise must have shape (batch_size, z_dim), which is ({},{})\\\".format(\\n self.gan.config.batch_size, self.gan.config.z_dim)\\n if self.gan.use_features:\\n assert input_features.shape == (self.gan.config.batch_size, len(self.gan.features)), \\\\\\n \\\"Input Features must have shape (batch_size, n_features), which is ({},{})\\\".format(self.gan.config.batch_size, len(self.gan.features))\\n\\n out_features = dict()\\n\\n\\n # Associating map names to sample indices\\n fm_idx = self.gan.maps.index(\\\"floormap\\\")\\n wm_idx = self.gan.maps.index(\\\"wallmap\\\")\\n tm_idx = self.gan.maps.index(\\\"thingsmap\\\")\\n\\n\\n time_gen_start = time.time() if benchmark else None\\n self.last_generated_samples = self.gan.sample(mode='direct', y_batch=input_features, z_override=input_noise, postprocess=True).astype(np.uint8)\\n print(\\\"Generation of {} samples took {} seconds\\\".format(self.gan.config.batch_size, time.time()-time_gen_start)) if benchmark else None\\n if thread_count > 1:\\n # This function takes the list of samples that has to be processed for each single thread (len=2 if 32 samples and 16 threads)\\n def extraction(sample_list):\\n feature_list = list()\\n for s in sample_list:\\n # This manages errors in feature computation due to degenerate levels\\n feature = None\\n try:\\n feature = self.extractor.extract_features_from_maps(s[:, ..., fm_idx], s[:, ..., wm_idx], s[:, ..., tm_idx])\\n except:\\n print(\\\"Cannot compute features for a requested map\\\")\\n feature_list.append(feature)\\n return feature_list\\n\\n time_feat_start = time.time() if benchmark else None\\n pool = ThreadPool()\\n temp_features = pool.map(extraction, np.array_split(self.last_generated_samples, thread_count, axis=0))\\n pool.close()\\n pool.join()\\n print(\\\"Feature calculation of {} samples took {} seconds with {} threads\\\".format(self.gan.config.batch_size,\\n time.time() - time_feat_start, thread_count)) if benchmark else None\\n # Now temp_features has dimensions (n_threads, samples_per_thread, n_features)\\n # merging the first two dimensions to obtain (n_samples, n_features)\\n temp_features = np.concatenate(temp_features, axis=0)\\n else:\\n temp_features = list()\\n for s in self.last_generated_samples[:, ...]:\\n # This manages errors in feature computation due to degenerate levels\\n feature = None\\n try:\\n feature = self.extractor.extract_features_from_maps(s[:, ..., fm_idx], s[:, ..., wm_idx], s[:, ..., tm_idx])\\n except:\\n print(\\\"Cannot compute features for a requested map\\\")\\n temp_features.append(feature)\\n # Converting list of dicts to dict of lists\\n # Finding the representative dict from which to extract the columns\\n repr = None\\n for dic in temp_features:\\n if dic is not None:\\n repr = dic\\n if repr is None:\\n return None\\n for feature in repr:\\n out_features[feature] = []\\n for sample_dict in temp_features:\\n if sample_dict is not None:\\n out_features[feature].append(sample_dict[feature])\\n else:\\n out_features[feature].append(None)\\n return out_features\",\n \"def img_map(ts):\\n image_map = \\\"\\\"\\n texdata = bpy.data.textures[ts.texture]\\n if ts.mapping == \\\"FLAT\\\":\\n image_map = \\\"map_type 0 \\\"\\n elif ts.mapping == \\\"SPHERE\\\":\\n image_map = \\\"map_type 1 \\\"\\n elif ts.mapping == \\\"TUBE\\\":\\n image_map = \\\"map_type 2 \\\"\\n\\n # map_type 3 and 4 in development (?) (ENV in pov 3.8)\\n # for POV-Ray, currently they just seem to default back to Flat (type 0)\\n # elif ts.mapping==\\\"?\\\":\\n # image_map = \\\" map_type 3 \\\"\\n # elif ts.mapping==\\\"?\\\":\\n # image_map = \\\" map_type 4 \\\"\\n if ts.use_interpolation: # Available if image sampling class reactivated?\\n image_map += \\\" interpolate 2 \\\"\\n if texdata.extension == \\\"CLIP\\\":\\n image_map += \\\" once \\\"\\n # image_map += \\\"}\\\"\\n # if ts.mapping=='CUBE':\\n # image_map+= \\\"warp { cubic } rotate <-90,0,180>\\\"\\n # no direct cube type mapping. Though this should work in POV 3.7\\n # it doesn't give that good results(best suited to environment maps?)\\n # if image_map == \\\"\\\":\\n # print(\\\" No texture image found \\\")\\n return image_map\",\n \"def _get_sample(self):\\n mu = self._get_mean().reshape((1, self.out_dim))\\n sigma = self.variables[\\\"s\\\"]\\n sample = self.random.normal(mu, sigma)\\n sample = sample.reshape(self.out_dim)\\n return sample\",\n \"def _sample_single(self):\\n ss = super(SuperResolutions, self)._sample_single()\\n image = ss['data']\\n # Down sample\\n max_down_sample = max(self.data_down_sample, self.label_down_sample)\\n if self.is_down_sample:\\n images = []\\n images.append(image)\\n for i in range(max_down_sample):\\n image = self.downsample(image)\\n images.append(image)\\n data = images[self.data_down_sample]\\n label = images[self.label_down_sample]\\n return {'data': data, 'label': label}\",\n \"def lensedImage(self, source, scale, xl=8., yl=4., gamma=0.):\\n image, magMap = lens(self.ltype, self.dist, source, self.x01, self.x02, xl, yl, gamma)\\n\\n return image, magMap\",\n \"def random_sample(grid_size):\\r\\n g = grid_size\\r\\n x_range = g[1] - g[0]\\r\\n\\r\\n y_range = g[3] - g[2]\\r\\n\\r\\n x_off = g[0]\\r\\n y_off = g[2]\\r\\n (x,y) = (x_range*np.random.ranf()+x_off,y_range*np.random.ranf()+y_off) \\r\\n return (x,y)\",\n \"def getLocalMap(dist_compl):\\n sdc=dist_compl*RES\\n #clms are real ;)\\n #rws are imaginary :D #rows\\n map_padd = 1*RES #add a meter\\n rws_ofs = abs(sdc.imag.min())+map_padd #offsetX\\n rws = abs(sdc.imag.max())+(rws_ofs)\\n clms_ofs = abs(sdc.real.min())+map_padd\\n clms = abs(sdc.real.max())+(clms_ofs)\\n M = np.zeros((np.round(rws+map_padd).astype(int),np.round(clms+map_padd).astype(int))).astype(dtype=MAP_D_TYPE)#empty local map\\n Mg = M.copy()\\n points = sdc + np.array([clms_ofs+1j*rws_ofs]) #scale\\n #M[points.imag.astype(int),points.real.astype(int)]=10 \\n for p in points:\\n r=np.round(p.imag).astype(int)\\n c=np.round(p.real).astype(int)\\n try:\\n #draw line in matrix\\n lc = [np.round(rws_ofs).astype(int),np.round(clms_ofs).astype(int),r,c]\\n rr, cc, val = line_aa(*lc) #not really demaning --> 1%\\n M[rr, cc] = np.logical_or(M[rr,cc]>0, val>0) \\n #add gaussian\\n Mg[r-GPoints//2:r+GPoints//2,c-GPoints//2:c+GPoints//2]+=Gau\\n except:\\n print('Error: out of array when calculating the local map',r,c)\\n Mg[Mg>100]=100 #cap the gaussian matrix\\n car_pos_in_loc_mat = np.array([np.round(clms_ofs).astype(int), np.round(rws_ofs).astype(int)])\\n #Mg[car_pos_in_loc_mat[1],car_pos_in_loc_mat[0]]=300 #add car pos\\n return M*(-100)+Mg, car_pos_in_loc_mat\",\n \"def generate_samples(self, n_samples):\",\n \"def generate_samples(self, n_samples):\",\n \"def _sample(self, points: Iterable[float]) -> np.array:\\n pass\",\n \"def sample_trajectories(self):\\n minibatch = []\\n for i in range(self.num_avg_gradient):\\n trajectory = self.replay_buffer[random.randint(0, len(self.replay_buffer) - 1)]\\n trajectory = trajectory[random.randint(0, len(trajectory) - 1):]\\n minibatch.append(trajectory)\\n return minibatch\",\n \"def fully_sample_sky(region = \\\"allsky\\\", limitregion = False, adaptivep0 = True, useprior = \\\"RHTPrior\\\", velrangestring = \\\"-10_10\\\", \\n gausssmooth_prior = False, tol=1E-5, sampletype = \\\"mean_bayes\\\", mcmc=False, deltafuncprior=False, testpsiproj=False, \\n testthetas=False, save=True, baseprioramp = 1E-8, smoothprior=False, sig=30, fixwidth=False):\\n \\n print(\\\"Fully sampling sky with options: region = {}, limitregion = {}, useprior = {}, velrangestring = {}, gausssmooth_prior = {}, deltafuncprior = {}, testpsiproj = {}, testthetas = {}\\\".format(region, limitregion, useprior, velrangestring, gausssmooth_prior, deltafuncprior, testpsiproj, testthetas))\\n\\n out_root = \\\"/disks/jansky/a/users/goldston/susan/Wide_maps/\\\"\\n\\n # Get ids of all pixels that contain RHT data\\n rht_cursor, tablename = get_rht_cursor(region = region, velrangestring = velrangestring)\\n print(\\\"table name is\\\", tablename)\\n all_ids = get_all_rht_ids(rht_cursor, tablename)\\n \\n if limitregion is True:\\n print(\\\"Loading all allsky data points that are in the SC_241 region\\\")\\n # Get all ids that are in both allsky data and SC_241\\n all_ids_SC = pickle.load(open(\\\"SC_241_healpix_ids.p\\\", \\\"rb\\\"))\\n all_ids = list(set(all_ids).intersection(all_ids_SC))\\n \\n print(\\\"beginning creation of all posteriors\\\")\\n \\n if testthetas is False:\\n # Create and sample posteriors for all pixels\\n if useprior is \\\"RHTPrior\\\":\\n all_pMB, all_psiMB = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, baseprioramp=baseprioramp)\\n elif useprior is \\\"ThetaRHT\\\":\\n all_pMB, all_psiMB = sample_all_rht_points_ThetaRHTPrior(all_ids, adaptivep0 = adaptivep0, region = region, useprior = useprior, local = False, tol=tol, smoothprior=smoothprior, sig=sig, fixwidth=fixwidth)\\n \\n # Place into healpix map\\n hp_psiMB = make_hp_map(all_psiMB, all_ids, Nside = 2048, nest = True)\\n hp_pMB = make_hp_map(all_pMB, all_ids, Nside = 2048, nest = True)\\n \\n if limitregion is False:\\n psiMB_out_fn = \\\"psiMB_allsky_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_allsky_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\".fits\\\"\\n elif limitregion is True:\\n if mcmc is True:\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_mcmc_50_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n pMB_out_fn = \\\"pMB_DR2_SC_241_mcmc_50_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n else:\\n if sampletype is \\\"mean_bayes\\\":\\n print(\\\"saving mean bayes sampled planck+rht data\\\")\\n #psiMB_out_fn = \\\"psiMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n #pMB_out_fn = \\\"pMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_tol_{}.fits\\\".format(tol)\\n #psiMB_out_fn = \\\"psiMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_fixedpsi0_reverseRHT.fits\\\"\\n #pMB_out_fn = \\\"pMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_fixedpsi0_reverseRHT.fits\\\"\\n if useprior is \\\"RHTPrior\\\":\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n elif useprior is \\\"ThetaRHT\\\":\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(smoothprior)+\\\"_sig_\\\"+str(sig)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_fixwidth_\\\"+str(fixwidth)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_DR2_SC_241_prior_\\\"+useprior+\\\"_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(smoothprior)+\\\"_sig_\\\"+str(sig)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_fixwidth_\\\"+str(fixwidth)+\\\".fits\\\"\\n \\n \\n elif sampletype is \\\"MAP\\\":\\n psiMB_out_fn = \\\"psiMB_MAP_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n pMB_out_fn = \\\"pMB_MAP_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_baseprioramp_\\\"+str(baseprioramp)+\\\".fits\\\"\\n \\n if testpsiproj is True:\\n psiMB_out_fn = \\\"psiMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_testpsiproj_\\\"+str(testpsiproj)+\\\"_smalloffset.fits\\\"\\n pMB_out_fn = \\\"pMB_DR2_SC_241_\\\"+velrangestring+\\\"_smoothprior_\\\"+str(gausssmooth_prior)+\\\"_adaptivep0_\\\"+str(adaptivep0)+\\\"_deltafuncprior_\\\"+str(deltafuncprior)+\\\"_testpsiproj_\\\"+str(testpsiproj)+\\\"_smalloffset.fits\\\"\\n \\n if save:\\n hp.fitsfunc.write_map(out_root + psiMB_out_fn, hp_psiMB, coord = \\\"G\\\", nest = True) \\n hp.fitsfunc.write_map(out_root + pMB_out_fn, hp_pMB, coord = \\\"G\\\", nest = True) \\n else:\\n all_maxrhts, zzz = sample_all_rht_points(all_ids, adaptivep0 = adaptivep0, rht_cursor = rht_cursor, region = region, useprior = useprior, gausssmooth_prior = gausssmooth_prior, tol=tol, sampletype = sampletype, mcmc = mcmc, deltafuncprior=deltafuncprior, testpsiproj=testpsiproj, testthetas=testthetas)\\n maxrhts = make_hp_map(all_maxrhts, all_ids, Nside = 2048, nest = True)\\n hp.fitsfunc.write_map(out_root + \\\"vel_\\\" + velrangestring +\\\"_maxrht.fits\\\", maxrhts, coord = \\\"G\\\", nest = True)\",\n \"def sampleFromGrid(grid, xypoints, method='nearest'):\\n samples = []\\n for lon, lat in xypoints:\\n sample = grid.getValue(lat, lon, method=method)\\n samples.append(sample)\\n\\n return np.array(samples)\",\n \"def get_surface_samples_from_single_r2n2_depth_image(self, idx):\\n depth_im = self.r2n2_depth_images[idx, ...]\\n is_valid = depth_im != 0.0\\n is_valid = np.reshape(is_valid, [224, 224])\\n world_xyz = self.r2n2_xyz_images.copy()[idx, ...]\\n world_n = self.r2n2_normal_world_images.copy()[idx, ...]\\n world_xyzn = np.concatenate([world_xyz, world_n], axis=-1)\\n world_xyzn = world_xyzn[is_valid, :]\\n world_xyzn = np.reshape(world_xyzn, [-1, 6])\\n np.random.shuffle(world_xyzn)\\n point_count = world_xyzn.shape[0]\\n assert point_count > 0\\n log.info('The number of valid samples for idx %i is: %i' %\\n (idx, point_count))\\n while point_count < 10000:\\n world_xyzn = np.tile(world_xyzn, [2, 1])\\n point_count = world_xyzn.shape[0]\\n return world_xyzn[:10000, :]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61733603","0.6100167","0.60555536","0.59709185","0.59704363","0.5918826","0.5892295","0.58649856","0.5847293","0.581955","0.58138406","0.5768181","0.5711329","0.57023966","0.5692044","0.56795436","0.5646572","0.5634537","0.5623634","0.5615229","0.5611063","0.56063586","0.5578262","0.5575475","0.5562674","0.5546452","0.5546378","0.5545793","0.5543639","0.5534251","0.5532258","0.5517653","0.5476281","0.545923","0.54587805","0.54498607","0.5446853","0.54420334","0.5439162","0.54227865","0.54168415","0.5402458","0.5400554","0.53548044","0.5349794","0.5347773","0.5336215","0.53307855","0.5319917","0.5307926","0.53027946","0.5296207","0.52890635","0.52885646","0.52811706","0.52796686","0.5277389","0.5275923","0.52758276","0.5274463","0.52703565","0.52695495","0.5260386","0.5253793","0.5252815","0.5247861","0.5238779","0.52358025","0.52348894","0.5230541","0.52244806","0.5221997","0.52180165","0.5214366","0.52053535","0.52037287","0.520229","0.51848704","0.51816034","0.51810753","0.5179931","0.51656353","0.5160314","0.5156529","0.5153683","0.5152612","0.51466703","0.514455","0.514358","0.51433694","0.514209","0.51418245","0.5140703","0.5140326","0.5140326","0.5139212","0.51307803","0.5130308","0.51256204","0.5124513"],"string":"[\n \"0.61733603\",\n \"0.6100167\",\n \"0.60555536\",\n \"0.59709185\",\n \"0.59704363\",\n \"0.5918826\",\n \"0.5892295\",\n \"0.58649856\",\n \"0.5847293\",\n \"0.581955\",\n \"0.58138406\",\n \"0.5768181\",\n \"0.5711329\",\n \"0.57023966\",\n \"0.5692044\",\n \"0.56795436\",\n \"0.5646572\",\n \"0.5634537\",\n \"0.5623634\",\n \"0.5615229\",\n \"0.5611063\",\n \"0.56063586\",\n \"0.5578262\",\n \"0.5575475\",\n \"0.5562674\",\n \"0.5546452\",\n \"0.5546378\",\n \"0.5545793\",\n \"0.5543639\",\n \"0.5534251\",\n \"0.5532258\",\n \"0.5517653\",\n \"0.5476281\",\n \"0.545923\",\n \"0.54587805\",\n \"0.54498607\",\n \"0.5446853\",\n \"0.54420334\",\n \"0.5439162\",\n \"0.54227865\",\n \"0.54168415\",\n \"0.5402458\",\n \"0.5400554\",\n \"0.53548044\",\n \"0.5349794\",\n \"0.5347773\",\n \"0.5336215\",\n \"0.53307855\",\n \"0.5319917\",\n \"0.5307926\",\n \"0.53027946\",\n \"0.5296207\",\n \"0.52890635\",\n \"0.52885646\",\n \"0.52811706\",\n \"0.52796686\",\n \"0.5277389\",\n \"0.5275923\",\n \"0.52758276\",\n \"0.5274463\",\n \"0.52703565\",\n \"0.52695495\",\n \"0.5260386\",\n \"0.5253793\",\n \"0.5252815\",\n \"0.5247861\",\n \"0.5238779\",\n \"0.52358025\",\n \"0.52348894\",\n \"0.5230541\",\n \"0.52244806\",\n \"0.5221997\",\n \"0.52180165\",\n \"0.5214366\",\n \"0.52053535\",\n \"0.52037287\",\n \"0.520229\",\n \"0.51848704\",\n \"0.51816034\",\n \"0.51810753\",\n \"0.5179931\",\n \"0.51656353\",\n \"0.5160314\",\n \"0.5156529\",\n \"0.5153683\",\n \"0.5152612\",\n \"0.51466703\",\n \"0.514455\",\n \"0.514358\",\n \"0.51433694\",\n \"0.514209\",\n \"0.51418245\",\n \"0.5140703\",\n \"0.5140326\",\n \"0.5140326\",\n \"0.5139212\",\n \"0.51307803\",\n \"0.5130308\",\n \"0.51256204\",\n \"0.5124513\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5777933"},"document_rank":{"kind":"string","value":"11"}}},{"rowIdx":88363,"cells":{"query":{"kind":"string","value":"r\"\"\"Given an input image x, returns the reconstructed image"},"document":{"kind":"string","value":"def generate(self, x):\n return self.forward(x)[0]"},"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 recreate_image(x):\n reverse_mean = [-0.485, -0.456, -0.406]\n reverse_std = [1/0.229, 1/0.224, 1/0.225]\n in_channel = x.shape[-1]\n recreated_im = copy.copy(x) # C, H, W\n if in_channel == 3:\n for c in range(in_channel):\n recreated_im[:, :, c] /= reverse_std[c]\n recreated_im[:, :, c] -= reverse_mean[c]\n elif in_channel == 1:\n recreated_im[:, :, 0] /= reverse_std[1]\n recreated_im[:, :, 0] -= reverse_mean[1]\n recreated_im[recreated_im > 1] = 1\n recreated_im[recreated_im < 0] = 0\n recreated_im = np.round(recreated_im * 255)\n\n recreated_im = np.uint8(recreated_im) # H, W, C\n return recreated_im","def preprocess_feature(x, image_width, image_height, image_depth):\n x_max = np.max(x)\n x = x/x_max\n return x.reshape(1, image_width, image_height, image_depth)","def to_image(x):\n x = denorm(x.data.cpu())\n ndarr = x.mul(255).clamp(0, 255).byte().permute(1, 2, 0).cpu().numpy()\n im = ndarr\n return im","def get_preprocessing_pipeline(x):\n\n x = keras.layers.Cropping2D(cropping=((50, 20), (0, 0)))(x)\n\n # Poor man's resize, since using\n # x = keras.layers.Lambda(lambda data: tf.image.resize_images(data, size=(45, 160)))(x)\n # fails on model load...\n x = keras.layers.AveragePooling2D(pool_size=(2, 2))(x)\n x = keras.layers.Lambda(lambda data: data / 255)(x)\n\n return x","def reconstruct(self, x):\n return self.inverse_transform(self.transform(x))","def x_redim(self, x):\n x[0:4] *= self.r_scale\n return x","def preprocess_image(x, mode='caffe'):\n # mostly identical to \"https://github.com/keras-team/keras-applications/blob/master/keras_applications/imagenet_utils.py\"\n # except for converting RGB -> BGR since we assume BGR already\n\n # covert always to float32 to keep compatibility with opencv\n x = x.astype(np.float32)\n \n if mode == 'tf':\n x /= 127.5\n x -= 1.\n elif mode == 'caffe':\n x[..., 0] -= 103.939\n x[..., 1] -= 116.779\n x[..., 2] -= 123.68\n\n return x","def retinanet_preprocess_image(x, mode='caffe'):\n # mostly identical to \"https://github.com/keras-team/keras-applications/blob/master/keras_applications/imagenet_utils.py\"\n # except for converting RGB -> BGR since we assume BGR already\n\n # covert always to float32 to keep compatibility with opencv\n x = x.astype(np.float32)\n\n if mode == 'tf':\n x /= 127.5\n x -= 1.\n elif mode == 'caffe':\n x[..., 0] -= 103.939\n x[..., 1] -= 116.779\n x[..., 2] -= 123.68\n\n return x","def _preprocess_input(self, x):\n\n # 'RGB'->'BGR'\n x = x[:, :, ::-1]\n # Zero-center by mean pixel\n x = x - tf.stack((tf.ones_like(x[:, :, :, 0]) * tf.constant(103.939),\n tf.ones_like(x[:, :, :, 1]) * tf.constant(116.779)\n , tf.ones_like(x[:, :, :, 2]) * tf.constant(123.68)), axis=-1)\n\n # x = 2*x/255\n return x","def mnist_to_img(x: Any) -> Any:\n x = (x > 0).float()\n d = x.reshape([28, 28, 1]) * 255\n return np.concatenate([d, d, d], 2)","def transform(self, x):\n x = x * 0.5 + 0.5\n x_grey = x[:, [2], :, :] * 299 / 1000 + x[:, [1], :, :] * \\\n 587 / 1000 + x[:, [0], :, :] * 114 / 1000\n x_grey = (x_grey - 0.5) / 0.5\n return x_grey","def preprocess_input(img):\n img /= 255.\n img -= 0.5\n img *= 2.\n return img","def _preprocessing(self, input_image):\n if self.resize:\n input_image = self._np_resize_image(input_image,\n self.input_size,\n dtype='int')\n image = self._np_transpose(input_image)\n image = self._np_normalize(image)\n image = self._np_flip_n_cat(image)\n return image","def preprocess_input(x, data_format=None):\n if data_format is None:\n data_format = K.image_data_format()\n assert data_format in {'channels_last', 'channels_first'}\n\n if data_format == 'channels_first':\n # 'RGB'->'BGR'\n x = x[:, ::-1, :, :]\n # Zero-center by mean pixel\n x[:, 0, :, :] -= 103.939\n x[:, 1, :, :] -= 116.779\n x[:, 2, :, :] -= 123.68\n else:\n # 'RGB'->'BGR'\n x = x[:, :, :, ::-1]\n # Zero-center by mean pixel\n x[:, :, :, 0] -= 103.939\n x[:, :, :, 1] -= 116.779\n x[:, :, :, 2] -= 123.68\n return x","def resh(x):\r\n a = x.shape[0]\r\n b = x.shape[1]\r\n return x.reshape(a*b, 1), a, b","def mnist_to_img(x):\r\n x = (x > 0).astype(np.float32)\r\n d = x.reshape([28, 28, 1]) * 255\r\n return np.concatenate([d, d, d], 2)","def preprocess_input(x):\n return imagenet_utils.preprocess_input(x, mode='tf')","def reconstruct(self, X):\n return self.sess.run(self.reconstruction, feed_dict={self.x: X, self.scale: self.training_scale})","def preprocess_input(x):\n return imagenet_utils.preprocess_input(x, mode='tf')","def reshape(input):\n\n input = input / 255\n input = trans.resize(input, (args.size, args.size))\n input = np.reshape(input, input.shape + (1,))\n input = np.reshape(input, (1,) + input.shape)\n return input","def preprocess(image):\n return (image / 255) * 2 - 1","def cifar_10_preprocess(x, xtest, image_size=32):\n new_shape = (-1, 3, image_size, image_size)\n x, xtest = sample_zero_mean(x), sample_zero_mean(xtest)\n x, xtest = gcn(x), gcn(xtest)\n x, xtest = feature_zero_mean(x, xtest)\n # x, xtest = zca(x, xtest)\n x, xtest = x.reshape(new_shape), xtest.reshape(new_shape)\n return x, xtest","def preprocess(image):\n return image - MEAN_PIXEL","def preprocess(self, x: paddle.Tensor) -> paddle.Tensor:\n # Normalize colors\n x = (x - self.pixel_mean) / self.pixel_std\n\n # Pad\n h, w = x.shape[-2:]\n padh = self.image_encoder.img_size - h\n padw = self.image_encoder.img_size - w\n x = F.pad(x, (0, padw, 0, padh))\n return x","def prepare(img):\n return sobel(rgb2gray(img))","def convert_image_to_1d_array(x):\r\n\r\n #x = cv2.imread(img, cv2.IMREAD_GRAYSCALE)\r\n if x is None:\r\n print( \"ERROR: loading image ' + img + ' failed.\")\r\n return None\r\n \r\n x = cv2.threshold(x, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\r\n if x is None:\r\n print (\"ERROR: thresholding image ' + img + ' failed.\")\r\n return None\r\n\r\n return x.flatten()","def flatten_image(x):\n *batch_shape, h, w, c = x.shape\n return x.reshape((*batch_shape, h * w * c))","def tensor_to_image(x):\n\n # scale back from [-1,1] to [0,255] \n x = x.add(1).mul_(255).div_(2) # x = ((x + 1)*255 / (2))\n \n if x.is_cuda:\n x = x.cpu()\n\n x = x.data.numpy().astype(np.uint8) # convert to numpy\n\n return x","def preprocess_image(image, height, width):\n image = np.uint8(\n resize(rgb2gray(image), [height, width], mode='constant')*255)\n image = np.reshape(image, [height, width, 1])/255.\n return image","def preprocess(path, scale=3):\n image = imread(path, is_grayscale=True)\n # Must be normalized\n image = (image-127.5 )/ 127.5 \n input_ = scipy.ndimage.interpolation.zoom(input_, (scale/1.), prefilter=False)\n return input_","def transform_images(x_image: tf.Tensor, size: int) -> tf.Tensor:\n x_image = tf.image.resize(x_image, (size, size))\n x_image = x_image / 255\n return x_image","def transform_image(self):\n im = cv2.imread(\"result.png\", 0)\n im2 = cv2.resize(im, (28, 28))\n im = im2.reshape(28, 28, -1)\n im = im.reshape(1, 1, 28, 28)\n im = cv2.bitwise_not(im)\n im = im.reshape(28,28)\n \n with out:\n clear_output()\n \n # resize\n img = np.array(im)\n img = img.reshape(28*28,)\n \n #img = img/255.0\n \n return img","def postprocess(X, image_shape=(28, 28)):\n return tf.reshape(X, image_shape) * 255","def reconstructImage(self,arr):\n\t\tarr = arr * 256\n\t\tarr = np.array(np.round(arr),dtype=np.uint8)\n\t\t#arr = np.array(arr,dtype=np.uint8)\n\n\t\t# We need to transpose the array because we flatten X by columns\n\t\t#arr = arr.T\n\t\t#a = arr.reshape((self.width, self.height,3))\n\t\t\n\t\tif self.mode == 'L':\n\t\t\ta = arr.reshape((self.width, self.height))\n\t\telse:\n\t\t\ta = arr.reshape((self.width, self.height,3))\n\n\t\t#a = arr.reshape((3,self.width, self.height))\t\t\n\t\t#a = arr.transpose(0, 3, 1, 2)\n\n\t\tim = Image.fromarray(a,mode=self.mode)\n\n\t\treturn im","def reconstruct_intermediate(self, X: numpy.ndarray) -> numpy.ndarray:\n\n reduced_repr_intr = self.intermediate_transform(X)\n return self.intermediate_inverse_transform(reduced_repr_intr)","def reconstruct(self, X: numpy.ndarray) -> numpy.ndarray:\n\n reduced_repr = self.transform(X)\n return self.inverse_transform(reduced_repr)","def process_image(image):\n image = resize(image)\n return image","def __call__(self, image):\n\n image = np.array(image)\n image = self.transform(image=image)['image']\n return image","def preprocess(self, image, input_shape):\n # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n h, w, _ = image.shape\n\n input_h, input_w = input_shape\n scale = min(float(input_w) / float(w), float(input_h) / float(h))\n nw = int(w * scale)\n nh = int(h * scale)\n\n image = cv2.resize(image, (nw, nh))\n\n new_image = np.zeros((input_h, input_w, 3), np.float32)\n new_image.fill(128)\n bh, bw, _ = new_image.shape\n new_image[int((bh - nh) / 2):(nh + int((bh - nh) / 2)), int((bw - nw) / 2):(nw + int((bw - nw) / 2)), :] = image\n\n new_image /= 255.\n new_image = np.expand_dims(new_image, 0) # Add batch dimension.\n return new_image","def forward(self, x):\n y = pixel_shuffle_1d(x, 2)\n return y","def rescale_image_0255(image):\n # scale image to from [0.0, 1.0] to [0, 255]\n image *= 255\n return image.astype(np.uint8)","def get_image_and_prep(self,file_path):\r\n img = np.array(Image.open(file_path).convert('1'))\r\n img = img.reshape(28,28,1)\r\n return img","def preprocess(path, scale=3):\n image = imread(path, is_grayscale=True)\n label_ = modcrop(image, scale)\n\n # Must be normalized\n \n label_ = label_ / 255.\n \n\n\n input_ = scipy.ndimage.interpolation.zoom(label_, (1. / scale), prefilter=False)\n input_ = scipy.ndimage.interpolation.zoom(input_, (scale / 1.), prefilter=False)\n\n return input_, label_","def preprocess_image(image):\n image = tf.image.decode_jpeg(image, channels=3, dct_method=\"INTEGER_ACCURATE\")\n return scale(image)","def normalise(image):","def preprocess_observation(self, observation):\r\n #grayscale_observation = color.rgb2gray(observation)\r\n observation_dim = observation.shape\r\n resized_observation = observation.reshape(1, observation_dim[0], observation_dim[1], observation_dim[2])\r\n resized_observation = resized_observation.astype('float32')\r\n resized_observation = resized_observation/255\r\n return resized_observation","def preprocess_(image, input_shape):\n if isinstance(image, str):\n filename = image\n image = Image.open(image)\n if isinstance(image, np.ndarray):\n image = Image.fromarray(image)\n assert (isinstance(image, Image.Image)) \n\n w_ori, h_ori = image.size\n h, w = input_shape\n image = image.convert(\"RGB\")\n\n if w_ori > h or h_ori > w:\n scale = max(1.0*w_ori / w, 1.0*h_ori / h)\n image.thumbnail((w,h), Image.BILINEAR)\n else:\n scale = 1\n\n image = image.crop((0, 0, w, h))\n img_data = np.array(image).reshape((1, h, w, 3))\n img_data = img_data / 256. - 0.5\n\n return img_data, scale, w_ori, h_ori","def recreate_image(im_as_var):\n recreated_im = im_as_var.data.numpy()[0]\n recreated_im[recreated_im > 1] = 1\n recreated_im[recreated_im < 0] = 0\n # recreated_im = np.round(recreated_im * 255)\n return recreated_im","def process_image(image):\r\n image = random_brightness(image)\r\n image = crop_image(image)\r\n image = resize(image)\r\n return image","def preprocess_one_image(self):\n im = self.image\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\n #plt.imshow(im)\n im_pp = image.img_to_array(im)\n im_pp = preprocess_input(im_pp)\n im_pp = im_pp.reshape(1, 224, 224, 3)\n return im_pp","def preprocessing(image, w, h):\n image = cv2.resize(image, (w, h))\n image = np.transpose(image, (2, 0, 1))\n image = image.reshape(1, 3, h, w)\n \n return image","def process_new_image(name):\n #preprocess the image\n img = cv2.imread(name)\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n img = img/255.-.5\n return img","def preprocess(input_image, input_mask, input_size=128, keep_ratio=True):\n if keep_ratio == False:\n input_image_ = cv2.resize(input_image, (input_size, input_size))\n input_mask_ = cv2.resize(input_mask, (input_size, input_size))\n else:\n input_image_ = np.zeros((input_size, input_size, 3))\n h, w, _ = input_image.shape\n ratio = min(input_size/h, input_size/w)\n scaled_image = cv2.resize(input_image, None, None, ratio, ratio)\n \n new_h, new_w, _ = scaled_image.shape\n offset_h, offset_w = (input_size-new_h)//2, (input_size - new_w)//2\n input_image_[offset_h: offset_h + new_h, offset_w: offset_w + new_w, :] = scaled_image\n\n\n input_mask_ = np.zeros((input_size, input_size))\n scaled_mask = cv2.resize(input_mask, None, None, ratio, ratio)\n input_mask_[offset_h: offset_h + new_h, offset_w: offset_w + new_w] = scaled_mask\n\n input_image_ = input_image_/255.0\n return input_image_, input_mask_","def get_image(self, image):\n \n # transform image with proper padding\n row, column, _ = image.shape\n image = cv2.copyMakeBorder(image, (column-row)//2, (column-row)//2, \n 0, 0, cv2.BORDER_CONSTANT)\n \n # reshape image in proper size\n image = cv2.resize(image, (self.shape[0], self.shape[1]), \\\n interpolation=cv2.INTER_CUBIC)\n \n return self.transform(image)","def preprocess_image(image_path, desired_size=SIZE):\n im = Image.open(image_path)\n im = im.resize((desired_size,) * 2, resample=Image.LANCZOS)\n\n return im","def process(img):\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) \n x_t = cv2.resize(img, (112, 160), interpolation=cv2.INTER_AREA)\n x_t = np.nan_to_num(x_t)\n x_t = cv2.Laplacian(x_t,cv2.CV_8U)\n\n return x_t.astype(np.uint8)","def image_preprocessing(image):\n\treturn cv2.GaussianBlur(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), (5,5), 0)","def _preprocess(self, image):\n\n # Scale from [0, 255] to [0, 1] and BGR to RGB \n return (image / 255.0)[:, :, ::-1]","def preprocess(self, img):\n img_ = image.load_img(img, target_size=(299, 299))\n img_ = image.img_to_array(img_)\n img_ = np.expand_dims(img_, axis=0)\n img_ = preprocess_input(img_)\n return img_","def preprocess_image(image):\n\n gray_image = grayscale_image(image)\n # any other preprocessing steps such as bluring would go here\n\n binary_image = binarize_image(gray_image)\n\n return binary_image","def preprocess_data(X):\n # NOTE: # If you have conducted any pre-processing on the image,\n # please implement this function to apply onto test images.\n return X","def preprocess(self, resized_inputs):\n return (2.0 / 255.0) * resized_inputs - 1.0","def preprocess(self, image):\n if self.rotate == 0:\n return image\n\n angle = self.rotate * -90\n return image.rotate(angle, expand=True).crop((0, 0, self._w, self._h))","def rescale_image_01(image):\n # scale image to from [0, 255] to [0.0, 1.0]\n image = image.astype(np.float32)\n return image / 255","def preprocess_image(self, img):\r\n\r\n # if channel 1 then as grayscale\r\n try:\r\n if img.shape[1] / img.shape[0] < 6.4:\r\n img = pad_image(img, (self.crnn_cfg().width, self.crnn_cfg().height), self.crnn_cfg().nb_channels)\r\n else:\r\n img = resize_image(img, (self.crnn_cfg().width, self.crnn_cfg().height))\r\n if self.crnn_cfg().nb_channels == 1:\r\n img = img.transpose([1, 0])\r\n else:\r\n img = img.transpose([1, 0, 2])\r\n\r\n img = np.flip(img, 1)\r\n img = img / 255.0\r\n if self.crnn_cfg().nb_channels == 1:\r\n img = img[:, :, np.newaxis]\r\n return img\r\n except:\r\n print('Error in method {0} in module {1}'.format('preprocess_image', 'crnn_bridge.py'))\r\n return None","def process_image(img):\n img[0] = img[0] * 0.229\n img[1] = img[1] * 0.224\n img[2] = img[2] * 0.225\n img[0] += 0.485\n img[1] += 0.456\n img[2] += 0.406\n\n return img.cpu().numpy().transpose((1, 2, 0))","def usample(x):\n # Allow the batch dimension to be unknown at graph build time.\n _, image_height, image_width, n_channels = x.shape.as_list()\n # Add extra degenerate dimension after the dimensions corresponding to the\n # rows and columns.\n expanded_x = tf.expand_dims(tf.expand_dims(x, axis=2), axis=4)\n # Duplicate data in the expanded dimensions.\n after_tile = tf.tile(expanded_x, [1, 1, 2, 1, 2, 1])\n return tf.reshape(after_tile,\n [-1, image_height * 2, image_width * 2, n_channels])","def _postprocess(img):\n img = _scale_to_zero_one(img)\n img = img.reshape(1, -1) # to avoid a scikit-learn deprecation warning later\n return img","def flatten(x_tensor):\n with tf.name_scope('input_reshape'):\n x = x_tensor.get_shape().as_list()[1]\n y = x_tensor.get_shape().as_list()[2]\n z = x_tensor.get_shape().as_list()[3]\n image_shaped_input = tf.reshape(x_tensor, [-1, x*y*z])\n return image_shaped_input","def _preprocess_image(self, image_raw):\n\n image = tf.io.decode_raw(image_raw, tf.float64)\n\n return image * self.rescale","def img_reshape(self, input_img):\n _img = np.transpose(input_img, (1, 2, 0)) \n _img = np.flipud(_img)\n _img = np.reshape(_img, (1, img_dim[0], img_dim[1], img_dim[2]))\n return _img","def mold_image(image, config=None):\n if np.max(image) <= 1 and np.min(image) >= 0:\n image[:,:,:3] = image[:,:,:3]*2.0 - 1.0\n elif np.min(image) >= 0:\n image[:, :, :3] = image[:, :, :3] * (1.0/127.5) - 1.0\n return image.astype(np.float32)","def prepro(o,image_size=[80,80]):\n # y = 0.2126 * o[:, :, 0] + 0.7152 * o[:, :, 1] + 0.0722 * o[:, :, 2]\n # y = y.astype(np.uint8)\n y = 0.2125 * o[:, :, 0] + 0.7154 * o[:, :, 1] + 0.0721 * o[:, :, 2]\n resized = scipy.misc.imresize(y, image_size)\n return np.expand_dims(resized.astype(np.float32),axis=0)","def transform(self, x: Array2D) -> Array2D:","def preprocess(img: 'np.ndarray') -> 'np.ndarray':\n return cv2.resize(img, (45, 45), interpolation=cv2.INTER_AREA)[:,:,:3]","def load_image(path, preprocess=True):\n x = image.load_img(path, target_size=(H, W))\n if preprocess:\n x = image.img_to_array(x)\n x = np.expand_dims(x, axis=0)\n x = x / 255.0\n return x","def preprocess(image, resize=rsz_default, kernel=kernel_size, sigma=0):\n\timage = to_uint8(image)\n\timage_small = cv2.resize(image, (0,0), fx=resize, fy=resize)\n\timage_gblur = cv2.GaussianBlur(image_small, kernel, sigma)\n\treturn image_gblur","def transform2Grey(input_image):\n return np.array([create_features(img) for img in input_image])","def preprocess_image(image_path, input_size):\n img = tf.io.read_file(image_path)\n img = tf.io.decode_image(img, channels=3)\n img = tf.image.convert_image_dtype(img, tf.uint8)\n original_image = img\n resized_img = tf.image.resize(img, input_size)\n resized_img = resized_img[tf.newaxis, :]\n return resized_img, original_image","def forward(self, x, z_rot_input=None):\n # x is the image\n z_structure, z_rot_output = self.encoder(x)\n z_rot = z_rot_output if z_rot_input is None else z_rot_input\n x_hat = self.decoder(z_structure, z_rot)\n return x_hat, z_rot_output.squeeze()","def transform(self, previousimage):","def partial_x(img):\n\n out = None\n\n #####################################\n # START YOUR CODE HERE #\n #####################################\n kernel = np.array([[0.5, 0, -0.5]])\n out = conv(img, kernel)\n ######################################\n # END OF YOUR CODE #\n ######################################\n\n return out","def _preprocess_image(self, image):\n img = tf.convert_to_tensor(image)\n # img = tf.io.decode_image(img, channels=3)\n img = tf.image.convert_image_dtype(img, tf.uint8)\n\n resized_img = tf.image.resize(img, (self._input_height, self._input_width))\n resized_img = resized_img[tf.newaxis, :]\n return resized_img","def pre_process(img, img_size):\n resized = cv2.resize(\n img, (img_size, img_size), interpolation=cv2.INTER_LINEAR\n )\n img_in = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)\n img_in = np.transpose(img_in, (2, 0, 1)).astype(np.float32)\n img_in = np.expand_dims(img_in, axis=0)\n img_in /= 255.0\n img_in = np.ascontiguousarray(img_in)\n return img_in","def image_rotation(x):\n rands = tf.truncated_normal([tf.shape(x)[0]], stddev=0.05)\n return images_rotate(x, rands, interpolation='BILINEAR')","def _preprocess_image(self, image_raw):\n\n image = tf.io.decode_raw(image_raw, tf.float64)\n \n if self.rescale is not None:\n image_out = image * self.rescale\n else:\n image_out = image\n\n return image_out","def pre_processing_image(img):\n\n #print(img.shape)\n # apply gamma correction and show the images\n #adjusted = adjust_gamma(img, gamma=0.65)\n\n adjusted = exposure.adjust_gamma(img, gamma=1.65)\n #print(adjusted.shape)\n\n # log transform of image\n\n logarithmic_corrected = exposure.adjust_log(adjusted, 1)\n #print(logarithmic_corrected.shape)\n\n # denoising\n #dst2 = cv2.fastNlMeansDenoisingColored(logarithmic_corrected, None, 10, 10, 7, 21)\n #print(dst2.shape)\n dst2 = logarithmic_corrected\n return dst2","def preprocess_image(self, image_path, input_size):\n img = tf.io.read_file(image_path)\n img = tf.io.decode_image(img, channels=3)\n img = tf.image.convert_image_dtype(img, tf.uint8)\n resized_img = tf.image.resize(img, input_size)\n resized_img = resized_img[tf.newaxis, :]\n return resized_img","def __call__(self, image: torch.Tensor) -> torch.Tensor:\n assert len(image.shape) == 4\n res = image.clone()\n if self.for_segmentation_input_maps:\n res = res.int()\n else:\n res = res.float()\n if res.max() > 1:\n raise ValueError(\"Image tensor should be in \"\n \"range 0-1 for conversion to PIL\")\n\n # Sample parameters defining the transformation\n transforms = self.draw_next_transform()\n for c in range(image.shape[0]):\n res[c] = self.apply_transform_on_3d_image(res[c], transforms)\n if not self.use_joint_channel_transformation:\n # Resample transformations for the next channel\n transforms = self.draw_next_transform()\n return res.to(dtype=image.dtype)","def construct(self, x):\n identity = x\n out = self.conv1(x)\n out = self.bn1(out)\n out = self.relu(out)\n\n out = self.conv2(out)\n out = self.bn2(out)\n\n if self.downsample is not None:\n identity = self.downsample(x)\n\n out = self.add(out, identity)\n out = self.relu(out)\n\n return out","def chainercv_preprocess(image):\n image = skio.imread(image)\n image = image.transpose(2, 0, 1)\n return [image]","def preprocess_image(self, img_path):\n im = Image.open(img_path)\n im = im.resize((IM_WIDTH, IM_HEIGHT))\n im = np.array(im) / 255.0\n \n return im","def preprocess(image):\n image = rgb2yuv(image)\n return image","def preprocessImage(img):\n shape = img.shape\n img = img[math.floor(shape[0]/4) : shape[0] - 25, 0:shape[1]]\n img = cv2.resize(img, (img_columns, img_rows), interpolation = cv2.INTER_AREA)\n return img","def process_image(self, image):\r\n img = cv2.imread(image)\r\n img = img.astype(float)/127 - 1\r\n return np.expand_dims(img, axis=0)","def transform(self, image):\n preprocess = transforms.Compose([\n transforms.Resize(256),\n transforms.CenterCrop(224),\n transforms.ToTensor(),\n transforms.Normalize(\n mean=[0.485, 0.456, 0.406],\n std=[0.229, 0.224, 0.225]\n ),\n ])\n input_tensor = preprocess(image)\n return input_tensor","def preprocess(file_path, model_preprocess_function):\n img = image.load_img(file_path, target_size=(224, 224))\n x = image.img_to_array(img)\n # x = np.expand_dims(x, axis=0)\n x = model_preprocess_function(x)\n return x","def preprocess(path, path2 , scale):\n image = imread(path)\n label_ = imread(path2)\n\n #label_ = modcrop(label, scale)\n\n # Must be normalized\n input_ = image / 255.\n label_ = label_ / 255.\n\n #input_ = scipy.ndimage.interpolation.zoom(label_, (1./scale), prefilter=False)\n #input_ = scipy.ndimage.interpolation.zoom(input_, (scale/1.), prefilter=False)\n\n return input_, label_","def preprocess(img):\n if img.ndim != 3:\n raise TypeError('bad ndim of img')\n if img.dtype != np.uint8:\n raise TypeError('bad dtype of img')\n img = cv2.resize(img, (224, 224))\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n img = img.astype(np.float32)\n img *= (2.0/255) # normalize to: 0.0~2.0\n img -= 1.0 # subtract mean to make it: -1.0~1.0\n img = np.expand_dims(img, axis=0)\n return img","def partial_x(img):\n\n out = None\n\n ### YOUR CODE HERE\n kernel = 0.5*np.array([[1,0,-1]])\n out = conv(img,kernel)\n ### END YOUR CODE\n\n return out","def transform_image(img_path: Path) -> torch.Tensor:\n # define transformation steps\n crop_to_lower_percentage = 50\n output_size = (256, 256)\n transform = get_predict_image_transform()\n\n # load image\n img = torchvision.io.read_image(str(img_path)).float()\n\n # perform transformation\n input = transform(img)\n\n # single image instead of batch\n input = input.unsqueeze(0)\n\n return input"],"string":"[\n \"def recreate_image(x):\\n reverse_mean = [-0.485, -0.456, -0.406]\\n reverse_std = [1/0.229, 1/0.224, 1/0.225]\\n in_channel = x.shape[-1]\\n recreated_im = copy.copy(x) # C, H, W\\n if in_channel == 3:\\n for c in range(in_channel):\\n recreated_im[:, :, c] /= reverse_std[c]\\n recreated_im[:, :, c] -= reverse_mean[c]\\n elif in_channel == 1:\\n recreated_im[:, :, 0] /= reverse_std[1]\\n recreated_im[:, :, 0] -= reverse_mean[1]\\n recreated_im[recreated_im > 1] = 1\\n recreated_im[recreated_im < 0] = 0\\n recreated_im = np.round(recreated_im * 255)\\n\\n recreated_im = np.uint8(recreated_im) # H, W, C\\n return recreated_im\",\n \"def preprocess_feature(x, image_width, image_height, image_depth):\\n x_max = np.max(x)\\n x = x/x_max\\n return x.reshape(1, image_width, image_height, image_depth)\",\n \"def to_image(x):\\n x = denorm(x.data.cpu())\\n ndarr = x.mul(255).clamp(0, 255).byte().permute(1, 2, 0).cpu().numpy()\\n im = ndarr\\n return im\",\n \"def get_preprocessing_pipeline(x):\\n\\n x = keras.layers.Cropping2D(cropping=((50, 20), (0, 0)))(x)\\n\\n # Poor man's resize, since using\\n # x = keras.layers.Lambda(lambda data: tf.image.resize_images(data, size=(45, 160)))(x)\\n # fails on model load...\\n x = keras.layers.AveragePooling2D(pool_size=(2, 2))(x)\\n x = keras.layers.Lambda(lambda data: data / 255)(x)\\n\\n return x\",\n \"def reconstruct(self, x):\\n return self.inverse_transform(self.transform(x))\",\n \"def x_redim(self, x):\\n x[0:4] *= self.r_scale\\n return x\",\n \"def preprocess_image(x, mode='caffe'):\\n # mostly identical to \\\"https://github.com/keras-team/keras-applications/blob/master/keras_applications/imagenet_utils.py\\\"\\n # except for converting RGB -> BGR since we assume BGR already\\n\\n # covert always to float32 to keep compatibility with opencv\\n x = x.astype(np.float32)\\n \\n if mode == 'tf':\\n x /= 127.5\\n x -= 1.\\n elif mode == 'caffe':\\n x[..., 0] -= 103.939\\n x[..., 1] -= 116.779\\n x[..., 2] -= 123.68\\n\\n return x\",\n \"def retinanet_preprocess_image(x, mode='caffe'):\\n # mostly identical to \\\"https://github.com/keras-team/keras-applications/blob/master/keras_applications/imagenet_utils.py\\\"\\n # except for converting RGB -> BGR since we assume BGR already\\n\\n # covert always to float32 to keep compatibility with opencv\\n x = x.astype(np.float32)\\n\\n if mode == 'tf':\\n x /= 127.5\\n x -= 1.\\n elif mode == 'caffe':\\n x[..., 0] -= 103.939\\n x[..., 1] -= 116.779\\n x[..., 2] -= 123.68\\n\\n return x\",\n \"def _preprocess_input(self, x):\\n\\n # 'RGB'->'BGR'\\n x = x[:, :, ::-1]\\n # Zero-center by mean pixel\\n x = x - tf.stack((tf.ones_like(x[:, :, :, 0]) * tf.constant(103.939),\\n tf.ones_like(x[:, :, :, 1]) * tf.constant(116.779)\\n , tf.ones_like(x[:, :, :, 2]) * tf.constant(123.68)), axis=-1)\\n\\n # x = 2*x/255\\n return x\",\n \"def mnist_to_img(x: Any) -> Any:\\n x = (x > 0).float()\\n d = x.reshape([28, 28, 1]) * 255\\n return np.concatenate([d, d, d], 2)\",\n \"def transform(self, x):\\n x = x * 0.5 + 0.5\\n x_grey = x[:, [2], :, :] * 299 / 1000 + x[:, [1], :, :] * \\\\\\n 587 / 1000 + x[:, [0], :, :] * 114 / 1000\\n x_grey = (x_grey - 0.5) / 0.5\\n return x_grey\",\n \"def preprocess_input(img):\\n img /= 255.\\n img -= 0.5\\n img *= 2.\\n return img\",\n \"def _preprocessing(self, input_image):\\n if self.resize:\\n input_image = self._np_resize_image(input_image,\\n self.input_size,\\n dtype='int')\\n image = self._np_transpose(input_image)\\n image = self._np_normalize(image)\\n image = self._np_flip_n_cat(image)\\n return image\",\n \"def preprocess_input(x, data_format=None):\\n if data_format is None:\\n data_format = K.image_data_format()\\n assert data_format in {'channels_last', 'channels_first'}\\n\\n if data_format == 'channels_first':\\n # 'RGB'->'BGR'\\n x = x[:, ::-1, :, :]\\n # Zero-center by mean pixel\\n x[:, 0, :, :] -= 103.939\\n x[:, 1, :, :] -= 116.779\\n x[:, 2, :, :] -= 123.68\\n else:\\n # 'RGB'->'BGR'\\n x = x[:, :, :, ::-1]\\n # Zero-center by mean pixel\\n x[:, :, :, 0] -= 103.939\\n x[:, :, :, 1] -= 116.779\\n x[:, :, :, 2] -= 123.68\\n return x\",\n \"def resh(x):\\r\\n a = x.shape[0]\\r\\n b = x.shape[1]\\r\\n return x.reshape(a*b, 1), a, b\",\n \"def mnist_to_img(x):\\r\\n x = (x > 0).astype(np.float32)\\r\\n d = x.reshape([28, 28, 1]) * 255\\r\\n return np.concatenate([d, d, d], 2)\",\n \"def preprocess_input(x):\\n return imagenet_utils.preprocess_input(x, mode='tf')\",\n \"def reconstruct(self, X):\\n return self.sess.run(self.reconstruction, feed_dict={self.x: X, self.scale: self.training_scale})\",\n \"def preprocess_input(x):\\n return imagenet_utils.preprocess_input(x, mode='tf')\",\n \"def reshape(input):\\n\\n input = input / 255\\n input = trans.resize(input, (args.size, args.size))\\n input = np.reshape(input, input.shape + (1,))\\n input = np.reshape(input, (1,) + input.shape)\\n return input\",\n \"def preprocess(image):\\n return (image / 255) * 2 - 1\",\n \"def cifar_10_preprocess(x, xtest, image_size=32):\\n new_shape = (-1, 3, image_size, image_size)\\n x, xtest = sample_zero_mean(x), sample_zero_mean(xtest)\\n x, xtest = gcn(x), gcn(xtest)\\n x, xtest = feature_zero_mean(x, xtest)\\n # x, xtest = zca(x, xtest)\\n x, xtest = x.reshape(new_shape), xtest.reshape(new_shape)\\n return x, xtest\",\n \"def preprocess(image):\\n return image - MEAN_PIXEL\",\n \"def preprocess(self, x: paddle.Tensor) -> paddle.Tensor:\\n # Normalize colors\\n x = (x - self.pixel_mean) / self.pixel_std\\n\\n # Pad\\n h, w = x.shape[-2:]\\n padh = self.image_encoder.img_size - h\\n padw = self.image_encoder.img_size - w\\n x = F.pad(x, (0, padw, 0, padh))\\n return x\",\n \"def prepare(img):\\n return sobel(rgb2gray(img))\",\n \"def convert_image_to_1d_array(x):\\r\\n\\r\\n #x = cv2.imread(img, cv2.IMREAD_GRAYSCALE)\\r\\n if x is None:\\r\\n print( \\\"ERROR: loading image ' + img + ' failed.\\\")\\r\\n return None\\r\\n \\r\\n x = cv2.threshold(x, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\\r\\n if x is None:\\r\\n print (\\\"ERROR: thresholding image ' + img + ' failed.\\\")\\r\\n return None\\r\\n\\r\\n return x.flatten()\",\n \"def flatten_image(x):\\n *batch_shape, h, w, c = x.shape\\n return x.reshape((*batch_shape, h * w * c))\",\n \"def tensor_to_image(x):\\n\\n # scale back from [-1,1] to [0,255] \\n x = x.add(1).mul_(255).div_(2) # x = ((x + 1)*255 / (2))\\n \\n if x.is_cuda:\\n x = x.cpu()\\n\\n x = x.data.numpy().astype(np.uint8) # convert to numpy\\n\\n return x\",\n \"def preprocess_image(image, height, width):\\n image = np.uint8(\\n resize(rgb2gray(image), [height, width], mode='constant')*255)\\n image = np.reshape(image, [height, width, 1])/255.\\n return image\",\n \"def preprocess(path, scale=3):\\n image = imread(path, is_grayscale=True)\\n # Must be normalized\\n image = (image-127.5 )/ 127.5 \\n input_ = scipy.ndimage.interpolation.zoom(input_, (scale/1.), prefilter=False)\\n return input_\",\n \"def transform_images(x_image: tf.Tensor, size: int) -> tf.Tensor:\\n x_image = tf.image.resize(x_image, (size, size))\\n x_image = x_image / 255\\n return x_image\",\n \"def transform_image(self):\\n im = cv2.imread(\\\"result.png\\\", 0)\\n im2 = cv2.resize(im, (28, 28))\\n im = im2.reshape(28, 28, -1)\\n im = im.reshape(1, 1, 28, 28)\\n im = cv2.bitwise_not(im)\\n im = im.reshape(28,28)\\n \\n with out:\\n clear_output()\\n \\n # resize\\n img = np.array(im)\\n img = img.reshape(28*28,)\\n \\n #img = img/255.0\\n \\n return img\",\n \"def postprocess(X, image_shape=(28, 28)):\\n return tf.reshape(X, image_shape) * 255\",\n \"def reconstructImage(self,arr):\\n\\t\\tarr = arr * 256\\n\\t\\tarr = np.array(np.round(arr),dtype=np.uint8)\\n\\t\\t#arr = np.array(arr,dtype=np.uint8)\\n\\n\\t\\t# We need to transpose the array because we flatten X by columns\\n\\t\\t#arr = arr.T\\n\\t\\t#a = arr.reshape((self.width, self.height,3))\\n\\t\\t\\n\\t\\tif self.mode == 'L':\\n\\t\\t\\ta = arr.reshape((self.width, self.height))\\n\\t\\telse:\\n\\t\\t\\ta = arr.reshape((self.width, self.height,3))\\n\\n\\t\\t#a = arr.reshape((3,self.width, self.height))\\t\\t\\n\\t\\t#a = arr.transpose(0, 3, 1, 2)\\n\\n\\t\\tim = Image.fromarray(a,mode=self.mode)\\n\\n\\t\\treturn im\",\n \"def reconstruct_intermediate(self, X: numpy.ndarray) -> numpy.ndarray:\\n\\n reduced_repr_intr = self.intermediate_transform(X)\\n return self.intermediate_inverse_transform(reduced_repr_intr)\",\n \"def reconstruct(self, X: numpy.ndarray) -> numpy.ndarray:\\n\\n reduced_repr = self.transform(X)\\n return self.inverse_transform(reduced_repr)\",\n \"def process_image(image):\\n image = resize(image)\\n return image\",\n \"def __call__(self, image):\\n\\n image = np.array(image)\\n image = self.transform(image=image)['image']\\n return image\",\n \"def preprocess(self, image, input_shape):\\n # image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\\n h, w, _ = image.shape\\n\\n input_h, input_w = input_shape\\n scale = min(float(input_w) / float(w), float(input_h) / float(h))\\n nw = int(w * scale)\\n nh = int(h * scale)\\n\\n image = cv2.resize(image, (nw, nh))\\n\\n new_image = np.zeros((input_h, input_w, 3), np.float32)\\n new_image.fill(128)\\n bh, bw, _ = new_image.shape\\n new_image[int((bh - nh) / 2):(nh + int((bh - nh) / 2)), int((bw - nw) / 2):(nw + int((bw - nw) / 2)), :] = image\\n\\n new_image /= 255.\\n new_image = np.expand_dims(new_image, 0) # Add batch dimension.\\n return new_image\",\n \"def forward(self, x):\\n y = pixel_shuffle_1d(x, 2)\\n return y\",\n \"def rescale_image_0255(image):\\n # scale image to from [0.0, 1.0] to [0, 255]\\n image *= 255\\n return image.astype(np.uint8)\",\n \"def get_image_and_prep(self,file_path):\\r\\n img = np.array(Image.open(file_path).convert('1'))\\r\\n img = img.reshape(28,28,1)\\r\\n return img\",\n \"def preprocess(path, scale=3):\\n image = imread(path, is_grayscale=True)\\n label_ = modcrop(image, scale)\\n\\n # Must be normalized\\n \\n label_ = label_ / 255.\\n \\n\\n\\n input_ = scipy.ndimage.interpolation.zoom(label_, (1. / scale), prefilter=False)\\n input_ = scipy.ndimage.interpolation.zoom(input_, (scale / 1.), prefilter=False)\\n\\n return input_, label_\",\n \"def preprocess_image(image):\\n image = tf.image.decode_jpeg(image, channels=3, dct_method=\\\"INTEGER_ACCURATE\\\")\\n return scale(image)\",\n \"def normalise(image):\",\n \"def preprocess_observation(self, observation):\\r\\n #grayscale_observation = color.rgb2gray(observation)\\r\\n observation_dim = observation.shape\\r\\n resized_observation = observation.reshape(1, observation_dim[0], observation_dim[1], observation_dim[2])\\r\\n resized_observation = resized_observation.astype('float32')\\r\\n resized_observation = resized_observation/255\\r\\n return resized_observation\",\n \"def preprocess_(image, input_shape):\\n if isinstance(image, str):\\n filename = image\\n image = Image.open(image)\\n if isinstance(image, np.ndarray):\\n image = Image.fromarray(image)\\n assert (isinstance(image, Image.Image)) \\n\\n w_ori, h_ori = image.size\\n h, w = input_shape\\n image = image.convert(\\\"RGB\\\")\\n\\n if w_ori > h or h_ori > w:\\n scale = max(1.0*w_ori / w, 1.0*h_ori / h)\\n image.thumbnail((w,h), Image.BILINEAR)\\n else:\\n scale = 1\\n\\n image = image.crop((0, 0, w, h))\\n img_data = np.array(image).reshape((1, h, w, 3))\\n img_data = img_data / 256. - 0.5\\n\\n return img_data, scale, w_ori, h_ori\",\n \"def recreate_image(im_as_var):\\n recreated_im = im_as_var.data.numpy()[0]\\n recreated_im[recreated_im > 1] = 1\\n recreated_im[recreated_im < 0] = 0\\n # recreated_im = np.round(recreated_im * 255)\\n return recreated_im\",\n \"def process_image(image):\\r\\n image = random_brightness(image)\\r\\n image = crop_image(image)\\r\\n image = resize(image)\\r\\n return image\",\n \"def preprocess_one_image(self):\\n im = self.image\\n im = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)\\n #plt.imshow(im)\\n im_pp = image.img_to_array(im)\\n im_pp = preprocess_input(im_pp)\\n im_pp = im_pp.reshape(1, 224, 224, 3)\\n return im_pp\",\n \"def preprocessing(image, w, h):\\n image = cv2.resize(image, (w, h))\\n image = np.transpose(image, (2, 0, 1))\\n image = image.reshape(1, 3, h, w)\\n \\n return image\",\n \"def process_new_image(name):\\n #preprocess the image\\n img = cv2.imread(name)\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n img = img/255.-.5\\n return img\",\n \"def preprocess(input_image, input_mask, input_size=128, keep_ratio=True):\\n if keep_ratio == False:\\n input_image_ = cv2.resize(input_image, (input_size, input_size))\\n input_mask_ = cv2.resize(input_mask, (input_size, input_size))\\n else:\\n input_image_ = np.zeros((input_size, input_size, 3))\\n h, w, _ = input_image.shape\\n ratio = min(input_size/h, input_size/w)\\n scaled_image = cv2.resize(input_image, None, None, ratio, ratio)\\n \\n new_h, new_w, _ = scaled_image.shape\\n offset_h, offset_w = (input_size-new_h)//2, (input_size - new_w)//2\\n input_image_[offset_h: offset_h + new_h, offset_w: offset_w + new_w, :] = scaled_image\\n\\n\\n input_mask_ = np.zeros((input_size, input_size))\\n scaled_mask = cv2.resize(input_mask, None, None, ratio, ratio)\\n input_mask_[offset_h: offset_h + new_h, offset_w: offset_w + new_w] = scaled_mask\\n\\n input_image_ = input_image_/255.0\\n return input_image_, input_mask_\",\n \"def get_image(self, image):\\n \\n # transform image with proper padding\\n row, column, _ = image.shape\\n image = cv2.copyMakeBorder(image, (column-row)//2, (column-row)//2, \\n 0, 0, cv2.BORDER_CONSTANT)\\n \\n # reshape image in proper size\\n image = cv2.resize(image, (self.shape[0], self.shape[1]), \\\\\\n interpolation=cv2.INTER_CUBIC)\\n \\n return self.transform(image)\",\n \"def preprocess_image(image_path, desired_size=SIZE):\\n im = Image.open(image_path)\\n im = im.resize((desired_size,) * 2, resample=Image.LANCZOS)\\n\\n return im\",\n \"def process(img):\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) \\n x_t = cv2.resize(img, (112, 160), interpolation=cv2.INTER_AREA)\\n x_t = np.nan_to_num(x_t)\\n x_t = cv2.Laplacian(x_t,cv2.CV_8U)\\n\\n return x_t.astype(np.uint8)\",\n \"def image_preprocessing(image):\\n\\treturn cv2.GaussianBlur(cv2.cvtColor(image, cv2.COLOR_BGR2GRAY), (5,5), 0)\",\n \"def _preprocess(self, image):\\n\\n # Scale from [0, 255] to [0, 1] and BGR to RGB \\n return (image / 255.0)[:, :, ::-1]\",\n \"def preprocess(self, img):\\n img_ = image.load_img(img, target_size=(299, 299))\\n img_ = image.img_to_array(img_)\\n img_ = np.expand_dims(img_, axis=0)\\n img_ = preprocess_input(img_)\\n return img_\",\n \"def preprocess_image(image):\\n\\n gray_image = grayscale_image(image)\\n # any other preprocessing steps such as bluring would go here\\n\\n binary_image = binarize_image(gray_image)\\n\\n return binary_image\",\n \"def preprocess_data(X):\\n # NOTE: # If you have conducted any pre-processing on the image,\\n # please implement this function to apply onto test images.\\n return X\",\n \"def preprocess(self, resized_inputs):\\n return (2.0 / 255.0) * resized_inputs - 1.0\",\n \"def preprocess(self, image):\\n if self.rotate == 0:\\n return image\\n\\n angle = self.rotate * -90\\n return image.rotate(angle, expand=True).crop((0, 0, self._w, self._h))\",\n \"def rescale_image_01(image):\\n # scale image to from [0, 255] to [0.0, 1.0]\\n image = image.astype(np.float32)\\n return image / 255\",\n \"def preprocess_image(self, img):\\r\\n\\r\\n # if channel 1 then as grayscale\\r\\n try:\\r\\n if img.shape[1] / img.shape[0] < 6.4:\\r\\n img = pad_image(img, (self.crnn_cfg().width, self.crnn_cfg().height), self.crnn_cfg().nb_channels)\\r\\n else:\\r\\n img = resize_image(img, (self.crnn_cfg().width, self.crnn_cfg().height))\\r\\n if self.crnn_cfg().nb_channels == 1:\\r\\n img = img.transpose([1, 0])\\r\\n else:\\r\\n img = img.transpose([1, 0, 2])\\r\\n\\r\\n img = np.flip(img, 1)\\r\\n img = img / 255.0\\r\\n if self.crnn_cfg().nb_channels == 1:\\r\\n img = img[:, :, np.newaxis]\\r\\n return img\\r\\n except:\\r\\n print('Error in method {0} in module {1}'.format('preprocess_image', 'crnn_bridge.py'))\\r\\n return None\",\n \"def process_image(img):\\n img[0] = img[0] * 0.229\\n img[1] = img[1] * 0.224\\n img[2] = img[2] * 0.225\\n img[0] += 0.485\\n img[1] += 0.456\\n img[2] += 0.406\\n\\n return img.cpu().numpy().transpose((1, 2, 0))\",\n \"def usample(x):\\n # Allow the batch dimension to be unknown at graph build time.\\n _, image_height, image_width, n_channels = x.shape.as_list()\\n # Add extra degenerate dimension after the dimensions corresponding to the\\n # rows and columns.\\n expanded_x = tf.expand_dims(tf.expand_dims(x, axis=2), axis=4)\\n # Duplicate data in the expanded dimensions.\\n after_tile = tf.tile(expanded_x, [1, 1, 2, 1, 2, 1])\\n return tf.reshape(after_tile,\\n [-1, image_height * 2, image_width * 2, n_channels])\",\n \"def _postprocess(img):\\n img = _scale_to_zero_one(img)\\n img = img.reshape(1, -1) # to avoid a scikit-learn deprecation warning later\\n return img\",\n \"def flatten(x_tensor):\\n with tf.name_scope('input_reshape'):\\n x = x_tensor.get_shape().as_list()[1]\\n y = x_tensor.get_shape().as_list()[2]\\n z = x_tensor.get_shape().as_list()[3]\\n image_shaped_input = tf.reshape(x_tensor, [-1, x*y*z])\\n return image_shaped_input\",\n \"def _preprocess_image(self, image_raw):\\n\\n image = tf.io.decode_raw(image_raw, tf.float64)\\n\\n return image * self.rescale\",\n \"def img_reshape(self, input_img):\\n _img = np.transpose(input_img, (1, 2, 0)) \\n _img = np.flipud(_img)\\n _img = np.reshape(_img, (1, img_dim[0], img_dim[1], img_dim[2]))\\n return _img\",\n \"def mold_image(image, config=None):\\n if np.max(image) <= 1 and np.min(image) >= 0:\\n image[:,:,:3] = image[:,:,:3]*2.0 - 1.0\\n elif np.min(image) >= 0:\\n image[:, :, :3] = image[:, :, :3] * (1.0/127.5) - 1.0\\n return image.astype(np.float32)\",\n \"def prepro(o,image_size=[80,80]):\\n # y = 0.2126 * o[:, :, 0] + 0.7152 * o[:, :, 1] + 0.0722 * o[:, :, 2]\\n # y = y.astype(np.uint8)\\n y = 0.2125 * o[:, :, 0] + 0.7154 * o[:, :, 1] + 0.0721 * o[:, :, 2]\\n resized = scipy.misc.imresize(y, image_size)\\n return np.expand_dims(resized.astype(np.float32),axis=0)\",\n \"def transform(self, x: Array2D) -> Array2D:\",\n \"def preprocess(img: 'np.ndarray') -> 'np.ndarray':\\n return cv2.resize(img, (45, 45), interpolation=cv2.INTER_AREA)[:,:,:3]\",\n \"def load_image(path, preprocess=True):\\n x = image.load_img(path, target_size=(H, W))\\n if preprocess:\\n x = image.img_to_array(x)\\n x = np.expand_dims(x, axis=0)\\n x = x / 255.0\\n return x\",\n \"def preprocess(image, resize=rsz_default, kernel=kernel_size, sigma=0):\\n\\timage = to_uint8(image)\\n\\timage_small = cv2.resize(image, (0,0), fx=resize, fy=resize)\\n\\timage_gblur = cv2.GaussianBlur(image_small, kernel, sigma)\\n\\treturn image_gblur\",\n \"def transform2Grey(input_image):\\n return np.array([create_features(img) for img in input_image])\",\n \"def preprocess_image(image_path, input_size):\\n img = tf.io.read_file(image_path)\\n img = tf.io.decode_image(img, channels=3)\\n img = tf.image.convert_image_dtype(img, tf.uint8)\\n original_image = img\\n resized_img = tf.image.resize(img, input_size)\\n resized_img = resized_img[tf.newaxis, :]\\n return resized_img, original_image\",\n \"def forward(self, x, z_rot_input=None):\\n # x is the image\\n z_structure, z_rot_output = self.encoder(x)\\n z_rot = z_rot_output if z_rot_input is None else z_rot_input\\n x_hat = self.decoder(z_structure, z_rot)\\n return x_hat, z_rot_output.squeeze()\",\n \"def transform(self, previousimage):\",\n \"def partial_x(img):\\n\\n out = None\\n\\n #####################################\\n # START YOUR CODE HERE #\\n #####################################\\n kernel = np.array([[0.5, 0, -0.5]])\\n out = conv(img, kernel)\\n ######################################\\n # END OF YOUR CODE #\\n ######################################\\n\\n return out\",\n \"def _preprocess_image(self, image):\\n img = tf.convert_to_tensor(image)\\n # img = tf.io.decode_image(img, channels=3)\\n img = tf.image.convert_image_dtype(img, tf.uint8)\\n\\n resized_img = tf.image.resize(img, (self._input_height, self._input_width))\\n resized_img = resized_img[tf.newaxis, :]\\n return resized_img\",\n \"def pre_process(img, img_size):\\n resized = cv2.resize(\\n img, (img_size, img_size), interpolation=cv2.INTER_LINEAR\\n )\\n img_in = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)\\n img_in = np.transpose(img_in, (2, 0, 1)).astype(np.float32)\\n img_in = np.expand_dims(img_in, axis=0)\\n img_in /= 255.0\\n img_in = np.ascontiguousarray(img_in)\\n return img_in\",\n \"def image_rotation(x):\\n rands = tf.truncated_normal([tf.shape(x)[0]], stddev=0.05)\\n return images_rotate(x, rands, interpolation='BILINEAR')\",\n \"def _preprocess_image(self, image_raw):\\n\\n image = tf.io.decode_raw(image_raw, tf.float64)\\n \\n if self.rescale is not None:\\n image_out = image * self.rescale\\n else:\\n image_out = image\\n\\n return image_out\",\n \"def pre_processing_image(img):\\n\\n #print(img.shape)\\n # apply gamma correction and show the images\\n #adjusted = adjust_gamma(img, gamma=0.65)\\n\\n adjusted = exposure.adjust_gamma(img, gamma=1.65)\\n #print(adjusted.shape)\\n\\n # log transform of image\\n\\n logarithmic_corrected = exposure.adjust_log(adjusted, 1)\\n #print(logarithmic_corrected.shape)\\n\\n # denoising\\n #dst2 = cv2.fastNlMeansDenoisingColored(logarithmic_corrected, None, 10, 10, 7, 21)\\n #print(dst2.shape)\\n dst2 = logarithmic_corrected\\n return dst2\",\n \"def preprocess_image(self, image_path, input_size):\\n img = tf.io.read_file(image_path)\\n img = tf.io.decode_image(img, channels=3)\\n img = tf.image.convert_image_dtype(img, tf.uint8)\\n resized_img = tf.image.resize(img, input_size)\\n resized_img = resized_img[tf.newaxis, :]\\n return resized_img\",\n \"def __call__(self, image: torch.Tensor) -> torch.Tensor:\\n assert len(image.shape) == 4\\n res = image.clone()\\n if self.for_segmentation_input_maps:\\n res = res.int()\\n else:\\n res = res.float()\\n if res.max() > 1:\\n raise ValueError(\\\"Image tensor should be in \\\"\\n \\\"range 0-1 for conversion to PIL\\\")\\n\\n # Sample parameters defining the transformation\\n transforms = self.draw_next_transform()\\n for c in range(image.shape[0]):\\n res[c] = self.apply_transform_on_3d_image(res[c], transforms)\\n if not self.use_joint_channel_transformation:\\n # Resample transformations for the next channel\\n transforms = self.draw_next_transform()\\n return res.to(dtype=image.dtype)\",\n \"def construct(self, x):\\n identity = x\\n out = self.conv1(x)\\n out = self.bn1(out)\\n out = self.relu(out)\\n\\n out = self.conv2(out)\\n out = self.bn2(out)\\n\\n if self.downsample is not None:\\n identity = self.downsample(x)\\n\\n out = self.add(out, identity)\\n out = self.relu(out)\\n\\n return out\",\n \"def chainercv_preprocess(image):\\n image = skio.imread(image)\\n image = image.transpose(2, 0, 1)\\n return [image]\",\n \"def preprocess_image(self, img_path):\\n im = Image.open(img_path)\\n im = im.resize((IM_WIDTH, IM_HEIGHT))\\n im = np.array(im) / 255.0\\n \\n return im\",\n \"def preprocess(image):\\n image = rgb2yuv(image)\\n return image\",\n \"def preprocessImage(img):\\n shape = img.shape\\n img = img[math.floor(shape[0]/4) : shape[0] - 25, 0:shape[1]]\\n img = cv2.resize(img, (img_columns, img_rows), interpolation = cv2.INTER_AREA)\\n return img\",\n \"def process_image(self, image):\\r\\n img = cv2.imread(image)\\r\\n img = img.astype(float)/127 - 1\\r\\n return np.expand_dims(img, axis=0)\",\n \"def transform(self, image):\\n preprocess = transforms.Compose([\\n transforms.Resize(256),\\n transforms.CenterCrop(224),\\n transforms.ToTensor(),\\n transforms.Normalize(\\n mean=[0.485, 0.456, 0.406],\\n std=[0.229, 0.224, 0.225]\\n ),\\n ])\\n input_tensor = preprocess(image)\\n return input_tensor\",\n \"def preprocess(file_path, model_preprocess_function):\\n img = image.load_img(file_path, target_size=(224, 224))\\n x = image.img_to_array(img)\\n # x = np.expand_dims(x, axis=0)\\n x = model_preprocess_function(x)\\n return x\",\n \"def preprocess(path, path2 , scale):\\n image = imread(path)\\n label_ = imread(path2)\\n\\n #label_ = modcrop(label, scale)\\n\\n # Must be normalized\\n input_ = image / 255.\\n label_ = label_ / 255.\\n\\n #input_ = scipy.ndimage.interpolation.zoom(label_, (1./scale), prefilter=False)\\n #input_ = scipy.ndimage.interpolation.zoom(input_, (scale/1.), prefilter=False)\\n\\n return input_, label_\",\n \"def preprocess(img):\\n if img.ndim != 3:\\n raise TypeError('bad ndim of img')\\n if img.dtype != np.uint8:\\n raise TypeError('bad dtype of img')\\n img = cv2.resize(img, (224, 224))\\n img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n img = img.astype(np.float32)\\n img *= (2.0/255) # normalize to: 0.0~2.0\\n img -= 1.0 # subtract mean to make it: -1.0~1.0\\n img = np.expand_dims(img, axis=0)\\n return img\",\n \"def partial_x(img):\\n\\n out = None\\n\\n ### YOUR CODE HERE\\n kernel = 0.5*np.array([[1,0,-1]])\\n out = conv(img,kernel)\\n ### END YOUR CODE\\n\\n return out\",\n \"def transform_image(img_path: Path) -> torch.Tensor:\\n # define transformation steps\\n crop_to_lower_percentage = 50\\n output_size = (256, 256)\\n transform = get_predict_image_transform()\\n\\n # load image\\n img = torchvision.io.read_image(str(img_path)).float()\\n\\n # perform transformation\\n input = transform(img)\\n\\n # single image instead of batch\\n input = input.unsqueeze(0)\\n\\n return input\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7366667","0.6921181","0.6734784","0.6608169","0.6577374","0.64686996","0.64662826","0.6452119","0.6434497","0.62245506","0.62063634","0.62025005","0.6197715","0.6181233","0.61551434","0.6153792","0.61470103","0.6140627","0.6138117","0.61186534","0.6110178","0.6092078","0.60463","0.6043737","0.6035541","0.6029845","0.6009539","0.6007681","0.6005715","0.59966946","0.5972009","0.5967427","0.5956246","0.5937739","0.593349","0.5908785","0.5870012","0.5865813","0.5819746","0.58173263","0.58145165","0.5810299","0.5786824","0.57849115","0.5781181","0.5768925","0.57665807","0.57620585","0.5760786","0.5751334","0.57487977","0.57244164","0.57039666","0.56959677","0.5693223","0.5684753","0.568313","0.5682964","0.566843","0.56664205","0.5661604","0.56602275","0.5644161","0.56397504","0.56338996","0.5629483","0.56106424","0.5608554","0.5608457","0.5607516","0.5606559","0.5605467","0.5598585","0.5592664","0.55917704","0.5588339","0.55880415","0.55868834","0.558392","0.5580928","0.5574345","0.5567514","0.55605125","0.55480814","0.554788","0.5546643","0.5545142","0.55422306","0.55420226","0.5540238","0.5538539","0.55379605","0.55343074","0.55291325","0.55265456","0.55209404","0.5512282","0.5506786","0.550455","0.55000055","0.5488687"],"string":"[\n \"0.7366667\",\n \"0.6921181\",\n \"0.6734784\",\n \"0.6608169\",\n \"0.6577374\",\n \"0.64686996\",\n \"0.64662826\",\n \"0.6452119\",\n \"0.6434497\",\n \"0.62245506\",\n \"0.62063634\",\n \"0.62025005\",\n \"0.6197715\",\n \"0.6181233\",\n \"0.61551434\",\n \"0.6153792\",\n \"0.61470103\",\n \"0.6140627\",\n \"0.6138117\",\n \"0.61186534\",\n \"0.6110178\",\n \"0.6092078\",\n \"0.60463\",\n \"0.6043737\",\n \"0.6035541\",\n \"0.6029845\",\n \"0.6009539\",\n \"0.6007681\",\n \"0.6005715\",\n \"0.59966946\",\n \"0.5972009\",\n \"0.5967427\",\n \"0.5956246\",\n \"0.5937739\",\n \"0.593349\",\n \"0.5908785\",\n \"0.5870012\",\n \"0.5865813\",\n \"0.5819746\",\n \"0.58173263\",\n \"0.58145165\",\n \"0.5810299\",\n \"0.5786824\",\n \"0.57849115\",\n \"0.5781181\",\n \"0.5768925\",\n \"0.57665807\",\n \"0.57620585\",\n \"0.5760786\",\n \"0.5751334\",\n \"0.57487977\",\n \"0.57244164\",\n \"0.57039666\",\n \"0.56959677\",\n \"0.5693223\",\n \"0.5684753\",\n \"0.568313\",\n \"0.5682964\",\n \"0.566843\",\n \"0.56664205\",\n \"0.5661604\",\n \"0.56602275\",\n \"0.5644161\",\n \"0.56397504\",\n \"0.56338996\",\n \"0.5629483\",\n \"0.56106424\",\n \"0.5608554\",\n \"0.5608457\",\n \"0.5607516\",\n \"0.5606559\",\n \"0.5605467\",\n \"0.5598585\",\n \"0.5592664\",\n \"0.55917704\",\n \"0.5588339\",\n \"0.55880415\",\n \"0.55868834\",\n \"0.558392\",\n \"0.5580928\",\n \"0.5574345\",\n \"0.5567514\",\n \"0.55605125\",\n \"0.55480814\",\n \"0.554788\",\n \"0.5546643\",\n \"0.5545142\",\n \"0.55422306\",\n \"0.55420226\",\n \"0.5540238\",\n \"0.5538539\",\n \"0.55379605\",\n \"0.55343074\",\n \"0.55291325\",\n \"0.55265456\",\n \"0.55209404\",\n \"0.5512282\",\n \"0.5506786\",\n \"0.550455\",\n \"0.55000055\",\n \"0.5488687\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88364,"cells":{"query":{"kind":"string","value":"Get account data from SWAG (via S3)"},"document":{"kind":"string","value":"def get_swag():\n swag_opts = {\n 'swag.type': 's3',\n 'swag.bucket_name': CONFIG.swag_bucket,\n 'swag.data_file': CONFIG.swag_data_file,\n 'swag.region': CONFIG.swag_region,\n 'swag.cache_expires': 0\n }\n return SWAGManager(**parse_swag_config_options(swag_opts))"},"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 _get_usofa_data(bucketname):\n client = boto3.client('s3')\n result = client.get_object(Bucket=bucketname, Key='accounts.json')\n return json.loads(result['Body'].read().decode('utf-8'))","def s3_read_data(self):\n\n self.k.open()\n self.k.read()","def __retrieve_from_bucket(fname):\n blob = BUCKET.blob(fname)\n json_data = json.loads(blob.download_as_string())\n return json_data","def _aws_get_object(bucket, key, request_pays=True, client=None):\n if not client:\n session = boto3_session(region_name=REGION)\n client = session.client(\"s3\")\n\n params = {\"Bucket\": bucket, \"Key\": key}\n if request_pays:\n params[\"RequestPayer\"] = \"requester\"\n response = client.get_object(**params)\n return response[\"Body\"].read()","def get_s3_object(self, key):\n try:\n bucket_name = app.config['S3_BUCKET_NAME']\n s3_client = app.config['S3']\n response = s3_client.get_object(Bucket=bucket_name, Key=key)\n return response['Body'].read()\n except Exception:\n return None","def get(self, key):\n return s3.Object(self.bucket.name, key).get()['Body'].read()","def get_from_s3(s3_client, s3_url):\n url = urlparse(s3_url)\n\n # Split the bucket from the key\n bucket_name = urllib2.unquote(url.netloc).decode('utf8')\n key_name = urllib2.unquote(url.path[1:]).decode('utf8')\n\n # We're done parsing; start doing some S3 ops\n bucket = s3_client.get_bucket(bucket_name, validate=False)\n key = bucket.get_key(key_name)\n return key.get_contents_as_string()","def retrieve_s3_contents ( s3_conn, bucket_name, key_name, stored_filename = None ) :\n bucket = s3_conn.get_bucket( bucket_name )\n key = boto.s3.key.Key( bucket )\n key.key = key_name\n if key.exists( ) :\n if stored_filename :\n key.get_contents_to_filename( stored_filename )\n return stored_filename\n\n return key.get_contents_as_string( )\n\n return None","def get_amazon_adj_cls_from_s3(s3_resource, bucket_name, prefix='') -> dict:\n amzn_filename = \"AMZN.json\"\n complete_path = os.path.join(prefix, amzn_filename)\n json_object = s3_resource.Object(bucket_name, complete_path)\n file_content = json_object.get()['Body'].read().decode('utf-8')\n json_content = json.loads(file_content)\n return json_content","def fetch(iid):\n if AWS_CLIENT_CONFIG and BUCKET_NAME:\n try:\n s3 = boto3.resource('s3', **AWS_CLIENT_CONFIG)\n obj = s3.Bucket(BUCKET_NAME).Object(iid).get()\n if obj:\n return obj.get('Body')\n except botocore.exceptions.ClientError as e:\n logger.error(e)\n else:\n # get locally from temp dir (tests, local development)\n return get_temp_file(iid)\n return None","def get_object(self, key):\n r = self.s3client.get_object(Bucket = self.s3_bucket, Key = key)\n data = r['Body'].read()\n return data","def download_keypair ( s3_infra_conn, aws_account_type, region_name, keypair_type ) :\n keypair_name = get_keypair_name( aws_account_type, region_name, keypair_type )\n keypair_bucket = get_admin_bucket_name( region_name = region_name )\n return retrieve_s3_contents( s3_conn = s3_infra_conn,\n bucket_name = keypair_bucket,\n key_name = get_keypair_keypath( aws_account_type ) + get_keypair_keyname( keypair_name ),\n stored_filename = keypair_name )","def fetch_config_from_s3(client):\n try:\n response = client.assume_role(\n RoleArn=\"arn:aws:iam::548760365095:role/Ec2StartStopLambdaActionRole\",\n RoleSessionName=\"Ec2-Start-Stop-Lambda-Session-Role\"\n )\n fetcher = boto3.client(\n 's3',\n aws_access_key_id=response['Credentials']['AccessKeyId'],\n aws_secret_access_key=response['Credentials']['SecretAccessKey'],\n aws_session_token=response['Credentials']['SessionToken']\n )\n return json_to_dict(fetcher)\n except Exception as error:\n logger.info(\"Creating a temporary S3 privileged user failed with the following error : {}\".format(error))","async def get_or_create_temporary_s3_access(user_id: UserID):","def s3(ctx, bucket_name, data_file, region):\n ctx.obj['BUCKET_NAME'] = bucket_name\n ctx.obj['DATA_FILE'] = data_file\n ctx.obj['TYPE'] = 's3'\n ctx.obj['REGION'] = region","def s3_data_conn ( self ) :\n if not self.s3_data :\n self.s3_data = boto.s3.connection.S3Connection( self.access_key, self.access_key_secret )\n return self.s3_data","def get_google_adj_cls_from_s3(s3_resource, bucket_name, prefix='') -> dict:\n googl_filename = \"GOOGL.json\"\n complete_path = os.path.join(prefix, googl_filename)\n json_object = s3_resource.Object(bucket_name, complete_path)\n file_content = json_object.get()['Body'].read().decode('utf-8')\n json_content = json.loads(file_content)\n return json_content","def get_s3_access_key(self):\n return self.__ACCESS_KEY","def access_s3():\n try:\n s3helper = S3Helper()\n bucket = s3helper.get_bucket(get_archive_bucket())\n LOG.info('Access S3 bucket name: {0}'.format(bucket.name))\n except Exception:\n LOG.exception('check_database_connection')\n return False\n\n return True","def get_s3_keys(bucket, user_keys = None):\n keys = []\n if user_keys is None:\n \t\t\t\ts3 = boto3.client('s3')\n else:\n s3 = boto3.client('s3', \n aws_access_key_id = user_keys[\"AWS_ACCESS_KEY_ID\"], \n aws_secret_access_key = user_keys[\"AWS_SECRET_ACCESS_KEY\"], \n region_name = user_keys[\"REGION_NAME\"]\n ) \t \n \n resp = s3.list_objects_v2(Bucket= bucket)\n for obj in resp['Contents']:\n keys.append(obj['Key'])\n return keys","def get_object(self, bucket_name, key, stream=False, extra_get_args={}):\n url = self.__key_url(bucket_name, key)\n res = self.infinispan_client.get(url, headers=self.headers, auth=self.basicAuth)\n data = res.content\n return data","def get_text(bucket, key):\n s3 = boto3.resource(\"s3\")\n\n ocr_obj = s3.Object(bucket, key)\n response = ocr_obj.get()\n data = response[\"Body\"].read()\n\n return data","def get_apple_adj_cls_from_s3(s3_resource, bucket_name, prefix='') -> dict:\n aapl_filename = \"AAPL.json\"\n complete_path = os.path.join(prefix, aapl_filename)\n json_object = s3_resource.Object(bucket_name, complete_path)\n file_content = json_object.get()['Body'].read().decode('utf-8')\n json_content = json.loads(file_content)\n return json_content","def authorizedClientCall(self):\n\t\tclient \t\t= boto3.client(\"s3\")\n\t\treturn(client)","def _get_s3_object(self, s3_path):\n bucket_name, key = S3Util.get_bucket_and_key(s3_path)\n return self.s3_resource.Object(bucket_name, key)","def boto_init_s3(bucket_name):\n c = boto.connect_s3(aws_access_key_id=settings.AWS_ACCESS_KEY_ID,\n aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY)\n b = c.get_bucket(bucket_name)\n\n return b","def list_public_s3_objects(self):\n _response = urllib.urlopen(self.options.s3_bucket_url)\n _html = _response.read()\n\n if LOCAL_DEBUG:\n print _html\n\n try:\n assert \"AccessDenied\" not in _html\n assert \"NoSuchBucket\" not in _html\n except:\n print(\"ERROR: AccessDenied or NoSuchBucket for {}\".format(self.options.s3_bucket_url))\n raise","def get_buckets_for_user(self):\n s3 = self.credentials.session.resource('s3')\n bucket_list = [bucket.name for bucket in s3.buckets.all()]\n\n return bucket_list;","def load_archives_from_s3(self):\n s3_bucket = S3Backend(self.conf).bucket\n try:\n k = Key(s3_bucket)\n k.key = self.backup_key\n\n return json.loads(k.get_contents_as_string())\n except S3ResponseError, exc:\n log.error(exc)\n return {}","def get_s3_content(bucket, key, access_id, access_secret):\n try:\n response = s3_client(access_id, access_secret).get_object(Bucket=bucket, Key=key)\n body = response['Body'].read()\n return body\n except ClientError as error:\n LOGGER.error(error)\n return None","def get_file_s3(bucket, key):\n \n client = boto3.client('s3')\n return client.get_object(Bucket=bucket, Key=key)['Body'].read().decode('utf-8')","def get(handler, *args, **kwargs):\n bucket_id = args[0]\n user_id = args[1]\n BucketClasss = type(\"Bucket_%s\" % (bucket_id), (Bucket,), {})\n bucket = yield BucketClasss.get(user_id)\n result = {}\n if bucket:\n result = bucket.data\n elif handler.sbs_client:\n try:\n result = yield handler.sbs_client.getBucketData(bucket_id, user_id)\n except Exception, e:\n logging.info(str(e)) \n \n if not bucket: \n bucket = BucketClasss()\n bucket.pkey = user_id\n bucket.data = result\n yield bucket.put()\n\n if not bucket.data:\n raise Return((404, result))\n\n raise Return((200, result))","def get(self, bucket: str, object_name: str) -> bytes:\n raise NotImplementedError()","def get_dropbox_policy ( bucket_name, requires_aspera = False ) :\n if requires_aspera :\n return \"\"\"{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Sid\": \"GrantUploadDownloadPermissionsToBucket\",\n \"Effect\": \"Allow\",\n \"Action\": [\n \"s3:AbortMultipartUpload\",\n \"s3:DeleteObject\",\n \"s3:DeleteObjectVersion\",\n \"s3:GetBucketAcl\",\n \"s3:GetBucketLocation\",\n \"s3:GetBucketLogging\",\n \"s3:GetBucketNotification\",\n \"s3:GetBucketPolicy\",\n \"s3:GetBucketRequestPayment\",\n \"s3:GetBucketTagging\",\n \"s3:GetBucketVersioning\",\n \"s3:GetBucketWebsite\",\n \"s3:GetLifecycleConfiguration\",\n \"s3:GetObject\",\n \"s3:GetObjectAcl\",\n \"s3:GetObjectTorrent\",\n \"s3:GetObjectVersion\",\n \"s3:GetObjectVersionAcl\",\n \"s3:GetObjectVersionTorrent\",\n \"s3:ListAllMyBuckets\",\n \"s3:ListBucket\",\n \"s3:ListBucketMultipartUploads\",\n \"s3:ListBucketVersions\",\n \"s3:ListMultipartUploadParts\",\n \"s3:PutBucketVersioning\",\n \"s3:PutObject\"\n ],\n \"Resource\": [\n \"arn:aws:s3:::\"\"\" + bucket_name + \"\"\"\",\n \"arn:aws:s3:::\"\"\" + bucket_name + \"\"\"/*\"\n ]\n },\n {\n \"Sid\": \"AllowAsperaRootLevelListingOfTheBucket\",\n \"Action\": [\"s3:ListBucket\"],\n \"Effect\": \"Allow\",\n \"Resource\": [\n \"arn:aws:s3:::\"\"\" + bucket_name + \"\"\"\"\n ],\n \"Condition\":{\n \"StringEquals\":{\n \"s3:prefix\":[\"\"], \"s3:delimiter\":[\"/\"]\n }\n }\n },\n {\n \"Sid\" : \"AllowGroupToSeeBucketListInAsperaConsole\",\n \"Action\" : [\n \"s3:ListAllMyBuckets\",\n \"s3:GetBucketLocation\"\n ],\n \"Effect\" : \"Allow\",\n \"Resource\" : [ \"arn:aws:s3:::\" ]\n }\n ]\n}\"\"\"\n\n else :\n return \"\"\"{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n \"Sid\": \"GrantUploadDownloadPermissionsToBucket\",\n \"Effect\": \"Allow\",\n \"Action\": [\n \"s3:AbortMultipartUpload\",\n \"s3:DeleteObject\",\n \"s3:DeleteObjectVersion\",\n \"s3:GetBucketAcl\",\n \"s3:GetBucketLocation\",\n \"s3:GetBucketLogging\",\n \"s3:GetBucketNotification\",\n \"s3:GetBucketPolicy\",\n \"s3:GetBucketRequestPayment\",\n \"s3:GetBucketTagging\",\n \"s3:GetBucketVersioning\",\n \"s3:GetBucketWebsite\",\n \"s3:GetLifecycleConfiguration\",\n \"s3:GetObject\",\n \"s3:GetObjectAcl\",\n \"s3:GetObjectTorrent\",\n \"s3:GetObjectVersion\",\n \"s3:GetObjectVersionAcl\",\n \"s3:GetObjectVersionTorrent\",\n \"s3:ListAllMyBuckets\",\n \"s3:ListBucket\",\n \"s3:ListBucketMultipartUploads\",\n \"s3:ListBucketVersions\",\n \"s3:ListMultipartUploadParts\",\n \"s3:PutBucketVersioning\",\n \"s3:PutObject\"\n ],\n \"Resource\": [\n \"arn:aws:s3:::\"\"\" + bucket_name + \"\"\"\",\n \"arn:aws:s3:::\"\"\" + bucket_name + \"\"\"/*\"\n ]\n }\n ]\n}\"\"\"","def read_bucket_objects(bucket_name):\n s3 = boto3.resource('s3')\n bucket = s3.Bucket(bucket_name)\n for obj in bucket.objects.all():\n response = obj.get()\n body = response['Body'].read().decode('utf-8')\n print(body)","def get_object(Bucket=None, IfMatch=None, IfModifiedSince=None, IfNoneMatch=None, IfUnmodifiedSince=None, Key=None, Range=None, ResponseCacheControl=None, ResponseContentDisposition=None, ResponseContentEncoding=None, ResponseContentLanguage=None, ResponseContentType=None, ResponseExpires=None, VersionId=None, SSECustomerAlgorithm=None, SSECustomerKey=None, SSECustomerKeyMD5=None, RequestPayer=None, PartNumber=None):\n pass","def test_s3():\n vc = vtec.parse(EX1)\n assert vc[0].s3() == \"TO.W.130\"","def read_key_s3(self, keyUrl='', bucket=None):\n \n if bucket is None:\n bucket = self.AWS_S3_BUCKET\n\n try:\n\n fileobj = self.get_s3_client().get_object(\n Bucket= bucket,\n Key= keyUrl\n )\n readKey = fileobj['Body'].read()\n # contentObj = readKey.decode('utf-8')\n\n return readKey\n\n except:\n time.sleep(1)\n pass","async def getStorObjStats(app, key, bucket=None):\n # TBD - will need to be refactored to handle azure responses\n\n client = _getStorageClient(app)\n if not bucket:\n bucket = app['bucket_name']\n stats = {}\n\n if key[0] == '/':\n #key = key[1:] # no leading slash\n msg = f\"key with leading slash: {key}\"\n log.error(msg)\n raise KeyError(msg)\n\n log.info(f\"getStorObjStats({key})\")\n\n resp = await client.list_keys(bucket=bucket, limit=1, prefix=key)\n\n if 'Contents' not in resp:\n msg = f\"key: {key} not found\"\n log.info(msg)\n raise HTTPInternalServerError()\n contents = resp['Contents']\n log.debug(f\"storage_contents: {contents}\")\n\n found = False\n if len(contents) > 0:\n item = contents[0]\n if item[\"Key\"] == key:\n # if the key is a S3 folder, the key will be the first object in the folder,\n # not the requested object\n found = True\n if item[\"ETag\"]:\n etag = item[\"ETag\"]\n if len(etag) > 2 and etag[0] == '\"' and etag[-1] == '\"':\n # S3 returning extra quotes around etag?\n etag = etag[1:-1]\n stats[\"ETag\"] = etag\n else:\n if \"Owner\" in item and \"ID\" in item[\"Owner\"] and item[\"Owner\"][\"ID\"] == \"minio\":\n pass # minio is not creating ETags...\n else:\n log.warn(f\"No ETag for key: {key}\")\n # If no ETAG put in a fake one\n stats[\"ETag\"] = \"9999\"\n stats[\"Size\"] = item[\"Size\"]\n stats[\"LastModified\"] = int(item[\"LastModified\"].timestamp())\n if not found:\n msg = f\"key: {key} not found\"\n log.info(msg)\n raise HTTPNotFound()\n\n return stats","def s3resource(self):\n return self._s3resource","def list_s3_resources(memberAccountId=None, nextToken=None, maxResults=None):\n pass","def _s3_get_file(url):\n try:\n return S3().get_contents_from_url(url)\n except Exception as e:\n raise ScrBaseException(\"Could not load file from {0}: {1}\".format(url, e))","def s3_download(path):\n with s3_read(path):\n # Reading the file will cache the file locally.\n pass","def list_buckets():\n for bucket in s3.buckets.all():\n print(bucket)","def lambda_handler(event, context):\n qpmBucket = event['queryStringParameters']['bucket']\n fn_bucket = list_s3_objects(qpmBucket)\n print(fn_bucket)\n \n \n return {\n \"statusCode\": 200,\n \"body\": json.dumps(str(fn_bucket)),\n }","def s3_get(url, temp_file):\n s3_resource = boto3.resource(\"s3\")\n bucket_name, s3_path = split_s3_path(url)\n s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file)","def s3_get(url, temp_file):\n s3_resource = boto3.resource(\"s3\")\n bucket_name, s3_path = split_s3_path(url)\n s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file)","def get_s3_file(self, no_copy=False):\n return self.get_file(uri_type=URI_S3, no_copy=no_copy)","def get_s3_client(profile_name):\n try:\n session = boto3.session.Session(profile_name=profile_name)\n except ProfileNotFound as e:\n print(e, file=sys.stderr)\n raise FailureException from e\n return session.resource('s3')","def _read_s3_url(cls, s3_url):\n\n parsed_url = urllib.parse.urlparse(s3_url)\n return cls.s3.get_object(Bucket=parsed_url.netloc,\n Key=parsed_url.path.lstrip(\"/\"))[\"Body\"].read()","def get_transcribe_output(key):\n s3 = boto3.client('s3')\n\n obj = s3.get_object(Bucket=os.getenv(\"S3_BUCKET\"), Key=key)\n\n return json.loads(obj[\"Body\"].read())","def get_boto3(args=None, logger=None, stats=None):\n return Boto3(**__get_arguments(args, logger, stats))","def get_s3_client():\n return boto3.resource('s3')","def get_s3_bucket(env):\n s3 = boto3.resource('s3')\n bucket_name = 'govuk-%s-fastly-logs' % env\n logging.info('S3 bucket name: %s', bucket_name)\n return s3.Bucket(bucket_name)","def get_manifest_data(bucket,team, dataset,manifest_key):\n dynamo_config = DynamoConfiguration()\n dynamo_interface = DynamoInterface(dynamo_config)\n s3_interface = S3Interface()\n local_path = s3_interface.download_object(bucket, manifest_key)\n ddb_keys=[]\n items=[]\n with open(local_path, \"r\") as raw_file:\n file_names = [file_name.strip().split(\"/\")[-1]\n for file_name in raw_file]\n for file in file_names:\n ddb_keys.append({\n \"dataset_name\": team+\"-\"+dataset,\n \"manifest_file_name\": manifest_key.split(\"/\")[-1], \"datafile_name\": file\n })\n for ddb_key in ddb_keys:\n try:\n items.append(dynamo_interface.get_item_from_manifests_control_table(\n ddb_key[\"dataset_name\"], ddb_key[\"manifest_file_name\"], ddb_key[\"datafile_name\"]))\n except KeyError:\n logger.error(\"The manifest file has not been processed in Stage A\")\n raise Exception(\"Manifest File has not been processed in Stage A\")\n\n return items","def get_bytes(bucket: str, key: str) -> bytes:\n logger.debug(f'Reading from s3://{bucket}/{key}')\n response = client().get_object(Bucket=bucket, Key=key)\n return response['Body'].read()","def load_file_aws(file_path, aws_credentials):\n bucket_engine = S3Bucket(*aws_credentials)\n return json.loads(\n gzip.decompress(\n bucket_engine.read(file_path)\n ).decode('utf-8')\n )","def read_s3_file(date):\n \"\"\" history from S3 \"\"\"\n bucket = os.getenv(\"SPOTIFY_BUCKET_NAME\")\n path = os.getenv(\"SPOTIFY_BUCKET_PATH\")\n s3 = boto3.resource('s3')\n try:\n s3.Object(bucket, \"%s/%s.json\" % (path, date)).load()\n except botocore.exceptions.ClientError as e:\n logger.info(\"No existing history file found for %s, %s\" %\n (date, e.response['Error']['Code']))\n if e.response['Error']['Code'] == '404':\n return []\n else:\n logger.warning(\"Unexpected error code returned!\")\n return []\n else:\n logger.info(\"Reading history file for %s\" % date)\n content_object = s3.Object(bucket, \"%s/%s.json\" % (path, date))\n file_content = content_object.get()['Body'].read().decode('utf-8')\n json_content = json.loads(file_content)\n return json_content","def _do_retrieve(bucket_name, key_path, number_retries=DEFAULT_S3_RETRIES):\n try:\n return conn.get_object(Bucket=bucket_name, Key=key_path, ResponseContentType='string')\n except Exception:\n if number_retries > 0:\n print(\"s3_retrieve failed with incomplete read, retrying on %s\" % key_path)\n return _do_retrieve(bucket_name, key_path, number_retries=number_retries - 1)\n raise","def aws():\n pass","def openBucket(name):\n conn = boto.connect_s3() \n print \"Connecting to bucket: {}\".format(name)\n bucket = conn.get_bucket(name, validate=True)\n return bucket","def get_matching_s3_keys(bucket, prefix=\"\", suffix=\"\"):\n for obj in get_matching_s3_objects(bucket, prefix, suffix):\n yield obj[\"Key\"]\n\n def download_froms3(myfile, env='prod'):\n # session = boto3.Session(profile_name=PROFILE)\n boto_s3_session = boto3.Session(profile_name=env)\n s3 = boto_s3_session.resource('s3')\n s3client = boto_s3_session.client('s3', region_name='eu-west-2')\n try:\n file_name = unquote(myfile.split('/')[-1])\n oparse = urlparse(myfile, allow_fragments=False)\n print(oparse)\n S3_SRC_BUCKET_NAME = oparse.netloc\n key = oparse.path[1:]\n download_path = '{0}{1}'.format(BASE_PATH, file_name)\n print(f'Downloading from {S3_SRC_BUCKET_NAME} , {key} to {download_path} ')\n # s3.Bucket(S3_SRC_BUCKET_NAME).download_file(key, download_path)\n # s3.Bucket(S3_SRC_BUCKET_NAME).download_file(file_name, download_path)\n s3client.download_file(S3_SRC_BUCKET_NAME, key, download_path)\n print('File Downloaded')\n except botocore.exceptions.ClientError as err:\n if err.response['Error']['Code'] == \"404\":\n print(\"The object does not exist.\", err)\n else:\n # raise\n error = str(err)\n print(error)\n\n return myfile","def make_s3(sitename):\n return s3.S3(sitename)","def bucket_info(request):\n\n session_check = _check_session_valid(request)\n\n if session_check:\n return session_check\n\n return JsonResponse(request.session[\"analytics\"].bucket_info())","def list_s3_content(bucket, access_id, access_secret, prefix=\"\"):\n try:\n response = s3_client(access_id, access_secret).list_objects(Bucket=bucket, Prefix=prefix)\n objects = []\n if response.get(\"Contents\"):\n for key in response['Contents']:\n objects.append(key['Key'])\n return objects\n except ClientError as error:\n LOGGER.error(error)\n return None","def template():\n\n return s3_rest_controller(rheader = s3db.dc_rheader)","def load_from_s3(filename):\n s3 = boto3.client('s3')\n obj = s3.get_object(Bucket=BUCKET_NAME, Key=S3_PATH.format(filename))\n return obj['Body'].read().decode()","def read_data_from_s3(self, name, loc):\n try:\n filename = loc + name + \".json\"\n logger.info('Retrieving the data from the S3 file %s' % filename)\n return self._retrieve_dict(filename)\n except Exception as e:\n logger.error(e)\n return False","def ls(region_name=DEFAULT_REGION):\n s3conn = s3.connect_to_region(region_name)\n buckets = s3conn.get_all_buckets()\n for bucket in buckets:\n print(bucket.name)","def get_s3_object_text(s3_resource: boto3.session.Session.resource, bucket_name: str, key: str) -> str:\n obj = s3_resource.Object(bucket_name, key)\n return obj.get()['Body'].read().decode('utf-8')","def s3_get(url, temp_file, proxies=None):\n\ts3_resource = boto3.resource (\"s3\", config=Config (proxies=proxies))\n\tbucket_name, s3_path = split_s3_path (url)\n\ts3_resource.Bucket (bucket_name).download_fileobj (s3_path, temp_file)","def get_bucket_cors(Bucket=None):\n pass","def data_pull_s3(self):\n year = self.month_year[0]\n month = self.month_year[1]\n self.s3 = boto3.resource('s3',aws_access_key_id=self.creds_data['key_id'],\n aws_secret_access_key=self.creds_data['key_access'])\n bucket = self.s3.Bucket('himatdata')\n home = os.getcwd()\n file_path = os.path.join(*[home, 'Trmm/', self.output_folder, year + '_' + month])\n print(file_path)\n if not os.path.exists(file_path):\n os.makedirs(file_path)\n for obj in bucket.objects.filter(Delimiter='', Prefix='Trmm/{}{}_{}'.format(self.output_folder, year, month)):\n if obj.key.endswith('.nc4'):\n bucket.download_file(obj.key,os.path.join(os.path.join(home, obj.key)))\n logging.info(\"Done with Year Month: %s\", month_year)","async def get_user_account(self):\n uri = \"/v3/spot/assets\"\n success, error = await self.request(\"GET\", uri, auth=True)\n return success, error","def setup_s3_client(job_data):\n key_id = job_data['artifactCredentials']['accessKeyId']\n key_secret = job_data['artifactCredentials']['secretAccessKey']\n session_token = job_data['artifactCredentials']['sessionToken']\n\n session = Session(aws_access_key_id=key_id,\n aws_secret_access_key=key_secret,\n aws_session_token=session_token)\n return session.client('s3', config=botocore.client.Config(signature_version='s3v4'))","def test_s3_gets_object_content(self):\n mock_s3 = Mock()\n mock_s3_object = Mock()\n s3_response = {'Body': mock_s3_object}\n mock_s3_object.read.return_value = \"file content\"\n mock_s3.get_object.return_value = s3_response\n\n s3_bucket = S3Bucket('bucket_name', s3_client=mock_s3)\n assert s3_bucket.get_content('/file.text') == \\\n 'file content'","def _retrieve_blob(self, object_key):\n return self.s3_resource.Object(self.CVE_BUCKET, object_key).get()['Body'].read()","def get_image(filename):\n\n client.download_file(S3_BUCKET, filename, 'uploads/{}'.format(filename))","def s3(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"s3\")","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 question():\n\n return s3_rest_controller()","def create_boto_session(account):\n aws_access_key_id = account['aws_access_key_id']\n aws_secret_access_key = account['aws_secret_access_key']\n region = account['region']\n #aws_profile = account['aws_profile']\n\n\n session = boto3.Session(\n aws_access_key_id=aws_access_key_id,\n aws_secret_access_key=aws_secret_access_key,\n region_name=region,\n #profile_name=aws_profile,\n )\n\n return session","def ListFiles(s3):\n response = s3.list_objects(Bucket='mynewbucket123')\n for content in response.get('Contents', []):\n yield content.get('Key')","async def getStorJSONObj(app, key, bucket=None):\n\n client = _getStorageClient(app)\n if not bucket:\n bucket = app['bucket_name']\n if key[0] == '/':\n key = key[1:] # no leading slash\n log.info(f\"getStorJSONObj({bucket})/{key}\")\n\n data = await client.get_object(key, bucket=bucket)\n\n try:\n json_dict = json.loads(data.decode('utf8'))\n except UnicodeDecodeError:\n log.error(f\"Error loading JSON at key: {key}\")\n raise HTTPInternalServerError()\n\n log.debug(f\"storage key {key} returned: {json_dict}\")\n return json_dict","def get_creds(bucket_name, folder_name):\n client = boto3.client('sts')\n # pprint(client.get_caller_identity())\n\n # A name of our choice (no spaces allowed)\n credential_name = f'AccessTimeline-{folder_name}'\n policy = {\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n # A name of our choice [0-9a-zA-Z]\n \"Sid\": f'ListBucket{folder_name}',\n \"Action\": [\n \"s3:ListBucket\",\n ],\n \"Effect\": \"Allow\",\n \"Resource\": [\n f'arn:aws:s3:::{bucket_name}',\n ],\n \"Condition\": {\n \"StringEquals\": {\n \"s3:prefix\": [\n f'{folder_name}/'\n ],\n \"s3:delimiter\": [\n '/'\n ],\n }\n }\n\n },\n {\n \"Sid\": f'GetObject{folder_name}',\n \"Action\": [\n \"s3:GetObject\",\n ],\n \"Effect\": \"Allow\",\n \"Resource\": [\n f'arn:aws:s3:::{bucket_name}/{folder_name}/*',\n ],\n\n # FIXME: it should be possible to place restrictions using Condition,\n # but I haven't been able to get this to work.\n #\n # \"Condition\": {\n # \"StringLike\": {\n # \"s3:prefix\": [\n # f'{folder_name}/*'\n # ],\n # \"s3:delimiter\": [\n # '/'\n # ],\n # }\n # }\n },\n ]\n }\n\n # pprint(policy)\n policy = json.dumps(policy)\n credential_lifetime = 900 # 900 seconds is the minimum value\n\n creds = client.get_federation_token(\n Name=credential_name,\n Policy=policy,\n DurationSeconds=credential_lifetime,\n )\n\n # pprint(creds)\n return creds['Credentials']","def bcbio_s3_instance_profile(conn, args):\n import boto\n if hasattr(args, \"nocreate\") and args.nocreate:\n return {\"instance_profile\": \"\"}\n base_name = args.cluster if hasattr(args, \"cluster\") and args.cluster else \"bcbio\"\n name = \"%s_full_s3_access\" % (base_name)\n try:\n ip = conn.get_instance_profile(name)\n except boto.exception.BotoServerError:\n print(\"Instance profile %s doesn't exist, creating\" % name)\n ip = conn.create_instance_profile(name)\n try:\n conn.get_role(name)\n except boto.exception.BotoServerError:\n print(\"Role %s doesn't exist, creating\" % name)\n conn.create_role(name)\n conn.put_role_policy(name, name, S3_POLICY)\n if not tz.get_in([\"get_instance_profile_response\", \"get_instance_profile_result\", \"instance_profile\", \"roles\"],\n ip):\n conn.add_role_to_instance_profile(name, name)\n print(\"Instance profile: %s\" % name)\n return {\"instance_profile\": name}","def get_s3_object(bucket, key_name, local_file):\n\n tracer.put_metadata('object', f's3://{bucket}/{key_name}')\n\n try:\n s3_resource.Bucket(bucket).download_file(key_name, local_file)\n result = 'ok'\n tracer.put_annotation('OBJECT_DOWNLOAD', 'SUCCESS')\n except botocore.exceptions.ClientError as e:\n tracer.put_annotation('OBJECT_DOWNLOAD', 'FAILURE')\n if e.response['Error']['Code'] == '404':\n result = f'Error: s3://{bucket}/{key_name} does not exist'\n else:\n result = f'Error: {str(e)}'\n\n return(result)","def collect_s3(self):\n print('Collecting artifacts matching %s from S3 bucket %s' % (self.match, s3_bucket))\n self.s3 = boto3.resource('s3')\n self.s3_bucket = self.s3.Bucket(s3_bucket)\n self.s3_client = boto3.client('s3')\n for item in self.s3_client.list_objects(Bucket=s3_bucket, Prefix='librdkafka/').get('Contents'):\n self.collect_single(item.get('Key'))\n\n for a in self.artifacts:\n a.download()","def get_current_ami ( s3_infra_conn, region_name, env_type, app_name ) :\n ami_bucket = get_admin_bucket_name( region_name = region_name )\n return retrieve_s3_contents( s3_conn = s3_infra_conn,\n bucket_name = ami_bucket,\n key_name = get_ami_keypath( env_type ) + get_ami_keyname( app_name ) )","def __get_s3_client(self):\n if self.AWS_ACCESS_KEY:\n s3_client = boto3.client(\n \"s3\",\n aws_access_key_id=self.AWS_ACCESS_KEY,\n aws_secret_access_key=self.AWS_SECRET_ACCESS_KEY,\n )\n else:\n s3_client = boto3.client(\"s3\")\n return s3_client","def get_image(event, context):\n try:\n bucket_key = event['pathParameters']['bucket_key']\n except KeyError:\n return _bad_request_error('No bucket key')\n try:\n session_token= event['headers']['s3-session-token']\n access_key_id = event['headers']['s3-access-key-id']\n secret_access_key = event['headers']['s3-access-key']\n except KeyError:\n return _non_authorized_error(\n 'Not enough credentials to authorize')\n try:\n image = SafeImage(\n session_token=session_token,\n access_key_id=access_key_id,\n secret_access_key=secret_access_key).retrieve(bucket_key)\n except ClientError as e:\n # TODO: log here\n print(e)\n return _non_authorized_error(\n 'Invalid credentials')\n return _success_image(image)","def s3(self) -> Optional['outputs.DataRepositoryAssociationS3']:\n return pulumi.get(self, \"s3\")","def _get_buckets():\n\n return __opts__[\"s3.buckets\"] if \"s3.buckets\" in __opts__ else {}","def get_secret(key):\n global s3\n bucket = os.environ.get(\"S3_SECRETS_BUCKET\", \"numerai-api-ml-secrets\")\n print(\"bucket\", bucket)\n obj = s3.Object(bucket, key)\n secret = obj.get()['Body'].read().decode('utf-8')\n return secret","def read_file_from_s3(bucket, key, profile):\n s3_client = boto3.Session(profile_name=profile).client('s3')\n resp = s3_client.get_object(Bucket=bucket, Key=key)\n # Python 3.8/3.9 can't download files over 2GB via HTTP, so file is \n # streamed in chunks just in case\n content = ''.join([\n chunk.decode() for chunk in resp['Body'].iter_chunks()\n ])\n \n return content","def s3_resource(self):\n return boto3.resource('s3', \n aws_access_key_id=os.environ.get(\"MINIO_ACCESS_KEY\"),\n aws_secret_access_key=os.environ.get(\"MINIO_SECRET_KEY\"),\n endpoint_url=f'http://{os.environ.get(\"MINIO_SERVER\")}',\n config=Config(signature_version='s3v4')\n )","def get_config():\n\n # Retrieve config from S3\n config = get_json(BUCKET, CONFIG_S3_KEY)\n\n # If config does not currently exist, create a default one and save to S3\n if not config:\n config = generate_config()\n save_config(config)\n\n return config","def __init__(self, access_key, secret_key, bucket):\n # amazon s3 connection\n self.s3_conn = None\n self.__set_amazon_s3_service__(access_key, secret_key)\n\n # data bucket to be used\n self.bucket = self.s3_conn.get_bucket(bucket)","def test_get_buckets(self):\n conn = boto3.resource('s3', region_name='us-east-1')\n # We need to create the bucket since this is all in Moto's 'virtual' AWS account\n conn.create_bucket(Bucket='foobucket')\n\n s3_connector = S3Connector()\n s3_connector.connect(\"default\")\n self.assertEqual(s3_connector.get_buckets(), [\"foobucket\"])","def get_s3_object(self, remote_s3_url):\n try:\n _file = tempfile.mkstemp()[1]\n parsed_s3_path = remote_s3_url.split(\"/\", 3) # s3://bucket-name/key\n remote_bucket = parsed_s3_path[2] # Bucket name\n remote_key = parsed_s3_path[3] # Key\n self.download_file(remote_bucket, remote_key, _file)\n return _file\n except Exception as e:\n message = {'FILE': __file__.split('/')[-1],\n 'METHOD': inspect.stack()[0][3], 'EXCEPTION': str(e)}\n self.logger.exception(message)\n raise","def sync_swag(owner, bucket_name, bucket_prefix, bucket_region, account_type, spinnaker):\n from security_monkey.account_manager import account_registry\n\n swag_opts = {\n 'swag.type': 's3',\n 'swag.bucket_name': bucket_name,\n 'swag.data_file': bucket_prefix,\n 'swag.region': bucket_region\n }\n\n swag = SWAGManager(**parse_swag_config_options(swag_opts))\n account_manager = account_registry[account_type]()\n\n for account in swag.get_all(\"[?provider=='{provider}']\".format(provider=account_type.lower())):\n active = False\n for s in account['services']:\n if s['name'] == 'security_monkey':\n for status in s['status']:\n if status['region'] == 'all':\n active = status['enabled']\n\n thirdparty = True\n if account['owner'] == owner:\n thirdparty = False\n\n if spinnaker:\n spinnaker_name = swag.get_service_name('spinnaker', \"[?id=='{id}']\".format(id=account['id']))\n if not spinnaker_name:\n name = account['name']\n else:\n name = spinnaker_name\n else:\n name = account['name']\n\n notes = account['description']\n identifier = account['id']\n\n custom_fields = {}\n s3_name = swag.get_service_name('s3', \"[?id=='{id}']\".format(id=account['id']))\n if s3_name:\n custom_fields['s3_name'] = s3_name\n\n for service in account['services']:\n if service['name'] == 's3':\n c_id = service['metadata'].get('canonicalId')\n if c_id:\n custom_fields['canonical_id'] = c_id\n\n account_manager.sync(account_manager.account_type, name, active, thirdparty,\n notes, identifier,\n custom_fields=custom_fields)\n db.session.close()\n app.logger.info('SWAG sync successful.')"],"string":"[\n \"def _get_usofa_data(bucketname):\\n client = boto3.client('s3')\\n result = client.get_object(Bucket=bucketname, Key='accounts.json')\\n return json.loads(result['Body'].read().decode('utf-8'))\",\n \"def s3_read_data(self):\\n\\n self.k.open()\\n self.k.read()\",\n \"def __retrieve_from_bucket(fname):\\n blob = BUCKET.blob(fname)\\n json_data = json.loads(blob.download_as_string())\\n return json_data\",\n \"def _aws_get_object(bucket, key, request_pays=True, client=None):\\n if not client:\\n session = boto3_session(region_name=REGION)\\n client = session.client(\\\"s3\\\")\\n\\n params = {\\\"Bucket\\\": bucket, \\\"Key\\\": key}\\n if request_pays:\\n params[\\\"RequestPayer\\\"] = \\\"requester\\\"\\n response = client.get_object(**params)\\n return response[\\\"Body\\\"].read()\",\n \"def get_s3_object(self, key):\\n try:\\n bucket_name = app.config['S3_BUCKET_NAME']\\n s3_client = app.config['S3']\\n response = s3_client.get_object(Bucket=bucket_name, Key=key)\\n return response['Body'].read()\\n except Exception:\\n return None\",\n \"def get(self, key):\\n return s3.Object(self.bucket.name, key).get()['Body'].read()\",\n \"def get_from_s3(s3_client, s3_url):\\n url = urlparse(s3_url)\\n\\n # Split the bucket from the key\\n bucket_name = urllib2.unquote(url.netloc).decode('utf8')\\n key_name = urllib2.unquote(url.path[1:]).decode('utf8')\\n\\n # We're done parsing; start doing some S3 ops\\n bucket = s3_client.get_bucket(bucket_name, validate=False)\\n key = bucket.get_key(key_name)\\n return key.get_contents_as_string()\",\n \"def retrieve_s3_contents ( s3_conn, bucket_name, key_name, stored_filename = None ) :\\n bucket = s3_conn.get_bucket( bucket_name )\\n key = boto.s3.key.Key( bucket )\\n key.key = key_name\\n if key.exists( ) :\\n if stored_filename :\\n key.get_contents_to_filename( stored_filename )\\n return stored_filename\\n\\n return key.get_contents_as_string( )\\n\\n return None\",\n \"def get_amazon_adj_cls_from_s3(s3_resource, bucket_name, prefix='') -> dict:\\n amzn_filename = \\\"AMZN.json\\\"\\n complete_path = os.path.join(prefix, amzn_filename)\\n json_object = s3_resource.Object(bucket_name, complete_path)\\n file_content = json_object.get()['Body'].read().decode('utf-8')\\n json_content = json.loads(file_content)\\n return json_content\",\n \"def fetch(iid):\\n if AWS_CLIENT_CONFIG and BUCKET_NAME:\\n try:\\n s3 = boto3.resource('s3', **AWS_CLIENT_CONFIG)\\n obj = s3.Bucket(BUCKET_NAME).Object(iid).get()\\n if obj:\\n return obj.get('Body')\\n except botocore.exceptions.ClientError as e:\\n logger.error(e)\\n else:\\n # get locally from temp dir (tests, local development)\\n return get_temp_file(iid)\\n return None\",\n \"def get_object(self, key):\\n r = self.s3client.get_object(Bucket = self.s3_bucket, Key = key)\\n data = r['Body'].read()\\n return data\",\n \"def download_keypair ( s3_infra_conn, aws_account_type, region_name, keypair_type ) :\\n keypair_name = get_keypair_name( aws_account_type, region_name, keypair_type )\\n keypair_bucket = get_admin_bucket_name( region_name = region_name )\\n return retrieve_s3_contents( s3_conn = s3_infra_conn,\\n bucket_name = keypair_bucket,\\n key_name = get_keypair_keypath( aws_account_type ) + get_keypair_keyname( keypair_name ),\\n stored_filename = keypair_name )\",\n \"def fetch_config_from_s3(client):\\n try:\\n response = client.assume_role(\\n RoleArn=\\\"arn:aws:iam::548760365095:role/Ec2StartStopLambdaActionRole\\\",\\n RoleSessionName=\\\"Ec2-Start-Stop-Lambda-Session-Role\\\"\\n )\\n fetcher = boto3.client(\\n 's3',\\n aws_access_key_id=response['Credentials']['AccessKeyId'],\\n aws_secret_access_key=response['Credentials']['SecretAccessKey'],\\n aws_session_token=response['Credentials']['SessionToken']\\n )\\n return json_to_dict(fetcher)\\n except Exception as error:\\n logger.info(\\\"Creating a temporary S3 privileged user failed with the following error : {}\\\".format(error))\",\n \"async def get_or_create_temporary_s3_access(user_id: UserID):\",\n \"def s3(ctx, bucket_name, data_file, region):\\n ctx.obj['BUCKET_NAME'] = bucket_name\\n ctx.obj['DATA_FILE'] = data_file\\n ctx.obj['TYPE'] = 's3'\\n ctx.obj['REGION'] = region\",\n \"def s3_data_conn ( self ) :\\n if not self.s3_data :\\n self.s3_data = boto.s3.connection.S3Connection( self.access_key, self.access_key_secret )\\n return self.s3_data\",\n \"def get_google_adj_cls_from_s3(s3_resource, bucket_name, prefix='') -> dict:\\n googl_filename = \\\"GOOGL.json\\\"\\n complete_path = os.path.join(prefix, googl_filename)\\n json_object = s3_resource.Object(bucket_name, complete_path)\\n file_content = json_object.get()['Body'].read().decode('utf-8')\\n json_content = json.loads(file_content)\\n return json_content\",\n \"def get_s3_access_key(self):\\n return self.__ACCESS_KEY\",\n \"def access_s3():\\n try:\\n s3helper = S3Helper()\\n bucket = s3helper.get_bucket(get_archive_bucket())\\n LOG.info('Access S3 bucket name: {0}'.format(bucket.name))\\n except Exception:\\n LOG.exception('check_database_connection')\\n return False\\n\\n return True\",\n \"def get_s3_keys(bucket, user_keys = None):\\n keys = []\\n if user_keys is None:\\n \\t\\t\\t\\ts3 = boto3.client('s3')\\n else:\\n s3 = boto3.client('s3', \\n aws_access_key_id = user_keys[\\\"AWS_ACCESS_KEY_ID\\\"], \\n aws_secret_access_key = user_keys[\\\"AWS_SECRET_ACCESS_KEY\\\"], \\n region_name = user_keys[\\\"REGION_NAME\\\"]\\n ) \\t \\n \\n resp = s3.list_objects_v2(Bucket= bucket)\\n for obj in resp['Contents']:\\n keys.append(obj['Key'])\\n return keys\",\n \"def get_object(self, bucket_name, key, stream=False, extra_get_args={}):\\n url = self.__key_url(bucket_name, key)\\n res = self.infinispan_client.get(url, headers=self.headers, auth=self.basicAuth)\\n data = res.content\\n return data\",\n \"def get_text(bucket, key):\\n s3 = boto3.resource(\\\"s3\\\")\\n\\n ocr_obj = s3.Object(bucket, key)\\n response = ocr_obj.get()\\n data = response[\\\"Body\\\"].read()\\n\\n return data\",\n \"def get_apple_adj_cls_from_s3(s3_resource, bucket_name, prefix='') -> dict:\\n aapl_filename = \\\"AAPL.json\\\"\\n complete_path = os.path.join(prefix, aapl_filename)\\n json_object = s3_resource.Object(bucket_name, complete_path)\\n file_content = json_object.get()['Body'].read().decode('utf-8')\\n json_content = json.loads(file_content)\\n return json_content\",\n \"def authorizedClientCall(self):\\n\\t\\tclient \\t\\t= boto3.client(\\\"s3\\\")\\n\\t\\treturn(client)\",\n \"def _get_s3_object(self, s3_path):\\n bucket_name, key = S3Util.get_bucket_and_key(s3_path)\\n return self.s3_resource.Object(bucket_name, key)\",\n \"def boto_init_s3(bucket_name):\\n c = boto.connect_s3(aws_access_key_id=settings.AWS_ACCESS_KEY_ID,\\n aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY)\\n b = c.get_bucket(bucket_name)\\n\\n return b\",\n \"def list_public_s3_objects(self):\\n _response = urllib.urlopen(self.options.s3_bucket_url)\\n _html = _response.read()\\n\\n if LOCAL_DEBUG:\\n print _html\\n\\n try:\\n assert \\\"AccessDenied\\\" not in _html\\n assert \\\"NoSuchBucket\\\" not in _html\\n except:\\n print(\\\"ERROR: AccessDenied or NoSuchBucket for {}\\\".format(self.options.s3_bucket_url))\\n raise\",\n \"def get_buckets_for_user(self):\\n s3 = self.credentials.session.resource('s3')\\n bucket_list = [bucket.name for bucket in s3.buckets.all()]\\n\\n return bucket_list;\",\n \"def load_archives_from_s3(self):\\n s3_bucket = S3Backend(self.conf).bucket\\n try:\\n k = Key(s3_bucket)\\n k.key = self.backup_key\\n\\n return json.loads(k.get_contents_as_string())\\n except S3ResponseError, exc:\\n log.error(exc)\\n return {}\",\n \"def get_s3_content(bucket, key, access_id, access_secret):\\n try:\\n response = s3_client(access_id, access_secret).get_object(Bucket=bucket, Key=key)\\n body = response['Body'].read()\\n return body\\n except ClientError as error:\\n LOGGER.error(error)\\n return None\",\n \"def get_file_s3(bucket, key):\\n \\n client = boto3.client('s3')\\n return client.get_object(Bucket=bucket, Key=key)['Body'].read().decode('utf-8')\",\n \"def get(handler, *args, **kwargs):\\n bucket_id = args[0]\\n user_id = args[1]\\n BucketClasss = type(\\\"Bucket_%s\\\" % (bucket_id), (Bucket,), {})\\n bucket = yield BucketClasss.get(user_id)\\n result = {}\\n if bucket:\\n result = bucket.data\\n elif handler.sbs_client:\\n try:\\n result = yield handler.sbs_client.getBucketData(bucket_id, user_id)\\n except Exception, e:\\n logging.info(str(e)) \\n \\n if not bucket: \\n bucket = BucketClasss()\\n bucket.pkey = user_id\\n bucket.data = result\\n yield bucket.put()\\n\\n if not bucket.data:\\n raise Return((404, result))\\n\\n raise Return((200, result))\",\n \"def get(self, bucket: str, object_name: str) -> bytes:\\n raise NotImplementedError()\",\n \"def get_dropbox_policy ( bucket_name, requires_aspera = False ) :\\n if requires_aspera :\\n return \\\"\\\"\\\"{\\n \\\"Version\\\": \\\"2012-10-17\\\",\\n \\\"Statement\\\": [\\n {\\n \\\"Sid\\\": \\\"GrantUploadDownloadPermissionsToBucket\\\",\\n \\\"Effect\\\": \\\"Allow\\\",\\n \\\"Action\\\": [\\n \\\"s3:AbortMultipartUpload\\\",\\n \\\"s3:DeleteObject\\\",\\n \\\"s3:DeleteObjectVersion\\\",\\n \\\"s3:GetBucketAcl\\\",\\n \\\"s3:GetBucketLocation\\\",\\n \\\"s3:GetBucketLogging\\\",\\n \\\"s3:GetBucketNotification\\\",\\n \\\"s3:GetBucketPolicy\\\",\\n \\\"s3:GetBucketRequestPayment\\\",\\n \\\"s3:GetBucketTagging\\\",\\n \\\"s3:GetBucketVersioning\\\",\\n \\\"s3:GetBucketWebsite\\\",\\n \\\"s3:GetLifecycleConfiguration\\\",\\n \\\"s3:GetObject\\\",\\n \\\"s3:GetObjectAcl\\\",\\n \\\"s3:GetObjectTorrent\\\",\\n \\\"s3:GetObjectVersion\\\",\\n \\\"s3:GetObjectVersionAcl\\\",\\n \\\"s3:GetObjectVersionTorrent\\\",\\n \\\"s3:ListAllMyBuckets\\\",\\n \\\"s3:ListBucket\\\",\\n \\\"s3:ListBucketMultipartUploads\\\",\\n \\\"s3:ListBucketVersions\\\",\\n \\\"s3:ListMultipartUploadParts\\\",\\n \\\"s3:PutBucketVersioning\\\",\\n \\\"s3:PutObject\\\"\\n ],\\n \\\"Resource\\\": [\\n \\\"arn:aws:s3:::\\\"\\\"\\\" + bucket_name + \\\"\\\"\\\"\\\",\\n \\\"arn:aws:s3:::\\\"\\\"\\\" + bucket_name + \\\"\\\"\\\"/*\\\"\\n ]\\n },\\n {\\n \\\"Sid\\\": \\\"AllowAsperaRootLevelListingOfTheBucket\\\",\\n \\\"Action\\\": [\\\"s3:ListBucket\\\"],\\n \\\"Effect\\\": \\\"Allow\\\",\\n \\\"Resource\\\": [\\n \\\"arn:aws:s3:::\\\"\\\"\\\" + bucket_name + \\\"\\\"\\\"\\\"\\n ],\\n \\\"Condition\\\":{\\n \\\"StringEquals\\\":{\\n \\\"s3:prefix\\\":[\\\"\\\"], \\\"s3:delimiter\\\":[\\\"/\\\"]\\n }\\n }\\n },\\n {\\n \\\"Sid\\\" : \\\"AllowGroupToSeeBucketListInAsperaConsole\\\",\\n \\\"Action\\\" : [\\n \\\"s3:ListAllMyBuckets\\\",\\n \\\"s3:GetBucketLocation\\\"\\n ],\\n \\\"Effect\\\" : \\\"Allow\\\",\\n \\\"Resource\\\" : [ \\\"arn:aws:s3:::\\\" ]\\n }\\n ]\\n}\\\"\\\"\\\"\\n\\n else :\\n return \\\"\\\"\\\"{\\n \\\"Version\\\": \\\"2012-10-17\\\",\\n \\\"Statement\\\": [\\n {\\n \\\"Sid\\\": \\\"GrantUploadDownloadPermissionsToBucket\\\",\\n \\\"Effect\\\": \\\"Allow\\\",\\n \\\"Action\\\": [\\n \\\"s3:AbortMultipartUpload\\\",\\n \\\"s3:DeleteObject\\\",\\n \\\"s3:DeleteObjectVersion\\\",\\n \\\"s3:GetBucketAcl\\\",\\n \\\"s3:GetBucketLocation\\\",\\n \\\"s3:GetBucketLogging\\\",\\n \\\"s3:GetBucketNotification\\\",\\n \\\"s3:GetBucketPolicy\\\",\\n \\\"s3:GetBucketRequestPayment\\\",\\n \\\"s3:GetBucketTagging\\\",\\n \\\"s3:GetBucketVersioning\\\",\\n \\\"s3:GetBucketWebsite\\\",\\n \\\"s3:GetLifecycleConfiguration\\\",\\n \\\"s3:GetObject\\\",\\n \\\"s3:GetObjectAcl\\\",\\n \\\"s3:GetObjectTorrent\\\",\\n \\\"s3:GetObjectVersion\\\",\\n \\\"s3:GetObjectVersionAcl\\\",\\n \\\"s3:GetObjectVersionTorrent\\\",\\n \\\"s3:ListAllMyBuckets\\\",\\n \\\"s3:ListBucket\\\",\\n \\\"s3:ListBucketMultipartUploads\\\",\\n \\\"s3:ListBucketVersions\\\",\\n \\\"s3:ListMultipartUploadParts\\\",\\n \\\"s3:PutBucketVersioning\\\",\\n \\\"s3:PutObject\\\"\\n ],\\n \\\"Resource\\\": [\\n \\\"arn:aws:s3:::\\\"\\\"\\\" + bucket_name + \\\"\\\"\\\"\\\",\\n \\\"arn:aws:s3:::\\\"\\\"\\\" + bucket_name + \\\"\\\"\\\"/*\\\"\\n ]\\n }\\n ]\\n}\\\"\\\"\\\"\",\n \"def read_bucket_objects(bucket_name):\\n s3 = boto3.resource('s3')\\n bucket = s3.Bucket(bucket_name)\\n for obj in bucket.objects.all():\\n response = obj.get()\\n body = response['Body'].read().decode('utf-8')\\n print(body)\",\n \"def get_object(Bucket=None, IfMatch=None, IfModifiedSince=None, IfNoneMatch=None, IfUnmodifiedSince=None, Key=None, Range=None, ResponseCacheControl=None, ResponseContentDisposition=None, ResponseContentEncoding=None, ResponseContentLanguage=None, ResponseContentType=None, ResponseExpires=None, VersionId=None, SSECustomerAlgorithm=None, SSECustomerKey=None, SSECustomerKeyMD5=None, RequestPayer=None, PartNumber=None):\\n pass\",\n \"def test_s3():\\n vc = vtec.parse(EX1)\\n assert vc[0].s3() == \\\"TO.W.130\\\"\",\n \"def read_key_s3(self, keyUrl='', bucket=None):\\n \\n if bucket is None:\\n bucket = self.AWS_S3_BUCKET\\n\\n try:\\n\\n fileobj = self.get_s3_client().get_object(\\n Bucket= bucket,\\n Key= keyUrl\\n )\\n readKey = fileobj['Body'].read()\\n # contentObj = readKey.decode('utf-8')\\n\\n return readKey\\n\\n except:\\n time.sleep(1)\\n pass\",\n \"async def getStorObjStats(app, key, bucket=None):\\n # TBD - will need to be refactored to handle azure responses\\n\\n client = _getStorageClient(app)\\n if not bucket:\\n bucket = app['bucket_name']\\n stats = {}\\n\\n if key[0] == '/':\\n #key = key[1:] # no leading slash\\n msg = f\\\"key with leading slash: {key}\\\"\\n log.error(msg)\\n raise KeyError(msg)\\n\\n log.info(f\\\"getStorObjStats({key})\\\")\\n\\n resp = await client.list_keys(bucket=bucket, limit=1, prefix=key)\\n\\n if 'Contents' not in resp:\\n msg = f\\\"key: {key} not found\\\"\\n log.info(msg)\\n raise HTTPInternalServerError()\\n contents = resp['Contents']\\n log.debug(f\\\"storage_contents: {contents}\\\")\\n\\n found = False\\n if len(contents) > 0:\\n item = contents[0]\\n if item[\\\"Key\\\"] == key:\\n # if the key is a S3 folder, the key will be the first object in the folder,\\n # not the requested object\\n found = True\\n if item[\\\"ETag\\\"]:\\n etag = item[\\\"ETag\\\"]\\n if len(etag) > 2 and etag[0] == '\\\"' and etag[-1] == '\\\"':\\n # S3 returning extra quotes around etag?\\n etag = etag[1:-1]\\n stats[\\\"ETag\\\"] = etag\\n else:\\n if \\\"Owner\\\" in item and \\\"ID\\\" in item[\\\"Owner\\\"] and item[\\\"Owner\\\"][\\\"ID\\\"] == \\\"minio\\\":\\n pass # minio is not creating ETags...\\n else:\\n log.warn(f\\\"No ETag for key: {key}\\\")\\n # If no ETAG put in a fake one\\n stats[\\\"ETag\\\"] = \\\"9999\\\"\\n stats[\\\"Size\\\"] = item[\\\"Size\\\"]\\n stats[\\\"LastModified\\\"] = int(item[\\\"LastModified\\\"].timestamp())\\n if not found:\\n msg = f\\\"key: {key} not found\\\"\\n log.info(msg)\\n raise HTTPNotFound()\\n\\n return stats\",\n \"def s3resource(self):\\n return self._s3resource\",\n \"def list_s3_resources(memberAccountId=None, nextToken=None, maxResults=None):\\n pass\",\n \"def _s3_get_file(url):\\n try:\\n return S3().get_contents_from_url(url)\\n except Exception as e:\\n raise ScrBaseException(\\\"Could not load file from {0}: {1}\\\".format(url, e))\",\n \"def s3_download(path):\\n with s3_read(path):\\n # Reading the file will cache the file locally.\\n pass\",\n \"def list_buckets():\\n for bucket in s3.buckets.all():\\n print(bucket)\",\n \"def lambda_handler(event, context):\\n qpmBucket = event['queryStringParameters']['bucket']\\n fn_bucket = list_s3_objects(qpmBucket)\\n print(fn_bucket)\\n \\n \\n return {\\n \\\"statusCode\\\": 200,\\n \\\"body\\\": json.dumps(str(fn_bucket)),\\n }\",\n \"def s3_get(url, temp_file):\\n s3_resource = boto3.resource(\\\"s3\\\")\\n bucket_name, s3_path = split_s3_path(url)\\n s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file)\",\n \"def s3_get(url, temp_file):\\n s3_resource = boto3.resource(\\\"s3\\\")\\n bucket_name, s3_path = split_s3_path(url)\\n s3_resource.Bucket(bucket_name).download_fileobj(s3_path, temp_file)\",\n \"def get_s3_file(self, no_copy=False):\\n return self.get_file(uri_type=URI_S3, no_copy=no_copy)\",\n \"def get_s3_client(profile_name):\\n try:\\n session = boto3.session.Session(profile_name=profile_name)\\n except ProfileNotFound as e:\\n print(e, file=sys.stderr)\\n raise FailureException from e\\n return session.resource('s3')\",\n \"def _read_s3_url(cls, s3_url):\\n\\n parsed_url = urllib.parse.urlparse(s3_url)\\n return cls.s3.get_object(Bucket=parsed_url.netloc,\\n Key=parsed_url.path.lstrip(\\\"/\\\"))[\\\"Body\\\"].read()\",\n \"def get_transcribe_output(key):\\n s3 = boto3.client('s3')\\n\\n obj = s3.get_object(Bucket=os.getenv(\\\"S3_BUCKET\\\"), Key=key)\\n\\n return json.loads(obj[\\\"Body\\\"].read())\",\n \"def get_boto3(args=None, logger=None, stats=None):\\n return Boto3(**__get_arguments(args, logger, stats))\",\n \"def get_s3_client():\\n return boto3.resource('s3')\",\n \"def get_s3_bucket(env):\\n s3 = boto3.resource('s3')\\n bucket_name = 'govuk-%s-fastly-logs' % env\\n logging.info('S3 bucket name: %s', bucket_name)\\n return s3.Bucket(bucket_name)\",\n \"def get_manifest_data(bucket,team, dataset,manifest_key):\\n dynamo_config = DynamoConfiguration()\\n dynamo_interface = DynamoInterface(dynamo_config)\\n s3_interface = S3Interface()\\n local_path = s3_interface.download_object(bucket, manifest_key)\\n ddb_keys=[]\\n items=[]\\n with open(local_path, \\\"r\\\") as raw_file:\\n file_names = [file_name.strip().split(\\\"/\\\")[-1]\\n for file_name in raw_file]\\n for file in file_names:\\n ddb_keys.append({\\n \\\"dataset_name\\\": team+\\\"-\\\"+dataset,\\n \\\"manifest_file_name\\\": manifest_key.split(\\\"/\\\")[-1], \\\"datafile_name\\\": file\\n })\\n for ddb_key in ddb_keys:\\n try:\\n items.append(dynamo_interface.get_item_from_manifests_control_table(\\n ddb_key[\\\"dataset_name\\\"], ddb_key[\\\"manifest_file_name\\\"], ddb_key[\\\"datafile_name\\\"]))\\n except KeyError:\\n logger.error(\\\"The manifest file has not been processed in Stage A\\\")\\n raise Exception(\\\"Manifest File has not been processed in Stage A\\\")\\n\\n return items\",\n \"def get_bytes(bucket: str, key: str) -> bytes:\\n logger.debug(f'Reading from s3://{bucket}/{key}')\\n response = client().get_object(Bucket=bucket, Key=key)\\n return response['Body'].read()\",\n \"def load_file_aws(file_path, aws_credentials):\\n bucket_engine = S3Bucket(*aws_credentials)\\n return json.loads(\\n gzip.decompress(\\n bucket_engine.read(file_path)\\n ).decode('utf-8')\\n )\",\n \"def read_s3_file(date):\\n \\\"\\\"\\\" history from S3 \\\"\\\"\\\"\\n bucket = os.getenv(\\\"SPOTIFY_BUCKET_NAME\\\")\\n path = os.getenv(\\\"SPOTIFY_BUCKET_PATH\\\")\\n s3 = boto3.resource('s3')\\n try:\\n s3.Object(bucket, \\\"%s/%s.json\\\" % (path, date)).load()\\n except botocore.exceptions.ClientError as e:\\n logger.info(\\\"No existing history file found for %s, %s\\\" %\\n (date, e.response['Error']['Code']))\\n if e.response['Error']['Code'] == '404':\\n return []\\n else:\\n logger.warning(\\\"Unexpected error code returned!\\\")\\n return []\\n else:\\n logger.info(\\\"Reading history file for %s\\\" % date)\\n content_object = s3.Object(bucket, \\\"%s/%s.json\\\" % (path, date))\\n file_content = content_object.get()['Body'].read().decode('utf-8')\\n json_content = json.loads(file_content)\\n return json_content\",\n \"def _do_retrieve(bucket_name, key_path, number_retries=DEFAULT_S3_RETRIES):\\n try:\\n return conn.get_object(Bucket=bucket_name, Key=key_path, ResponseContentType='string')\\n except Exception:\\n if number_retries > 0:\\n print(\\\"s3_retrieve failed with incomplete read, retrying on %s\\\" % key_path)\\n return _do_retrieve(bucket_name, key_path, number_retries=number_retries - 1)\\n raise\",\n \"def aws():\\n pass\",\n \"def openBucket(name):\\n conn = boto.connect_s3() \\n print \\\"Connecting to bucket: {}\\\".format(name)\\n bucket = conn.get_bucket(name, validate=True)\\n return bucket\",\n \"def get_matching_s3_keys(bucket, prefix=\\\"\\\", suffix=\\\"\\\"):\\n for obj in get_matching_s3_objects(bucket, prefix, suffix):\\n yield obj[\\\"Key\\\"]\\n\\n def download_froms3(myfile, env='prod'):\\n # session = boto3.Session(profile_name=PROFILE)\\n boto_s3_session = boto3.Session(profile_name=env)\\n s3 = boto_s3_session.resource('s3')\\n s3client = boto_s3_session.client('s3', region_name='eu-west-2')\\n try:\\n file_name = unquote(myfile.split('/')[-1])\\n oparse = urlparse(myfile, allow_fragments=False)\\n print(oparse)\\n S3_SRC_BUCKET_NAME = oparse.netloc\\n key = oparse.path[1:]\\n download_path = '{0}{1}'.format(BASE_PATH, file_name)\\n print(f'Downloading from {S3_SRC_BUCKET_NAME} , {key} to {download_path} ')\\n # s3.Bucket(S3_SRC_BUCKET_NAME).download_file(key, download_path)\\n # s3.Bucket(S3_SRC_BUCKET_NAME).download_file(file_name, download_path)\\n s3client.download_file(S3_SRC_BUCKET_NAME, key, download_path)\\n print('File Downloaded')\\n except botocore.exceptions.ClientError as err:\\n if err.response['Error']['Code'] == \\\"404\\\":\\n print(\\\"The object does not exist.\\\", err)\\n else:\\n # raise\\n error = str(err)\\n print(error)\\n\\n return myfile\",\n \"def make_s3(sitename):\\n return s3.S3(sitename)\",\n \"def bucket_info(request):\\n\\n session_check = _check_session_valid(request)\\n\\n if session_check:\\n return session_check\\n\\n return JsonResponse(request.session[\\\"analytics\\\"].bucket_info())\",\n \"def list_s3_content(bucket, access_id, access_secret, prefix=\\\"\\\"):\\n try:\\n response = s3_client(access_id, access_secret).list_objects(Bucket=bucket, Prefix=prefix)\\n objects = []\\n if response.get(\\\"Contents\\\"):\\n for key in response['Contents']:\\n objects.append(key['Key'])\\n return objects\\n except ClientError as error:\\n LOGGER.error(error)\\n return None\",\n \"def template():\\n\\n return s3_rest_controller(rheader = s3db.dc_rheader)\",\n \"def load_from_s3(filename):\\n s3 = boto3.client('s3')\\n obj = s3.get_object(Bucket=BUCKET_NAME, Key=S3_PATH.format(filename))\\n return obj['Body'].read().decode()\",\n \"def read_data_from_s3(self, name, loc):\\n try:\\n filename = loc + name + \\\".json\\\"\\n logger.info('Retrieving the data from the S3 file %s' % filename)\\n return self._retrieve_dict(filename)\\n except Exception as e:\\n logger.error(e)\\n return False\",\n \"def ls(region_name=DEFAULT_REGION):\\n s3conn = s3.connect_to_region(region_name)\\n buckets = s3conn.get_all_buckets()\\n for bucket in buckets:\\n print(bucket.name)\",\n \"def get_s3_object_text(s3_resource: boto3.session.Session.resource, bucket_name: str, key: str) -> str:\\n obj = s3_resource.Object(bucket_name, key)\\n return obj.get()['Body'].read().decode('utf-8')\",\n \"def s3_get(url, temp_file, proxies=None):\\n\\ts3_resource = boto3.resource (\\\"s3\\\", config=Config (proxies=proxies))\\n\\tbucket_name, s3_path = split_s3_path (url)\\n\\ts3_resource.Bucket (bucket_name).download_fileobj (s3_path, temp_file)\",\n \"def get_bucket_cors(Bucket=None):\\n pass\",\n \"def data_pull_s3(self):\\n year = self.month_year[0]\\n month = self.month_year[1]\\n self.s3 = boto3.resource('s3',aws_access_key_id=self.creds_data['key_id'],\\n aws_secret_access_key=self.creds_data['key_access'])\\n bucket = self.s3.Bucket('himatdata')\\n home = os.getcwd()\\n file_path = os.path.join(*[home, 'Trmm/', self.output_folder, year + '_' + month])\\n print(file_path)\\n if not os.path.exists(file_path):\\n os.makedirs(file_path)\\n for obj in bucket.objects.filter(Delimiter='', Prefix='Trmm/{}{}_{}'.format(self.output_folder, year, month)):\\n if obj.key.endswith('.nc4'):\\n bucket.download_file(obj.key,os.path.join(os.path.join(home, obj.key)))\\n logging.info(\\\"Done with Year Month: %s\\\", month_year)\",\n \"async def get_user_account(self):\\n uri = \\\"/v3/spot/assets\\\"\\n success, error = await self.request(\\\"GET\\\", uri, auth=True)\\n return success, error\",\n \"def setup_s3_client(job_data):\\n key_id = job_data['artifactCredentials']['accessKeyId']\\n key_secret = job_data['artifactCredentials']['secretAccessKey']\\n session_token = job_data['artifactCredentials']['sessionToken']\\n\\n session = Session(aws_access_key_id=key_id,\\n aws_secret_access_key=key_secret,\\n aws_session_token=session_token)\\n return session.client('s3', config=botocore.client.Config(signature_version='s3v4'))\",\n \"def test_s3_gets_object_content(self):\\n mock_s3 = Mock()\\n mock_s3_object = Mock()\\n s3_response = {'Body': mock_s3_object}\\n mock_s3_object.read.return_value = \\\"file content\\\"\\n mock_s3.get_object.return_value = s3_response\\n\\n s3_bucket = S3Bucket('bucket_name', s3_client=mock_s3)\\n assert s3_bucket.get_content('/file.text') == \\\\\\n 'file content'\",\n \"def _retrieve_blob(self, object_key):\\n return self.s3_resource.Object(self.CVE_BUCKET, object_key).get()['Body'].read()\",\n \"def get_image(filename):\\n\\n client.download_file(S3_BUCKET, filename, 'uploads/{}'.format(filename))\",\n \"def s3(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"s3\\\")\",\n \"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\",\n \"def question():\\n\\n return s3_rest_controller()\",\n \"def create_boto_session(account):\\n aws_access_key_id = account['aws_access_key_id']\\n aws_secret_access_key = account['aws_secret_access_key']\\n region = account['region']\\n #aws_profile = account['aws_profile']\\n\\n\\n session = boto3.Session(\\n aws_access_key_id=aws_access_key_id,\\n aws_secret_access_key=aws_secret_access_key,\\n region_name=region,\\n #profile_name=aws_profile,\\n )\\n\\n return session\",\n \"def ListFiles(s3):\\n response = s3.list_objects(Bucket='mynewbucket123')\\n for content in response.get('Contents', []):\\n yield content.get('Key')\",\n \"async def getStorJSONObj(app, key, bucket=None):\\n\\n client = _getStorageClient(app)\\n if not bucket:\\n bucket = app['bucket_name']\\n if key[0] == '/':\\n key = key[1:] # no leading slash\\n log.info(f\\\"getStorJSONObj({bucket})/{key}\\\")\\n\\n data = await client.get_object(key, bucket=bucket)\\n\\n try:\\n json_dict = json.loads(data.decode('utf8'))\\n except UnicodeDecodeError:\\n log.error(f\\\"Error loading JSON at key: {key}\\\")\\n raise HTTPInternalServerError()\\n\\n log.debug(f\\\"storage key {key} returned: {json_dict}\\\")\\n return json_dict\",\n \"def get_creds(bucket_name, folder_name):\\n client = boto3.client('sts')\\n # pprint(client.get_caller_identity())\\n\\n # A name of our choice (no spaces allowed)\\n credential_name = f'AccessTimeline-{folder_name}'\\n policy = {\\n \\\"Version\\\": \\\"2012-10-17\\\",\\n \\\"Statement\\\": [\\n {\\n # A name of our choice [0-9a-zA-Z]\\n \\\"Sid\\\": f'ListBucket{folder_name}',\\n \\\"Action\\\": [\\n \\\"s3:ListBucket\\\",\\n ],\\n \\\"Effect\\\": \\\"Allow\\\",\\n \\\"Resource\\\": [\\n f'arn:aws:s3:::{bucket_name}',\\n ],\\n \\\"Condition\\\": {\\n \\\"StringEquals\\\": {\\n \\\"s3:prefix\\\": [\\n f'{folder_name}/'\\n ],\\n \\\"s3:delimiter\\\": [\\n '/'\\n ],\\n }\\n }\\n\\n },\\n {\\n \\\"Sid\\\": f'GetObject{folder_name}',\\n \\\"Action\\\": [\\n \\\"s3:GetObject\\\",\\n ],\\n \\\"Effect\\\": \\\"Allow\\\",\\n \\\"Resource\\\": [\\n f'arn:aws:s3:::{bucket_name}/{folder_name}/*',\\n ],\\n\\n # FIXME: it should be possible to place restrictions using Condition,\\n # but I haven't been able to get this to work.\\n #\\n # \\\"Condition\\\": {\\n # \\\"StringLike\\\": {\\n # \\\"s3:prefix\\\": [\\n # f'{folder_name}/*'\\n # ],\\n # \\\"s3:delimiter\\\": [\\n # '/'\\n # ],\\n # }\\n # }\\n },\\n ]\\n }\\n\\n # pprint(policy)\\n policy = json.dumps(policy)\\n credential_lifetime = 900 # 900 seconds is the minimum value\\n\\n creds = client.get_federation_token(\\n Name=credential_name,\\n Policy=policy,\\n DurationSeconds=credential_lifetime,\\n )\\n\\n # pprint(creds)\\n return creds['Credentials']\",\n \"def bcbio_s3_instance_profile(conn, args):\\n import boto\\n if hasattr(args, \\\"nocreate\\\") and args.nocreate:\\n return {\\\"instance_profile\\\": \\\"\\\"}\\n base_name = args.cluster if hasattr(args, \\\"cluster\\\") and args.cluster else \\\"bcbio\\\"\\n name = \\\"%s_full_s3_access\\\" % (base_name)\\n try:\\n ip = conn.get_instance_profile(name)\\n except boto.exception.BotoServerError:\\n print(\\\"Instance profile %s doesn't exist, creating\\\" % name)\\n ip = conn.create_instance_profile(name)\\n try:\\n conn.get_role(name)\\n except boto.exception.BotoServerError:\\n print(\\\"Role %s doesn't exist, creating\\\" % name)\\n conn.create_role(name)\\n conn.put_role_policy(name, name, S3_POLICY)\\n if not tz.get_in([\\\"get_instance_profile_response\\\", \\\"get_instance_profile_result\\\", \\\"instance_profile\\\", \\\"roles\\\"],\\n ip):\\n conn.add_role_to_instance_profile(name, name)\\n print(\\\"Instance profile: %s\\\" % name)\\n return {\\\"instance_profile\\\": name}\",\n \"def get_s3_object(bucket, key_name, local_file):\\n\\n tracer.put_metadata('object', f's3://{bucket}/{key_name}')\\n\\n try:\\n s3_resource.Bucket(bucket).download_file(key_name, local_file)\\n result = 'ok'\\n tracer.put_annotation('OBJECT_DOWNLOAD', 'SUCCESS')\\n except botocore.exceptions.ClientError as e:\\n tracer.put_annotation('OBJECT_DOWNLOAD', 'FAILURE')\\n if e.response['Error']['Code'] == '404':\\n result = f'Error: s3://{bucket}/{key_name} does not exist'\\n else:\\n result = f'Error: {str(e)}'\\n\\n return(result)\",\n \"def collect_s3(self):\\n print('Collecting artifacts matching %s from S3 bucket %s' % (self.match, s3_bucket))\\n self.s3 = boto3.resource('s3')\\n self.s3_bucket = self.s3.Bucket(s3_bucket)\\n self.s3_client = boto3.client('s3')\\n for item in self.s3_client.list_objects(Bucket=s3_bucket, Prefix='librdkafka/').get('Contents'):\\n self.collect_single(item.get('Key'))\\n\\n for a in self.artifacts:\\n a.download()\",\n \"def get_current_ami ( s3_infra_conn, region_name, env_type, app_name ) :\\n ami_bucket = get_admin_bucket_name( region_name = region_name )\\n return retrieve_s3_contents( s3_conn = s3_infra_conn,\\n bucket_name = ami_bucket,\\n key_name = get_ami_keypath( env_type ) + get_ami_keyname( app_name ) )\",\n \"def __get_s3_client(self):\\n if self.AWS_ACCESS_KEY:\\n s3_client = boto3.client(\\n \\\"s3\\\",\\n aws_access_key_id=self.AWS_ACCESS_KEY,\\n aws_secret_access_key=self.AWS_SECRET_ACCESS_KEY,\\n )\\n else:\\n s3_client = boto3.client(\\\"s3\\\")\\n return s3_client\",\n \"def get_image(event, context):\\n try:\\n bucket_key = event['pathParameters']['bucket_key']\\n except KeyError:\\n return _bad_request_error('No bucket key')\\n try:\\n session_token= event['headers']['s3-session-token']\\n access_key_id = event['headers']['s3-access-key-id']\\n secret_access_key = event['headers']['s3-access-key']\\n except KeyError:\\n return _non_authorized_error(\\n 'Not enough credentials to authorize')\\n try:\\n image = SafeImage(\\n session_token=session_token,\\n access_key_id=access_key_id,\\n secret_access_key=secret_access_key).retrieve(bucket_key)\\n except ClientError as e:\\n # TODO: log here\\n print(e)\\n return _non_authorized_error(\\n 'Invalid credentials')\\n return _success_image(image)\",\n \"def s3(self) -> Optional['outputs.DataRepositoryAssociationS3']:\\n return pulumi.get(self, \\\"s3\\\")\",\n \"def _get_buckets():\\n\\n return __opts__[\\\"s3.buckets\\\"] if \\\"s3.buckets\\\" in __opts__ else {}\",\n \"def get_secret(key):\\n global s3\\n bucket = os.environ.get(\\\"S3_SECRETS_BUCKET\\\", \\\"numerai-api-ml-secrets\\\")\\n print(\\\"bucket\\\", bucket)\\n obj = s3.Object(bucket, key)\\n secret = obj.get()['Body'].read().decode('utf-8')\\n return secret\",\n \"def read_file_from_s3(bucket, key, profile):\\n s3_client = boto3.Session(profile_name=profile).client('s3')\\n resp = s3_client.get_object(Bucket=bucket, Key=key)\\n # Python 3.8/3.9 can't download files over 2GB via HTTP, so file is \\n # streamed in chunks just in case\\n content = ''.join([\\n chunk.decode() for chunk in resp['Body'].iter_chunks()\\n ])\\n \\n return content\",\n \"def s3_resource(self):\\n return boto3.resource('s3', \\n aws_access_key_id=os.environ.get(\\\"MINIO_ACCESS_KEY\\\"),\\n aws_secret_access_key=os.environ.get(\\\"MINIO_SECRET_KEY\\\"),\\n endpoint_url=f'http://{os.environ.get(\\\"MINIO_SERVER\\\")}',\\n config=Config(signature_version='s3v4')\\n )\",\n \"def get_config():\\n\\n # Retrieve config from S3\\n config = get_json(BUCKET, CONFIG_S3_KEY)\\n\\n # If config does not currently exist, create a default one and save to S3\\n if not config:\\n config = generate_config()\\n save_config(config)\\n\\n return config\",\n \"def __init__(self, access_key, secret_key, bucket):\\n # amazon s3 connection\\n self.s3_conn = None\\n self.__set_amazon_s3_service__(access_key, secret_key)\\n\\n # data bucket to be used\\n self.bucket = self.s3_conn.get_bucket(bucket)\",\n \"def test_get_buckets(self):\\n conn = boto3.resource('s3', region_name='us-east-1')\\n # We need to create the bucket since this is all in Moto's 'virtual' AWS account\\n conn.create_bucket(Bucket='foobucket')\\n\\n s3_connector = S3Connector()\\n s3_connector.connect(\\\"default\\\")\\n self.assertEqual(s3_connector.get_buckets(), [\\\"foobucket\\\"])\",\n \"def get_s3_object(self, remote_s3_url):\\n try:\\n _file = tempfile.mkstemp()[1]\\n parsed_s3_path = remote_s3_url.split(\\\"/\\\", 3) # s3://bucket-name/key\\n remote_bucket = parsed_s3_path[2] # Bucket name\\n remote_key = parsed_s3_path[3] # Key\\n self.download_file(remote_bucket, remote_key, _file)\\n return _file\\n except Exception as e:\\n message = {'FILE': __file__.split('/')[-1],\\n 'METHOD': inspect.stack()[0][3], 'EXCEPTION': str(e)}\\n self.logger.exception(message)\\n raise\",\n \"def sync_swag(owner, bucket_name, bucket_prefix, bucket_region, account_type, spinnaker):\\n from security_monkey.account_manager import account_registry\\n\\n swag_opts = {\\n 'swag.type': 's3',\\n 'swag.bucket_name': bucket_name,\\n 'swag.data_file': bucket_prefix,\\n 'swag.region': bucket_region\\n }\\n\\n swag = SWAGManager(**parse_swag_config_options(swag_opts))\\n account_manager = account_registry[account_type]()\\n\\n for account in swag.get_all(\\\"[?provider=='{provider}']\\\".format(provider=account_type.lower())):\\n active = False\\n for s in account['services']:\\n if s['name'] == 'security_monkey':\\n for status in s['status']:\\n if status['region'] == 'all':\\n active = status['enabled']\\n\\n thirdparty = True\\n if account['owner'] == owner:\\n thirdparty = False\\n\\n if spinnaker:\\n spinnaker_name = swag.get_service_name('spinnaker', \\\"[?id=='{id}']\\\".format(id=account['id']))\\n if not spinnaker_name:\\n name = account['name']\\n else:\\n name = spinnaker_name\\n else:\\n name = account['name']\\n\\n notes = account['description']\\n identifier = account['id']\\n\\n custom_fields = {}\\n s3_name = swag.get_service_name('s3', \\\"[?id=='{id}']\\\".format(id=account['id']))\\n if s3_name:\\n custom_fields['s3_name'] = s3_name\\n\\n for service in account['services']:\\n if service['name'] == 's3':\\n c_id = service['metadata'].get('canonicalId')\\n if c_id:\\n custom_fields['canonical_id'] = c_id\\n\\n account_manager.sync(account_manager.account_type, name, active, thirdparty,\\n notes, identifier,\\n custom_fields=custom_fields)\\n db.session.close()\\n app.logger.info('SWAG sync successful.')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.678359","0.67407","0.65665984","0.64687663","0.62724787","0.6271271","0.61905503","0.6168407","0.6160477","0.6136951","0.613336","0.6129173","0.61195844","0.61035234","0.6100174","0.60862297","0.6084497","0.60571164","0.6030108","0.5998103","0.59974277","0.5973756","0.5967869","0.5963451","0.59628487","0.5962059","0.59349227","0.5923681","0.59176546","0.59115696","0.5909429","0.58833116","0.5876734","0.5867884","0.58667403","0.5861725","0.5845158","0.58342355","0.58291745","0.5826039","0.5819409","0.581777","0.58077973","0.57972634","0.57946366","0.57800704","0.57800704","0.5763222","0.57504","0.5747777","0.5738144","0.57350296","0.57233524","0.57132035","0.57090783","0.5648269","0.5644292","0.5641707","0.5640212","0.56078625","0.56052864","0.5597094","0.559512","0.5593971","0.55890226","0.5587547","0.5582628","0.55761045","0.55724883","0.5568405","0.5567078","0.55635285","0.55562335","0.5552502","0.5551192","0.5547793","0.554247","0.5535262","0.5531208","0.5524192","0.55186975","0.55060667","0.55044574","0.55024683","0.55015147","0.54992205","0.5493692","0.54924774","0.54880923","0.5480864","0.5466682","0.544948","0.54361093","0.5431841","0.5429864","0.54272145","0.5423361","0.54209405","0.54165846","0.54153293","0.5413989"],"string":"[\n \"0.678359\",\n \"0.67407\",\n \"0.65665984\",\n \"0.64687663\",\n \"0.62724787\",\n \"0.6271271\",\n \"0.61905503\",\n \"0.6168407\",\n \"0.6160477\",\n \"0.6136951\",\n \"0.613336\",\n \"0.6129173\",\n \"0.61195844\",\n \"0.61035234\",\n \"0.6100174\",\n \"0.60862297\",\n \"0.6084497\",\n \"0.60571164\",\n \"0.6030108\",\n \"0.5998103\",\n \"0.59974277\",\n \"0.5973756\",\n \"0.5967869\",\n \"0.5963451\",\n \"0.59628487\",\n \"0.5962059\",\n \"0.59349227\",\n \"0.5923681\",\n \"0.59176546\",\n \"0.59115696\",\n \"0.5909429\",\n \"0.58833116\",\n \"0.5876734\",\n \"0.5867884\",\n \"0.58667403\",\n \"0.5861725\",\n \"0.5845158\",\n \"0.58342355\",\n \"0.58291745\",\n \"0.5826039\",\n \"0.5819409\",\n \"0.581777\",\n \"0.58077973\",\n \"0.57972634\",\n \"0.57946366\",\n \"0.57800704\",\n \"0.57800704\",\n \"0.5763222\",\n \"0.57504\",\n \"0.5747777\",\n \"0.5738144\",\n \"0.57350296\",\n \"0.57233524\",\n \"0.57132035\",\n \"0.57090783\",\n \"0.5648269\",\n \"0.5644292\",\n \"0.5641707\",\n \"0.5640212\",\n \"0.56078625\",\n \"0.56052864\",\n \"0.5597094\",\n \"0.559512\",\n \"0.5593971\",\n \"0.55890226\",\n \"0.5587547\",\n \"0.5582628\",\n \"0.55761045\",\n \"0.55724883\",\n \"0.5568405\",\n \"0.5567078\",\n \"0.55635285\",\n \"0.55562335\",\n \"0.5552502\",\n \"0.5551192\",\n \"0.5547793\",\n \"0.554247\",\n \"0.5535262\",\n \"0.5531208\",\n \"0.5524192\",\n \"0.55186975\",\n \"0.55060667\",\n \"0.55044574\",\n \"0.55024683\",\n \"0.55015147\",\n \"0.54992205\",\n \"0.5493692\",\n \"0.54924774\",\n \"0.54880923\",\n \"0.5480864\",\n \"0.5466682\",\n \"0.544948\",\n \"0.54361093\",\n \"0.5431841\",\n \"0.5429864\",\n \"0.54272145\",\n \"0.5423361\",\n \"0.54209405\",\n \"0.54165846\",\n \"0.54153293\",\n \"0.5413989\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88365,"cells":{"query":{"kind":"string","value":"Given a network G, a dict of characteristics chars for node IDs, and dict of node IDs for each node in the network, find the homophily of the network."},"document":{"kind":"string","value":"def homophily(G, chars, IDs):\n num_same_ties = 0\n num_ties = 0\n for n1, n2 in G.edges():\n if IDs[n1] in chars and IDs[n2] in chars:\n if G.has_edge(n1, n2):\n num_ties += 1\n if chars[IDs[n1]] == chars[IDs[n2]]:\n num_same_ties += 1\n return (num_same_ties / num_ties)"},"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 check_Motifs(H, m):\n\t#This function will take each possible subgraphs of gr of size 3, then\n\t#compare them to the mo dict using .subgraph() and is_isomorphic\n\t\n\t#This line simply creates a dictionary with 0 for all values, and the\n\t#motif names as keys\n\n\t##paper source \"Higher-order organization ofcomplex networks\" (2016) Benson et al, Science\n\t## I choose only the unidirection ones : M1, M5, M8, M9, M10\n\n\n\ts = int(m)\n\n\tif (s==3):\n\t\t#motifs = {'M1': nx.DiGraph([(1,2),(2,3),(3,1)]), 'M5': nx.DiGraph([(1,2),(2,3),(1,3)]), 'M8': nx.DiGraph([(2, 1),(2,3)]), 'M9': nx.DiGraph([(2, 1),(3, 2)]), 'M10': nx.DiGraph([(1,2),(3,2)])}\n\t\tmotifs = {'M1': [(1,2),(2,3),(3,1)], 'M5': [(1,2),(2,3),(1,3)], 'M8': [(2, 1),(2,3)], 'M9': [(2, 1),(3, 2)], 'M10': [(1,2),(3,2)],\n\t\t\t\t\t'M2': [(1,2),(2,3),(3,2),(3,1)], 'M3': [(1,2),(2,3),(3,2),(1,3),(3,1)], 'M4': [(1,2),(2,1),(2,3),(3,2),(1,3),(3,1)], 'M6': [(2, 1),(2,3),(1,3),(3,1)], 'M7': [(1,2),(3,2),(1,3),(3,1)],\n\t\t\t\t\t'M11': [(1,2),(2,1),(2,3)], 'M12': [(1,2),(2,1),(3,2)], 'M13': [(1,2),(2,1),(2,3),(3,2)]}\n\n\telif (s==4): ## under development\n\t\tmotifs = {'bifan': [(1,2),(1,3),(4,2),(4,3)]}\n\n\t\t#edgeLists=[[[1,2],[1,3],[1,4]]]\n\t\t#edgeLists.append([[1,2],[1,3],[1,4],[2,3]])\n\t\t#edgeLists.append([[1,2],[1,3],[1,4],[2,3],[3,4]])\n\t\t#edgeLists.append([[1,2],[1,3],[1,4],[2,3],[3,4],[2,4]])\n\telse:\n\t\traise nx.NetworkXNotImplemented('Size of motif must be 3 or 4')\n\n\t#outf = open(f2, 'w')\n\t#print >> outf, 'commitid|motiflabel|count'\n\n\tG = H\n\n\tmcount = dict(zip(motifs.keys(), list(map(int, np.zeros(len(motifs))))))\n\n\t## match the pattern and count the motifs \n\tdict_edges = defaultdict(list); dict_nodes = defaultdict(list)\n\tfor key in motifs :\n\t\n\t\t\tpattern = motifs[key]\n\t\t\n\t\t\tgmoti = nx.DiGraph()\n\t\t\tgmoti.add_edges_from(pattern)\n\n\t\t\tmotif_pattern_obs = subgraph_pattern(G, gmoti, sign_sensitive=False)\n\n\t\t\ts = []\n\t\t\tfor subgraph in motif_pattern_obs :\n\t\t\t\ttup = tuple(subgraph.keys())\n\t\t\t\ts.append(tup)\n\n\t\t\tuniqs = list(set(s))\n\n\t\t\tif len(uniqs) > 0 :\n\t\t\t\tmaplist = map(list, uniqs)\n\n\t\t\t### label the edges as per the motif labels\n\t\t\t\tmcount[str(key)] = len(maplist)\n\n\t\t\t\tfor triplets in maplist :\n\t\t\t\t\tsubgraph = G.subgraph(triplets)\n\t\t\t\t\tedgeLists = [e for e in subgraph.edges() if G.has_edge(*e)]\n\n\t\t\t\t## an edge is part of multiple motifs\n\t\t\t\t## lets count the number of motifs an edge is part of \n\t\t\t\t\tfor u, v in edgeLists :\n\t\t\t\t\t\tdict_edges[(u, v)].append(str(key))\n\t\n\n\t\t\t\t## A node is also part of multiple motifs. \n\t\t\t\t## We count the total number of motifs a node is part of\n\t\t\t\t## We count the frequency of occurence each motif the node is part of\n\t\t\t\t\tnodelists = subgraph.nodes()\n\t\t\t\t\tfor n in nodelists :\n\t\t\t\t\t\tdict_nodes[str(n)].append(str(key))\n\n\n\n\t\t#for keys, values in mcount.items() :\n\t\t#\tprint >> outf, '%s|%s|%s' %(outname, keys, values) \n\n\t### Let's mark the edge with motif type and count. We count the number of types\n\t### of motif an edge is a part of. An edge could appear in M1: M1x times and in M2: M2x times and so on\n\n\tfor u,v in G.edges() :\n\t\t\tif (u,v) in dict_edges :\n\t\t\t\tG[u][v]['num_motif_edge'] = len(list(set(dict_edges[(u,v)])))\n\n\t### Let's mark the node with motif type and count. We count the number of types of motif a node is a part of. \n\n\tfor n in G.nodes() :\n\t\tmotficountnode = dict(zip(motifs.keys(), list(map(int, np.zeros(len(motifs))))))\n\n\t\tif str(n) in dict_nodes :\n\t\t\tsubgraphnodeslist = dict_nodes[str(n)]\n\n\t\t\tfor key in subgraphnodeslist:\n\t\t\t\tmotficountnode[str(key)] +=1\n\n\t\tfor motif, count in motficountnode.items() :\n\t\t\tG.node[n][str(motif)] = int(count)\n\n\t### Let's mark the edge with motif type and count. We count the number of types\n\t### of motif an edge is a part of. An edge could appear in M1: M1x times and in M2: M2x times and so on\n\n\tfor u,v in G.edges() :\n\t\tmotficountedge = dict(zip(motifs.keys(), list(map(int, np.zeros(len(motifs))))))\n\n\t\tif (u,v) in dict_edges :\n\t\t\tsubgraphedgeslist = dict_edges[(u,v)]\n\n\t\t\tfor key in subgraphedgeslist:\n\t\t\t\tmotficountedge[str(key)] +=1\n\n\t\tfor motif, count in motficountedge.items() :\n\t\t\tG[u][v][str(motif)] = int(count)\n\n\n\treturn G","def detection_algorithm(G, edge_weight):\n Gc = G.copy()\n set_node_attributes(Gc, attr_name='k-index')\n seed_node2communities = {}\n\n from operator import itemgetter\n while Gc.number_of_nodes() > 0:\n seed_node = max(list(Gc.nodes(data='k-index')), key=itemgetter(1))[0]\n nodes_in_community, modularity = find_local_community(Gc, seed_node=seed_node, weight=edge_weight)\n seed_node2communities[seed_node] = (nodes_in_community, modularity)\n Gc.remove_nodes_from(nodes_in_community)\n return seed_node2communities","def same_host_descent(G, host_species):\n nodes = set() # nodes that are involved in human-human transmission.\n for sc, sk, d in G.edges(data=True):\n sc_host = G.node[sc]['host_species']\n sk_host = G.node[sk]['host_species']\n \n sc_subtype = G.node[sc]['subtype']\n sk_subtype = G.node[sk]['subtype']\n \n subtype_exclusions = ['Mixed', 'mixed']\n \n not_mixed = (sc_subtype not in subtype_exclusions) and (sk_subtype not in subtype_exclusions)\n is_clonal = d['edge_type'] == 'full_complement'\n \n if sc_host == host_species and sk_host == host_species and not_mixed and is_clonal:\n nodes.add(sc)\n nodes.add(sk)\n\n return nodes","def get_graph_attributes(net_G):\r\n # number of nodes\r\n num_of_nodes = net_G.number_of_nodes()\r\n # number of nodes\r\n num_of_edges = net_G.number_of_edges()\r\n # density of net\r\n net_density = nx.density(net_G)\r\n # maximum degree and average degree\r\n nodes_degree = nx.degree(net_G)\r\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\r\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\r\n # global clustering coefficient: n - count numbers of paths of length two\r\n nodes_triangles = nx.triangles(net_G)\r\n num_of_triangles = sum(nodes_triangles.values())\r\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\r\n n = 0 \r\n for node in pairs_path_length.keys(): \r\n for item in pairs_path_length[node].values():\r\n if item == 2:\r\n n = n + 1\r\n global_clustering_coefficient = (num_of_triangles * 6) / n\r\n # size of giant component\r\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\r\n # return number of edges in graph=graph size\r\n size_of_giant = nx.Graph.size(giant_component)\r\n # calculate the average path length of giant component\r\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\r\n # maximum centrality and average centrality\r\n nodes_centrality = nx.degree_centrality(net_G)\r\n maximum_of_centrality = max(nodes_centrality.values())\r\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\r\n # maximum betweenness centrality\r\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\r\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\r\n # maximum closeness centrality\r\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\r\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\r\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\r\n # summarize graph attributes\r\n graph_attributes = [[\"Number of nodes:\", num_of_nodes], \\\r\n [\"Number of edges:\", num_of_edges], \\\r\n [\"Global clustering coefficient:\", global_clustering_coefficient], \\\r\n [\"Maximum degree:\", maximum_degree], \\\r\n [\"Average degree:\", average_degree], \\\r\n [\"Size of giant component:\", size_of_giant], \\\r\n [\"Average path length:\", average_shortest_path_length],\\\r\n [\"Maximum centrality:\", maximum_of_centrality], \\\r\n [\"Average centrality:\", average_of_centrality],\\\r\n [\"Maximum betweenness centrality:\", maximum_betweenness_centrality],\\\r\n [\"Maximum closeness centrality:\", maximum_closeness_centrality], \\\r\n [\"Average closeness centrality:\", average_closeness_centrality], \\\r\n [\"Net density:\", net_density]]\r\n return graph_attributes","def generate_network_graph(network):\n num_nodes = len(network)\n network_graph = {}\n\n for y_node in range(num_nodes):\n neighbors = {}\n for x_node in range(num_nodes):\n if network[y_node][x_node] is not 0:\n neighbors[x_node] = network[y_node][x_node]\n network_graph[y_node] = neighbors\n\n return network_graph","def _generate_G_from_H(H, variable_weight=False):\n H = np.array(H)\n n_edge = H.shape[1]\n # the weight of the hyperedge\n W = np.ones(n_edge)\n # the degree of the node\n DV = np.sum(H * W, axis=1)\n # the degree of the hyperedge\n DE = np.sum(H, axis=0)\n\n invDE = np.mat(np.diag(np.power(DE, -1)))\n DV2 = np.mat(np.diag(np.power(DV, -0.5)))\n W = np.mat(np.diag(W))\n H = np.mat(H)\n HT = H.T\n\n if variable_weight:\n DV2_H = DV2 * H\n invDE_HT_DV2 = invDE * HT * DV2\n return DV2_H, W, invDE_HT_DV2\n else:\n G = DV2 * H * W * invDE * HT * DV2\n return G","def infomap_communities(G):\n name_map = {}\n name_map_inverted = {}\n for n in G.nodes():\n id_ = hash(n) % 100000\n name_map_inverted[id_] = n\n name_map[n] = id_\n \n infomapSimple = infomap.Infomap(\"--two-level\")\n network = infomapSimple.network()\n \n for n1, n2, data in G.edges(data=True):\n network.addLink(name_map[n1], name_map[n2], data['weight'] if 'weight' in data else 1)\n\n infomapSimple.run()\n\n return dict(\n (name_map_inverted[node.physicalId], node.moduleIndex())\n for node in infomapSimple.iterTree()\n if node.isLeaf()\n )","def _generate_G_from_H(H, variable_weight=False):\n n_edge = H.shape[1]\n # the weight of the hyperedge\n W_vector = np.ones(n_edge)\n W = sp.diags(W_vector, format=\"csr\")\n # W = np.ones(n_edge)\n # the degree of the node\n DV = H\n DV = DV.sum(axis=1)\n #DV = np.sum(H * W, axis=1)\n # the degree of the hyperedge\n #DE = np.sum(H, axis=0)\n DE = H.sum(axis=0)\n invDE = np.squeeze(np.asarray(np.power(DE, -1)))\n invDE = sp.diags(invDE, format=\"csr\")\n DV2 = sp.diags(np.squeeze(np.asarray(np.power(DV, -0.5))), format=\"csr\")\n\n # invDE = np.mat(np.diag(np.power(DE, -1)))\n # DV2 = np.mat(np.diag(np.power(DV, -0.5)))\n HT = H.T\n\n if variable_weight:\n DV2_H = DV2 * H\n invDE_HT_DV2 = invDE * HT * DV2\n #invDE_HT = invDE * HT\n return DV2_H.toarray(), W_vector, invDE_HT_DV2.toarray()\n else:\n W = sp.diags(W_vector, format=\"csr\")\n G = DV2 * H * W * invDE * HT * DV2\n return G","def buildGraph(pickl, his=False):\n\n dic = pickl\n\n dic1 = dic\n G = nx.Graph()\n dic3 = dict(dic)\n checked = []\n\n # Adding nodes with bios greater than 30 words.\n for key in dic:\n if((re.sub(\"[ ]+\", \"\", dic[key]) != \"\") and len(dic[key])) > 30:\n G.add_node(key)\n else:\n del dic3[key]\n\n dic1 = dic3\n\n vect = TfidfVectorizer(min_df=1)\n coefs = list()\n\n joint_dict = dict()\n # Cosine similarity measure matrix\n F = vect.fit_transform(dic3.values())\n Cosine_mat = (F*F.T).A # Symmetric matrix:\n # Traverse uper triangle for cosine similarity measures.\n for i, key in enumerate(dic3):\n for j, key1 in enumerate(dic1):\n if(i > j):\n # obtain coef for corresponding key\n tfidf = Cosine_mat[i, j]\n # Repeated nodes must be filtered\n if dic[key] == dic[key1]:\n\n continue\n else:\n coefs.append(tfidf)\n joint_dict[str(key) + str(key1)] = tfidf\n\n data = [c for c in coefs if c]\n # max(data)\n\n mu = np.mean(data)\n std = np.std(data)\n binwidth = 0.007\n if his:\n plt.subplot(1, 2, 0)\n plt.hist(data, bins=np.arange(min(data), max(data) + binwidth, binwidth))\n # PLot gaussian fit contrast\n plt.xlabel(\"$cos(\\\\theta)$\")\n plt.ylabel(\"frecuency count of $cos(\\\\theta)$ values\")\n plt.subplot(1, 2, 1)\n plt.plot(np.arange(0, max(data), 0.001),\n gaussian(np.arange(0, max(data), 0.001), mu, std),\n linewidth=2)\n plt.xlabel(\"$cos(\\\\theta)$\")\n plt.ylabel(\"fitted gaussian\")\n plt.show()\n\n # Edge creation !\n for key in dic3:\n for key1 in dic1:\n if(key != key1):\n try:\n x = joint_dict[str(key) + str(key1)]\n # If cosine similarity is an outlier with 95% change\n # Make edge between nodes that conform the similarity\n if(x - mu > 2 * std):\n G.add_edge(key, key1)\n except:\n pass\n\n # Return the conected component with largest cardinality of nodes\n # Throw away small connected components we are interested in the big one\n # For our mini project exploration purposes\n G = max(nx.connected_component_subgraphs(G), key=len)\n return G","def differentiate(hp):\n if hp.force_skip:\n G.add_edge(\"input\", \"output\")\n for node in G.nodes(data=True):\n node_id, node_data = node\n log(\"differentiate\", node_id, node_data)\n node_data[\"output\"] = None\n node_data[\"op\"] = None\n if node_data[\"shape\"] is \"square\" or \"output\" in node_id:\n if node_id == \"output\":\n d_out = node_data[\"output_shape\"][-1]\n node_type = hp.last_layer\n activation = \"tanh\"\n else:\n node_type = str(np.random.choice(['sepconv1d', 'transformer',\n 'k_conv1', 'k_conv2', 'k_conv3',\n \"deep\", \"wide_deep\"],\n 1, p=hp.layer_distribution).item(0))\n activation = str(np.random.choice([ 'tanh', 'linear', 'relu', 'selu',\n 'elu', 'sigmoid', 'hard_sigmoid', 'exponential', 'softmax',\n 'softplus', 'softsign', 'gaussian', 'sin', 'cos', 'swish'],\n 1, p=hp.activation_distribution).item(0))\n d_out = None\n node_data[\"force_residual\"] = random.random() < hp.p_force_residual\n node_data[\"activation\"] = clean_activation(activation)\n node_data[\"node_type\"] = node_type\n node_data['style'] = \"\"\n if node_type == 'sepconv1d':\n if d_out is None:\n d_out = safe_sample(hp.min_filters, hp.max_filters)\n node_data[\"filters\"] = d_out\n node_data[\"kernel_size\"] = 1\n if node_type == \"transformer\":\n if d_out is None:\n d_out = safe_sample(hp.min_units, hp.max_units) * hp.attn_heads\n node_data[\"d_model\"] = d_out\n node_data[\"n_heads\"] = 2 if d_out % 2 == 0 else 1\n if \"k_conv\" in node_type or node_type in [\"deep\", \"wide_deep\"]:\n layers = design_layers(hp, d_out, activation)\n if d_out is None:\n d_out = layers[-1][0]\n node_data[\"stddev\"] = hp.stddev\n node_data['layers'] = layers\n node_data[\"d_out\"] = d_out\n if node_type in [\"deep\", \"wide_deep\"]:\n node_data['kernel'] = node_type\n else:\n node_data['kernel'] = \"wide_deep\" if random.random() < hp.p_wide_deep else \"deep\"\n label = f\"{node_type}\"\n log(f\"set {node_id} to {label}\")\n node_data[\"label\"] = label\n node_data[\"color\"] = \"green\"\n # we handle recurrent shapes:\n try:\n feedback_node_id = f\"{node_id}_feedback\"\n input_shape = (None, d_out)\n log(f\"attempt to set input_shape for {feedback_node_id} to {input_shape}\")\n feedback_node = G.node[feedback_node_id]\n feedback_node[\"input_shape\"] = input_shape\n node_data[\"gives_feedback\"] = True\n except Exception as e:\n log(\"ERROR HANDLING FEEDBACK SHAPE:\", e)","def find_and_print_network_communities(G, code_dict=None):\n\n comm_dict = partition(G)\n\n comm_members = {}\n for comm in set(comm_dict.values()):\n countries = [node for node in comm_dict if comm_dict[node] == comm]\n if code_dict is not None:\n countries = [code_dict[code] for code in countries]\n\n comm_members[comm] = countries\n\n return comm_members, get_modularity(G, comm_dict)","def gtom(graph):\n\n # modified from uinvite(), copied for convenience (TODO consolidate by moving outside to its own function)\n # return list of neighbors of neighbors of i, that aren't themselves neighbors of i\n # i.e., an edge between i and any item in nn forms a triangle\n def neighborsofneighbors(i, nxg):\n nn=[] # neighbors of neighbors (nn)\n n=list(nx.all_neighbors(nxg,i))\n for j in n:\n nn=nn+list(nx.all_neighbors(nxg,j))\n nn=list(set(nn))\n if i in nn:\n nn.remove(i) # remove self\n return nn\n \n nxgraph = nx.to_networkx_graph(graph)\n numnodes = nx.number_of_nodes(nxgraph)\n gtom_mat = np.zeros((numnodes,numnodes))\n \n nn_dict = {}\n for i in range(numnodes):\n nn_dict[i] = neighborsofneighbors(i, nxgraph)\n \n for i in range(numnodes):\n for j in range(i+1,numnodes):\n i_neighbors = nn_dict[i]\n j_neighbors = nn_dict[j]\n min_neighbors = min(len(i_neighbors),len(j_neighbors))\n len_overlap = len(set.intersection(set(i_neighbors),set(j_neighbors)))\n gtom_mat[i, j] = 1 - (float(len_overlap) / min_neighbors)\n gtom_mat[j, i] = gtom_mat[i, j]\n\n return gtom_mat","def make_er_graph(num_nodes, probability):\n graph = {}\n for node in range(0, num_nodes):\n graph[node] = set([])\n\n for node in range(0, num_nodes - 1):\n for potential_neighbor in range(node + 1, num_nodes):\n if random.random() < probability:\n graph[node].add(potential_neighbor)\n graph[potential_neighbor].add(node)\n\n return graph","def node_edge_centrality(\n H,\n f=lambda x: np.power(x, 2),\n g=lambda x: np.power(x, 0.5),\n phi=lambda x: np.power(x, 2),\n psi=lambda x: np.power(x, 0.5),\n max_iter=100,\n tol=1e-6,\n):\n from ..algorithms import is_connected\n\n # if there aren't any nodes or edges, return an empty dict\n if H.num_nodes == 0 or H.num_edges == 0 or not is_connected(H):\n return {n: np.nan for n in H.nodes}, {e: np.nan for e in H.edges}\n # if the hypergraph is not connected,\n # this metric doesn't make sense and should return nan.\n # if not is_connected(H):\n # return {n: np.nan for n in H.nodes}, {e: np.nan for e in H.edges}\n\n n = H.num_nodes\n m = H.num_edges\n x = np.ones(n) / n\n y = np.ones(m) / m\n\n I, node_dict, edge_dict = incidence_matrix(H, index=True)\n\n check = np.inf\n\n for iter in range(max_iter):\n u = np.multiply(x, g(I @ f(y)))\n v = np.multiply(y, psi(I.T @ phi(x)))\n # multiply by the sign to try and enforce positivity\n new_x = np.sign(u[0]) * u / norm(u, 1)\n new_y = np.sign(v[0]) * v / norm(v, 1)\n\n check = norm(new_x - x) + norm(new_y - y)\n if check < tol:\n break\n x = new_x.copy()\n y = new_y.copy()\n else:\n warn(\"Iteration did not converge!\")\n return {node_dict[n]: new_x[n] for n in node_dict}, {\n edge_dict[e]: new_y[e] for e in edge_dict\n }","def build_auxiliary_node_connectivity(G):\n directed = G.is_directed()\n\n mapping = {}\n H = nx.DiGraph()\n\n for i, node in enumerate(G):\n mapping[node] = i\n H.add_node('%dA' % i, id=node)\n H.add_node('%dB' % i, id=node)\n H.add_edge('%dA' % i, '%dB' % i, capacity=1)\n\n edges = []\n for (source, target) in G.edges():\n edges.append(('%sB' % mapping[source], '%sA' % mapping[target]))\n if not directed:\n edges.append(('%sB' % mapping[target], '%sA' % mapping[source]))\n H.add_edges_from(edges, capacity=1)\n\n # Store mapping as graph attribute\n H.graph['mapping'] = mapping\n return H","def network(self):\n G = nx.MultiDiGraph()\n reaction_hash = []\n product_count = 0\n mapping = {}\n reaction_count = 0\n\n for r in self.reactions:\n reaction_count += 1\n\n reaction_dict = r.__dict__\n G.add_edge(reaction_dict.get('left'), hash(r))\n G.add_edge(reaction_dict.get('right'), hash(r))\n G.add_edge(hash(r), reaction_dict.get('left2'))\n G.add_edge(hash(r), reaction_dict.get('right2'))\n\n product_count += 1\n mapping[reaction_dict.get('left')] = \"x{}\".format(product_count)\n product_count += 1\n mapping[reaction_dict.get('right')] = \"x{}\".format(product_count)\n product_count += 1\n mapping[reaction_dict.get('left2')] = \"x{}\".format(product_count)\n product_count += 1\n mapping[reaction_dict.get('right2')] = \"x{}\".format(product_count)\n\n mapping[hash(r)] = \"r{}\".format(reaction_dict.get(\"reaction_n\"))\n reaction_hash.append(hash(r))\n\n return G, mapping","def greedy_modularity_communities(G, weight=None):\n\n # Count nodes and edges\n N = len(G.nodes())\n m = sum([d.get('weight', 1) for u, v, d in G.edges(data=True)])\n q0 = 1.0 / (2.0*m)\n\n # Map node labels to contiguous integers\n label_for_node = dict((i, v) for i, v in enumerate(G.nodes()))\n node_for_label = dict((label_for_node[i], i) for i in range(N))\n\n # Calculate degrees\n k_for_label = G.degree(G.nodes(), weight=weight)\n k = [k_for_label[label_for_node[i]] for i in range(N)]\n\n # Initialize community and merge lists\n communities = dict((i, frozenset([i])) for i in range(N))\n merges = []\n\n # Initial modularity\n partition = [[label_for_node[x] for x in c] for c in communities.values()]\n q_cnm = modularity(G, partition)\n\n # Initialize data structures\n # CNM Eq 8-9 (Eq 8 was missing a factor of 2 (from A_ij + A_ji)\n # a[i]: fraction of edges within community i\n # dq_dict[i][j]: dQ for merging community i, j\n # dq_heap[i][n] : (-dq, i, j) for communitiy i nth largest dQ\n # H[n]: (-dq, i, j) for community with nth largest max_j(dQ_ij)\n a = [k[i]*q0 for i in range(N)]\n dq_dict = dict(\n (i, dict(\n (j, 2*q0 - 2*k[i]*k[j]*q0*q0)\n for j in [\n node_for_label[u]\n for u in G.neighbors(label_for_node[i])]\n if j != i))\n for i in range(N))\n dq_heap = [\n MappedQueue([\n (-dq, i, j)\n for j, dq in dq_dict[i].items()])\n for i in range(N)]\n H = MappedQueue([\n dq_heap[i].h[0]\n for i in range(N)\n if len(dq_heap[i]) > 0])\n\n # Merge communities until we can't improve modularity\n while len(H) > 1:\n # Find best merge\n # Remove from heap of row maxes\n # Ties will be broken by choosing the pair with lowest min community id\n try:\n dq, i, j = H.pop()\n except IndexError:\n break\n dq = -dq\n # Remove best merge from row i heap\n dq_heap[i].pop()\n # Push new row max onto H\n if len(dq_heap[i]) > 0:\n H.push(dq_heap[i].h[0])\n # If this element was also at the root of row j, we need to remove the\n # duplicate entry from H\n if dq_heap[j].h[0] == (-dq, j, i):\n H.remove((-dq, j, i))\n # Remove best merge from row j heap\n dq_heap[j].remove((-dq, j, i))\n # Push new row max onto H\n if len(dq_heap[j]) > 0:\n H.push(dq_heap[j].h[0])\n else:\n # Duplicate wasn't in H, just remove from row j heap\n dq_heap[j].remove((-dq, j, i))\n # Stop when change is non-positive\n if dq <= 0:\n break\n\n # Perform merge\n communities[j] = frozenset(communities[i] | communities[j])\n del communities[i]\n merges.append((i, j, dq))\n # New modularity\n q_cnm += dq\n # Get list of communities connected to merged communities\n i_set = set(dq_dict[i].keys())\n j_set = set(dq_dict[j].keys())\n all_set = (i_set | j_set) - set([i, j])\n both_set = i_set & j_set\n # Merge i into j and update dQ\n for k in all_set:\n # Calculate new dq value\n if k in both_set:\n dq_jk = dq_dict[j][k] + dq_dict[i][k]\n elif k in j_set:\n dq_jk = dq_dict[j][k] - 2.0*a[i]*a[k]\n else:\n # k in i_set\n dq_jk = dq_dict[i][k] - 2.0*a[j]*a[k]\n # Update rows j and k\n for row, col in [(j, k), (k, j)]:\n # Save old value for finding heap index\n if k in j_set:\n d_old = (-dq_dict[row][col], row, col)\n else:\n d_old = None\n # Update dict for j,k only (i is removed below)\n dq_dict[row][col] = dq_jk\n # Save old max of per-row heap\n if len(dq_heap[row]) > 0:\n d_oldmax = dq_heap[row].h[0]\n else:\n d_oldmax = None\n # Add/update heaps\n d = (-dq_jk, row, col)\n if d_old is None:\n # We're creating a new nonzero element, add to heap\n dq_heap[row].push(d)\n else:\n # Update existing element in per-row heap\n dq_heap[row].update(d_old, d)\n # Update heap of row maxes if necessary\n if d_oldmax is None:\n # No entries previously in this row, push new max\n H.push(d)\n else:\n # We've updated an entry in this row, has the max changed?\n if dq_heap[row].h[0] != d_oldmax:\n H.update(d_oldmax, dq_heap[row].h[0])\n\n # Remove row/col i from matrix\n i_neighbors = dq_dict[i].keys()\n for k in i_neighbors:\n # Remove from dict\n dq_old = dq_dict[k][i]\n del dq_dict[k][i]\n # Remove from heaps if we haven't already\n if k != j:\n # Remove both row and column\n for row, col in [(k, i), (i, k)]:\n # Check if replaced dq is row max\n d_old = (-dq_old, row, col)\n if dq_heap[row].h[0] == d_old:\n # Update per-row heap and heap of row maxes\n dq_heap[row].remove(d_old)\n H.remove(d_old)\n # Update row max\n if len(dq_heap[row]) > 0:\n H.push(dq_heap[row].h[0])\n else:\n # Only update per-row heap\n dq_heap[row].remove(d_old)\n\n del dq_dict[i]\n # Mark row i as deleted, but keep placeholder\n dq_heap[i] = MappedQueue()\n # Merge i into j and update a\n a[j] += a[i]\n a[i] = 0\n\n communities = [\n frozenset([label_for_node[i] for i in c])\n for c in communities.values()]\n return sorted(communities, key=len, reverse=True)","def neighborhood(G,n,o):\n base = G[n]\n neighbors = {}\n neighbors[n] = 0\n newNodes = set(neighbors.keys())\n for i in range(1,o+1):\n #for node in neighbors.keys():\n nodes = newNodes.copy()\n newNodes = set()\n for node in nodes:\n branch = G[node]\n for node in branch:\n if node not in neighbors:\n newNodes.add(node)\n neighbors[node]=i\n return neighbors","def complex_network_mapping(graph):\n vect = []\n\n n = nx.number_of_nodes(graph)\n e = nx.number_of_edges(graph)\n print n, e\n\n# adj = nx.adjacency_matrix(graph).toarray()\n# adj_bin = np.where(adj > 0, 1., 0.)\n# adj_conn = 1 - adj\n adj_bin = nx.adjacency_matrix(graph).toarray()\n adj_bin = np.array(adj_bin, dtype=np.float)\n\n # Node Betweenness binary\n bt_bin = nx.betweenness_centrality(graph).values()\n avg_btb = np.mean(bt_bin)\n vect.append(avg_btb)\n\n # Edge betweenness\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\n vect.append(np.mean(ebt))\n\n # Eigen vector centrality binary\n evc_bin = eigenvector_centrality_und(adj_bin)\n avg_evcb = np.mean(evc_bin)\n vect.append(avg_evcb)\n\n # Flow coefficient\n _, flow_bin, _ = flow_coef_bd(adj_bin)\n avg_flow = np.mean(flow_bin)\n vect.append(avg_flow)\n\n # Kcoreness centrality\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\n avg_kcor = np.mean(kcor_bin)\n vect.append(avg_kcor)\n\n # Degree assortivity\n dac = nx.degree_assortativity_coefficient(graph)\n vect.append(dac)\n\n # Page rank centrality\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\n# avg_pgr = np.mean(pgr_wei)\n# vect.append(avg_pgr)\n\n # Rich club coefficient\n# rcc = nx.rich_club_coefficient(graph).values()\n# avg_rcc = np.mean(rcc)\n# vect.append(avg_rcc)\n\n # Transitivity\n tr = nx.transitivity(graph)\n vect.append(tr)\n\n # average clustering\n avg_clst = nx.average_clustering(graph)\n vect.append(avg_clst)\n\n glb_ef = efficiency_bin(adj_bin)\n vect.append(glb_ef)\n\n return vect","def intersection(G, H):\n\n if G.order() != H.order():\n msg = \"Node sets of the two directed graphs are not equal!\"\n raise StaticGraphNotEqNodesException(msg) \n \n n_nodes = G.order()\n edges = ((u, v) for u in G.nodes()\n for v in set(G.successors(u)) & set(H.successors(u)))\n deg = make_deg(n_nodes, edges) \n edges = ((u, v) for u in G.nodes()\n for v in set(G.successors(u)) & set(H.successors(u)))\n GH = make(n_nodes, G.size(), edges, deg)\n return GH","def network_nodes_species(self):\n G, mapping = self.network()\n waste, resources, intmed_products = self.amenities()\n\n node_dict = {}\n\n for nd in G:\n # print(nd)\n if isinstance(nd, int):\n node_dict[nd] = \"r\"\n elif nd in self.commodity:\n node_dict[nd] = \"Xc\"\n elif nd in waste:\n node_dict[nd] = \"w\"\n elif nd in resources:\n node_dict[nd] = \"Xr\"\n elif nd in intmed_products:\n node_dict[nd] = \"InPr\"\n\n return node_dict","def graph():\n\n graph = {'A': ['B', 'C'],\n 'B': ['C', 'D'],\n 'C': ['D'],\n 'D': ['C'],\n 'E': ['F'],\n 'F': ['C']}\n\n def generate_edges(graph):\n \"\"\" Convert the dict representation of a graph into a list one\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\n \"\"\"\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges\n\n a = generate_edges(graph=graph)\n print(a)","def find_chimera_indices(G):\n\n # if the nodes are orderable, we want the lowest-order one.\n try:\n nlist = sorted(G.nodes)\n except TypeError:\n nlist = G.nodes()\n\n n_nodes = len(nlist)\n\n # create the object that will store the indices\n chimera_indices = {}\n\n # ok, let's first check for the simple cases\n if n_nodes == 0:\n return chimera_indices\n elif n_nodes == 1:\n raise DWaveNetworkXException('Singleton graphs are not Chimera-structured')\n elif n_nodes == 2:\n return {nlist[0]: (0, 0, 0, 0), nlist[1]: (0, 0, 1, 0)}\n\n # next, let's get the bicoloring of the graph; this raises an exception if the graph is\n # not bipartite\n coloring = color(G)\n\n # we want the color of the node to be the u term in the Chimera-index, so we want the\n # first node in nlist to be color 0\n if coloring[nlist[0]] == 1:\n coloring = {v: 1 - coloring[v] for v in coloring}\n\n # we also want the diameter of the graph\n # claim: diameter(G) == m + n for |G| > 2\n dia = diameter(G)\n\n # we have already handled the |G| <= 2 case, so we know, for diameter == 2, that the Chimera\n # graph is a single tile\n if dia == 2:\n shore_indices = [0, 0]\n\n for v in nlist:\n u = coloring[v]\n chimera_indices[v] = (0, 0, u, shore_indices[u])\n shore_indices[u] += 1\n\n return chimera_indices\n\n # NB: max degree == shore size <==> one tile\n\n raise Exception('not yet implemented for Chimera graphs with more than one tile')","def greedy_modularity_communities(G, K, weight=None):\n G = nx.from_numpy_array(G.detach().numpy(), create_using = nx.DiGraph())\n # Count nodes and edges\n N = len(G.nodes())\n m = sum([d.get('weight', 1) for u, v, d in G.edges(data=True)])\n q0 = 1.0 / (2.0*m)\n\n # Map node labels to contiguous integers\n label_for_node = dict((i, v) for i, v in enumerate(G.nodes()))\n node_for_label = dict((label_for_node[i], i) for i in range(N))\n\n # Calculate degrees\n k_for_label = G.degree(G.nodes(), weight=weight)\n k = [k_for_label[label_for_node[i]] for i in range(N)]\n\n # Initialize community and merge lists\n communities = dict((i, frozenset([i])) for i in range(N))\n merges = []\n\n # Initial modularity\n partition = [[label_for_node[x] for x in c] for c in communities.values()]\n q_cnm = modularity(G, partition)\n\n # Initialize data structures\n # CNM Eq 8-9 (Eq 8 was missing a factor of 2 (from A_ij + A_ji)\n # a[i]: fraction of edges within community i\n # dq_dict[i][j]: dQ for merging community i, j\n # dq_heap[i][n] : (-dq, i, j) for communitiy i nth largest dQ\n # H[n]: (-dq, i, j) for community with nth largest max_j(dQ_ij)\n a = [k[i]*q0 for i in range(N)]\n dq_dict = dict(\n (i, dict(\n (j, q0*(G[i][j]['weight'] + G[j][i]['weight']) - 2*k[i]*k[j]*q0*q0)\n for j in [\n node_for_label[u]\n for u in G.neighbors(label_for_node[i])]\n if j != i))\n for i in range(N))\n# print(min([len(x[1]) for x in dq_dict.values()]))\n# raise Exception()\n# return dq_dict\n dq_heap = [\n MappedQueue([\n (-dq, i, j)\n for j, dq in dq_dict[i].items()])\n for i in range(N)]\n H = MappedQueue([\n dq_heap[i].h[0]\n for i in range(N)\n if len(dq_heap[i]) > 0])\n\n # Merge communities until we can't improve modularity\n while len(H) > 1:\n # Find best merge\n # Remove from heap of row maxes\n # Ties will be broken by choosing the pair with lowest min community id\n try:\n dq, i, j = H.pop()\n except IndexError:\n break\n dq = -dq\n # Remove best merge from row i heap\n dq_heap[i].pop()\n # Push new row max onto H\n if len(dq_heap[i]) > 0:\n H.push(dq_heap[i].h[0])\n # If this element was also at the root of row j, we need to remove the\n # duplicate entry from H\n if dq_heap[j].h[0] == (-dq, j, i):\n H.remove((-dq, j, i))\n # Remove best merge from row j heap\n dq_heap[j].remove((-dq, j, i))\n # Push new row max onto H\n if len(dq_heap[j]) > 0:\n H.push(dq_heap[j].h[0])\n else:\n # Duplicate wasn't in H, just remove from row j heap\n dq_heap[j].remove((-dq, j, i))\n\n # Perform merge\n communities[j] = frozenset(communities[i] | communities[j])\n del communities[i]\n merges.append((i, j, dq))\n \n# print(len(communities))\n # Stop when change is non-positive\n if len(communities) == K:\n break\n\n # New modularity\n q_cnm += dq\n # Get list of communities connected to merged communities\n i_set = set(dq_dict[i].keys())\n j_set = set(dq_dict[j].keys())\n all_set = (i_set | j_set) - set([i, j])\n both_set = i_set & j_set\n # Merge i into j and update dQ\n for k in all_set:\n # Calculate new dq value\n if k in both_set:\n dq_jk = dq_dict[j][k] + dq_dict[i][k]\n elif k in j_set:\n dq_jk = dq_dict[j][k] - 2.0*a[i]*a[k]\n else:\n # k in i_set\n dq_jk = dq_dict[i][k] - 2.0*a[j]*a[k]\n # Update rows j and k\n for row, col in [(j, k), (k, j)]:\n # Save old value for finding heap index\n if k in j_set:\n d_old = (-dq_dict[row][col], row, col)\n else:\n d_old = None\n # Update dict for j,k only (i is removed below)\n dq_dict[row][col] = dq_jk\n # Save old max of per-row heap\n if len(dq_heap[row]) > 0:\n d_oldmax = dq_heap[row].h[0]\n else:\n d_oldmax = None\n # Add/update heaps\n d = (-dq_jk, row, col)\n if d_old is None:\n # We're creating a new nonzero element, add to heap\n dq_heap[row].push(d)\n else:\n # Update existing element in per-row heap\n dq_heap[row].update(d_old, d)\n # Update heap of row maxes if necessary\n if d_oldmax is None:\n # No entries previously in this row, push new max\n H.push(d)\n else:\n # We've updated an entry in this row, has the max changed?\n if dq_heap[row].h[0] != d_oldmax:\n H.update(d_oldmax, dq_heap[row].h[0])\n\n # Remove row/col i from matrix\n i_neighbors = dq_dict[i].keys()\n for k in i_neighbors:\n # Remove from dict\n dq_old = dq_dict[k][i]\n del dq_dict[k][i]\n # Remove from heaps if we haven't already\n if k != j:\n # Remove both row and column\n for row, col in [(k, i), (i, k)]:\n # Check if replaced dq is row max\n d_old = (-dq_old, row, col)\n if dq_heap[row].h[0] == d_old:\n # Update per-row heap and heap of row maxes\n dq_heap[row].remove(d_old)\n H.remove(d_old)\n # Update row max\n if len(dq_heap[row]) > 0:\n H.push(dq_heap[row].h[0])\n else:\n # Only update per-row heap\n# if d_old in dq_heap[row].d:\n dq_heap[row].remove(d_old)\n\n del dq_dict[i]\n # Mark row i as deleted, but keep placeholder\n dq_heap[i] = MappedQueue()\n # Merge i into j and update a\n a[j] += a[i]\n a[i] = 0\n\n# communities = [\n# set([label_for_node[i] for i in c])\n# for c in communities.values()]\n heap = []\n for j in communities:\n heapq.heappush(heap, (a[j], set(communities[j])))\n while len(heap) > K:\n weight1, com1 = heapq.heappop(heap)\n weight2, com2 = heapq.heappop(heap)\n com1.update(com2)\n heapq.heappush(heap, (weight1+weight2, com1))\n communities = [x[1] for x in heap]\n r = torch.zeros(N, K)\n print(len(communities))\n for i,c in enumerate(communities):\n for v in c:\n r[v, i] = 1\n return r","def community_detection(net_G):\r\n if list(nx.isolates(net_G)) == []:\r\n part = community.best_partition(net_G)\r\n #values = [part.get(node) for node in net_G.nodes()]\r\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\r\n #plt.show()\r\n else:\r\n net_G = net_G.copy()\r\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\r\n part = community.best_partition(net_G)\r\n list_nodes = []\r\n for com in set(part.values()):\r\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\r\n num_of_communities = len(list_nodes)\r\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\r\n net_communities = [[\"Numbers of communities:\", num_of_communities], \\\r\n [\"Partition performance:\", partition_performance]]\r\n return net_communities","def count_automorphisms(g: Graph) -> int:\n\n def generate_mapping(g: Graph, h: Graph):\n \"\"\"\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\n We map g to h.\n :param g: A graph\n :param h: A graph\n :return: A permutation with the mapping from g to h\n \"\"\"\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)\n\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\n \"\"\"\n Is called recursively to traverse through the branching tree and to find all automorphisms.\n :param g: A copy of the original graph\n :param h: Another copy of the original graph\n :param d: A list with pre-colored vertices for graph g\n :param i: A list with pre-colored vertices for graph h\n \"\"\"\n\n # Refine the graphs g and h.\n color_refinement([g, h])\n\n # Make sure that the colors are balanced, and check for a bijection.\n if not is_balanced(g, h):\n return\n if is_bijection(g, h):\n\n # Generate the mapping from g -> h.\n p = generate_mapping(g, h)\n\n # If the permutation cannot be generated by this generating set, we need to add it.\n if not is_member(generating_set, p):\n generating_set.append(p)\n\n # We can now back to the last trivial ancestor nodes in the branching tree.\n while [v.label for v in d] != [v.label for v in i]:\n # We remove the vertices from d and i and mark them as 'used'.\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\n d.pop().pre_labeled = True\n i.pop().pre_labeled = True\n\n return\n\n c, next_color = get_c([g, h])\n for v_g in g:\n if v_g.colornum == c:# and not v_g.pre_labeled:\n x = v_g\n break\n\n for v_h in h:\n if v_h.colornum == c and not v_h.pre_labeled:\n g1 = g + Graph(False)\n h1 = h + Graph(False)\n g1.vertices[g.vertices.index(x)].colornum = next_color\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\n d.append(x)\n i.append(v_h)\n generate_automorphisms(g1, h1, d, i)\n\n generating_set = []\n graph_copy_1 = g + Graph(False)\n graph_copy_2 = g + Graph(False)\n for v in graph_copy_1.vertices:\n v.pre_labeled = False\n for v in graph_copy_2.vertices:\n v.pre_labeled = False\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\n return compute_order(generating_set)","def odd_decomposition(G) -> Tuple[Set[int], Set[int]]:\n multi = isinstance(G, nx.MultiGraph)\n\n # create a MultiGraph copy of G\n G = nx.MultiGraph(G)\n\n # remove isolated nodes from the graph, since they are irrelevant and we are working on a copy\n G.remove_nodes_from(list(nx.isolates(G)))\n\n # if the base graph is already odd\n if is_odd(G):\n return (set(G.edges(keys=multi)), set())\n\n odd_subgraph = G.subgraph(odd_nodes(G))\n even_subgraph = G.subgraph(even_nodes(G))\n\n odd_components = nx.connected_components(odd_subgraph)\n even_components = nx.connected_components(even_subgraph)\n\n # use the same notation as in our source paper\n X = list(odd_components)\n Y, Z = partition(even_components, lambda x: len(x) % 2 == 0)\n\n lX, lY, lZ = len(X), len(Y), len(Z)\n linear_system = Matrix(lY + lZ, lX + 1, bin_field)\n\n # create a linear system over GF(2) as described in our source paper\n for i, Yi in enumerate(Y):\n for j, Xi in enumerate(X):\n if n_joining(G, Xi, Yi) % 2 == 1:\n linear_system.set(i, j, 1)\n else:\n linear_system.set(i, j, 0)\n linear_system.set(i, lX, 1)\n\n for i, Zi in enumerate(Z):\n for j, Xi in enumerate(X):\n if n_joining(G, Xi, Zi) % 2 == 1:\n linear_system.set(i + lY, j, 1)\n else:\n linear_system.set(i + lY, j, 0)\n linear_system.set(i + lY, lX, 0)\n\n # transform the system into RREF\n linear_system.reduced_row_echelon_form()\n red = set()\n\n # we only need one solution\n # every non pivot is set to 0 (meaning blue)\n # while every pivot matches the augmented value\n # only create the red set since this is the only one we need\n\n for i in range(lY + lZ):\n val = linear_system.get(i, lX)\n # don't cross the last column (augmented part)\n for j in range(lX):\n v = linear_system.get(i, j)\n if v == 1:\n if val == 1:\n red.add(j)\n break\n else:\n if val == 1:\n # if any of the lines has no pivot and 1 as the augmented value this system is not solvable\n raise NotDecomposableError(\"The graph is not decomposable due to unsolvable system\")\n else:\n # this is a zero row ane there are no pivots after this row\n break\n\n red_nodes = set.union(*[X[i] for i in red]) if red else set()\n # edges adjacent to red nodes\n red_edges = set(G.edges(nbunch=red_nodes, keys=True))\n # calculate the red degree for every even node\n degrees = dict()\n for i in even_subgraph.nodes():\n degrees[i] = 0\n\n for i, j, k in red_edges:\n if i in degrees:\n degrees[i] += 1\n if j in degrees:\n degrees[j] += 1\n\n # T set is the set of all nodes of even red degree\n T = {i for i, deg in degrees.items() if deg % 2 == 0}\n\n # compute the T-join and mark the nodes as red/blue\n red_join = T_join(even_subgraph, T)\n\n red_edges.update(red_join)\n blue_edges = set(G.edges(keys=True)).difference(red_edges)\n\n if not multi:\n red_edges = {(i, j) for i, j, k in red_edges}\n blue_edges = {(i, j) for i, j, k in blue_edges}\n\n return (red_edges, blue_edges)","def MST_pathfinder(G):\n NG = nx.Graph()\n NG.add_nodes_from(list(range(numnodes)))\n edges = sorted( ((G[a][b]['weight'],a,b) for a,b in G.edges()),\n reverse=False) # smaller distances are more similar\n clusters = {node:i for i,node in enumerate(G.nodes())}\n while not edges == []:\n w1,a,b = edges[0]\n l = []\n # Select edges to be considered this round:\n for w2,u,v in edges:\n if w1 == w2:\n l.append((u,v,w2))\n else:\n break\n # Remaining edges are those not being considered this round:\n edges = edges[len(l):]\n # Only select those edges for which the items are not in the same cluster\n l = [(a,b,c) for a,b,c in l if not clusters[a]==clusters[b]]\n # Add these edges to the graph:\n NG.add_weighted_edges_from(l)\n # Merge the clusters:\n for a,b,w in l:\n cluster_1 = clusters[a]\n cluster_2 = clusters[b]\n clusters = {node:cluster_1 if i==cluster_2 else i\n for node,i in clusters.items()}\n return NG","def get_neighbors(graph):\n neighbor_dict = dict()\n for node in graph:\n neighbor_dict[node] = set(graph[node])\n return neighbor_dict","def undirected_graph_to_dictionary_form(G):\n G_dict = dict() # initialize the dictionary\n for node in G.get_nodeset(): # for every node\n G_dict[node.get_name()] = dict() # initialize the inner dictionary\n for edge in node.get_incident_edges(): # for every edge\n other_node = {node for node in edge.get_incident_nodes() if not node.get_name().__eq__()}.pop()\n # add the edge, including the edge weight\n G_dict[node.get_name()][other_node.get_name()] = edge.get_weight()\n return G_dict # return the populated adjacency matrix representation","def gmaps_optical_nodes(request):\n # Cypher query to get all cables with cable type fiber that are connected\n # to two optical node.\n q = \"\"\"\n MATCH (cable:Cable)\n WHERE cable.cable_type = \"Dark Fiber\"\n MATCH (cable)-[Connected_to]->(port)\n WITH cable, port\n MATCH (port)<-[:Has*0..]-(equipment)\n WHERE (equipment:Optical_Node) AND NOT equipment.type =~ \"(?i).*tss.*\"\n WITH cable, port, equipment\n MATCH p2=(equipment)-[:Located_in]->()<-[:Has*0..]-(loc)\n WHERE (loc:Site)\n RETURN cable, equipment, loc\n \"\"\"\n result = nc.query_to_list(nc.graphdb.manager, q)\n nodes = {}\n edges = {}\n for item in result:\n node = {\n 'name': item['equipment']['name'],\n 'url': helpers.get_node_url(item['equipment']['handle_id']),\n 'lng': float(str(item['loc'].get('longitude', 0))),\n 'lat': float(str(item['loc'].get('latitude', 0)))\n }\n coords = {\n 'lng': float(str(item['loc'].get('longitude', 0))),\n 'lat': float(str(item['loc'].get('latitude', 0)))\n }\n edge = {\n 'name': item['cable']['name'],\n 'url': helpers.get_node_url(item['cable']['handle_id']),\n 'end_points': [coords]\n }\n nodes[item['equipment']['name']] = node\n if item['cable']['name'] in edges:\n edges[item['cable']['name']]['end_points'].append(coords)\n else:\n edges[item['cable']['name']] = edge\n response = HttpResponse(content_type='application/json')\n json.dump({'nodes': list(nodes.values()), 'edges': list(edges.values())}, response)\n return response","def _community_detection(self, kg: KG) -> None:\n nx_graph = nx.Graph()\n\n for vertex in kg._vertices:\n if not vertex.predicate:\n nx_graph.add_node(str(vertex), vertex=vertex)\n\n for vertex in kg._vertices:\n if not vertex.predicate:\n # Neighbors are predicates\n for pred in kg.get_neighbors(vertex):\n for obj in kg.get_neighbors(pred):\n nx_graph.add_edge(\n str(vertex), str(obj), name=str(pred)\n )\n\n # Create a dictionary that maps the URI on a community\n partition = community.best_partition(\n nx_graph, resolution=self.resolution\n )\n self.labels_per_community = defaultdict(list)\n\n self.communities = {}\n vertices = nx.get_node_attributes(nx_graph, \"vertex\")\n for node in partition:\n if node in vertices:\n self.communities[vertices[node]] = partition[node]\n\n for node in self.communities:\n self.labels_per_community[self.communities[node]].append(node)","def complement(G):\n\n nset = set(G.nodes())\n n_nodes = G.order()\n n_edges = n_nodes * (n_nodes - 1) - G.size() + 1\n \n cmp_edges = ((u, v) for u in G.nodes()\n\t\t for v in nset - set(G.successors(u)))\n deg = make_deg(n_nodes, cmp_edges)\n cmp_edges = ((u, v) for u in G.nodes()\n\t\t for v in nset - set(G.successors(u)))\n H = make(n_nodes, n_edges, cmp_edges, deg)\n return H","def rwgraph(G,i0=0,M=100,Nt=100):\r\n\r\n adj_dict=nx.convert.to_dict_of_lists(G)\r\n X=np.ones((M,Nt+1),dtype=int)\r\n X[:,0]=X[:,0]*i0\r\n\r\n n=len(adj_dict)\r\n\r\n if M*Nt<n:\r\n for i in range(M):\r\n for j in range(0,Nt):\r\n X[i,j+1]=np.random.choice(adj_dict[X[i,j]])\r\n\r\n else:\r\n #creates array of degree of nodes\r\n degree_arr=np.asarray(G.degree(),dtype=int)[:,1]\r\n max_degree=max(degree_arr)\r\n\r\n #create denses matrix\r\n Mat=np.zeros((n,max_degree+1))\r\n for i in range(0,n):\r\n Mat[i,0:len(adj_dict[i])]= np.asarray(adj_dict[i],dtype=int)\r\n\r\n w=np.random.random((M,Nt))\r\n #iterate through time\r\n for j in range(0,Nt):\r\n X[:,j+1]=Mat[X[:,j],np.floor(degree_arr[X[:,j]]*w[:,j]).astype(int)]\r\n return X","def aggregate_maps(self, G=[], node_tags={}):\n\n self.map = nx.DiGraph() \n \n # loop over graphs in list of graphs\n for g in G:\n # add nodes to graph\n self.map.add_nodes_from(g.nodes())\n # loop over edges \n for edge in g.edges(data=True):\n # if edge is already present, add weight to edge\n if self.map.has_edge(edge[0],edge[1]):\n self.map[edge[0]][edge[1]]['weight'] += edge[2]['weight']\n # if edge is not already present, add it with weight=1\n else:\n self.map.add_edge(edge[0],edge[1], weight=1)\n \n # relabel nodes according to mapping provided by 'node_tags'\n nx.set_node_attributes(self.map, name = 'node_label', values = node_tags) \n nx.relabel_nodes(self.map, mapping=node_tags, copy=False)\n\n # assign a random color to each node\n colour_list = np.random.choice( list(colors.get_named_colors_mapping().values()), len(self.map) )\n colour_dict = dict( zip(self.map.nodes, colour_list) )\n nx.set_node_attributes(self.map, name = 'node_color', values = colour_dict)\n\n # save node attributes to CoMap object\n self.node_labels = nx.get_node_attributes(self.map, name = 'node_label')\n self.node_colors = nx.get_node_attributes(self.map, name = 'node_color')\n \n return","def matching_graph(n):\r\n k_n = nx.complete_graph(n)\r\n G = nx.Graph()\r\n for i in k_n.edges():\r\n G.add_node(i)\r\n w = []\r\n for i in k_n.edges():\r\n for j in k_n.edges():\r\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \r\n w.append((i,j))\r\n G.add_edge(i,j)\r\n return G","def test_DRGEP_GraphSearchFromG(self):\n graph = nx.DiGraph()\n graph.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \n 'L', 'M', 'N', 'O'\n ])\n\n graph.add_weighted_edges_from([('A','F', 0), ('C','F',1.0), ('A','C',1.0),\n ('A','N',0), ('N','C',1.0), ('C','D',1.0),\n ('D','I',1.0), ('I','O',1.0), ('A','E',1.0),\n ('E','G',0), ('G','I',0), ('G','M',0),\n ('G','L',1.0), ('E','H',1.0), ('H','J',0)\n ])\n\n subgraph = nx.DiGraph([(u,v,d) for u,v,d in graph.edges(data=True) if d['weight'] > 0])\n\n\n #temporary solution\n max_dic = graph_search_drgep(subgraph, 'G')\n\n assert 'G' in max_dic\n assert max_dic['G']\n assert [n in max_dic for n in ['G', 'L']]\n assert [n not in max_dic for n in ['A','B','C','D','E','F','H','I', 'J', 'K', 'L','M', 'N']]\n assert max_dic['G']==1\n assert max_dic['L']==1","def hashimoto_matrix(G, create_using=None):\n if create_using is None:\n L = G.fresh_copy()\n else:\n L = create_using\n\n # Create a graph specific edge function.\n get_edges = g.generators.line._edge_func(G)\n\n for from_node in get_edges():\n # from_node is: (u,v) or (u,v,key)\n L.add_node(from_node)\n for to_node in get_edges(from_node[1]):\n # Modification here: make sure there aren't reciprocal edges.\n if to_node != (from_node[1], from_node[0]):\n L.add_edge(from_node, to_node)\n return L","def isomorphic(g, h):\n # Note: for some applications, it can speed things up to\n # check equality of orders here.\n #n = len(g)\n #if n != len(h):\n # return False\n\n # Make dicts of verts of each nbr-degree, for graphs g, h\n gdv = _degree_verts(g)\n hdv = _degree_verts(h)\n\n # Compare nbr-degree sequences\n if len(gdv) != len(hdv):\n return False\n for k in gdv:\n if k not in hdv:\n return False\n if len(gdv[k]) != len(hdv[k]):\n return False\n # Now we know that g, h have the same order\n\n # Sort (& renumber) verts by nbr-degree\n gvp = list(itertools.chain.from_iterable(\n ( gdv[k] for k in sorted(gdv.keys()) )\n ))\n g = [ sorted([gvp.index(w) for w in g[v]]) for v in gvp ]\n hvp = list(itertools.chain.from_iterable(\n ( hdv[k] for k in sorted(hdv.keys()) )\n ))\n h = [ sorted([hvp.index(w) for w in h[v]]) for v in hvp ]\n\n # Remake dict of verts of each nbr-degree, for g\n gdv = _degree_verts(g)\n\n # Try all permutations of the vertex set of graph g that take each\n # vertex to a vertex whose neighbors have the same degree sequence.\n n = len(g)\n hsets = list(map(set, h))\n for p in _partition_perms(list(gdv.values()), n):\n for v in range(n):\n if hsets[p[v]] != set([p[w] for w in g[v]]):\n # A set comprehension would be nice above\n break\n else:\n return True\n return False","def classify(genes, G):\n\n import networkx as nx\n\n # Calculate distance\n gendist = gen_dist(genes)\n N = gendist.shape[0]\n\n # Make the distance with comparison \"upper triangular\" by\n # setting lower diagonal of matrix extremely large\n gendist[np.arange(N)[:,None] >= np.arange(N)] = 999999\n\n # Get a list of pairs of indices (i,j) satisfying distance(i,j) < G\n indices = np.where(gendist <= G)\n indices = list(zip(indices[0], indices[1]))\n\n # Now is the tricky part. I want to combine all the (i,j) indices\n # that share at least either i or j. This non-trivial problem can be\n # modeled as a graph problem (stackoverflow link). The solution is\n G = nx.Graph()\n G.add_edges_from(indices)\n return list(nx.connected_components(G))","def jupiteNetwork(): \n \n # Build a graph for large clos topo\n tor_cut, aggr_cut, spine_cut = 512, 256, 256\n #2048, 4096, 4096 #32*4*2, 64*2, 16*2\n switches, edges = tp.jupiter_topo(\n tor_cut=tor_cut, aggr_cut=aggr_cut, spine_cut=spine_cut\n )\n \n G = build_graph(edges)\n external_edges = []\n for node in G.nodes():\n if 'sh' in node:\n G.add_edge(node, 'e1')\n \n \"\"\"\n paths = list(nx.all_shortest_paths(G, 'tor385', 'tor1'))\n #print(paths)\n #eee\n paths = list(nx.all_shortest_paths(G, 'tor129', 'tor257'))\n #print(paths)\n paths = list(nx.all_shortest_paths(G, 'tor257', 'tor385'))\n #print(paths)\n #eee\n \"\"\"\n switch_nodes, hnodes, tors, anodes, snodes = tp.getJupiternNodes(\n tors_num=tor_cut, aggr_num=aggr_cut, spine_num=spine_cut\n )\n print('**** is_connected(G)', nx.is_connected(G))\n print('**** number of components', nx.number_connected_components(G))\n \n tors = tors[0:512] + ['e1']\n\n # Get the routing path of all nodes\n table_file_name = '../outputs/jupiter_routing_table_anodes_cut4.txt'\n\n if((os.path.isfile(table_file_name)) == False):\n table = all_routing(G, tors, table_file_name)\n else:\n json_data = open(table_file_name).read()\n table = json.loads(json_data)\n \n seeds, polys = cf.get_seeds_table_jupiter(switch_nodes + ['e1']) #\n \n return G, tors, edges, table, seeds, polys, anodes","def cluster_connectivity(G, weight='weight'):\n\t# 1) indexing the edges by community\n\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\n\tfor node1, node2 in G.edges():\n\t\tcomm1 = G.nodes[node1]['community']\n\t\tcomm2 = G.nodes[node2]['community']\n\t\tif comm2 not in sum_edges_dic[comm1]:\n\t\t\tsum_edges_dic[comm1][comm2] = 0\n\t\t\tsum_edges_dic[comm2][comm1] = 0\n\t\telse:\n\t\t\tif weight is None:\n\t\t\t\tsum_edges_dic[comm1][comm2] += 1\n\t\t\t\tsum_edges_dic[comm2][comm1] += 1\n\t\t\telse:\t\n\t\t\t\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\n\t\t\t\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\n\tc_connectivity = {}\n\t# 2) computing the connectivity\n\tfor com in sum_edges_dic:\n\t\tin_out_edges = sum(sum_edges_dic[com].values())\n\t\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \n\treturn c_connectivity","def nodes_with_m_nbrs(G,m):\n nodes = set()\n \n # Iterate over all nodes in G\n for n in G.nodes():\n \n # Check if the number of neighbors of n matches m\n if len(G.neighbors(n)) == m:\n \n # Add the node n to the set\n nodes.add(n)\n \n # Return the nodes with m neighbors\n return nodes","def test_get_hyperflex_node_by_moid(self):\n pass","def create_hop_matrix(G, max_hops, node_list):\n distances = dict(nx.all_pairs_dijkstra_path_length(G))\n hop_matrix = torch.zeros(max_hops, G.number_of_nodes(), G.number_of_nodes(), dtype=torch.int)\n for hop in range(max_hops):\n for i, node_from in enumerate(node_list):\n for j, node_to in enumerate(node_list):\n if node_to in distances[node_from].keys() and distances[node_from][node_to] == hop:\n hop_matrix[hop,i,j] = 1\n return hop_matrix","def condensation(G):\n scc = strongly_connected_components(G)\n mapping = dict([(n,tuple(sorted(c))) for c in scc for n in c])\n cG = nx.DiGraph()\n for u in mapping:\n cG.add_node(mapping[u])\n for _,v,d in G.edges_iter(u, data=True):\n if v not in mapping[u]:\n cG.add_edge(mapping[u], mapping[v])\n return cG","def nodes_with_m_nbrs(G, m):\n nodes = set()\n\n # Iterate over all nodes in G\n for n in G.nodes():\n\n # Check if the number of neighbors of n matches m\n if len(G.neighbors(n)) == m:\n\n # Add the node n to the set\n nodes.add(n)\n\n # Return the nodes with m neighbors\n return nodes","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def test_get_hyperflex_node_profile_by_moid(self):\n pass","def allReachable(g, n):\n nodeList = []\n \n keysList = []\n\n for key in g.keys():\n keysList.append(key)\n \n for i in keysList:\n if findPath(g, n, i) != None:\n nodeList.append(i)\n \n nodeList.sort()\n nodeList.remove(n)\n \n return nodeList","def find_eulerian_path(G):\n from operator import itemgetter\n\n # Verify that graph is connected, short circuit\n if G.is_directed() and not nx.is_weakly_connected(G):\n raise nx.NetworkXError(\"G is not connected.\")\n\n # is undirected\n if not G.is_directed() and not nx.is_connected(G):\n raise nx.NetworkXError(\"G is not connected.\")\n\n # Now verify if has an eulerian circuit:\n # even condition of all nodes is satified.\n if nx.is_eulerian(G):\n x = nx.eulerian_circuit(G) # generator of edges\n for i in x:\n yield i\n\n # Not all vertex have even degree,\n # check if exactly two vertex have odd degrees.\n # If yes, then there is an Euler path. If not,\n # raise an error (no euler path can be found)\n else:\n g = G.__class__(G) # copy graph structure (not attributes)\n\n # list to check the odd degree condition, and a flag\n check_odd = []\n directed = False\n\n if g.is_directed():\n degree = g.in_degree\n out_degree = g.out_degree\n edges = g.in_edges_iter\n get_vertex = itemgetter(0)\n directed = True\n else:\n degree = g.degree\n edges = g.edges_iter\n get_vertex = itemgetter(1)\n\n # Verify if an euler path can be found. Complexity O(n) ?\n for vertex in g.nodes():\n deg = degree(vertex)\n # directed case\n if directed:\n outdeg = out_degree(vertex)\n if deg != outdeg:\n # if we have more than 2 odd nodes,\n # we do a raise (no euler path)\n if len(check_odd) > 2:\n raise nx.NetworkXError(\"G doesn't have an Euler Path.\")\n # is odd and we append it.\n else:\n check_odd.append(vertex)\n # undirected case\n else:\n if deg % 2 != 0:\n # if we have more than 2 odd nodes,\n # we do a raise (no euler path)\n if len(check_odd) > 2:\n raise nx.NetworkXError(\"G doesn't have an Euler Path.\")\n # is odd and we append it.\n else:\n check_odd.append(vertex)\n\n if directed:\n def verify_odd_cond(g, check_odd):\n first = check_odd[0]\n second = check_odd[1]\n if (g.out_degree(first) == g.in_degree(first) + 1 and\n g.in_degree(second) == g.out_degree(second) + 1):\n return second\n elif (g.out_degree(second) == g.in_degree(second) + 1 and\n g.in_degree(first) == g.out_degree(first) + 1):\n return first\n else:\n return None\n start = verify_odd_cond(g, check_odd)\n else:\n start = check_odd[0]\n\n # if the odd condition is not meet, raise an error.\n if not start:\n raise nx.NetworkXError(\"G doesn't have an Euler Path.\")\n # Begin algorithm:\n vertex_stack = [start]\n last_vertex = None\n\n while vertex_stack:\n\n current_vertex = vertex_stack[-1] # (4)\n # if no neighbors:\n if degree(current_vertex) == 0:\n # Special case, we cannot add a None vertex to the path.\n if last_vertex is not None:\n yield (last_vertex, current_vertex)\n last_vertex = current_vertex\n vertex_stack.pop()\n # we have neighbors, so add the vertex to the stack (2),\n # take any of its neighbors (1)\n # remove the edge between selected neighbor and that vertex,\n # and set that neighbor as the current vertex (4).\n else:\n random_edge = next(edges(current_vertex)) # (1)\n vertex_stack.append(get_vertex(random_edge)) # (2)\n g.remove_edge(*random_edge) # (3)","def create_graph(id):\n\n\timport numpy as np\n\timport networkx as nx\n\n\t# seed the rng\n\tseed = id\n\n\t# set base number of nodes and minimum number of edges\n\tn = 50\n\te = 100\n\n\t# randomise number of nodes\n\tpm1 = (-1)**(seed % 2)\n\tseed = rng(seed)\n\tn += pm1*(seed % 11)\n\tseed = rng(seed)\n\n\t# randomise minimum number of edges\n\tpm2 = (-1)**(seed % 2)\n\tseed = rng(seed)\n\te = 2*n + pm2*(seed % 11)\n\tseed = rng(seed)\n\n\t# initialise empty graph\n\tG = nx.convert_node_labels_to_integers(nx.empty_graph(n))\n\n\t# add e random edges before checking connectedness\n\twhile G.number_of_edges() < e:\n\t\tnode1 = seed % n\n\t\tseed = rng(seed)\n\t\tnode2 = seed % n\n\t\tseed = rng(seed)\n\t\tif node1 != node2:\n\t\t\tif node2 > node1:\n\t\t\t\tnode1, node2 = node2, node1\n\t\t\tG.add_edge(node1, node2)\n\n\t# if G is disconnected, find connected components and add edges\n\tif not nx.is_connected(G):\n\t\tcc = sorted(list(nx.connected_components(G)))\n\t\tlargest = cc[0]\n\t\tfor i in range(len(cc)):\n\t\t\tif len(cc[i]) > len(largest):\n\t\t\t\tlargest = cc[i]\t\t\n\t\tfor component in cc:\n\t\t\tif component != largest:\n\t\t\t\tnode1 = list(component)[seed % len(component)]\n\t\t\t\tseed = rng(seed)\n\t\t\t\tnode2 = list(largest)[seed % len(largest)]\n\t\t\t\tseed = rng(seed)\n\t\t\t\tif node2 > node1:\n\t\t\t\t\tnode1, node2 = node2, node1\n\t\t\t\tG.add_edge(node1, node2)\n\n\t# if for some reason G is still disconnected, print a helpful error message\n\tif nx.is_connected(G):\n\t\treturn G\n\telse:\n\t\tprint(\"Sorry, failed to produce a connected graph :( Please contact one of your lecturers.\")","def IsomorphicHash(self) -> int:\n # The hash is based on the nodes and edges, not their attributes.\n return hash((tuple(self.nodes), tuple(self.edges)))","def test_DRGEP_GraphSearchHalve(self):\n graph = nx.DiGraph()\n graph.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \n 'L', 'M', 'N', 'O'\n ])\n\n graph.add_weighted_edges_from([('A','B', .5), ('B','C',.5), ('C','D',.5), \n ('D','E',.5), ('E','F',.5)\n ])\n\n\n subgraph = nx.DiGraph([(u,v,d) for u,v,d in graph.edges(data=True) if d['weight'] > 0])\n\n\n #temporary solution\n max_dic = graph_search_drgep(subgraph, 'A')\n\n assert 'A' in max_dic\n assert max_dic['A']==1\n assert max_dic['B']==.5\n assert max_dic['C']==.25\n assert max_dic['D']==.125\n assert max_dic['E']==.0625\n assert max_dic['F']==.03125","def T_join(G, T: Set[int]) -> Set[Tuple[int, int]]:\n edge_count = defaultdict(int)\n components = nx.connected_components(G)\n\n # analyse every connected component on its own\n for c in components:\n Ti = T.intersection(c)\n\n # required and sufficient condition for existence of the T-join\n if len(Ti) % 2 == 1:\n raise ValueError(\"T-join does not exist for odd intersections of T\")\n\n while Ti:\n # pop vertices 2 by 2 and find a simple path between them\n x, y = Ti.pop(), Ti.pop()\n path = next(nx.all_simple_paths(G, x, y))\n # count how many times each edge is used\n for i, j in zip(path[:-1], path[1:]):\n edge_count[(min(i, j), max(i, j), 0)] += 1\n\n return {e for e, count in edge_count.items() if count % 2 == 1}","def bipartite_color(G):\n color={}\n for n in G: # handle disconnected graphs\n if n in color: continue\n queue=[n] \n color[n]=1 # nodes seen with color (1 or 0)\n while queue:\n v=queue.pop()\n c=1-color[v] # opposite color of node v\n for w in G[v]: \n if w in color: \n if color[w]==color[v]:\n raise networkx.NetworkXError(\"Graph is not bipartite.\")\n else:\n color[w]=c\n queue.append(w)\n return color","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def randnet(G):\n\t\n\t#initializationo of the lists\n\telst = G.get_edgelist()\n\tclst = G.es['color'][:]\n\tcdic = {}\n\tfor i,c in enumerate(clst):\n\t\tcdic[c]=i\n\tlst1 = [[]]*len(key)\n\tfor i,e in enumerate(elst):\n\t\tlst1[cdic[clst[i]]].append([e[0],e[1]])\n\t\t\n\t#randomization procedure\n\tfor i in range(random.randrange(100,200)):\n\t\tcid = cdic[random.choice(clst)] #random choice weighted by the frequency of each color\n\t\te1id = random.randrange(0,len(lst1[cid])) #random choice of edge with that color\n\t\te2id = random.randrange(0,len(lst1[cid]))\n\t\textop = random.randrange(0,2)#random choice of top/bottom\n\t\tttemp = lst1[cid][e1id][extop]\n\t\tlst1[cid][e1id][extop] = lst1[cid][e2id][extop]\n\t\tlst1[cid][e2id][extop] = ttemp\n\t\n\tcoutlst = []\n\teoutlst\t= []\n\tfor i in range(len(lst1)):\n\t\tc = clst[i]\n\t\tfor e in lst1[i]:\n\t\t\tcoutlst.append(c)\n\t\t\teoutlst.append((e[0],e[1]))\n\n\treturn [eoutlst,coutlst]","def multi_edge():\n from networkx.readwrite import json_graph\n import networkx as nx\n import autonetkit\n # returns a house graph\n data = {'directed': False,\n 'graph': [],\n 'links': [{'_ports': {'r4': 2, 'r5': 1},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 1},\n {'_ports': {'r2': 3, 'r4': 1},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 3},\n {'_ports': {'r2': 4, 'r4': 3},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 3},\n {'_ports': {'r3': 3, 'r5': 2},\n 'raw_interfaces': {},\n 'source': 1,\n 'target': 4},\n {'_ports': {'r1': 1, 'r2': 1},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 3},\n {'_ports': {'r1': 3, 'r2': 5},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 3},\n {'_ports': {'r1': 2, 'r3': 1},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r1': 4, 'r3': 4},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r1': 5, 'r3': 5},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r2': 2, 'r3': 2},\n 'raw_interfaces': {},\n 'source': 3,\n 'target': 4}],\n 'multigraph': True,\n 'nodes': [{'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r4 to r5', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth2'}},\n 'asn': 2,\n 'device_type': 'router',\n 'id': 'r4',\n 'label': 'r4',\n 'x': 675,\n 'y': 300},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r5 to r4', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r5 to r3', 'id': 'eth1'}},\n 'asn': 2,\n 'device_type': 'router',\n 'id': 'r5',\n 'label': 'r5',\n 'x': 675,\n 'y': 500},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r1',\n 'label': 'r1',\n 'x': 350,\n 'y': 400},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r2 to r3', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r2',\n 'label': 'r2',\n 'x': 500,\n 'y': 300},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r3 to r2', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r3 to r5', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r3',\n 'label': 'r3',\n 'x': 500,\n 'y': 500}]}\n graph = json_graph.node_link_graph(data)\n anm = autonetkit.anm.NetworkModel()\n g_in = anm.add_overlay(\"input\")\n g_in._replace_graph(nx.MultiGraph(graph))\n # TODO: check if should build overlays here rather than clone in?\n g_phy = anm[\"phy\"]\n g_phy._replace_graph(graph)\n return anm","def get_neighbor_edges(G, nodes_in_community, weak_neighbor=False):\n neighbor_nodes = []\n for n in nodes_in_community:\n neighbor_nodes.extend([n for n in nx.neighbors(G, n) if n not in nodes_in_community])\n neighbor_nodes = set(neighbor_nodes)\n neighbor_edges = [e for e in G.edges(neighbor_nodes)]\n\n if weak_neighbor:\n # This case returns more edges than the case that weak_neighbor is False\n nodes_ = set(nodes_in_community).union(neighbor_nodes)\n neighbor_edges = list(filter(lambda e: e[0] in nodes_ and e[1] in nodes_, neighbor_edges))\n else:\n neighbor_edges = list(filter(lambda e: e[0] in nodes_in_community or e[1] in nodes_in_community, neighbor_edges))\n return neighbor_edges","def compute_wl_subtree_kernel(graphs, h):\n for G in graphs:\n for node in G.nodes():\n G.node[node]['label'] = G.degree(node)\n\n start_time = time.time()\n\n labels = {}\n label_lookup = {}\n label_counter = 0\n\n N = len(graphs)\n\n orig_graph_map = {it: {i: defaultdict(lambda: 0) for i in range(N)} for it in range(-1, h)}\n\n # initial labeling\n ind = 0\n for G in graphs:\n labels[ind] = np.zeros(G.number_of_nodes(), dtype=np.int32)\n node2index = {}\n for node in G.nodes():\n node2index[node] = len(node2index)\n\n for node in G.nodes():\n label = G.node[node]['label']\n if not label_lookup.has_key(label):\n label_lookup[label] = len(label_lookup)\n\n labels[ind][node2index[node]] = label_lookup[label]\n orig_graph_map[-1][ind][label] = orig_graph_map[-1][ind].get(label, 0) + 1\n\n ind += 1\n\n compressed_labels = copy.deepcopy(labels)\n\n # WL iterations\n for it in range(h):\n unique_labels_per_h = set()\n label_lookup = {}\n ind = 0\n for G in graphs:\n node2index = {}\n for node in G.nodes():\n node2index[node] = len(node2index)\n\n for node in G.nodes():\n node_label = tuple([labels[ind][node2index[node]]])\n neighbors = G.neighbors(node)\n if len(neighbors) > 0:\n neighbors_label = tuple([labels[ind][node2index[neigh]] for neigh in neighbors])\n node_label = str(node_label) + \"-\" + str(sorted(neighbors_label))\n if not label_lookup.has_key(node_label):\n label_lookup[node_label] = len(label_lookup)\n\n compressed_labels[ind][node2index[node]] = label_lookup[node_label]\n orig_graph_map[it][ind][node_label] = orig_graph_map[it][ind].get(node_label, 0) + 1\n\n ind += 1\n\n print \"Number of compressed labels at iteration %s: %s\" % (it, len(label_lookup))\n labels = copy.deepcopy(compressed_labels)\n\n K = np.zeros((N, N))\n\n for it in range(-1, h):\n for i in range(N):\n for j in range(N):\n common_keys = set(orig_graph_map[it][i].keys()) & set(orig_graph_map[it][j].keys())\n K[i][j] += sum([orig_graph_map[it][i].get(k, 0) * orig_graph_map[it][j].get(k, 0) for k in common_keys])\n\n end_time = time.time()\n print \"Total time for WL subtree kernel: \", (end_time - start_time)\n\n return K","def find_attribute_dict(G: nx.DiGraph, node1: NodeID, node2: NodeID, endnode: NodeID):\n edgeID = (node1, node2)\n attribute_dict = dict(G.edges[edgeID])\n attribute_dict[\"distance_efficiency\"] = calc_distance_efficiency(node1, node2, endnode)\n \n return attribute_dict","def generate_csv_dict(G):\n csv_dict = { start_node_id: { dest_node_id: None for dest_node_id in G.nodes } for start_node_id in G.nodes }\n return csv_dict","def network_graph(net_dict=None):\n if net_dict == None:\n net_dict = {}\n else:\n G = nx.from_dict_of_lists(net_dict)\n plt.figure(num=None, figsize=(30, 30), dpi=80, facecolor='w', edgecolor='c')\n nx.draw_networkx(G, with_labels=True, alpha=0.5, edge_color='c', cmap=plt.cm.GnBu)\n plt.savefig(\"metabolism_5years.png\", bbox_inches='tight')","def kegg_pathway_enrichment(degs, negs, dbpaths=dbpaths, show_all=True, pthresh=0.01):\n\n deg_num_ko, deg_keggs = cbir_to_kegg(degs)\n neg_num_ko, neg_keggs = cbir_to_kegg(negs)\n\n print \"%-4d kegg pathways from %d DEGs\" % (len(deg_keggs), len(degs) )\n print \"%-4d kegg pathways from %d nonDEGs\" % (len(neg_keggs), len(negs) )\n\n # create dictionary of kegg pathways {pathwaytype:{pathway:[ko1,ko2,ko3]}}\n pathwaytype_dict = {}\n pathway_dict = {}\n pathway_lookup = {}\n\n print \"extracting pathways...\"\n ko1_h = open(dbpaths['kegg'], 'rb')\n for line in ko1_h:\n if line[0] == 'B': # Kegg path type eg: B <b>Replication and repair</b>\n pathtype_f = re.search('B.*<b>(.*)<', line)\n if pathtype_f is not None:\n pathtype = pathtype_f.group(1)\n else:\n pathtype = 'unknown'\n pathwaytype_dict[pathtype] = {}\n elif line[0] == 'C': # Kegg Pathway eg: 01200 Carbon metabolism [PATH:ko01200]\n pathway_f = re.search(\"C +([0-9]*) *(.*)\\[PATH\", line)\n if pathway_f is not None:\n pathway_id = pathway_f.group(1)\n pathway_name = pathway_f.group(2)\n else:\n pathway_id = 'unknown'\n pathway_name = 'unknown'\n pathway_dict[pathway_id] = {}\n pathway_lookup[pathway_id] = pathway_name\n elif line[0] == 'D': # Kegg term eg: K00844 HK; hexokinase [EC:2.7.1.1]\n koterm_f = re.search(\"(K[0-9]*)\", line)\n if koterm_f is not None:\n koterm = koterm_f.group(1)\n else:\n koterm = 'unknown'\n pathwaytype_dict[pathtype][koterm] = 1\n pathway_dict[pathway_id][koterm] = 1\n\n\n print \"calculating enrichment...\"\n pathwaytype_ps = {}\n pathway_ps = {}\n # count number of degs and negs in each pathway:\n for pathwaytype in pathwaytype_dict:\n pwtsize = len(pathwaytype_dict)\n degs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in deg_keggs])\n negs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in neg_keggs])\n degs_not_in = len(deg_keggs) - degs_in_path\n negs_not_in = len(neg_keggs) - negs_in_path\n\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\n [negs_in_path, negs_not_in] ],\n alternative='greater')\n pathwaytype_ps[pathwaytype] = pval\n\n if pval < pthresh:\n print \"%s\\n \\\n In Path Not in Path\\n\\\n DEG : %-7d %d\\n\\\n non-DEG: %-7d %d\\n\\\n Odds Ratio:%.3f\\n\\\n P-value:%.4f\\n\" % (pathwaytype,degs_in_path,degs_not_in,negs_in_path,negs_not_in,\n oddrat, pval)\n\n\n for pathway in pathway_dict:\n pwtsize = len(pathway_dict)\n degs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in deg_keggs])\n negs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in neg_keggs])\n degs_not_in = len(deg_keggs) - degs_in_path\n negs_not_in = len(neg_keggs) - negs_in_path\n\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\n [negs_in_path, negs_not_in] ],\n alternative='greater')\n pathway_ps[pathway + ' ' + pathway_lookup[pathway]] = pval\n\n ## Fisher's Exact Test:\n # In Pathway: Not in Pathway:\n # DEG : degs_in_path degs_not_in\n # non-DEG : negs_in_path negs_not_in\n #\n\n return pathwaytype_ps, pathway_ps","def _generate_graph(self) -> None:\n self.g_ = nx.random_partition_graph(list(self._community_sizes),\n p_in=self.community_p_in,\n p_out=self.community_p_out,\n seed=self.seed)\n\n for _, nv in self.g_.nodes.data():\n nv[\"infected\"] = 0\n nv[\"immune\"] = False\n nv[\"alive\"] = True\n nv[\"_edges\"] = []\n nv[\"isolated\"] = False\n nv[\"mask\"] = 0.0","def construct_H_with_KNN(X, K_neigs=[10], is_probH=False, m_prob=1):\n if len(X.shape) != 2:\n X = X.reshape(-1, X.shape[-1])\n\n if type(K_neigs) == int:\n K_neigs = [K_neigs]\n\n dis_mat = cos_dis(X)\n H = None\n for k_neig in K_neigs:\n H_tmp = construct_H_with_KNN_from_distance(dis_mat, k_neig, is_probH, m_prob)\n H = hyperedge_concat(H, H_tmp)\n return H","def example_graph():\n g = nx.Graph()\n g.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D'), ('D', 'E'), ('D', 'F'), ('D', 'G'), ('E', 'F'), ('G', 'F')])\n return g","def communityGraph(graph):\n\n lapgr = nx.laplacian_matrix(graph)\n\n # Get the eigenvalues and eigenvectors of the Laplacian matrix\n evals, evec = np.linalg.eigh(lapgr.todense())\n\n fiedler = evec[1]\n results = []\n ## \"Fiedler\", fiedler\n median = np.median(fiedler, axis=1) # median of the second eigenvalue\n for i in range(0, fiedler.size): # divide the graph nodes into two\n if(fiedler[0, i] < median):\n results.append(0)\n else:\n results.append(1)\n return results, evals, evec","def wsngraph():\n G = nx.Graph()\n G.add_node(1)\n G.add_node(2)\n G.add_node(3)\n G.add_node(4)\n G.add_node(5)\n G.add_node(6)\n G.add_node(7)\n G.add_node(8)\n G.add_node(9)\n G.add_node(10)\n G.add_node(11)\n G.add_node(12)\n G.add_edge(1,3,weight=1)\n G.add_edge(1,2,weight=6)\n G.add_edge(1,12,weight=16)\n G.add_edge(2,11,weight=12)\n G.add_edge(2,6,weight=10)\n G.add_edge(2,5,weight=11)\n G.add_edge(3,4,weight=10)\n G.add_edge(3,7,weight=11)\n G.add_edge(3,8,weight=14)\n G.add_edge(3,9,weight=11)\n G.add_edge(4,7,weight=9)\n G.add_edge(5,6,weight=7)\n G.add_edge(5,9,weight=12)\n G.add_edge(6,9,weight=9)\n G.add_edge(7,10,weight=10)\n G.add_edge(8,10,weight=2)\n G.add_edge(8,11,weight=11)\n G.add_edge(8,9,weight=12)\n G.add_edge(9,11,weight=8)\n G.add_edge(10,12,weight=3)\n G.pos={}\n G.pos[1]=(6,4)\n G.pos[2]=(-1,3.7)\n G.pos[3]=(4.7,3.5)\n G.pos[4]=(5.3,3.2)\n G.pos[5]=(0,3)\n G.pos[6]=(1.4,3.4)\n G.pos[7]=(5,2.6)\n G.pos[8]=(4.7,0)\n G.pos[9]=(1.4,2.4)\n G.pos[10]=(5.2,0.5)\n G.pos[11]=(1.3,0)\n G.pos[12]=(6,2.4)\n elarge=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] > 8]\n esmall=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] <= 8]\n nx.draw_networkx_nodes(G,G.pos,node_color='w')\n nx.draw_networkx_edges(G,G.pos,elarge,width=3,edge_color='r',alpha=0.3)\n nx.draw_networkx_edges(G,G.pos,esmall,width=1,edge_color='b',alpha=0.3)\n nx.draw_networkx_labels(G,G.pos)\n ax=plt.gca()\n ax.axison = False\n label = {} \n for (u,v) in G.edges():\n d = G.get_edge_data(u,v)\n label[(u,v)]=d['weight']\n edge_label=nx.draw_networkx_edge_labels(G,G.pos,edge_labels=label)\n\n return(G)","def graph_search(self, node, query):\n\n\t\t\"\"\"\n\t\t<query> ::= <n_query> | <g_query>\n\t\t<n_query> ::= \"NEIGHBOURS WHO HAVE\" <n_conditions> | \"ALL NEIGHBOURS\"\n\t\t<n_conditions> ::= <n_and_condition> | <n_and_condition> \"OR\" <n_and_condition>\n\t\t<n_and_condition> ::= <n_condition> | <n_condition> \"AND\" <n_condition>\n\t\t<n_condition> ::= <label_condition> | <node_label_condition> | <neighbour_num_condition> | \"(\" <n_conditions> \")\"\n\n\t\t<label_condition> ::= \"LABEL\" <label>\n\t\t<node_label_condition> ::= \"NEIGHBOUR LABEL\" <label>\n\t\t<neighbour_num_condition> ::= <num_condition> | <num_label_condition>\n\t\t<num_operator> ::= \"EXACTLY\" | \"LESS THAN\" | \"MORE THAN\"\n\t\t<num_condition> ::= <num_operator> <num> \"NEIGHBOURS\"\n\t\t<num_label_condition> ::= <num_operator> <num> \"NEIGHBOURS WITH LABEL\" <label>\n\n\t\t<g_query> ::= \"PEOPLE WHO HAVE\" <g_conditions>\n\t\t<g_conditions> ::= <g_and_condition> | <g_and_condition> \"OR\" <g_and_condition>\n\t\t<g_and_condition> ::= <g_condition> | <g_condition> \"AND\" <g_condition>\n\t\t<g_condition> ::= <neighbour_num_condition> | <degrees_condition> | \"(\" <g_conditions> \")\"\n\t\t<degrees_condition> ::= <num> \"DEGREES OF SEPARATION FROM ME\"\n\t\t\"\"\"\n\n\t\tdef pop(tokens, legal, off=0):\n\t\t\tif tokens:\n\t\t\t\tfor t in legal:\n\t\t\t\t\tn = len(t.split())\n\n\t\t\t\t\ttoken = ' '.join(tokens[off:n+off])\n\n\t\t\t\t\tif token.lower() == t.lower():\n\t\t\t\t\t\tfor x in range(n):\n\t\t\t\t\t\t\tif len(tokens) > off:\n\t\t\t\t\t\t\t\ttokens.pop(off)\n\t\t\t\t\t\treturn t\n\n\t\t# overall query\n\t\tdef q(tokens):\n\t\t\ta = g_query(tokens)\n\n\t\t\tif a == None:\n\t\t\t\ta = n_query(tokens)\n\n\t\t\tif a == None or tokens:\n\t\t\t\traise ParseException\n\n\t\t\treturn sorted(a, key=lambda n:n.id)\n\n\t\t# N queries\n\t\tdef n_query(tokens):\n\t\t\tcond = None\n\n\t\t\tif pop(tokens, [\"NEIGHBOURS WHO HAVE\"]) and tokens:\n\t\t\t\tcond = n_conds(tokens)\n\t\t\t\tif not cond:\n\t\t\t\t\traise ParseException\n\n\t\t\telif pop(tokens, [\"ALL NEIGHBOURS\"]):\n\t\t\t\tcond = lambda n1,n2:True\n\t\t\t\tif tokens:\n\t\t\t\t\traise ParseException\n\n\t\t\tif cond:\n\t\t\t\treturn [N for n in node.neighbours.values() for N in n if cond(node, N)]\n\n\t\tdef n_conds(tokens):\n\t\t\tcond = n_and_cond(tokens)\n\n\t\t\tif cond and pop(tokens, [\"OR\"]):\n\t\t\t\ta = n_and_cond(tokens)\n\t\t\t\tif a:\n\t\t\t\t\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) or cond(n1, n2))\n\t\t\t\telse:\n\t\t\t\t\traise ParseException\n\n\t\t\treturn cond\n\n\t\tdef n_and_cond(tokens):\n\t\t\tcond = n_cond(tokens)\n\n\t\t\tif cond and pop(tokens, [\"AND\"]):\n\t\t\t\ta = n_cond(tokens)\n\t\t\t\tif a:\n\t\t\t\t\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) and cond(n1, n2))\n\t\t\t\telse:\n\t\t\t\t\traise ParseException\n\n\t\t\treturn cond\n\n\t\tdef n_cond(tokens):\n\t\t\tcond = label_cond(tokens) or node_label_cond(tokens) or neighbour_num_cond(tokens)\n\n\t\t\tif not cond and pop(tokens, [\"(\"]):\n\t\t\t\ttmp = n_conds(tokens)\n\t\t\t\tif tmp and pop(tokens, [\")\"]):\n\t\t\t\t\tcond = tmp\n\t\t\t\telse:\n\t\t\t\t\traise ParseException\n\n\t\t\treturn cond\n\n\t\tdef num_operator(tokens):\n\t\t\treturn pop(tokens, [\"EXACTLY\"]) or pop(tokens, [\"LESS THAN\"]) or pop(tokens, [\"MORE THAN\"])\n\n\t\tdef num_label_cond(tokens):\n\t\t\top = {\n\t\t\t\t\"EXACTLY\" : lambda a,b:a==b,\n\t\t\t\t\"LESS THAN\" : lambda a,b:a<b,\n\t\t\t\t\"MORE THAN\" : lambda a,b:a>b\n\t\t\t}.get(num_operator(tokens), None)\n\t\t\tnum = None\n\n\t\t\tif op and tokens:\n\t\t\t\tg = tokens.pop(0)\n\t\t\t\tif g.isnumeric():\n\t\t\t\t\tnum = int(g)\n\t\t\t\t\tif pop(tokens, [\"NEIGHBOURS WITH LABEL\"]) and tokens:\n\t\t\t\t\t\tl = tokens.pop(0)\n\t\t\t\t\t\treturn lambda n1,n2,num=num,l=l:op(len(n2.neighbours.get(l, [])), num)\n\t\t\t\t\telif pop(tokens, [\"NEIGHBOURS\"]):\n\t\t\t\t\t\treturn lambda n1,n2,num=num:op(len([y for x in n2.neighbours.values() for y in x]), num)\n\n\t\tdef neighbour_num_cond(tokens):\n\t\t\treturn num_label_cond(tokens)\n\n\t\t# General conditions\n\t\tdef label_cond(tokens):\n\t\t\tif pop(tokens, [\"LABEL\"]) and tokens:\n\t\t\t\tl = tokens.pop(0)\n\t\t\t\treturn lambda n1,n2,l=l:(n2.label == l)\n\n\t\tdef node_label_cond(tokens):\n\t\t\tif pop(tokens, [\"NEIGHBOUR LABEL\"]) and tokens:\n\t\t\t\tl = tokens.pop(0)\n\t\t\t\treturn lambda n1,n2,l=l:(n2 in n1.neighbours.get(l, []))\n\n\t\t# G queries\n\t\tdef g_query(tokens):\n\t\t\tcond = None\n\n\t\t\tif pop(tokens, [\"PEOPLE WHO HAVE\"]) and tokens:\n\t\t\t\tcond = g_conds(tokens)\n\t\t\t\tif not cond:\n\t\t\t\t\traise ParseException\n\n\t\t\tif cond:\n\t\t\t\treturn [N for N in self.nodes.values() if cond(node, N)]\n\n\t\tdef g_conds(tokens):\n\t\t\tcond = g_and_cond(tokens)\n\n\t\t\tif cond and pop(tokens, [\"OR\"]):\n\t\t\t\ta = g_and_cond(tokens)\n\t\t\t\tif a:\n\t\t\t\t\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) or cond(n1, n2))\n\t\t\t\telse:\n\t\t\t\t\traise ParseException\n\n\t\t\treturn cond\n\n\t\tdef g_and_cond(tokens):\n\t\t\tcond = g_cond(tokens)\n\n\t\t\tif cond and pop(tokens, [\"AND\"]):\n\t\t\t\ta = g_cond(tokens)\n\t\t\t\tif a:\n\t\t\t\t\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) and cond(n1, n2))\n\t\t\t\telse:\n\t\t\t\t\traise ParseException\n\n\t\t\treturn cond\n\n\t\tdef g_cond(tokens):\n\t\t\tcond = neighbour_num_cond(tokens) or deg_cond(tokens)\n\n\t\t\tif not cond and pop(tokens, [\"(\"]) and tokens:\n\t\t\t\ttmp = g_conds(tokens)\n\t\t\t\tif tmp and pop(tokens, [\")\"]):\n\t\t\t\t\tcond = tmp\n\t\t\t\telse:\n\t\t\t\t\traise ParseException\n\n\t\t\treturn cond\n\n\t\tdef deg_cond(tokens):\n\t\t\tif pop(tokens, [\"DEGREES OF SEPARATION FROM ME\"], 1) and tokens:\n\t\t\t\tt = int(tokens.pop(0))\n\t\t\t\treturn lambda n1,n2:(self.degrees_of_separation(n2.id, n1.id) == t)\n\n\t\treturn q(query.split())","def get_shortest_paths(G):\n \n shortest_paths = {}\n \n for origin in list(G.nodes):\n for destination in list(G.nodes):\n \n if origin != destination:\n shortest_path = nx.shortest_path(G, origin, destination, weight='length')\n shortest_paths[f'{origin}-{destination}'] = shortest_path\n \n return shortest_paths","def nx2gt(nxG):\n # Phase 0: Create a directed or undirected graph-tool Graph\n gtG = Graph(directed=nxG.is_directed())\n\n # Add the Graph properties as \"internal properties\"\n for key, value in list(nxG.graph.items()):\n # Convert the value and key into a type for graph-tool\n tname, value, key = get_prop_type(value, key)\n\n prop = gtG.new_graph_property(tname) # Create the PropertyMap\n \n gtG.graph_properties[key] = prop # Set the PropertyMap\n gtG.graph_properties[key] = value # Set the actual value\n\n # Phase 1: Add the vertex and edge property maps\n # Go through all nodes and edges and add seen properties\n # Add the node properties first\n nprops = set() # cache keys to only add properties once\n for node, data in nxG.nodes(data=True):\n\n # Go through all the properties if not seen and add them.\n for key, val in list(data.items()): \n if key in nprops: continue # Skip properties already added\n\n # Convert the value and key into a type for graph-tool\n tname, _, key = get_prop_type(val, key)\n\n prop = gtG.new_vertex_property(tname) # Create the PropertyMap\n gtG.vertex_properties[key] = prop # Set the PropertyMap\n\n # Add the key to the already seen properties\n nprops.add(key)\n\n # Also add the node id: in NetworkX a node can be any hashable type, but\n # in graph-tool node are defined as indices. So we capture any strings\n # in a special PropertyMap called 'id' -- modify as needed!\n gtG.vertex_properties['id'] = gtG.new_vertex_property('string')\n\n # Add the edge properties second\n eprops = set() # cache keys to only add properties once\n for src, dst, data in nxG.edges(data=True):\n\n # Go through all the edge properties if not seen and add them.\n for key, val in list(data.items()): \n if key in eprops: continue # Skip properties already added\n\n # Convert the value and key into a type for graph-tool\n tname, _, key = get_prop_type(val, key)\n \n prop = gtG.new_edge_property(tname) # Create the PropertyMap\n gtG.edge_properties[key] = prop # Set the PropertyMap\n\n # Add the key to the already seen properties\n eprops.add(key)\n\n # Phase 2: Actually add all the nodes and vertices with their properties\n # Add the nodes\n vertices = {} # vertex mapping for tracking edges later\n for node, data in nxG.nodes(data=True):\n\n # Create the vertex and annotate for our edges later\n v = gtG.add_vertex()\n vertices[node] = v\n\n # Set the vertex properties, not forgetting the id property\n data['id'] = str(node)\n for key, value in list(data.items()):\n gtG.vp[key][v] = value # vp is short for vertex_properties\n\n # Add the edges\n for src, dst, data in nxG.edges(data=True):\n\n # Look up the vertex structs from our vertices mapping and add edge.\n e = gtG.add_edge(vertices[src], vertices[dst])\n\n # Add the edge properties\n for key, value in list(data.items()):\n gtG.ep[key][e] = value # ep is short for edge_properties\n\n # Done, finally!\n return gtG","def graph_hash(self):\n return weisfeiler_lehman_graph_hash(self.graph.graph)","def difference(G, H):\n\n if G.order() != H.order():\n msg = \"Node sets of the two directed graphs are not equal!\"\n raise StaticGraphNotEqNodesException(msg)\n \n n_nodes = G.order()\n edges = ((u, v) for u in G.nodes()\n for v in set(G.successors(u)) - set(H.successors(u)))\n deg = make_deg(n_nodes, edges)\n edges = ((u, v) for u in G.nodes()\n for v in set(G.successors(u)) - set(H.successors(u)))\n D = make(n_nodes, G.size(), edges, deg)\n return D","def construct_network_from_neighbours_list(related_characters: list):\n graph = nx.Graph()\n for edge in related_characters:\n sentiment = edge[1]\n color = ''\n if sentiment == 'Positive':\n color = 'g'\n elif sentiment == 'Negative':\n color = 'r'\n elif sentiment == 'Neutral':\n color = 'k'\n # graph.add_node(edge[0][0], popularity=\n graph.add_edge(edge[0][0], edge[0][1], color=color, weight=edge[2])\n\n return graph","def lexicographic_product(G, H):\n GH = _init_product_graph(G, H)\n GH.add_nodes_from(_node_product(G, H))\n # Edges in G regardless of H designation\n GH.add_edges_from(_edges_cross_nodes_and_nodes(G, H))\n # For each x in G, only if there is an edge in H\n GH.add_edges_from(_nodes_cross_edges(G, H))\n return GH","def prepare_graph(label, nodes, edges, graphID):\n features = {'label': label}\n\n G = nx.DiGraph()\n nodes[\"id\"] = nodes[\"id\"].apply(lambda x : str(x))\n features['num_nodes'] = nodes.shape[0]\n op_node = None\n times = []\n friends = []\n followers = []\n for index, row in nodes.iterrows():\n G.add_node(row['id'], time=row['time'], friends=row['friends'], followers = row['followers'])\n times.append(row['time'])\n friends.append(2**row['friends'])\n followers.append(2**row['followers'])\n if row['time'] == 0:\n features['poster_friend_cnt'] = 2**row['friends']\n features['poster_follower_cnt'] = 2**row['followers']\n tweeter_id = row['id']\n op_node = row['id']\n features['avg_time'] = np.mean(times)\n features['avg_friends'] = np.mean(friends)\n features['avg_followers'] = np.mean(followers)\n features['max_followers'] = max(followers)\n features['max_friends'] = max(friends)\n features['friends_25th_percentile'] = np.percentile(friends, 25)\n features['friends_75th_percentile'] = np.percentile(friends, 75)\n features['followers_25th_percentile'] = np.percentile(followers, 25)\n features['followers_75th_percentile'] = np.percentile(followers, 75)\n node_list = []\n edge_count = 0\n for pair in edges:\n node1, node2 = pair.split()[0], pair.split()[1]\n node_list.append(node1)\n node_list.append(node2)\n G.add_edge(node1, node2)\n edge_count += 1\n features['num_edges'] = edge_count\n sum_users_without_followers = sum([1 for (node, val) in G.in_degree() if val==0])\n features['ratio_users_w/out_followers'] = sum_users_without_followers / len(G.nodes)\n features['num_connected_components'] = nx.number_strongly_connected_components(G)\n features['number_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id)\n features['percentage_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id) / features['poster_follower_cnt']\n features['avg_clustering'] = nx.average_clustering(G)\n features['op_clustering'] = nx.clustering(G,op_node)\n features['transitivity'] = nx.transitivity(G)\n node_list = list(set(node_list))\n features['nodeID_list'] = np.array(node_list)\n features['graph_id'] = graphID\n return features, G","def algorithm(df, params):\n\n output = {}\n\n # algorithm specific code\n # construct network analysis\n NW = Network(df, params['relations'])\n output['d3js'] = NW.export_json()\n output['gephi'] = NW.export_gephi()\n output['pajek'] = NW.export_pajek()\n output['assortativity'] = NW.assortativity()\n output['node_attributes'] = NW.node_attributes()\n output['edge_attributes'] = NW.edge_attributes()\n output['strong_components'] = NW.strong_components()\n output['weak_components'] = NW.weak_components()\n output['triads'] = NW.triads()\n\n # plot network\n pruned_network = NW.prune_network()\n output['div'] = plot.plot_network(pruned_network, params['layout'],\n params['relations'],\n title=params['relations']\n + ' Network graph of 500 nodes with highest degree centrality')\n\n return output","def get_matching_mwpm(graph):\n\n nxgraph = nx.Graph()\n\n def edge_func(nxgraph, e0, e1, weight):\n nxgraph.add_edge(e0, e1, weight=-weight)\n\n all_anyons, nxgraph = get_graph_edges(graph, edge_func, nxgraph)\n\n matching = nx.algorithms.matching.max_weight_matching(nxgraph, maxcardinality=True)\n return [[all_anyons[i0], all_anyons[i1]] for i0, i1 in matching]","def find_girth(self):\r\n girth = sys.maxint\r\n face = []\r\n vertices = list(self.graph.vertices)\r\n shift = random.randint(0,len(vertices)-1)\r\n vertices = vertices[shift:] + vertices[:shift]\r\n random.shuffle(vertices)\r\n \r\n for vertex in vertices:\r\n s = set() # set of explored edge id\r\n distance = {}\r\n distance[vertex.id] = 0\r\n father = {}\r\n father[vertex.id] = (None, None) # (a,b) a is v_id, b is edge id\r\n nodes = [vertex.id] # stack for the vertices to start with\r\n while len(nodes) > 0:\r\n node = nodes.pop(0)\r\n v_a = self.graph.get_vertex(node)\r\n nbrs = list(v_a.neighbors)\r\n random.shuffle(nbrs)\r\n for edge in nbrs:\r\n if not edge.id in s:\r\n another = edge.get_another_vertex(node)\r\n if not distance.has_key(another):\r\n nodes.append(another)\r\n s.add(edge.id)\r\n father[another] = (node, edge.id)\r\n distance[another] = distance[node] + 1\r\n elif distance[another] + distance[node] + 1 < girth:\r\n girth = distance[another] + distance[node] + 1\r\n\r\n face = list()\r\n face.append(edge.id)\r\n start = father[another]\r\n while start[0] is not None:\r\n face.append(start[1])\r\n start = father[start[0]]\r\n face.reverse()\r\n start = father[node]\r\n while start[0] is not None:\r\n face.append(start[1])\r\n start = father[start[0]]\r\n\r\n cycle = []\r\n edge0 = self.graph.get_edge(face[0])\r\n edge1 = self.graph.get_edge(face[1])\r\n (a, b) = edge0.get_endpoints()\r\n if a in edge1.get_endpoints():\r\n a, b = b, a\r\n for e in face:\r\n cycle.append(a)\r\n a = self.graph.get_edge(e).get_another_vertex(a)\r\n # logger.info(\"girth: %s\",cycle)\r\n return (face, cycle)","def construct_H_with_KNN_from_distance(dis_mat, k_neig, is_probH=False, m_prob=1):\n n_obj = dis_mat.shape[0]\n # construct hyperedge from the central feature space of each node\n n_edge = n_obj\n H = np.zeros((n_obj, n_edge))\n for center_idx in range(n_obj):\n dis_mat[center_idx, center_idx] = 0\n dis_vec = dis_mat[center_idx]\n nearest_idx = np.array(np.argsort(dis_vec)).squeeze()\n avg_dis = np.average(dis_vec)\n if not np.any(nearest_idx[:k_neig] == center_idx):\n nearest_idx[k_neig - 1] = center_idx\n\n for node_idx in nearest_idx[:k_neig]:\n if is_probH:\n H[node_idx, center_idx] = np.exp(-dis_vec[0, node_idx] ** 2 / (m_prob * avg_dis) ** 2)\n else:\n H[node_idx, center_idx] = 1.0\n return H","def diminished_disjunctive(G, H):\n if G == 0 or H == 0:\n return Game(0)\n else:\n left_1 = {diminished_disjunctive(G_L, H) for G_L in G._left}\n left_2 = {diminished_disjunctive(G, H_L) for H_L in H._left}\n right_1 = {diminished_disjunctive(G_R, H) for G_R in G._right}\n right_2 = {diminished_disjunctive(G, H_R) for H_R in H._right}\n return Game(left_1 | left_2, right_1 | right_2)","def solve(G):\n\n dominatingSet = nx.algorithms.approximation.dominating_set.min_weighted_dominating_set(G, weight=\"weight\")\n\n # Create the graph T and input the dominating set.\n T = nx.Graph()\n T.add_nodes_from(dominatingSet)\n\n # When the graph is fully dominated by one node, the cost is zero.\n if len(dominatingSet) == 1:\n return T\n\n # The variable defined below, apsp, stands for all pairs shortest paths from calling NetworkX built-in Dijkstra's algorithm.\n apsp = dict(nx.algorithms.shortest_paths.weighted.all_pairs_dijkstra(G, weight = \"weight\"))\n\n # In each iteration of the following for loop, we connect node to node2.\n node2 = None\n for node in dominatingSet:\n\n connected_nodes = nx.dfs_preorder_nodes(T, source=node2)\n\n print(\"Connecting \", node, \"to\", node2)\n print(node2, \"descendants: \", [n for n in connected_nodes])\n\n if node2 is not None and node2 not in list(connected_nodes):\n\n # We want to connect node to node2 in the cheapest way possible.\n # Thus, we search from all nodes connected to node2.\n # By default, we choose the shortest path from node to node2.\n shortest_path = apsp[node2][1][node]\n path_cost = apsp[node2][0][node]\n\n # Now, evaluate if there is a shorter, cheaper path from a different vertex.\n for connected_node in list(nx.dfs_preorder_nodes(T, source=node2)):\n print(\" Cheapest path from \" + str(connected_node) + \": \" + str(apsp[connected_node][0][node]))\n if apsp[connected_node][0][node] < path_cost:\n shortest_path = apsp[connected_node][1][node]\n path_cost = apsp[connected_node][0][node]\n print(\"Updating best path to \" + str(shortest_path) + \", cost \" + str(path_cost))\n\n print(\"Found path via \" + str(shortest_path) + \" of cost \" + str(path_cost))\n\n # Add all necessary vertices.\n for vertex in shortest_path:\n if vertex not in dominatingSet:\n T.add_node(vertex)\n\n # Add all necessary edges.\n for i in range(len(shortest_path) - 1):\n origin = shortest_path[i]\n terminus = shortest_path[i+1]\n T.add_edge(origin, terminus, weight=G.get_edge_data(origin, terminus)['weight'])\n #T[origin][terminus]['weight'] = G.get_edge_data(origin, terminus)['weight']\n\n node2 = node\n print()\n\n current_average = average_pairwise_distance(T)\n last_average = 4000\n print(current_average)\n\n # Until adding more edges doesn't improve the average pairwise cost\n while current_average < last_average:\n last_average = current_average\n # For every node in T\n for node in nx.dfs_preorder_nodes(T, source=list(T.nodes)[0]):\n neighbors = nx.algorithms.traversal.breadth_first_search.bfs_tree(G, node, reverse=False, depth_limit=1)\n # Get one of its neighbors NOT in T\n for node2 in neighbors:\n # and add the edge between that vertex and its neighbor\n # if it decreases the average pairwise cost.\n if node2 not in T and G.get_edge_data(node, node2)\\\n and G[node][node2]['weight'] < current_average:\n T.add_node(node2)\n T.add_edge(node, node2, weight=G.get_edge_data(node, node2)['weight'])\n new_average = average_pairwise_distance(T)\n if new_average > current_average:\n T.remove_node(node2)\n #T.remove_edge(node, node2)\n else:\n current_average = new_average\n print(\"Adding an edge between\", node, \"and\", node2, \"yields average\", new_average)\n\n\n\n print(\"Dominating vertices:\", [node for node in T])\n\n return T","def dhom(src, tgt):\n\n # the stack to hold recursive networks\n stk = [(src, tgt)]\n while len(stk) > 0:\n # pop up the networks at the top\n s, t = stk.pop()\n\n # homogeneity test:\n if not s.__homo__(t):\n return False\n\n # push in child networks\n stk.extend(zip(s, t))\n\n # source and target are deeply homogenuous.\n return True","def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):\n\n\t# Tracks frequency of states for each character in nodes\n\tcharacter_mutation_mapping = defaultdict(int)\n\n\t# G models the network that is returned recursively\n\tG = nx.DiGraph()\n\n\troot = root_finder(nodes)\n\n\t# Base case check for recursion, returns a graph with one node corresponding to the root of the remaining nodes\n\tif len(nodes) <= cutoff or len(nodes) == 1:\n\t\troot = root_finder(nodes)\n\t\tG.add_node(root)\n\t\treturn G, [[root, nodes]]\n\n\t# Accounting for frequency of mutated states per character, in order to choose the best split\n\tfor node in nodes:\n\t\tnode_list = node.split(\"_\")[0].split('|')\n\t\tfor i in range(0, len(node_list)):\n\t\t\tchar = node_list[i]\n\t\t\tif char != '0' and char != '-':\n\t\t\t\tcharacter_mutation_mapping[(str(i), char)] += 1\n #if char != '0':\n # if char == \"-\":\n # character_mutation_mapping[(str(i), char)] -= 1\n # else:\n # character_mutation_mapping[(str(i), char)] += 1\n\n\t# Choosing the best mutation to split on (ie character and state)\n\tcharacter, state = 0, 0\n\tmax_cost = 0\n\n\tmin_prior = 1\n\tif priors:\n\t\tfor i in priors.keys():\n\t\t\tfor j in priors[i].keys():\n\t\t\t\tmin_prior = min(min_prior, priors[i][j])\n\n\tfor i,j in character_mutation_mapping:\n\t\tif not (i,j) in considered:\n\t\t\tif not priors:\n\t\t\t\tif max_cost < character_mutation_mapping[(i, j)]:\n\t\t\t\t\tmax_cost = character_mutation_mapping[(i, j)]\n\t\t\t\t\tcharacter, state = i, j\n\t\t\telse:\n\t\t\t\tif j not in priors[int(i)]:\n\t\t\t\t\tpriors[int(i)][j] = min_prior\n\t\t\t\tif max_cost < -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]:\n\t\t\t\t\tmax_cost = -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]\n\t\t\t\t\tcharacter, state = i, j\n\tcharacter = int(character)\n\n\n\t# If there is no good split left, stop the process and return a graph with the remainder of nodes\n\tif character == 0 and state == 0:\n\t\tif len(nodes) == 1:\n\t\t\tG.add_node(nodes[0])\n\t\telse:\n\t\t\tfor i in range(0, len(nodes)):\n\t\t\t\tif nodes[i] != root:\n\t\t\t\t\tG.add_edge(root, nodes[i])\n\t\treturn G, []\n\n\t# Splitting nodes based on whether they have the mutation, don't have the mutation, or are NA('-') in that character\n\t# Right split is where nodes with the mutation go, everyone else goes to left split or NA chars\n\tleft_split, right_split, NA_chars = [], [], []\n\tright_split_temp = []\n\tleft_split_temp = []\n\tfor node in nodes:\n\t\tnode_list = node.split('|')\n\t\tif node_list[character] == state:\n\t\t\tright_split.append(node)\n\t\telif node_list[character] == '-':\n\t\t\tNA_chars.append(node)\n\t\telse:\n\t\t\tleft_split.append(node)\n\n\n\t# Seperates all nodes with NA in the character chosen to be split upon\n\t# Puts in right split or left split based on which list shares more mutated characters with this string\n\tfor node in NA_chars:\n\t\tright_split_score = 0\n\t\tleft_split_score = 0\n\t\tnode_list = node.split('|')\n\t\tnum_not_missing = len([n for n in node_list if n != \"-\"])\n\t\tfor i in range(0, len(node_list)):\n\t\t\tif node_list[i] != '0' and node_list[i] != '-':\n\t\t\t\tfor node_2 in left_split:\n\t\t\t\t\tnode2_list = node_2.split('|')\n\t\t\t\t\tif node_list[i] == node2_list[i]:\n\t\t\t\t\t\tleft_split_score += 1\n\t\t\t\tfor node_2 in right_split:\n\t\t\t\t\tnode2_list = node_2.split('|')\n\t\t\t\t\tif node_list[i] == node2_list[i]:\n\t\t\t\t\t\tright_split_score += 1\n\n\t\tavg_left_split_score = left_split_score / float(len(left_split) * num_not_missing + 1)\n\t\tavg_right_split_score = right_split_score / float(len(right_split) * num_not_missing + 1)\n\n\t\tif avg_left_split_score < avg_right_split_score:\n\t\t\tright_split_temp.append(node)\n\t\telse:\n\t\t\tleft_split_temp.append(node)\n\n\tright_split += right_split_temp\n\tleft_split += left_split_temp\n\n\t# Add character, state that split occurred to already considered mutations\n\tconsidered.add((str(character), state))\n\tG = nx.DiGraph()\n\t#splitter = str(character) + \" \" + str(state) + \" (\" + uniq + \")\"\n\tsplitter = root\n\n\t# Recursively build left side of network (ie side that did not mutation at the character with the specific state)\n\tG.add_node(splitter)\n\tleft_subproblems = []\n\tleft_network = None\n\tif len(left_split) != 0:\n\t\tleft_root = root_finder(left_split)\n\t\t# if left_root not in left_split and left_root in targets:\n\t\t# \tleft_root = left_root + \"_unique\"\n\n\t\tleft_network, left_subproblems = greedy_build(left_split, priors, cutoff, considered.copy(), uniq + \"0\", targets=targets)\n\n\t\tleft_nodes = [node for node in left_network.nodes() if left_network.in_degree(node) == 0]\n\t\tdup_dict = {}\n\t\tfor n in left_network:\n\t\t\tif n in list(G.nodes()) and n != left_root:\n\t\t\t\tdup_dict[n] = n + \"_\" + str(hashlib.md5(left_root.encode('utf-8')).hexdigest())\n\t\tleft_network = nx.relabel_nodes(left_network, dup_dict)\n\t\tG = nx.compose(G, left_network)\n\t\tif root != left_root:\n\t\t\tG.add_edge(splitter, left_root, weight=0, label=\"None\")\n\n\t# Recursively build right side of network\n\tright_network, right_subproblems = greedy_build(right_split, priors, cutoff, considered.copy(), uniq + \"1\", targets=targets)\n\tright_nodes = [node for node in right_network.nodes() if right_network.in_degree(node) == 0]\n\tright_root = root_finder(right_split)\n\n\tdup_dict = {}\n\tfor n in right_network:\n\t\tif n in list(G.nodes()) and n != right_root:\n\t\t\tdup_dict[n] = n + \"_\" + str(hashlib.md5(right_root.encode('utf-8')).hexdigest())\n\tfor n in dup_dict:\n\t\trename_dict = {n: dup_dict[n]}\n\t\tif right_network.out_degree(n) != 0:\n\t\t\tright_network = nx.relabel_nodes(right_network, rename_dict)\n\t\telse:\n\t\t\trename_dict = {n: dup_dict[n]}\n\t\t\tG = nx.relabel_nodes(G, rename_dict)\n\n\tG = nx.compose(G, right_network)\n\t# if right_root not in right_split and right_root in targets:\n\t# \tright_root = right_root + \"_unique\"\n\t#for node in right_nodes:\n\tif root != right_root:\n\t\tif not priors:\n\t\t\tG.add_edge(splitter, right_root, weight=1, label = str(character) + \": 0 -> \" + str(state))\n\t\telse:\n\t\t\tG.add_edge(splitter, right_root, weight=-np.log(priors[int(character)][state]), label=str(character) + \": 0 -> \" + str(state))\n\n\n\treturn G, left_subproblems + right_subproblems","def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\n if nbunch is None:\n nbunch = G\n else:\n nbunch = set(nbunch)\n\n directed = G.is_directed()\n if directed:\n iter_func = itertools.permutations\n else:\n iter_func = itertools.combinations\n\n all_pairs = {n: {} for n in nbunch}\n\n for u, v in iter_func(nbunch, 2):\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\n all_pairs[u][v] = k\n if not directed:\n all_pairs[v][u] = k\n\n return all_pairs","def stupid_current_distance(G):\n\n T = prepotential(G)\n edge_dict = {e:0 for e in G.edges}\n N = G.number_of_nodes()\n\n for s in range(N):\n for t in range(s+1,N):\n p = T[:,s] - T[:,t]\n for (v,w) in edge_dict:\n edge_dict[(v,w)] += abs(p[v]-p[w])\n return edge_dict","def make_mammalian_n_glycan_neighborhoods():\n neighborhoods = NeighborhoodCollection()\n\n _neuraminic = \"(%s)\" % ' + '.join(map(str, (\n FrozenMonosaccharideResidue.from_iupac_lite(\"NeuAc\"),\n FrozenMonosaccharideResidue.from_iupac_lite(\"NeuGc\")\n )))\n _terminal = _neuraminic + \\\n \" + max(%s - %%d, 0)\" % FrozenMonosaccharideResidue.from_iupac_lite(\"Hex\")\n _hexose = \"(%s)\" % ' + '.join(\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['Hex', ])))\n _hexnac = \"(%s)\" % ' + '.join(\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['HexNAc', ])))\n\n high_mannose = CompositionRangeRule(\n _hexose, 3, 12) & CompositionRangeRule(\n _hexnac, 2, 2) & CompositionRangeRule(\n _neuraminic, 0, 0)\n high_mannose.name = \"high-mannose\"\n neighborhoods.add(high_mannose)\n\n base_hexnac = 3\n base_terminal_groups = 2\n for i, spec in enumerate(['hybrid', 'bi', 'tri', 'tetra', 'penta', \"hexa\", \"hepta\"]):\n if spec == 'hybrid':\n rule = CompositionRangeRule(\n _hexnac, base_hexnac - 1, base_hexnac + 1\n ) & CompositionRangeRule(\n _neuraminic, 0, base_terminal_groups) & CompositionRangeRule(\n _hexose, base_hexnac + i - 1,\n base_hexnac + i + 3)\n rule.name = spec\n neighborhoods.add(rule)\n else:\n sialo = CompositionRangeRule(\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\n ) & CompositionRangeRule(\n (_neuraminic), 1, base_terminal_groups + i\n ) & CompositionExpressionRule(\n \"(Hex > %d) & (Hex < (%d - (NeuAc + NeuGc)))\" % (base_hexnac + i - 2, base_hexnac + (2 * i) + 3))\n\n sialo.name = \"%s-antennary\" % spec\n asialo = CompositionRangeRule(\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\n ) & CompositionRangeRule(\n _neuraminic, 0, 1 if i < 2 else 0\n ) & CompositionRangeRule(\n _hexose, base_hexnac + i - 1,\n base_hexnac + (2 * i) + 3)\n asialo.name = \"asialo-%s-antennary\" % spec\n neighborhoods.add(sialo)\n neighborhoods.add(asialo)\n return neighborhoods","def prim(network_graph):\n seen_nodes = set()\n mst = set()\n edges = set()\n\n # Using the first node in the network graph as the root of the tree\n current_node = list(network_graph.keys())[0]\n\n while True:\n # Adding all edges from the root to the list of edges\n for current_neighbor in network_graph[current_node]:\n # Edge represented as (weight, [node, neighbor])\n edge = (network_graph[current_node][current_neighbor],\n frozenset([current_node, current_neighbor]))\n if edge in mst:\n continue\n edges.remove(edge) if edge in edges else edges.add(edge)\n\n if edges:\n # Get the smallest edge in the list, remove & add to MST\n smallest_edge = min(edges)\n edges.remove(smallest_edge)\n mst.add(smallest_edge)\n\n # Get the next node to examine\n _, (new_node, new_neighbor) = smallest_edge\n seen_nodes.add(current_node)\n current_node = (new_node if new_neighbor in\n seen_nodes else new_neighbor)\n else:\n break\n\n # Convert from sets to dictionary of {edge: weight}\n # 'final_weight' indicates the smallest weight for the given 'final_edge'\n # between two nodes that doesn't create a cycle\n return dict((final_edge, final_weight) for (final_weight, final_edge) in\n mst)","def generate_homography_nn_sgd(self):\n # Create the NN\n self.set_optimizer_sgd()\n self.set_callback(utils.lr_callback)\n self.build_model()\n self.compile()","def hypergraph_homology_basis(h, k, shortest=False, log=None):\n max_dim = np.max([len(e) for e in h.edges()]) - 1\n\n if k > max_dim or k < 1:\n return 'wrong dim'\n C = dict()\n for i in range(k - 1, k + 2):\n C[i] = kchainbasis(h, i)\n bd = dict()\n for i in range(k, k + 2):\n bd[i] = bkMatrix(C[i - 1], C[i])\n if log:\n try:\n logdict = pickle.load(open(log, 'rb'))\n except:\n logdict = dict()\n logdict.update({'maxdim': max_dim,\n 'kchains': C,\n 'bd': bd, })\n pickle.dump(logdict, open(log, 'wb'))\n return homology_basis(bd, k, C=C[k], shortest=shortest, log=log)","def get_graph_karateclub():\n all_members = set(range(34))\n club1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 16, 17, 19, 21}\n # club2 = all_members - club1\n\n G = eg.Graph(name=\"Zachary's Karate Club\")\n for node in all_members:\n G.add_node(node+1)\n\n zacharydat = \"\"\"\\\n0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0\n1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0\n1 1 0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0\n1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1\n0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1\n0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0 1\n0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 1 0\"\"\"\n\n for row, line in enumerate(zacharydat.split('\\n')):\n thisrow = [int(b) for b in line.split()]\n for col, entry in enumerate(thisrow):\n if entry == 1:\n G.add_edge(row+1, col+1)\n\n # Add the name of each member's club as a node attribute.\n for v in G:\n G.nodes[v]['club'] = 'Mr. Hi' if v in club1 else 'Officer'\n return G","def er(num_nodes,p) :\n complete_graph = {}\n if (num_nodes <= 0):\n return complete_graph\n for node_index in range(num_nodes) :\n # Loop through all possible nodes and edges, adding edges to set\n complete_graph[node_index] = set([])\n for edge_index in range(num_nodes) :\n if (node_index != edge_index) :\n val = random.random()\n if (val < p):\n complete_graph[node_index].add(edge_index)\n return complete_graph","def SetHomoplasy(tree, skip=0):\n population = tree.size if 'size' in vars(tree) else (len(tree) * 2) - 1\n order = tree.traverse()\n root = next(order)\n homoplasy_hist = sp.csr_matrix(np.zeros(root.genotype.shape[1] - skip))\n for cur_node in tqdm.tqdm(order, total=population + 1):\n homoplasy_hist += (cur_node.genotype[0, skip:] != cur_node.up.genotype[0, skip:])\n homoplasy_dist = pd.Series(homoplasy_hist.data).value_counts(normalize=True)\n fit_dist = rv_discrete(values=(homoplasy_dist.index.astype(int), homoplasy_dist.values.astype(float)))\n root.homoplasy = fit_dist\n root.homoplasy_hist = homoplasy_hist.toarray()[0].astype(np.int)\n return tree","def generate_mapping(g: Graph, h: Graph):\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)","def BFTM_(adj_list,labels):\n G_prime = nx.Graph()\n num_clusters = list(np.unique(labels))\n clusters = {i:[] for i in num_clusters}\n hood = {n.id:[i for i in num_clusters if i != labels[n.id]] for n in adj_list}\n \n #Add nodes to clusters\n for idx,n in enumerate(adj_list):\n clusters[labels[idx]].append(n.id)\n \n root_cluster = random.choice(num_clusters)\n root_id = random.choice(list(clusters[root_cluster]))\n queue = [adj_list[root_id]]\n clusters[labels[root_id]].remove(root_id)\n \n \n #BFTM\n while len(queue) > 0:\n node = queue.pop(0)\n for c_id in hood[node.id]:\n if len(clusters[c_id]) > 0:\n sample_id = random.choice(clusters[c_id])\n clusters[labels[sample_id]].remove(sample_id)\n queue.append(adj_list[sample_id])\n hood[sample_id].remove(labels[node.id])\n G_prime.add_edge(node,adj_list[sample_id])\n hood[node.id] = None\n #Handle leftover nodes\n if len(queue) == 0:\n remaining = [c for i,c in clusters.items() if len(c) > 0]\n for rem_cluster in remaining:\n for n in rem_cluster:\n added = False\n while not added:\n rand_n = random.choice(list(G_prime.nodes))\n if labels[rand_n.id] != labels[n.id]:\n G_prime.add_edge(n,rand_n)\n added = True\n \n \n #Cliqify\n for node in list(G_prime.nodes):\n if G_prime.degree(node) < len(num_clusters) - 1:\n for _1_hop in list(G_prime.neighbors(node)):\n for _2_hop in list(G_prime.neighbors(_1_hop)):\n if _2_hop != node and G_prime.degree(_2_hop) < len(num_clusters) - 1:\n G_prime.add_edge(node,_2_hop)\n \n return G_prime","def smallClosNetwork():\n \n # Build a graph for Jupiter topo\n switch_nodes, edges = tp.tree_topo()\n G = build_graph(edges)\n nodes, host_nodes, tors, anodes, snodes = tp.getnodes()\n\n print('**** is_connected(G)', nx.is_connected(G))\n \n \n # Get the routing path of all nodes\n table_file_name = '../outputs/tree_routing_table.txt'\n if((os.path.isfile(table_file_name)) == False):\n table = all_routing(G, tors+['e1'], table_file_name)\n else:\n json_data = open(table_file_name).read()\n table = json.loads(json_data)\n \n print('**** Got routing table!')\n\n seeds, polys = cf.get_seeds_table_tree(switch_nodes) #\n \n return G, tors, edges, table, seeds, polys","def kAnonymit(g,k):\n rlist=list()\n degreeH=nx.degree_histogram(g)\n## print degreeH\n li=[[] for i in range(len(degreeH))]\n uNode=dict(zip(range(len(degreeH)),li))\n \n gd=g.degree()\n for e in gd:\n uNode[gd[e]].append(e)\n ad=list()\n mi=list()\n su=list() \n sel3(g,3,ad,mi,su)\n nodeAd=list()\n nodeMi=list()\n nodeSu=list() \n for i in ad:\n nodeAd=nodeAd+uNode[i]\n #nodeAd store the graph ID\n for i in mi:\n nodeMi=nodeMi+uNode[i]\n for i in su:\n nodeSu=nodeSu+uNode[i]\n\n print nodeAd,nodeMi,nodeSu\n\n\n i=0#Add edge \n while i<len(nodeAd)-1:\n j=i+1\n while j<len(nodeAd):\n if not g.has_edge(nodeAd[i],nodeAd[j]):\n g.add_edge(nodeAd[i],nodeAd[j])\n rlist.append(nodeAd[i])\n rlist.append(nodeAd[j])\n nodeAd.pop(j)\n nodeAd.pop(i)\n i=i-1\n break\n else:\n j=j+1\n i=i+1\n print nodeAd\n \n i=0#delet edge\n while i<len(nodeMi)-1:\n j=i+1\n while j<len(nodeMi):\n if g.has_edge(nodeMi[i],nodeMi[j]):\n g.remove_edge(nodeMi[i],nodeMi[j])\n rlist.append(nodeMi[i])\n rlist.append(nodeMi[j])\n nodeMi.pop(j)\n nodeMi.pop(i)\n i=i-1\n break\n else:\n j=j+1\n i=i+1\n print nodeMi\n \n i=0#Add edge \n while i<len(nodeSu):\n j=0\n while j<len(nodeAd):\n if not g.has_edge(nodeSu[i],nodeAd[j]):\n g.add_edge(nodeSu[i],nodeAd[j])\n rlist.append(nodeSu[i])\n rlist.append(nodeAd[j])\n nodeAd.pop(j)\n nodeSu.pop(i)\n \n i=i-1\n break\n else:\n j=j+1\n i=i+1\n print nodeSu\n \n i=0#delet edge\n while i<len(nodeSu):\n j=0\n while j<len(nodeMi):\n if g.has_edge(nodeSu[i],nodeMi[j]):\n g.remove_edge(nodeSu[i],nodeMi[j])\n rlist.append(nodeSu[i])\n rlist.append(nodeMi[j])\n nodeMi.pop(j)\n nodeSu.pop(i)\n i=i-1\n break\n else:\n j=j+1\n i=i+1\n print nodeSu\n return rlist","def erdos_rennie_like(num_nodes, num_hedges, max_hedge_width, self_loops=False):\n if max_hedge_width > num_nodes:\n print(\"Error: the requested construction is flawed! There are not enoough nodes to support the requested max_hedge_width!\")\n return -1\n \n if ((max_hedge_width * 2) > num_nodes) and (self_loops == False):\n print(\"Error: the requested construction is flawed! There are not enough nodes to support the requested max_hedge_width without self loops!\")\n return -1\n \n node_ls = [] \n hedge_ls = [] #hedges will be encoded as ordered lists, where entry 0 is a list containing nodes in the tail and entry 1 is a list containing nodes in the head\n hedge_set = set() #to avoid repeated edges I use a set to keep track of the edges. The set will be converted back to a list when it is returned.\n \n for n in range(num_nodes): #initializes nodes\n node_ls.append(str(n))\n \n hedges_full = False\n while hedges_full == False:\n tail_width = random.randint(1,max_hedge_width)\n head_width = random.randint(1,max_hedge_width)\n new_hedge = hedge_maker(tail_width, head_width, node_ls, self_loops)\n hedge_set.add(new_hedge)\n if len(hedge_set) >= num_hedges:\n hedges_full = True\n \n for hedge in hedge_set: #formats the hedges into lists instead of tuples containing frozensets\n tail_ls = []\n head_ls = []\n for node in hedge[0]:\n tail_ls.append(node)\n \n for node in hedge[1]:\n head_ls.append(node)\n \n formatted_hedge = [tail_ls, head_ls]\n hedge_ls.append(formatted_hedge)\n \n return node_ls, hedge_ls"],"string":"[\n \"def check_Motifs(H, m):\\n\\t#This function will take each possible subgraphs of gr of size 3, then\\n\\t#compare them to the mo dict using .subgraph() and is_isomorphic\\n\\t\\n\\t#This line simply creates a dictionary with 0 for all values, and the\\n\\t#motif names as keys\\n\\n\\t##paper source \\\"Higher-order organization ofcomplex networks\\\" (2016) Benson et al, Science\\n\\t## I choose only the unidirection ones : M1, M5, M8, M9, M10\\n\\n\\n\\ts = int(m)\\n\\n\\tif (s==3):\\n\\t\\t#motifs = {'M1': nx.DiGraph([(1,2),(2,3),(3,1)]), 'M5': nx.DiGraph([(1,2),(2,3),(1,3)]), 'M8': nx.DiGraph([(2, 1),(2,3)]), 'M9': nx.DiGraph([(2, 1),(3, 2)]), 'M10': nx.DiGraph([(1,2),(3,2)])}\\n\\t\\tmotifs = {'M1': [(1,2),(2,3),(3,1)], 'M5': [(1,2),(2,3),(1,3)], 'M8': [(2, 1),(2,3)], 'M9': [(2, 1),(3, 2)], 'M10': [(1,2),(3,2)],\\n\\t\\t\\t\\t\\t'M2': [(1,2),(2,3),(3,2),(3,1)], 'M3': [(1,2),(2,3),(3,2),(1,3),(3,1)], 'M4': [(1,2),(2,1),(2,3),(3,2),(1,3),(3,1)], 'M6': [(2, 1),(2,3),(1,3),(3,1)], 'M7': [(1,2),(3,2),(1,3),(3,1)],\\n\\t\\t\\t\\t\\t'M11': [(1,2),(2,1),(2,3)], 'M12': [(1,2),(2,1),(3,2)], 'M13': [(1,2),(2,1),(2,3),(3,2)]}\\n\\n\\telif (s==4): ## under development\\n\\t\\tmotifs = {'bifan': [(1,2),(1,3),(4,2),(4,3)]}\\n\\n\\t\\t#edgeLists=[[[1,2],[1,3],[1,4]]]\\n\\t\\t#edgeLists.append([[1,2],[1,3],[1,4],[2,3]])\\n\\t\\t#edgeLists.append([[1,2],[1,3],[1,4],[2,3],[3,4]])\\n\\t\\t#edgeLists.append([[1,2],[1,3],[1,4],[2,3],[3,4],[2,4]])\\n\\telse:\\n\\t\\traise nx.NetworkXNotImplemented('Size of motif must be 3 or 4')\\n\\n\\t#outf = open(f2, 'w')\\n\\t#print >> outf, 'commitid|motiflabel|count'\\n\\n\\tG = H\\n\\n\\tmcount = dict(zip(motifs.keys(), list(map(int, np.zeros(len(motifs))))))\\n\\n\\t## match the pattern and count the motifs \\n\\tdict_edges = defaultdict(list); dict_nodes = defaultdict(list)\\n\\tfor key in motifs :\\n\\t\\n\\t\\t\\tpattern = motifs[key]\\n\\t\\t\\n\\t\\t\\tgmoti = nx.DiGraph()\\n\\t\\t\\tgmoti.add_edges_from(pattern)\\n\\n\\t\\t\\tmotif_pattern_obs = subgraph_pattern(G, gmoti, sign_sensitive=False)\\n\\n\\t\\t\\ts = []\\n\\t\\t\\tfor subgraph in motif_pattern_obs :\\n\\t\\t\\t\\ttup = tuple(subgraph.keys())\\n\\t\\t\\t\\ts.append(tup)\\n\\n\\t\\t\\tuniqs = list(set(s))\\n\\n\\t\\t\\tif len(uniqs) > 0 :\\n\\t\\t\\t\\tmaplist = map(list, uniqs)\\n\\n\\t\\t\\t### label the edges as per the motif labels\\n\\t\\t\\t\\tmcount[str(key)] = len(maplist)\\n\\n\\t\\t\\t\\tfor triplets in maplist :\\n\\t\\t\\t\\t\\tsubgraph = G.subgraph(triplets)\\n\\t\\t\\t\\t\\tedgeLists = [e for e in subgraph.edges() if G.has_edge(*e)]\\n\\n\\t\\t\\t\\t## an edge is part of multiple motifs\\n\\t\\t\\t\\t## lets count the number of motifs an edge is part of \\n\\t\\t\\t\\t\\tfor u, v in edgeLists :\\n\\t\\t\\t\\t\\t\\tdict_edges[(u, v)].append(str(key))\\n\\t\\n\\n\\t\\t\\t\\t## A node is also part of multiple motifs. \\n\\t\\t\\t\\t## We count the total number of motifs a node is part of\\n\\t\\t\\t\\t## We count the frequency of occurence each motif the node is part of\\n\\t\\t\\t\\t\\tnodelists = subgraph.nodes()\\n\\t\\t\\t\\t\\tfor n in nodelists :\\n\\t\\t\\t\\t\\t\\tdict_nodes[str(n)].append(str(key))\\n\\n\\n\\n\\t\\t#for keys, values in mcount.items() :\\n\\t\\t#\\tprint >> outf, '%s|%s|%s' %(outname, keys, values) \\n\\n\\t### Let's mark the edge with motif type and count. We count the number of types\\n\\t### of motif an edge is a part of. An edge could appear in M1: M1x times and in M2: M2x times and so on\\n\\n\\tfor u,v in G.edges() :\\n\\t\\t\\tif (u,v) in dict_edges :\\n\\t\\t\\t\\tG[u][v]['num_motif_edge'] = len(list(set(dict_edges[(u,v)])))\\n\\n\\t### Let's mark the node with motif type and count. We count the number of types of motif a node is a part of. \\n\\n\\tfor n in G.nodes() :\\n\\t\\tmotficountnode = dict(zip(motifs.keys(), list(map(int, np.zeros(len(motifs))))))\\n\\n\\t\\tif str(n) in dict_nodes :\\n\\t\\t\\tsubgraphnodeslist = dict_nodes[str(n)]\\n\\n\\t\\t\\tfor key in subgraphnodeslist:\\n\\t\\t\\t\\tmotficountnode[str(key)] +=1\\n\\n\\t\\tfor motif, count in motficountnode.items() :\\n\\t\\t\\tG.node[n][str(motif)] = int(count)\\n\\n\\t### Let's mark the edge with motif type and count. We count the number of types\\n\\t### of motif an edge is a part of. An edge could appear in M1: M1x times and in M2: M2x times and so on\\n\\n\\tfor u,v in G.edges() :\\n\\t\\tmotficountedge = dict(zip(motifs.keys(), list(map(int, np.zeros(len(motifs))))))\\n\\n\\t\\tif (u,v) in dict_edges :\\n\\t\\t\\tsubgraphedgeslist = dict_edges[(u,v)]\\n\\n\\t\\t\\tfor key in subgraphedgeslist:\\n\\t\\t\\t\\tmotficountedge[str(key)] +=1\\n\\n\\t\\tfor motif, count in motficountedge.items() :\\n\\t\\t\\tG[u][v][str(motif)] = int(count)\\n\\n\\n\\treturn G\",\n \"def detection_algorithm(G, edge_weight):\\n Gc = G.copy()\\n set_node_attributes(Gc, attr_name='k-index')\\n seed_node2communities = {}\\n\\n from operator import itemgetter\\n while Gc.number_of_nodes() > 0:\\n seed_node = max(list(Gc.nodes(data='k-index')), key=itemgetter(1))[0]\\n nodes_in_community, modularity = find_local_community(Gc, seed_node=seed_node, weight=edge_weight)\\n seed_node2communities[seed_node] = (nodes_in_community, modularity)\\n Gc.remove_nodes_from(nodes_in_community)\\n return seed_node2communities\",\n \"def same_host_descent(G, host_species):\\n nodes = set() # nodes that are involved in human-human transmission.\\n for sc, sk, d in G.edges(data=True):\\n sc_host = G.node[sc]['host_species']\\n sk_host = G.node[sk]['host_species']\\n \\n sc_subtype = G.node[sc]['subtype']\\n sk_subtype = G.node[sk]['subtype']\\n \\n subtype_exclusions = ['Mixed', 'mixed']\\n \\n not_mixed = (sc_subtype not in subtype_exclusions) and (sk_subtype not in subtype_exclusions)\\n is_clonal = d['edge_type'] == 'full_complement'\\n \\n if sc_host == host_species and sk_host == host_species and not_mixed and is_clonal:\\n nodes.add(sc)\\n nodes.add(sk)\\n\\n return nodes\",\n \"def get_graph_attributes(net_G):\\r\\n # number of nodes\\r\\n num_of_nodes = net_G.number_of_nodes()\\r\\n # number of nodes\\r\\n num_of_edges = net_G.number_of_edges()\\r\\n # density of net\\r\\n net_density = nx.density(net_G)\\r\\n # maximum degree and average degree\\r\\n nodes_degree = nx.degree(net_G)\\r\\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\\r\\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\\r\\n # global clustering coefficient: n - count numbers of paths of length two\\r\\n nodes_triangles = nx.triangles(net_G)\\r\\n num_of_triangles = sum(nodes_triangles.values())\\r\\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\\r\\n n = 0 \\r\\n for node in pairs_path_length.keys(): \\r\\n for item in pairs_path_length[node].values():\\r\\n if item == 2:\\r\\n n = n + 1\\r\\n global_clustering_coefficient = (num_of_triangles * 6) / n\\r\\n # size of giant component\\r\\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\\r\\n # return number of edges in graph=graph size\\r\\n size_of_giant = nx.Graph.size(giant_component)\\r\\n # calculate the average path length of giant component\\r\\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\\r\\n # maximum centrality and average centrality\\r\\n nodes_centrality = nx.degree_centrality(net_G)\\r\\n maximum_of_centrality = max(nodes_centrality.values())\\r\\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\\r\\n # maximum betweenness centrality\\r\\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\\r\\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\\r\\n # maximum closeness centrality\\r\\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\\r\\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\\r\\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\\r\\n # summarize graph attributes\\r\\n graph_attributes = [[\\\"Number of nodes:\\\", num_of_nodes], \\\\\\r\\n [\\\"Number of edges:\\\", num_of_edges], \\\\\\r\\n [\\\"Global clustering coefficient:\\\", global_clustering_coefficient], \\\\\\r\\n [\\\"Maximum degree:\\\", maximum_degree], \\\\\\r\\n [\\\"Average degree:\\\", average_degree], \\\\\\r\\n [\\\"Size of giant component:\\\", size_of_giant], \\\\\\r\\n [\\\"Average path length:\\\", average_shortest_path_length],\\\\\\r\\n [\\\"Maximum centrality:\\\", maximum_of_centrality], \\\\\\r\\n [\\\"Average centrality:\\\", average_of_centrality],\\\\\\r\\n [\\\"Maximum betweenness centrality:\\\", maximum_betweenness_centrality],\\\\\\r\\n [\\\"Maximum closeness centrality:\\\", maximum_closeness_centrality], \\\\\\r\\n [\\\"Average closeness centrality:\\\", average_closeness_centrality], \\\\\\r\\n [\\\"Net density:\\\", net_density]]\\r\\n return graph_attributes\",\n \"def generate_network_graph(network):\\n num_nodes = len(network)\\n network_graph = {}\\n\\n for y_node in range(num_nodes):\\n neighbors = {}\\n for x_node in range(num_nodes):\\n if network[y_node][x_node] is not 0:\\n neighbors[x_node] = network[y_node][x_node]\\n network_graph[y_node] = neighbors\\n\\n return network_graph\",\n \"def _generate_G_from_H(H, variable_weight=False):\\n H = np.array(H)\\n n_edge = H.shape[1]\\n # the weight of the hyperedge\\n W = np.ones(n_edge)\\n # the degree of the node\\n DV = np.sum(H * W, axis=1)\\n # the degree of the hyperedge\\n DE = np.sum(H, axis=0)\\n\\n invDE = np.mat(np.diag(np.power(DE, -1)))\\n DV2 = np.mat(np.diag(np.power(DV, -0.5)))\\n W = np.mat(np.diag(W))\\n H = np.mat(H)\\n HT = H.T\\n\\n if variable_weight:\\n DV2_H = DV2 * H\\n invDE_HT_DV2 = invDE * HT * DV2\\n return DV2_H, W, invDE_HT_DV2\\n else:\\n G = DV2 * H * W * invDE * HT * DV2\\n return G\",\n \"def infomap_communities(G):\\n name_map = {}\\n name_map_inverted = {}\\n for n in G.nodes():\\n id_ = hash(n) % 100000\\n name_map_inverted[id_] = n\\n name_map[n] = id_\\n \\n infomapSimple = infomap.Infomap(\\\"--two-level\\\")\\n network = infomapSimple.network()\\n \\n for n1, n2, data in G.edges(data=True):\\n network.addLink(name_map[n1], name_map[n2], data['weight'] if 'weight' in data else 1)\\n\\n infomapSimple.run()\\n\\n return dict(\\n (name_map_inverted[node.physicalId], node.moduleIndex())\\n for node in infomapSimple.iterTree()\\n if node.isLeaf()\\n )\",\n \"def _generate_G_from_H(H, variable_weight=False):\\n n_edge = H.shape[1]\\n # the weight of the hyperedge\\n W_vector = np.ones(n_edge)\\n W = sp.diags(W_vector, format=\\\"csr\\\")\\n # W = np.ones(n_edge)\\n # the degree of the node\\n DV = H\\n DV = DV.sum(axis=1)\\n #DV = np.sum(H * W, axis=1)\\n # the degree of the hyperedge\\n #DE = np.sum(H, axis=0)\\n DE = H.sum(axis=0)\\n invDE = np.squeeze(np.asarray(np.power(DE, -1)))\\n invDE = sp.diags(invDE, format=\\\"csr\\\")\\n DV2 = sp.diags(np.squeeze(np.asarray(np.power(DV, -0.5))), format=\\\"csr\\\")\\n\\n # invDE = np.mat(np.diag(np.power(DE, -1)))\\n # DV2 = np.mat(np.diag(np.power(DV, -0.5)))\\n HT = H.T\\n\\n if variable_weight:\\n DV2_H = DV2 * H\\n invDE_HT_DV2 = invDE * HT * DV2\\n #invDE_HT = invDE * HT\\n return DV2_H.toarray(), W_vector, invDE_HT_DV2.toarray()\\n else:\\n W = sp.diags(W_vector, format=\\\"csr\\\")\\n G = DV2 * H * W * invDE * HT * DV2\\n return G\",\n \"def buildGraph(pickl, his=False):\\n\\n dic = pickl\\n\\n dic1 = dic\\n G = nx.Graph()\\n dic3 = dict(dic)\\n checked = []\\n\\n # Adding nodes with bios greater than 30 words.\\n for key in dic:\\n if((re.sub(\\\"[ ]+\\\", \\\"\\\", dic[key]) != \\\"\\\") and len(dic[key])) > 30:\\n G.add_node(key)\\n else:\\n del dic3[key]\\n\\n dic1 = dic3\\n\\n vect = TfidfVectorizer(min_df=1)\\n coefs = list()\\n\\n joint_dict = dict()\\n # Cosine similarity measure matrix\\n F = vect.fit_transform(dic3.values())\\n Cosine_mat = (F*F.T).A # Symmetric matrix:\\n # Traverse uper triangle for cosine similarity measures.\\n for i, key in enumerate(dic3):\\n for j, key1 in enumerate(dic1):\\n if(i > j):\\n # obtain coef for corresponding key\\n tfidf = Cosine_mat[i, j]\\n # Repeated nodes must be filtered\\n if dic[key] == dic[key1]:\\n\\n continue\\n else:\\n coefs.append(tfidf)\\n joint_dict[str(key) + str(key1)] = tfidf\\n\\n data = [c for c in coefs if c]\\n # max(data)\\n\\n mu = np.mean(data)\\n std = np.std(data)\\n binwidth = 0.007\\n if his:\\n plt.subplot(1, 2, 0)\\n plt.hist(data, bins=np.arange(min(data), max(data) + binwidth, binwidth))\\n # PLot gaussian fit contrast\\n plt.xlabel(\\\"$cos(\\\\\\\\theta)$\\\")\\n plt.ylabel(\\\"frecuency count of $cos(\\\\\\\\theta)$ values\\\")\\n plt.subplot(1, 2, 1)\\n plt.plot(np.arange(0, max(data), 0.001),\\n gaussian(np.arange(0, max(data), 0.001), mu, std),\\n linewidth=2)\\n plt.xlabel(\\\"$cos(\\\\\\\\theta)$\\\")\\n plt.ylabel(\\\"fitted gaussian\\\")\\n plt.show()\\n\\n # Edge creation !\\n for key in dic3:\\n for key1 in dic1:\\n if(key != key1):\\n try:\\n x = joint_dict[str(key) + str(key1)]\\n # If cosine similarity is an outlier with 95% change\\n # Make edge between nodes that conform the similarity\\n if(x - mu > 2 * std):\\n G.add_edge(key, key1)\\n except:\\n pass\\n\\n # Return the conected component with largest cardinality of nodes\\n # Throw away small connected components we are interested in the big one\\n # For our mini project exploration purposes\\n G = max(nx.connected_component_subgraphs(G), key=len)\\n return G\",\n \"def differentiate(hp):\\n if hp.force_skip:\\n G.add_edge(\\\"input\\\", \\\"output\\\")\\n for node in G.nodes(data=True):\\n node_id, node_data = node\\n log(\\\"differentiate\\\", node_id, node_data)\\n node_data[\\\"output\\\"] = None\\n node_data[\\\"op\\\"] = None\\n if node_data[\\\"shape\\\"] is \\\"square\\\" or \\\"output\\\" in node_id:\\n if node_id == \\\"output\\\":\\n d_out = node_data[\\\"output_shape\\\"][-1]\\n node_type = hp.last_layer\\n activation = \\\"tanh\\\"\\n else:\\n node_type = str(np.random.choice(['sepconv1d', 'transformer',\\n 'k_conv1', 'k_conv2', 'k_conv3',\\n \\\"deep\\\", \\\"wide_deep\\\"],\\n 1, p=hp.layer_distribution).item(0))\\n activation = str(np.random.choice([ 'tanh', 'linear', 'relu', 'selu',\\n 'elu', 'sigmoid', 'hard_sigmoid', 'exponential', 'softmax',\\n 'softplus', 'softsign', 'gaussian', 'sin', 'cos', 'swish'],\\n 1, p=hp.activation_distribution).item(0))\\n d_out = None\\n node_data[\\\"force_residual\\\"] = random.random() < hp.p_force_residual\\n node_data[\\\"activation\\\"] = clean_activation(activation)\\n node_data[\\\"node_type\\\"] = node_type\\n node_data['style'] = \\\"\\\"\\n if node_type == 'sepconv1d':\\n if d_out is None:\\n d_out = safe_sample(hp.min_filters, hp.max_filters)\\n node_data[\\\"filters\\\"] = d_out\\n node_data[\\\"kernel_size\\\"] = 1\\n if node_type == \\\"transformer\\\":\\n if d_out is None:\\n d_out = safe_sample(hp.min_units, hp.max_units) * hp.attn_heads\\n node_data[\\\"d_model\\\"] = d_out\\n node_data[\\\"n_heads\\\"] = 2 if d_out % 2 == 0 else 1\\n if \\\"k_conv\\\" in node_type or node_type in [\\\"deep\\\", \\\"wide_deep\\\"]:\\n layers = design_layers(hp, d_out, activation)\\n if d_out is None:\\n d_out = layers[-1][0]\\n node_data[\\\"stddev\\\"] = hp.stddev\\n node_data['layers'] = layers\\n node_data[\\\"d_out\\\"] = d_out\\n if node_type in [\\\"deep\\\", \\\"wide_deep\\\"]:\\n node_data['kernel'] = node_type\\n else:\\n node_data['kernel'] = \\\"wide_deep\\\" if random.random() < hp.p_wide_deep else \\\"deep\\\"\\n label = f\\\"{node_type}\\\"\\n log(f\\\"set {node_id} to {label}\\\")\\n node_data[\\\"label\\\"] = label\\n node_data[\\\"color\\\"] = \\\"green\\\"\\n # we handle recurrent shapes:\\n try:\\n feedback_node_id = f\\\"{node_id}_feedback\\\"\\n input_shape = (None, d_out)\\n log(f\\\"attempt to set input_shape for {feedback_node_id} to {input_shape}\\\")\\n feedback_node = G.node[feedback_node_id]\\n feedback_node[\\\"input_shape\\\"] = input_shape\\n node_data[\\\"gives_feedback\\\"] = True\\n except Exception as e:\\n log(\\\"ERROR HANDLING FEEDBACK SHAPE:\\\", e)\",\n \"def find_and_print_network_communities(G, code_dict=None):\\n\\n comm_dict = partition(G)\\n\\n comm_members = {}\\n for comm in set(comm_dict.values()):\\n countries = [node for node in comm_dict if comm_dict[node] == comm]\\n if code_dict is not None:\\n countries = [code_dict[code] for code in countries]\\n\\n comm_members[comm] = countries\\n\\n return comm_members, get_modularity(G, comm_dict)\",\n \"def gtom(graph):\\n\\n # modified from uinvite(), copied for convenience (TODO consolidate by moving outside to its own function)\\n # return list of neighbors of neighbors of i, that aren't themselves neighbors of i\\n # i.e., an edge between i and any item in nn forms a triangle\\n def neighborsofneighbors(i, nxg):\\n nn=[] # neighbors of neighbors (nn)\\n n=list(nx.all_neighbors(nxg,i))\\n for j in n:\\n nn=nn+list(nx.all_neighbors(nxg,j))\\n nn=list(set(nn))\\n if i in nn:\\n nn.remove(i) # remove self\\n return nn\\n \\n nxgraph = nx.to_networkx_graph(graph)\\n numnodes = nx.number_of_nodes(nxgraph)\\n gtom_mat = np.zeros((numnodes,numnodes))\\n \\n nn_dict = {}\\n for i in range(numnodes):\\n nn_dict[i] = neighborsofneighbors(i, nxgraph)\\n \\n for i in range(numnodes):\\n for j in range(i+1,numnodes):\\n i_neighbors = nn_dict[i]\\n j_neighbors = nn_dict[j]\\n min_neighbors = min(len(i_neighbors),len(j_neighbors))\\n len_overlap = len(set.intersection(set(i_neighbors),set(j_neighbors)))\\n gtom_mat[i, j] = 1 - (float(len_overlap) / min_neighbors)\\n gtom_mat[j, i] = gtom_mat[i, j]\\n\\n return gtom_mat\",\n \"def make_er_graph(num_nodes, probability):\\n graph = {}\\n for node in range(0, num_nodes):\\n graph[node] = set([])\\n\\n for node in range(0, num_nodes - 1):\\n for potential_neighbor in range(node + 1, num_nodes):\\n if random.random() < probability:\\n graph[node].add(potential_neighbor)\\n graph[potential_neighbor].add(node)\\n\\n return graph\",\n \"def node_edge_centrality(\\n H,\\n f=lambda x: np.power(x, 2),\\n g=lambda x: np.power(x, 0.5),\\n phi=lambda x: np.power(x, 2),\\n psi=lambda x: np.power(x, 0.5),\\n max_iter=100,\\n tol=1e-6,\\n):\\n from ..algorithms import is_connected\\n\\n # if there aren't any nodes or edges, return an empty dict\\n if H.num_nodes == 0 or H.num_edges == 0 or not is_connected(H):\\n return {n: np.nan for n in H.nodes}, {e: np.nan for e in H.edges}\\n # if the hypergraph is not connected,\\n # this metric doesn't make sense and should return nan.\\n # if not is_connected(H):\\n # return {n: np.nan for n in H.nodes}, {e: np.nan for e in H.edges}\\n\\n n = H.num_nodes\\n m = H.num_edges\\n x = np.ones(n) / n\\n y = np.ones(m) / m\\n\\n I, node_dict, edge_dict = incidence_matrix(H, index=True)\\n\\n check = np.inf\\n\\n for iter in range(max_iter):\\n u = np.multiply(x, g(I @ f(y)))\\n v = np.multiply(y, psi(I.T @ phi(x)))\\n # multiply by the sign to try and enforce positivity\\n new_x = np.sign(u[0]) * u / norm(u, 1)\\n new_y = np.sign(v[0]) * v / norm(v, 1)\\n\\n check = norm(new_x - x) + norm(new_y - y)\\n if check < tol:\\n break\\n x = new_x.copy()\\n y = new_y.copy()\\n else:\\n warn(\\\"Iteration did not converge!\\\")\\n return {node_dict[n]: new_x[n] for n in node_dict}, {\\n edge_dict[e]: new_y[e] for e in edge_dict\\n }\",\n \"def build_auxiliary_node_connectivity(G):\\n directed = G.is_directed()\\n\\n mapping = {}\\n H = nx.DiGraph()\\n\\n for i, node in enumerate(G):\\n mapping[node] = i\\n H.add_node('%dA' % i, id=node)\\n H.add_node('%dB' % i, id=node)\\n H.add_edge('%dA' % i, '%dB' % i, capacity=1)\\n\\n edges = []\\n for (source, target) in G.edges():\\n edges.append(('%sB' % mapping[source], '%sA' % mapping[target]))\\n if not directed:\\n edges.append(('%sB' % mapping[target], '%sA' % mapping[source]))\\n H.add_edges_from(edges, capacity=1)\\n\\n # Store mapping as graph attribute\\n H.graph['mapping'] = mapping\\n return H\",\n \"def network(self):\\n G = nx.MultiDiGraph()\\n reaction_hash = []\\n product_count = 0\\n mapping = {}\\n reaction_count = 0\\n\\n for r in self.reactions:\\n reaction_count += 1\\n\\n reaction_dict = r.__dict__\\n G.add_edge(reaction_dict.get('left'), hash(r))\\n G.add_edge(reaction_dict.get('right'), hash(r))\\n G.add_edge(hash(r), reaction_dict.get('left2'))\\n G.add_edge(hash(r), reaction_dict.get('right2'))\\n\\n product_count += 1\\n mapping[reaction_dict.get('left')] = \\\"x{}\\\".format(product_count)\\n product_count += 1\\n mapping[reaction_dict.get('right')] = \\\"x{}\\\".format(product_count)\\n product_count += 1\\n mapping[reaction_dict.get('left2')] = \\\"x{}\\\".format(product_count)\\n product_count += 1\\n mapping[reaction_dict.get('right2')] = \\\"x{}\\\".format(product_count)\\n\\n mapping[hash(r)] = \\\"r{}\\\".format(reaction_dict.get(\\\"reaction_n\\\"))\\n reaction_hash.append(hash(r))\\n\\n return G, mapping\",\n \"def greedy_modularity_communities(G, weight=None):\\n\\n # Count nodes and edges\\n N = len(G.nodes())\\n m = sum([d.get('weight', 1) for u, v, d in G.edges(data=True)])\\n q0 = 1.0 / (2.0*m)\\n\\n # Map node labels to contiguous integers\\n label_for_node = dict((i, v) for i, v in enumerate(G.nodes()))\\n node_for_label = dict((label_for_node[i], i) for i in range(N))\\n\\n # Calculate degrees\\n k_for_label = G.degree(G.nodes(), weight=weight)\\n k = [k_for_label[label_for_node[i]] for i in range(N)]\\n\\n # Initialize community and merge lists\\n communities = dict((i, frozenset([i])) for i in range(N))\\n merges = []\\n\\n # Initial modularity\\n partition = [[label_for_node[x] for x in c] for c in communities.values()]\\n q_cnm = modularity(G, partition)\\n\\n # Initialize data structures\\n # CNM Eq 8-9 (Eq 8 was missing a factor of 2 (from A_ij + A_ji)\\n # a[i]: fraction of edges within community i\\n # dq_dict[i][j]: dQ for merging community i, j\\n # dq_heap[i][n] : (-dq, i, j) for communitiy i nth largest dQ\\n # H[n]: (-dq, i, j) for community with nth largest max_j(dQ_ij)\\n a = [k[i]*q0 for i in range(N)]\\n dq_dict = dict(\\n (i, dict(\\n (j, 2*q0 - 2*k[i]*k[j]*q0*q0)\\n for j in [\\n node_for_label[u]\\n for u in G.neighbors(label_for_node[i])]\\n if j != i))\\n for i in range(N))\\n dq_heap = [\\n MappedQueue([\\n (-dq, i, j)\\n for j, dq in dq_dict[i].items()])\\n for i in range(N)]\\n H = MappedQueue([\\n dq_heap[i].h[0]\\n for i in range(N)\\n if len(dq_heap[i]) > 0])\\n\\n # Merge communities until we can't improve modularity\\n while len(H) > 1:\\n # Find best merge\\n # Remove from heap of row maxes\\n # Ties will be broken by choosing the pair with lowest min community id\\n try:\\n dq, i, j = H.pop()\\n except IndexError:\\n break\\n dq = -dq\\n # Remove best merge from row i heap\\n dq_heap[i].pop()\\n # Push new row max onto H\\n if len(dq_heap[i]) > 0:\\n H.push(dq_heap[i].h[0])\\n # If this element was also at the root of row j, we need to remove the\\n # duplicate entry from H\\n if dq_heap[j].h[0] == (-dq, j, i):\\n H.remove((-dq, j, i))\\n # Remove best merge from row j heap\\n dq_heap[j].remove((-dq, j, i))\\n # Push new row max onto H\\n if len(dq_heap[j]) > 0:\\n H.push(dq_heap[j].h[0])\\n else:\\n # Duplicate wasn't in H, just remove from row j heap\\n dq_heap[j].remove((-dq, j, i))\\n # Stop when change is non-positive\\n if dq <= 0:\\n break\\n\\n # Perform merge\\n communities[j] = frozenset(communities[i] | communities[j])\\n del communities[i]\\n merges.append((i, j, dq))\\n # New modularity\\n q_cnm += dq\\n # Get list of communities connected to merged communities\\n i_set = set(dq_dict[i].keys())\\n j_set = set(dq_dict[j].keys())\\n all_set = (i_set | j_set) - set([i, j])\\n both_set = i_set & j_set\\n # Merge i into j and update dQ\\n for k in all_set:\\n # Calculate new dq value\\n if k in both_set:\\n dq_jk = dq_dict[j][k] + dq_dict[i][k]\\n elif k in j_set:\\n dq_jk = dq_dict[j][k] - 2.0*a[i]*a[k]\\n else:\\n # k in i_set\\n dq_jk = dq_dict[i][k] - 2.0*a[j]*a[k]\\n # Update rows j and k\\n for row, col in [(j, k), (k, j)]:\\n # Save old value for finding heap index\\n if k in j_set:\\n d_old = (-dq_dict[row][col], row, col)\\n else:\\n d_old = None\\n # Update dict for j,k only (i is removed below)\\n dq_dict[row][col] = dq_jk\\n # Save old max of per-row heap\\n if len(dq_heap[row]) > 0:\\n d_oldmax = dq_heap[row].h[0]\\n else:\\n d_oldmax = None\\n # Add/update heaps\\n d = (-dq_jk, row, col)\\n if d_old is None:\\n # We're creating a new nonzero element, add to heap\\n dq_heap[row].push(d)\\n else:\\n # Update existing element in per-row heap\\n dq_heap[row].update(d_old, d)\\n # Update heap of row maxes if necessary\\n if d_oldmax is None:\\n # No entries previously in this row, push new max\\n H.push(d)\\n else:\\n # We've updated an entry in this row, has the max changed?\\n if dq_heap[row].h[0] != d_oldmax:\\n H.update(d_oldmax, dq_heap[row].h[0])\\n\\n # Remove row/col i from matrix\\n i_neighbors = dq_dict[i].keys()\\n for k in i_neighbors:\\n # Remove from dict\\n dq_old = dq_dict[k][i]\\n del dq_dict[k][i]\\n # Remove from heaps if we haven't already\\n if k != j:\\n # Remove both row and column\\n for row, col in [(k, i), (i, k)]:\\n # Check if replaced dq is row max\\n d_old = (-dq_old, row, col)\\n if dq_heap[row].h[0] == d_old:\\n # Update per-row heap and heap of row maxes\\n dq_heap[row].remove(d_old)\\n H.remove(d_old)\\n # Update row max\\n if len(dq_heap[row]) > 0:\\n H.push(dq_heap[row].h[0])\\n else:\\n # Only update per-row heap\\n dq_heap[row].remove(d_old)\\n\\n del dq_dict[i]\\n # Mark row i as deleted, but keep placeholder\\n dq_heap[i] = MappedQueue()\\n # Merge i into j and update a\\n a[j] += a[i]\\n a[i] = 0\\n\\n communities = [\\n frozenset([label_for_node[i] for i in c])\\n for c in communities.values()]\\n return sorted(communities, key=len, reverse=True)\",\n \"def neighborhood(G,n,o):\\n base = G[n]\\n neighbors = {}\\n neighbors[n] = 0\\n newNodes = set(neighbors.keys())\\n for i in range(1,o+1):\\n #for node in neighbors.keys():\\n nodes = newNodes.copy()\\n newNodes = set()\\n for node in nodes:\\n branch = G[node]\\n for node in branch:\\n if node not in neighbors:\\n newNodes.add(node)\\n neighbors[node]=i\\n return neighbors\",\n \"def complex_network_mapping(graph):\\n vect = []\\n\\n n = nx.number_of_nodes(graph)\\n e = nx.number_of_edges(graph)\\n print n, e\\n\\n# adj = nx.adjacency_matrix(graph).toarray()\\n# adj_bin = np.where(adj > 0, 1., 0.)\\n# adj_conn = 1 - adj\\n adj_bin = nx.adjacency_matrix(graph).toarray()\\n adj_bin = np.array(adj_bin, dtype=np.float)\\n\\n # Node Betweenness binary\\n bt_bin = nx.betweenness_centrality(graph).values()\\n avg_btb = np.mean(bt_bin)\\n vect.append(avg_btb)\\n\\n # Edge betweenness\\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\\n vect.append(np.mean(ebt))\\n\\n # Eigen vector centrality binary\\n evc_bin = eigenvector_centrality_und(adj_bin)\\n avg_evcb = np.mean(evc_bin)\\n vect.append(avg_evcb)\\n\\n # Flow coefficient\\n _, flow_bin, _ = flow_coef_bd(adj_bin)\\n avg_flow = np.mean(flow_bin)\\n vect.append(avg_flow)\\n\\n # Kcoreness centrality\\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\\n avg_kcor = np.mean(kcor_bin)\\n vect.append(avg_kcor)\\n\\n # Degree assortivity\\n dac = nx.degree_assortativity_coefficient(graph)\\n vect.append(dac)\\n\\n # Page rank centrality\\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\\n# avg_pgr = np.mean(pgr_wei)\\n# vect.append(avg_pgr)\\n\\n # Rich club coefficient\\n# rcc = nx.rich_club_coefficient(graph).values()\\n# avg_rcc = np.mean(rcc)\\n# vect.append(avg_rcc)\\n\\n # Transitivity\\n tr = nx.transitivity(graph)\\n vect.append(tr)\\n\\n # average clustering\\n avg_clst = nx.average_clustering(graph)\\n vect.append(avg_clst)\\n\\n glb_ef = efficiency_bin(adj_bin)\\n vect.append(glb_ef)\\n\\n return vect\",\n \"def intersection(G, H):\\n\\n if G.order() != H.order():\\n msg = \\\"Node sets of the two directed graphs are not equal!\\\"\\n raise StaticGraphNotEqNodesException(msg) \\n \\n n_nodes = G.order()\\n edges = ((u, v) for u in G.nodes()\\n for v in set(G.successors(u)) & set(H.successors(u)))\\n deg = make_deg(n_nodes, edges) \\n edges = ((u, v) for u in G.nodes()\\n for v in set(G.successors(u)) & set(H.successors(u)))\\n GH = make(n_nodes, G.size(), edges, deg)\\n return GH\",\n \"def network_nodes_species(self):\\n G, mapping = self.network()\\n waste, resources, intmed_products = self.amenities()\\n\\n node_dict = {}\\n\\n for nd in G:\\n # print(nd)\\n if isinstance(nd, int):\\n node_dict[nd] = \\\"r\\\"\\n elif nd in self.commodity:\\n node_dict[nd] = \\\"Xc\\\"\\n elif nd in waste:\\n node_dict[nd] = \\\"w\\\"\\n elif nd in resources:\\n node_dict[nd] = \\\"Xr\\\"\\n elif nd in intmed_products:\\n node_dict[nd] = \\\"InPr\\\"\\n\\n return node_dict\",\n \"def graph():\\n\\n graph = {'A': ['B', 'C'],\\n 'B': ['C', 'D'],\\n 'C': ['D'],\\n 'D': ['C'],\\n 'E': ['F'],\\n 'F': ['C']}\\n\\n def generate_edges(graph):\\n \\\"\\\"\\\" Convert the dict representation of a graph into a list one\\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\\n \\\"\\\"\\\"\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\\n\\n a = generate_edges(graph=graph)\\n print(a)\",\n \"def find_chimera_indices(G):\\n\\n # if the nodes are orderable, we want the lowest-order one.\\n try:\\n nlist = sorted(G.nodes)\\n except TypeError:\\n nlist = G.nodes()\\n\\n n_nodes = len(nlist)\\n\\n # create the object that will store the indices\\n chimera_indices = {}\\n\\n # ok, let's first check for the simple cases\\n if n_nodes == 0:\\n return chimera_indices\\n elif n_nodes == 1:\\n raise DWaveNetworkXException('Singleton graphs are not Chimera-structured')\\n elif n_nodes == 2:\\n return {nlist[0]: (0, 0, 0, 0), nlist[1]: (0, 0, 1, 0)}\\n\\n # next, let's get the bicoloring of the graph; this raises an exception if the graph is\\n # not bipartite\\n coloring = color(G)\\n\\n # we want the color of the node to be the u term in the Chimera-index, so we want the\\n # first node in nlist to be color 0\\n if coloring[nlist[0]] == 1:\\n coloring = {v: 1 - coloring[v] for v in coloring}\\n\\n # we also want the diameter of the graph\\n # claim: diameter(G) == m + n for |G| > 2\\n dia = diameter(G)\\n\\n # we have already handled the |G| <= 2 case, so we know, for diameter == 2, that the Chimera\\n # graph is a single tile\\n if dia == 2:\\n shore_indices = [0, 0]\\n\\n for v in nlist:\\n u = coloring[v]\\n chimera_indices[v] = (0, 0, u, shore_indices[u])\\n shore_indices[u] += 1\\n\\n return chimera_indices\\n\\n # NB: max degree == shore size <==> one tile\\n\\n raise Exception('not yet implemented for Chimera graphs with more than one tile')\",\n \"def greedy_modularity_communities(G, K, weight=None):\\n G = nx.from_numpy_array(G.detach().numpy(), create_using = nx.DiGraph())\\n # Count nodes and edges\\n N = len(G.nodes())\\n m = sum([d.get('weight', 1) for u, v, d in G.edges(data=True)])\\n q0 = 1.0 / (2.0*m)\\n\\n # Map node labels to contiguous integers\\n label_for_node = dict((i, v) for i, v in enumerate(G.nodes()))\\n node_for_label = dict((label_for_node[i], i) for i in range(N))\\n\\n # Calculate degrees\\n k_for_label = G.degree(G.nodes(), weight=weight)\\n k = [k_for_label[label_for_node[i]] for i in range(N)]\\n\\n # Initialize community and merge lists\\n communities = dict((i, frozenset([i])) for i in range(N))\\n merges = []\\n\\n # Initial modularity\\n partition = [[label_for_node[x] for x in c] for c in communities.values()]\\n q_cnm = modularity(G, partition)\\n\\n # Initialize data structures\\n # CNM Eq 8-9 (Eq 8 was missing a factor of 2 (from A_ij + A_ji)\\n # a[i]: fraction of edges within community i\\n # dq_dict[i][j]: dQ for merging community i, j\\n # dq_heap[i][n] : (-dq, i, j) for communitiy i nth largest dQ\\n # H[n]: (-dq, i, j) for community with nth largest max_j(dQ_ij)\\n a = [k[i]*q0 for i in range(N)]\\n dq_dict = dict(\\n (i, dict(\\n (j, q0*(G[i][j]['weight'] + G[j][i]['weight']) - 2*k[i]*k[j]*q0*q0)\\n for j in [\\n node_for_label[u]\\n for u in G.neighbors(label_for_node[i])]\\n if j != i))\\n for i in range(N))\\n# print(min([len(x[1]) for x in dq_dict.values()]))\\n# raise Exception()\\n# return dq_dict\\n dq_heap = [\\n MappedQueue([\\n (-dq, i, j)\\n for j, dq in dq_dict[i].items()])\\n for i in range(N)]\\n H = MappedQueue([\\n dq_heap[i].h[0]\\n for i in range(N)\\n if len(dq_heap[i]) > 0])\\n\\n # Merge communities until we can't improve modularity\\n while len(H) > 1:\\n # Find best merge\\n # Remove from heap of row maxes\\n # Ties will be broken by choosing the pair with lowest min community id\\n try:\\n dq, i, j = H.pop()\\n except IndexError:\\n break\\n dq = -dq\\n # Remove best merge from row i heap\\n dq_heap[i].pop()\\n # Push new row max onto H\\n if len(dq_heap[i]) > 0:\\n H.push(dq_heap[i].h[0])\\n # If this element was also at the root of row j, we need to remove the\\n # duplicate entry from H\\n if dq_heap[j].h[0] == (-dq, j, i):\\n H.remove((-dq, j, i))\\n # Remove best merge from row j heap\\n dq_heap[j].remove((-dq, j, i))\\n # Push new row max onto H\\n if len(dq_heap[j]) > 0:\\n H.push(dq_heap[j].h[0])\\n else:\\n # Duplicate wasn't in H, just remove from row j heap\\n dq_heap[j].remove((-dq, j, i))\\n\\n # Perform merge\\n communities[j] = frozenset(communities[i] | communities[j])\\n del communities[i]\\n merges.append((i, j, dq))\\n \\n# print(len(communities))\\n # Stop when change is non-positive\\n if len(communities) == K:\\n break\\n\\n # New modularity\\n q_cnm += dq\\n # Get list of communities connected to merged communities\\n i_set = set(dq_dict[i].keys())\\n j_set = set(dq_dict[j].keys())\\n all_set = (i_set | j_set) - set([i, j])\\n both_set = i_set & j_set\\n # Merge i into j and update dQ\\n for k in all_set:\\n # Calculate new dq value\\n if k in both_set:\\n dq_jk = dq_dict[j][k] + dq_dict[i][k]\\n elif k in j_set:\\n dq_jk = dq_dict[j][k] - 2.0*a[i]*a[k]\\n else:\\n # k in i_set\\n dq_jk = dq_dict[i][k] - 2.0*a[j]*a[k]\\n # Update rows j and k\\n for row, col in [(j, k), (k, j)]:\\n # Save old value for finding heap index\\n if k in j_set:\\n d_old = (-dq_dict[row][col], row, col)\\n else:\\n d_old = None\\n # Update dict for j,k only (i is removed below)\\n dq_dict[row][col] = dq_jk\\n # Save old max of per-row heap\\n if len(dq_heap[row]) > 0:\\n d_oldmax = dq_heap[row].h[0]\\n else:\\n d_oldmax = None\\n # Add/update heaps\\n d = (-dq_jk, row, col)\\n if d_old is None:\\n # We're creating a new nonzero element, add to heap\\n dq_heap[row].push(d)\\n else:\\n # Update existing element in per-row heap\\n dq_heap[row].update(d_old, d)\\n # Update heap of row maxes if necessary\\n if d_oldmax is None:\\n # No entries previously in this row, push new max\\n H.push(d)\\n else:\\n # We've updated an entry in this row, has the max changed?\\n if dq_heap[row].h[0] != d_oldmax:\\n H.update(d_oldmax, dq_heap[row].h[0])\\n\\n # Remove row/col i from matrix\\n i_neighbors = dq_dict[i].keys()\\n for k in i_neighbors:\\n # Remove from dict\\n dq_old = dq_dict[k][i]\\n del dq_dict[k][i]\\n # Remove from heaps if we haven't already\\n if k != j:\\n # Remove both row and column\\n for row, col in [(k, i), (i, k)]:\\n # Check if replaced dq is row max\\n d_old = (-dq_old, row, col)\\n if dq_heap[row].h[0] == d_old:\\n # Update per-row heap and heap of row maxes\\n dq_heap[row].remove(d_old)\\n H.remove(d_old)\\n # Update row max\\n if len(dq_heap[row]) > 0:\\n H.push(dq_heap[row].h[0])\\n else:\\n # Only update per-row heap\\n# if d_old in dq_heap[row].d:\\n dq_heap[row].remove(d_old)\\n\\n del dq_dict[i]\\n # Mark row i as deleted, but keep placeholder\\n dq_heap[i] = MappedQueue()\\n # Merge i into j and update a\\n a[j] += a[i]\\n a[i] = 0\\n\\n# communities = [\\n# set([label_for_node[i] for i in c])\\n# for c in communities.values()]\\n heap = []\\n for j in communities:\\n heapq.heappush(heap, (a[j], set(communities[j])))\\n while len(heap) > K:\\n weight1, com1 = heapq.heappop(heap)\\n weight2, com2 = heapq.heappop(heap)\\n com1.update(com2)\\n heapq.heappush(heap, (weight1+weight2, com1))\\n communities = [x[1] for x in heap]\\n r = torch.zeros(N, K)\\n print(len(communities))\\n for i,c in enumerate(communities):\\n for v in c:\\n r[v, i] = 1\\n return r\",\n \"def community_detection(net_G):\\r\\n if list(nx.isolates(net_G)) == []:\\r\\n part = community.best_partition(net_G)\\r\\n #values = [part.get(node) for node in net_G.nodes()]\\r\\n #nx.draw_spring(net_G, cmap = plt.get_cmap('jet'), node_color = values, node_size=30, with_labels=False)\\r\\n #plt.show()\\r\\n else:\\r\\n net_G = net_G.copy()\\r\\n net_G.remove_nodes_from(list(nx.isolates(net_G)))\\r\\n part = community.best_partition(net_G)\\r\\n list_nodes = []\\r\\n for com in set(part.values()):\\r\\n list_nodes.append([nodes for nodes in part.keys() if part[nodes] == com])\\r\\n num_of_communities = len(list_nodes)\\r\\n partition_performance = nx.algorithms.community.quality.performance(net_G, list_nodes)\\r\\n net_communities = [[\\\"Numbers of communities:\\\", num_of_communities], \\\\\\r\\n [\\\"Partition performance:\\\", partition_performance]]\\r\\n return net_communities\",\n \"def count_automorphisms(g: Graph) -> int:\\n\\n def generate_mapping(g: Graph, h: Graph):\\n \\\"\\\"\\\"\\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\\n We map g to h.\\n :param g: A graph\\n :param h: A graph\\n :return: A permutation with the mapping from g to h\\n \\\"\\\"\\\"\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\\n\\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\\n \\\"\\\"\\\"\\n Is called recursively to traverse through the branching tree and to find all automorphisms.\\n :param g: A copy of the original graph\\n :param h: Another copy of the original graph\\n :param d: A list with pre-colored vertices for graph g\\n :param i: A list with pre-colored vertices for graph h\\n \\\"\\\"\\\"\\n\\n # Refine the graphs g and h.\\n color_refinement([g, h])\\n\\n # Make sure that the colors are balanced, and check for a bijection.\\n if not is_balanced(g, h):\\n return\\n if is_bijection(g, h):\\n\\n # Generate the mapping from g -> h.\\n p = generate_mapping(g, h)\\n\\n # If the permutation cannot be generated by this generating set, we need to add it.\\n if not is_member(generating_set, p):\\n generating_set.append(p)\\n\\n # We can now back to the last trivial ancestor nodes in the branching tree.\\n while [v.label for v in d] != [v.label for v in i]:\\n # We remove the vertices from d and i and mark them as 'used'.\\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\\n d.pop().pre_labeled = True\\n i.pop().pre_labeled = True\\n\\n return\\n\\n c, next_color = get_c([g, h])\\n for v_g in g:\\n if v_g.colornum == c:# and not v_g.pre_labeled:\\n x = v_g\\n break\\n\\n for v_h in h:\\n if v_h.colornum == c and not v_h.pre_labeled:\\n g1 = g + Graph(False)\\n h1 = h + Graph(False)\\n g1.vertices[g.vertices.index(x)].colornum = next_color\\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\\n d.append(x)\\n i.append(v_h)\\n generate_automorphisms(g1, h1, d, i)\\n\\n generating_set = []\\n graph_copy_1 = g + Graph(False)\\n graph_copy_2 = g + Graph(False)\\n for v in graph_copy_1.vertices:\\n v.pre_labeled = False\\n for v in graph_copy_2.vertices:\\n v.pre_labeled = False\\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\\n return compute_order(generating_set)\",\n \"def odd_decomposition(G) -> Tuple[Set[int], Set[int]]:\\n multi = isinstance(G, nx.MultiGraph)\\n\\n # create a MultiGraph copy of G\\n G = nx.MultiGraph(G)\\n\\n # remove isolated nodes from the graph, since they are irrelevant and we are working on a copy\\n G.remove_nodes_from(list(nx.isolates(G)))\\n\\n # if the base graph is already odd\\n if is_odd(G):\\n return (set(G.edges(keys=multi)), set())\\n\\n odd_subgraph = G.subgraph(odd_nodes(G))\\n even_subgraph = G.subgraph(even_nodes(G))\\n\\n odd_components = nx.connected_components(odd_subgraph)\\n even_components = nx.connected_components(even_subgraph)\\n\\n # use the same notation as in our source paper\\n X = list(odd_components)\\n Y, Z = partition(even_components, lambda x: len(x) % 2 == 0)\\n\\n lX, lY, lZ = len(X), len(Y), len(Z)\\n linear_system = Matrix(lY + lZ, lX + 1, bin_field)\\n\\n # create a linear system over GF(2) as described in our source paper\\n for i, Yi in enumerate(Y):\\n for j, Xi in enumerate(X):\\n if n_joining(G, Xi, Yi) % 2 == 1:\\n linear_system.set(i, j, 1)\\n else:\\n linear_system.set(i, j, 0)\\n linear_system.set(i, lX, 1)\\n\\n for i, Zi in enumerate(Z):\\n for j, Xi in enumerate(X):\\n if n_joining(G, Xi, Zi) % 2 == 1:\\n linear_system.set(i + lY, j, 1)\\n else:\\n linear_system.set(i + lY, j, 0)\\n linear_system.set(i + lY, lX, 0)\\n\\n # transform the system into RREF\\n linear_system.reduced_row_echelon_form()\\n red = set()\\n\\n # we only need one solution\\n # every non pivot is set to 0 (meaning blue)\\n # while every pivot matches the augmented value\\n # only create the red set since this is the only one we need\\n\\n for i in range(lY + lZ):\\n val = linear_system.get(i, lX)\\n # don't cross the last column (augmented part)\\n for j in range(lX):\\n v = linear_system.get(i, j)\\n if v == 1:\\n if val == 1:\\n red.add(j)\\n break\\n else:\\n if val == 1:\\n # if any of the lines has no pivot and 1 as the augmented value this system is not solvable\\n raise NotDecomposableError(\\\"The graph is not decomposable due to unsolvable system\\\")\\n else:\\n # this is a zero row ane there are no pivots after this row\\n break\\n\\n red_nodes = set.union(*[X[i] for i in red]) if red else set()\\n # edges adjacent to red nodes\\n red_edges = set(G.edges(nbunch=red_nodes, keys=True))\\n # calculate the red degree for every even node\\n degrees = dict()\\n for i in even_subgraph.nodes():\\n degrees[i] = 0\\n\\n for i, j, k in red_edges:\\n if i in degrees:\\n degrees[i] += 1\\n if j in degrees:\\n degrees[j] += 1\\n\\n # T set is the set of all nodes of even red degree\\n T = {i for i, deg in degrees.items() if deg % 2 == 0}\\n\\n # compute the T-join and mark the nodes as red/blue\\n red_join = T_join(even_subgraph, T)\\n\\n red_edges.update(red_join)\\n blue_edges = set(G.edges(keys=True)).difference(red_edges)\\n\\n if not multi:\\n red_edges = {(i, j) for i, j, k in red_edges}\\n blue_edges = {(i, j) for i, j, k in blue_edges}\\n\\n return (red_edges, blue_edges)\",\n \"def MST_pathfinder(G):\\n NG = nx.Graph()\\n NG.add_nodes_from(list(range(numnodes)))\\n edges = sorted( ((G[a][b]['weight'],a,b) for a,b in G.edges()),\\n reverse=False) # smaller distances are more similar\\n clusters = {node:i for i,node in enumerate(G.nodes())}\\n while not edges == []:\\n w1,a,b = edges[0]\\n l = []\\n # Select edges to be considered this round:\\n for w2,u,v in edges:\\n if w1 == w2:\\n l.append((u,v,w2))\\n else:\\n break\\n # Remaining edges are those not being considered this round:\\n edges = edges[len(l):]\\n # Only select those edges for which the items are not in the same cluster\\n l = [(a,b,c) for a,b,c in l if not clusters[a]==clusters[b]]\\n # Add these edges to the graph:\\n NG.add_weighted_edges_from(l)\\n # Merge the clusters:\\n for a,b,w in l:\\n cluster_1 = clusters[a]\\n cluster_2 = clusters[b]\\n clusters = {node:cluster_1 if i==cluster_2 else i\\n for node,i in clusters.items()}\\n return NG\",\n \"def get_neighbors(graph):\\n neighbor_dict = dict()\\n for node in graph:\\n neighbor_dict[node] = set(graph[node])\\n return neighbor_dict\",\n \"def undirected_graph_to_dictionary_form(G):\\n G_dict = dict() # initialize the dictionary\\n for node in G.get_nodeset(): # for every node\\n G_dict[node.get_name()] = dict() # initialize the inner dictionary\\n for edge in node.get_incident_edges(): # for every edge\\n other_node = {node for node in edge.get_incident_nodes() if not node.get_name().__eq__()}.pop()\\n # add the edge, including the edge weight\\n G_dict[node.get_name()][other_node.get_name()] = edge.get_weight()\\n return G_dict # return the populated adjacency matrix representation\",\n \"def gmaps_optical_nodes(request):\\n # Cypher query to get all cables with cable type fiber that are connected\\n # to two optical node.\\n q = \\\"\\\"\\\"\\n MATCH (cable:Cable)\\n WHERE cable.cable_type = \\\"Dark Fiber\\\"\\n MATCH (cable)-[Connected_to]->(port)\\n WITH cable, port\\n MATCH (port)<-[:Has*0..]-(equipment)\\n WHERE (equipment:Optical_Node) AND NOT equipment.type =~ \\\"(?i).*tss.*\\\"\\n WITH cable, port, equipment\\n MATCH p2=(equipment)-[:Located_in]->()<-[:Has*0..]-(loc)\\n WHERE (loc:Site)\\n RETURN cable, equipment, loc\\n \\\"\\\"\\\"\\n result = nc.query_to_list(nc.graphdb.manager, q)\\n nodes = {}\\n edges = {}\\n for item in result:\\n node = {\\n 'name': item['equipment']['name'],\\n 'url': helpers.get_node_url(item['equipment']['handle_id']),\\n 'lng': float(str(item['loc'].get('longitude', 0))),\\n 'lat': float(str(item['loc'].get('latitude', 0)))\\n }\\n coords = {\\n 'lng': float(str(item['loc'].get('longitude', 0))),\\n 'lat': float(str(item['loc'].get('latitude', 0)))\\n }\\n edge = {\\n 'name': item['cable']['name'],\\n 'url': helpers.get_node_url(item['cable']['handle_id']),\\n 'end_points': [coords]\\n }\\n nodes[item['equipment']['name']] = node\\n if item['cable']['name'] in edges:\\n edges[item['cable']['name']]['end_points'].append(coords)\\n else:\\n edges[item['cable']['name']] = edge\\n response = HttpResponse(content_type='application/json')\\n json.dump({'nodes': list(nodes.values()), 'edges': list(edges.values())}, response)\\n return response\",\n \"def _community_detection(self, kg: KG) -> None:\\n nx_graph = nx.Graph()\\n\\n for vertex in kg._vertices:\\n if not vertex.predicate:\\n nx_graph.add_node(str(vertex), vertex=vertex)\\n\\n for vertex in kg._vertices:\\n if not vertex.predicate:\\n # Neighbors are predicates\\n for pred in kg.get_neighbors(vertex):\\n for obj in kg.get_neighbors(pred):\\n nx_graph.add_edge(\\n str(vertex), str(obj), name=str(pred)\\n )\\n\\n # Create a dictionary that maps the URI on a community\\n partition = community.best_partition(\\n nx_graph, resolution=self.resolution\\n )\\n self.labels_per_community = defaultdict(list)\\n\\n self.communities = {}\\n vertices = nx.get_node_attributes(nx_graph, \\\"vertex\\\")\\n for node in partition:\\n if node in vertices:\\n self.communities[vertices[node]] = partition[node]\\n\\n for node in self.communities:\\n self.labels_per_community[self.communities[node]].append(node)\",\n \"def complement(G):\\n\\n nset = set(G.nodes())\\n n_nodes = G.order()\\n n_edges = n_nodes * (n_nodes - 1) - G.size() + 1\\n \\n cmp_edges = ((u, v) for u in G.nodes()\\n\\t\\t for v in nset - set(G.successors(u)))\\n deg = make_deg(n_nodes, cmp_edges)\\n cmp_edges = ((u, v) for u in G.nodes()\\n\\t\\t for v in nset - set(G.successors(u)))\\n H = make(n_nodes, n_edges, cmp_edges, deg)\\n return H\",\n \"def rwgraph(G,i0=0,M=100,Nt=100):\\r\\n\\r\\n adj_dict=nx.convert.to_dict_of_lists(G)\\r\\n X=np.ones((M,Nt+1),dtype=int)\\r\\n X[:,0]=X[:,0]*i0\\r\\n\\r\\n n=len(adj_dict)\\r\\n\\r\\n if M*Nt<n:\\r\\n for i in range(M):\\r\\n for j in range(0,Nt):\\r\\n X[i,j+1]=np.random.choice(adj_dict[X[i,j]])\\r\\n\\r\\n else:\\r\\n #creates array of degree of nodes\\r\\n degree_arr=np.asarray(G.degree(),dtype=int)[:,1]\\r\\n max_degree=max(degree_arr)\\r\\n\\r\\n #create denses matrix\\r\\n Mat=np.zeros((n,max_degree+1))\\r\\n for i in range(0,n):\\r\\n Mat[i,0:len(adj_dict[i])]= np.asarray(adj_dict[i],dtype=int)\\r\\n\\r\\n w=np.random.random((M,Nt))\\r\\n #iterate through time\\r\\n for j in range(0,Nt):\\r\\n X[:,j+1]=Mat[X[:,j],np.floor(degree_arr[X[:,j]]*w[:,j]).astype(int)]\\r\\n return X\",\n \"def aggregate_maps(self, G=[], node_tags={}):\\n\\n self.map = nx.DiGraph() \\n \\n # loop over graphs in list of graphs\\n for g in G:\\n # add nodes to graph\\n self.map.add_nodes_from(g.nodes())\\n # loop over edges \\n for edge in g.edges(data=True):\\n # if edge is already present, add weight to edge\\n if self.map.has_edge(edge[0],edge[1]):\\n self.map[edge[0]][edge[1]]['weight'] += edge[2]['weight']\\n # if edge is not already present, add it with weight=1\\n else:\\n self.map.add_edge(edge[0],edge[1], weight=1)\\n \\n # relabel nodes according to mapping provided by 'node_tags'\\n nx.set_node_attributes(self.map, name = 'node_label', values = node_tags) \\n nx.relabel_nodes(self.map, mapping=node_tags, copy=False)\\n\\n # assign a random color to each node\\n colour_list = np.random.choice( list(colors.get_named_colors_mapping().values()), len(self.map) )\\n colour_dict = dict( zip(self.map.nodes, colour_list) )\\n nx.set_node_attributes(self.map, name = 'node_color', values = colour_dict)\\n\\n # save node attributes to CoMap object\\n self.node_labels = nx.get_node_attributes(self.map, name = 'node_label')\\n self.node_colors = nx.get_node_attributes(self.map, name = 'node_color')\\n \\n return\",\n \"def matching_graph(n):\\r\\n k_n = nx.complete_graph(n)\\r\\n G = nx.Graph()\\r\\n for i in k_n.edges():\\r\\n G.add_node(i)\\r\\n w = []\\r\\n for i in k_n.edges():\\r\\n for j in k_n.edges():\\r\\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \\r\\n w.append((i,j))\\r\\n G.add_edge(i,j)\\r\\n return G\",\n \"def test_DRGEP_GraphSearchFromG(self):\\n graph = nx.DiGraph()\\n graph.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \\n 'L', 'M', 'N', 'O'\\n ])\\n\\n graph.add_weighted_edges_from([('A','F', 0), ('C','F',1.0), ('A','C',1.0),\\n ('A','N',0), ('N','C',1.0), ('C','D',1.0),\\n ('D','I',1.0), ('I','O',1.0), ('A','E',1.0),\\n ('E','G',0), ('G','I',0), ('G','M',0),\\n ('G','L',1.0), ('E','H',1.0), ('H','J',0)\\n ])\\n\\n subgraph = nx.DiGraph([(u,v,d) for u,v,d in graph.edges(data=True) if d['weight'] > 0])\\n\\n\\n #temporary solution\\n max_dic = graph_search_drgep(subgraph, 'G')\\n\\n assert 'G' in max_dic\\n assert max_dic['G']\\n assert [n in max_dic for n in ['G', 'L']]\\n assert [n not in max_dic for n in ['A','B','C','D','E','F','H','I', 'J', 'K', 'L','M', 'N']]\\n assert max_dic['G']==1\\n assert max_dic['L']==1\",\n \"def hashimoto_matrix(G, create_using=None):\\n if create_using is None:\\n L = G.fresh_copy()\\n else:\\n L = create_using\\n\\n # Create a graph specific edge function.\\n get_edges = g.generators.line._edge_func(G)\\n\\n for from_node in get_edges():\\n # from_node is: (u,v) or (u,v,key)\\n L.add_node(from_node)\\n for to_node in get_edges(from_node[1]):\\n # Modification here: make sure there aren't reciprocal edges.\\n if to_node != (from_node[1], from_node[0]):\\n L.add_edge(from_node, to_node)\\n return L\",\n \"def isomorphic(g, h):\\n # Note: for some applications, it can speed things up to\\n # check equality of orders here.\\n #n = len(g)\\n #if n != len(h):\\n # return False\\n\\n # Make dicts of verts of each nbr-degree, for graphs g, h\\n gdv = _degree_verts(g)\\n hdv = _degree_verts(h)\\n\\n # Compare nbr-degree sequences\\n if len(gdv) != len(hdv):\\n return False\\n for k in gdv:\\n if k not in hdv:\\n return False\\n if len(gdv[k]) != len(hdv[k]):\\n return False\\n # Now we know that g, h have the same order\\n\\n # Sort (& renumber) verts by nbr-degree\\n gvp = list(itertools.chain.from_iterable(\\n ( gdv[k] for k in sorted(gdv.keys()) )\\n ))\\n g = [ sorted([gvp.index(w) for w in g[v]]) for v in gvp ]\\n hvp = list(itertools.chain.from_iterable(\\n ( hdv[k] for k in sorted(hdv.keys()) )\\n ))\\n h = [ sorted([hvp.index(w) for w in h[v]]) for v in hvp ]\\n\\n # Remake dict of verts of each nbr-degree, for g\\n gdv = _degree_verts(g)\\n\\n # Try all permutations of the vertex set of graph g that take each\\n # vertex to a vertex whose neighbors have the same degree sequence.\\n n = len(g)\\n hsets = list(map(set, h))\\n for p in _partition_perms(list(gdv.values()), n):\\n for v in range(n):\\n if hsets[p[v]] != set([p[w] for w in g[v]]):\\n # A set comprehension would be nice above\\n break\\n else:\\n return True\\n return False\",\n \"def classify(genes, G):\\n\\n import networkx as nx\\n\\n # Calculate distance\\n gendist = gen_dist(genes)\\n N = gendist.shape[0]\\n\\n # Make the distance with comparison \\\"upper triangular\\\" by\\n # setting lower diagonal of matrix extremely large\\n gendist[np.arange(N)[:,None] >= np.arange(N)] = 999999\\n\\n # Get a list of pairs of indices (i,j) satisfying distance(i,j) < G\\n indices = np.where(gendist <= G)\\n indices = list(zip(indices[0], indices[1]))\\n\\n # Now is the tricky part. I want to combine all the (i,j) indices\\n # that share at least either i or j. This non-trivial problem can be\\n # modeled as a graph problem (stackoverflow link). The solution is\\n G = nx.Graph()\\n G.add_edges_from(indices)\\n return list(nx.connected_components(G))\",\n \"def jupiteNetwork(): \\n \\n # Build a graph for large clos topo\\n tor_cut, aggr_cut, spine_cut = 512, 256, 256\\n #2048, 4096, 4096 #32*4*2, 64*2, 16*2\\n switches, edges = tp.jupiter_topo(\\n tor_cut=tor_cut, aggr_cut=aggr_cut, spine_cut=spine_cut\\n )\\n \\n G = build_graph(edges)\\n external_edges = []\\n for node in G.nodes():\\n if 'sh' in node:\\n G.add_edge(node, 'e1')\\n \\n \\\"\\\"\\\"\\n paths = list(nx.all_shortest_paths(G, 'tor385', 'tor1'))\\n #print(paths)\\n #eee\\n paths = list(nx.all_shortest_paths(G, 'tor129', 'tor257'))\\n #print(paths)\\n paths = list(nx.all_shortest_paths(G, 'tor257', 'tor385'))\\n #print(paths)\\n #eee\\n \\\"\\\"\\\"\\n switch_nodes, hnodes, tors, anodes, snodes = tp.getJupiternNodes(\\n tors_num=tor_cut, aggr_num=aggr_cut, spine_num=spine_cut\\n )\\n print('**** is_connected(G)', nx.is_connected(G))\\n print('**** number of components', nx.number_connected_components(G))\\n \\n tors = tors[0:512] + ['e1']\\n\\n # Get the routing path of all nodes\\n table_file_name = '../outputs/jupiter_routing_table_anodes_cut4.txt'\\n\\n if((os.path.isfile(table_file_name)) == False):\\n table = all_routing(G, tors, table_file_name)\\n else:\\n json_data = open(table_file_name).read()\\n table = json.loads(json_data)\\n \\n seeds, polys = cf.get_seeds_table_jupiter(switch_nodes + ['e1']) #\\n \\n return G, tors, edges, table, seeds, polys, anodes\",\n \"def cluster_connectivity(G, weight='weight'):\\n\\t# 1) indexing the edges by community\\n\\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\\n\\tfor node1, node2 in G.edges():\\n\\t\\tcomm1 = G.nodes[node1]['community']\\n\\t\\tcomm2 = G.nodes[node2]['community']\\n\\t\\tif comm2 not in sum_edges_dic[comm1]:\\n\\t\\t\\tsum_edges_dic[comm1][comm2] = 0\\n\\t\\t\\tsum_edges_dic[comm2][comm1] = 0\\n\\t\\telse:\\n\\t\\t\\tif weight is None:\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += 1\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += 1\\n\\t\\t\\telse:\\t\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\\n\\tc_connectivity = {}\\n\\t# 2) computing the connectivity\\n\\tfor com in sum_edges_dic:\\n\\t\\tin_out_edges = sum(sum_edges_dic[com].values())\\n\\t\\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \\n\\treturn c_connectivity\",\n \"def nodes_with_m_nbrs(G,m):\\n nodes = set()\\n \\n # Iterate over all nodes in G\\n for n in G.nodes():\\n \\n # Check if the number of neighbors of n matches m\\n if len(G.neighbors(n)) == m:\\n \\n # Add the node n to the set\\n nodes.add(n)\\n \\n # Return the nodes with m neighbors\\n return nodes\",\n \"def test_get_hyperflex_node_by_moid(self):\\n pass\",\n \"def create_hop_matrix(G, max_hops, node_list):\\n distances = dict(nx.all_pairs_dijkstra_path_length(G))\\n hop_matrix = torch.zeros(max_hops, G.number_of_nodes(), G.number_of_nodes(), dtype=torch.int)\\n for hop in range(max_hops):\\n for i, node_from in enumerate(node_list):\\n for j, node_to in enumerate(node_list):\\n if node_to in distances[node_from].keys() and distances[node_from][node_to] == hop:\\n hop_matrix[hop,i,j] = 1\\n return hop_matrix\",\n \"def condensation(G):\\n scc = strongly_connected_components(G)\\n mapping = dict([(n,tuple(sorted(c))) for c in scc for n in c])\\n cG = nx.DiGraph()\\n for u in mapping:\\n cG.add_node(mapping[u])\\n for _,v,d in G.edges_iter(u, data=True):\\n if v not in mapping[u]:\\n cG.add_edge(mapping[u], mapping[v])\\n return cG\",\n \"def nodes_with_m_nbrs(G, m):\\n nodes = set()\\n\\n # Iterate over all nodes in G\\n for n in G.nodes():\\n\\n # Check if the number of neighbors of n matches m\\n if len(G.neighbors(n)) == m:\\n\\n # Add the node n to the set\\n nodes.add(n)\\n\\n # Return the nodes with m neighbors\\n return nodes\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def test_get_hyperflex_node_profile_by_moid(self):\\n pass\",\n \"def allReachable(g, n):\\n nodeList = []\\n \\n keysList = []\\n\\n for key in g.keys():\\n keysList.append(key)\\n \\n for i in keysList:\\n if findPath(g, n, i) != None:\\n nodeList.append(i)\\n \\n nodeList.sort()\\n nodeList.remove(n)\\n \\n return nodeList\",\n \"def find_eulerian_path(G):\\n from operator import itemgetter\\n\\n # Verify that graph is connected, short circuit\\n if G.is_directed() and not nx.is_weakly_connected(G):\\n raise nx.NetworkXError(\\\"G is not connected.\\\")\\n\\n # is undirected\\n if not G.is_directed() and not nx.is_connected(G):\\n raise nx.NetworkXError(\\\"G is not connected.\\\")\\n\\n # Now verify if has an eulerian circuit:\\n # even condition of all nodes is satified.\\n if nx.is_eulerian(G):\\n x = nx.eulerian_circuit(G) # generator of edges\\n for i in x:\\n yield i\\n\\n # Not all vertex have even degree,\\n # check if exactly two vertex have odd degrees.\\n # If yes, then there is an Euler path. If not,\\n # raise an error (no euler path can be found)\\n else:\\n g = G.__class__(G) # copy graph structure (not attributes)\\n\\n # list to check the odd degree condition, and a flag\\n check_odd = []\\n directed = False\\n\\n if g.is_directed():\\n degree = g.in_degree\\n out_degree = g.out_degree\\n edges = g.in_edges_iter\\n get_vertex = itemgetter(0)\\n directed = True\\n else:\\n degree = g.degree\\n edges = g.edges_iter\\n get_vertex = itemgetter(1)\\n\\n # Verify if an euler path can be found. Complexity O(n) ?\\n for vertex in g.nodes():\\n deg = degree(vertex)\\n # directed case\\n if directed:\\n outdeg = out_degree(vertex)\\n if deg != outdeg:\\n # if we have more than 2 odd nodes,\\n # we do a raise (no euler path)\\n if len(check_odd) > 2:\\n raise nx.NetworkXError(\\\"G doesn't have an Euler Path.\\\")\\n # is odd and we append it.\\n else:\\n check_odd.append(vertex)\\n # undirected case\\n else:\\n if deg % 2 != 0:\\n # if we have more than 2 odd nodes,\\n # we do a raise (no euler path)\\n if len(check_odd) > 2:\\n raise nx.NetworkXError(\\\"G doesn't have an Euler Path.\\\")\\n # is odd and we append it.\\n else:\\n check_odd.append(vertex)\\n\\n if directed:\\n def verify_odd_cond(g, check_odd):\\n first = check_odd[0]\\n second = check_odd[1]\\n if (g.out_degree(first) == g.in_degree(first) + 1 and\\n g.in_degree(second) == g.out_degree(second) + 1):\\n return second\\n elif (g.out_degree(second) == g.in_degree(second) + 1 and\\n g.in_degree(first) == g.out_degree(first) + 1):\\n return first\\n else:\\n return None\\n start = verify_odd_cond(g, check_odd)\\n else:\\n start = check_odd[0]\\n\\n # if the odd condition is not meet, raise an error.\\n if not start:\\n raise nx.NetworkXError(\\\"G doesn't have an Euler Path.\\\")\\n # Begin algorithm:\\n vertex_stack = [start]\\n last_vertex = None\\n\\n while vertex_stack:\\n\\n current_vertex = vertex_stack[-1] # (4)\\n # if no neighbors:\\n if degree(current_vertex) == 0:\\n # Special case, we cannot add a None vertex to the path.\\n if last_vertex is not None:\\n yield (last_vertex, current_vertex)\\n last_vertex = current_vertex\\n vertex_stack.pop()\\n # we have neighbors, so add the vertex to the stack (2),\\n # take any of its neighbors (1)\\n # remove the edge between selected neighbor and that vertex,\\n # and set that neighbor as the current vertex (4).\\n else:\\n random_edge = next(edges(current_vertex)) # (1)\\n vertex_stack.append(get_vertex(random_edge)) # (2)\\n g.remove_edge(*random_edge) # (3)\",\n \"def create_graph(id):\\n\\n\\timport numpy as np\\n\\timport networkx as nx\\n\\n\\t# seed the rng\\n\\tseed = id\\n\\n\\t# set base number of nodes and minimum number of edges\\n\\tn = 50\\n\\te = 100\\n\\n\\t# randomise number of nodes\\n\\tpm1 = (-1)**(seed % 2)\\n\\tseed = rng(seed)\\n\\tn += pm1*(seed % 11)\\n\\tseed = rng(seed)\\n\\n\\t# randomise minimum number of edges\\n\\tpm2 = (-1)**(seed % 2)\\n\\tseed = rng(seed)\\n\\te = 2*n + pm2*(seed % 11)\\n\\tseed = rng(seed)\\n\\n\\t# initialise empty graph\\n\\tG = nx.convert_node_labels_to_integers(nx.empty_graph(n))\\n\\n\\t# add e random edges before checking connectedness\\n\\twhile G.number_of_edges() < e:\\n\\t\\tnode1 = seed % n\\n\\t\\tseed = rng(seed)\\n\\t\\tnode2 = seed % n\\n\\t\\tseed = rng(seed)\\n\\t\\tif node1 != node2:\\n\\t\\t\\tif node2 > node1:\\n\\t\\t\\t\\tnode1, node2 = node2, node1\\n\\t\\t\\tG.add_edge(node1, node2)\\n\\n\\t# if G is disconnected, find connected components and add edges\\n\\tif not nx.is_connected(G):\\n\\t\\tcc = sorted(list(nx.connected_components(G)))\\n\\t\\tlargest = cc[0]\\n\\t\\tfor i in range(len(cc)):\\n\\t\\t\\tif len(cc[i]) > len(largest):\\n\\t\\t\\t\\tlargest = cc[i]\\t\\t\\n\\t\\tfor component in cc:\\n\\t\\t\\tif component != largest:\\n\\t\\t\\t\\tnode1 = list(component)[seed % len(component)]\\n\\t\\t\\t\\tseed = rng(seed)\\n\\t\\t\\t\\tnode2 = list(largest)[seed % len(largest)]\\n\\t\\t\\t\\tseed = rng(seed)\\n\\t\\t\\t\\tif node2 > node1:\\n\\t\\t\\t\\t\\tnode1, node2 = node2, node1\\n\\t\\t\\t\\tG.add_edge(node1, node2)\\n\\n\\t# if for some reason G is still disconnected, print a helpful error message\\n\\tif nx.is_connected(G):\\n\\t\\treturn G\\n\\telse:\\n\\t\\tprint(\\\"Sorry, failed to produce a connected graph :( Please contact one of your lecturers.\\\")\",\n \"def IsomorphicHash(self) -> int:\\n # The hash is based on the nodes and edges, not their attributes.\\n return hash((tuple(self.nodes), tuple(self.edges)))\",\n \"def test_DRGEP_GraphSearchHalve(self):\\n graph = nx.DiGraph()\\n graph.add_nodes_from(['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', \\n 'L', 'M', 'N', 'O'\\n ])\\n\\n graph.add_weighted_edges_from([('A','B', .5), ('B','C',.5), ('C','D',.5), \\n ('D','E',.5), ('E','F',.5)\\n ])\\n\\n\\n subgraph = nx.DiGraph([(u,v,d) for u,v,d in graph.edges(data=True) if d['weight'] > 0])\\n\\n\\n #temporary solution\\n max_dic = graph_search_drgep(subgraph, 'A')\\n\\n assert 'A' in max_dic\\n assert max_dic['A']==1\\n assert max_dic['B']==.5\\n assert max_dic['C']==.25\\n assert max_dic['D']==.125\\n assert max_dic['E']==.0625\\n assert max_dic['F']==.03125\",\n \"def T_join(G, T: Set[int]) -> Set[Tuple[int, int]]:\\n edge_count = defaultdict(int)\\n components = nx.connected_components(G)\\n\\n # analyse every connected component on its own\\n for c in components:\\n Ti = T.intersection(c)\\n\\n # required and sufficient condition for existence of the T-join\\n if len(Ti) % 2 == 1:\\n raise ValueError(\\\"T-join does not exist for odd intersections of T\\\")\\n\\n while Ti:\\n # pop vertices 2 by 2 and find a simple path between them\\n x, y = Ti.pop(), Ti.pop()\\n path = next(nx.all_simple_paths(G, x, y))\\n # count how many times each edge is used\\n for i, j in zip(path[:-1], path[1:]):\\n edge_count[(min(i, j), max(i, j), 0)] += 1\\n\\n return {e for e, count in edge_count.items() if count % 2 == 1}\",\n \"def bipartite_color(G):\\n color={}\\n for n in G: # handle disconnected graphs\\n if n in color: continue\\n queue=[n] \\n color[n]=1 # nodes seen with color (1 or 0)\\n while queue:\\n v=queue.pop()\\n c=1-color[v] # opposite color of node v\\n for w in G[v]: \\n if w in color: \\n if color[w]==color[v]:\\n raise networkx.NetworkXError(\\\"Graph is not bipartite.\\\")\\n else:\\n color[w]=c\\n queue.append(w)\\n return color\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def randnet(G):\\n\\t\\n\\t#initializationo of the lists\\n\\telst = G.get_edgelist()\\n\\tclst = G.es['color'][:]\\n\\tcdic = {}\\n\\tfor i,c in enumerate(clst):\\n\\t\\tcdic[c]=i\\n\\tlst1 = [[]]*len(key)\\n\\tfor i,e in enumerate(elst):\\n\\t\\tlst1[cdic[clst[i]]].append([e[0],e[1]])\\n\\t\\t\\n\\t#randomization procedure\\n\\tfor i in range(random.randrange(100,200)):\\n\\t\\tcid = cdic[random.choice(clst)] #random choice weighted by the frequency of each color\\n\\t\\te1id = random.randrange(0,len(lst1[cid])) #random choice of edge with that color\\n\\t\\te2id = random.randrange(0,len(lst1[cid]))\\n\\t\\textop = random.randrange(0,2)#random choice of top/bottom\\n\\t\\tttemp = lst1[cid][e1id][extop]\\n\\t\\tlst1[cid][e1id][extop] = lst1[cid][e2id][extop]\\n\\t\\tlst1[cid][e2id][extop] = ttemp\\n\\t\\n\\tcoutlst = []\\n\\teoutlst\\t= []\\n\\tfor i in range(len(lst1)):\\n\\t\\tc = clst[i]\\n\\t\\tfor e in lst1[i]:\\n\\t\\t\\tcoutlst.append(c)\\n\\t\\t\\teoutlst.append((e[0],e[1]))\\n\\n\\treturn [eoutlst,coutlst]\",\n \"def multi_edge():\\n from networkx.readwrite import json_graph\\n import networkx as nx\\n import autonetkit\\n # returns a house graph\\n data = {'directed': False,\\n 'graph': [],\\n 'links': [{'_ports': {'r4': 2, 'r5': 1},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 1},\\n {'_ports': {'r2': 3, 'r4': 1},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 3},\\n {'_ports': {'r2': 4, 'r4': 3},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 3},\\n {'_ports': {'r3': 3, 'r5': 2},\\n 'raw_interfaces': {},\\n 'source': 1,\\n 'target': 4},\\n {'_ports': {'r1': 1, 'r2': 1},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 3},\\n {'_ports': {'r1': 3, 'r2': 5},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 3},\\n {'_ports': {'r1': 2, 'r3': 1},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r1': 4, 'r3': 4},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r1': 5, 'r3': 5},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r2': 2, 'r3': 2},\\n 'raw_interfaces': {},\\n 'source': 3,\\n 'target': 4}],\\n 'multigraph': True,\\n 'nodes': [{'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r4 to r5', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth2'}},\\n 'asn': 2,\\n 'device_type': 'router',\\n 'id': 'r4',\\n 'label': 'r4',\\n 'x': 675,\\n 'y': 300},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r5 to r4', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r5 to r3', 'id': 'eth1'}},\\n 'asn': 2,\\n 'device_type': 'router',\\n 'id': 'r5',\\n 'label': 'r5',\\n 'x': 675,\\n 'y': 500},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r1',\\n 'label': 'r1',\\n 'x': 350,\\n 'y': 400},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r2 to r3', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r2',\\n 'label': 'r2',\\n 'x': 500,\\n 'y': 300},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r3 to r2', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r3 to r5', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r3',\\n 'label': 'r3',\\n 'x': 500,\\n 'y': 500}]}\\n graph = json_graph.node_link_graph(data)\\n anm = autonetkit.anm.NetworkModel()\\n g_in = anm.add_overlay(\\\"input\\\")\\n g_in._replace_graph(nx.MultiGraph(graph))\\n # TODO: check if should build overlays here rather than clone in?\\n g_phy = anm[\\\"phy\\\"]\\n g_phy._replace_graph(graph)\\n return anm\",\n \"def get_neighbor_edges(G, nodes_in_community, weak_neighbor=False):\\n neighbor_nodes = []\\n for n in nodes_in_community:\\n neighbor_nodes.extend([n for n in nx.neighbors(G, n) if n not in nodes_in_community])\\n neighbor_nodes = set(neighbor_nodes)\\n neighbor_edges = [e for e in G.edges(neighbor_nodes)]\\n\\n if weak_neighbor:\\n # This case returns more edges than the case that weak_neighbor is False\\n nodes_ = set(nodes_in_community).union(neighbor_nodes)\\n neighbor_edges = list(filter(lambda e: e[0] in nodes_ and e[1] in nodes_, neighbor_edges))\\n else:\\n neighbor_edges = list(filter(lambda e: e[0] in nodes_in_community or e[1] in nodes_in_community, neighbor_edges))\\n return neighbor_edges\",\n \"def compute_wl_subtree_kernel(graphs, h):\\n for G in graphs:\\n for node in G.nodes():\\n G.node[node]['label'] = G.degree(node)\\n\\n start_time = time.time()\\n\\n labels = {}\\n label_lookup = {}\\n label_counter = 0\\n\\n N = len(graphs)\\n\\n orig_graph_map = {it: {i: defaultdict(lambda: 0) for i in range(N)} for it in range(-1, h)}\\n\\n # initial labeling\\n ind = 0\\n for G in graphs:\\n labels[ind] = np.zeros(G.number_of_nodes(), dtype=np.int32)\\n node2index = {}\\n for node in G.nodes():\\n node2index[node] = len(node2index)\\n\\n for node in G.nodes():\\n label = G.node[node]['label']\\n if not label_lookup.has_key(label):\\n label_lookup[label] = len(label_lookup)\\n\\n labels[ind][node2index[node]] = label_lookup[label]\\n orig_graph_map[-1][ind][label] = orig_graph_map[-1][ind].get(label, 0) + 1\\n\\n ind += 1\\n\\n compressed_labels = copy.deepcopy(labels)\\n\\n # WL iterations\\n for it in range(h):\\n unique_labels_per_h = set()\\n label_lookup = {}\\n ind = 0\\n for G in graphs:\\n node2index = {}\\n for node in G.nodes():\\n node2index[node] = len(node2index)\\n\\n for node in G.nodes():\\n node_label = tuple([labels[ind][node2index[node]]])\\n neighbors = G.neighbors(node)\\n if len(neighbors) > 0:\\n neighbors_label = tuple([labels[ind][node2index[neigh]] for neigh in neighbors])\\n node_label = str(node_label) + \\\"-\\\" + str(sorted(neighbors_label))\\n if not label_lookup.has_key(node_label):\\n label_lookup[node_label] = len(label_lookup)\\n\\n compressed_labels[ind][node2index[node]] = label_lookup[node_label]\\n orig_graph_map[it][ind][node_label] = orig_graph_map[it][ind].get(node_label, 0) + 1\\n\\n ind += 1\\n\\n print \\\"Number of compressed labels at iteration %s: %s\\\" % (it, len(label_lookup))\\n labels = copy.deepcopy(compressed_labels)\\n\\n K = np.zeros((N, N))\\n\\n for it in range(-1, h):\\n for i in range(N):\\n for j in range(N):\\n common_keys = set(orig_graph_map[it][i].keys()) & set(orig_graph_map[it][j].keys())\\n K[i][j] += sum([orig_graph_map[it][i].get(k, 0) * orig_graph_map[it][j].get(k, 0) for k in common_keys])\\n\\n end_time = time.time()\\n print \\\"Total time for WL subtree kernel: \\\", (end_time - start_time)\\n\\n return K\",\n \"def find_attribute_dict(G: nx.DiGraph, node1: NodeID, node2: NodeID, endnode: NodeID):\\n edgeID = (node1, node2)\\n attribute_dict = dict(G.edges[edgeID])\\n attribute_dict[\\\"distance_efficiency\\\"] = calc_distance_efficiency(node1, node2, endnode)\\n \\n return attribute_dict\",\n \"def generate_csv_dict(G):\\n csv_dict = { start_node_id: { dest_node_id: None for dest_node_id in G.nodes } for start_node_id in G.nodes }\\n return csv_dict\",\n \"def network_graph(net_dict=None):\\n if net_dict == None:\\n net_dict = {}\\n else:\\n G = nx.from_dict_of_lists(net_dict)\\n plt.figure(num=None, figsize=(30, 30), dpi=80, facecolor='w', edgecolor='c')\\n nx.draw_networkx(G, with_labels=True, alpha=0.5, edge_color='c', cmap=plt.cm.GnBu)\\n plt.savefig(\\\"metabolism_5years.png\\\", bbox_inches='tight')\",\n \"def kegg_pathway_enrichment(degs, negs, dbpaths=dbpaths, show_all=True, pthresh=0.01):\\n\\n deg_num_ko, deg_keggs = cbir_to_kegg(degs)\\n neg_num_ko, neg_keggs = cbir_to_kegg(negs)\\n\\n print \\\"%-4d kegg pathways from %d DEGs\\\" % (len(deg_keggs), len(degs) )\\n print \\\"%-4d kegg pathways from %d nonDEGs\\\" % (len(neg_keggs), len(negs) )\\n\\n # create dictionary of kegg pathways {pathwaytype:{pathway:[ko1,ko2,ko3]}}\\n pathwaytype_dict = {}\\n pathway_dict = {}\\n pathway_lookup = {}\\n\\n print \\\"extracting pathways...\\\"\\n ko1_h = open(dbpaths['kegg'], 'rb')\\n for line in ko1_h:\\n if line[0] == 'B': # Kegg path type eg: B <b>Replication and repair</b>\\n pathtype_f = re.search('B.*<b>(.*)<', line)\\n if pathtype_f is not None:\\n pathtype = pathtype_f.group(1)\\n else:\\n pathtype = 'unknown'\\n pathwaytype_dict[pathtype] = {}\\n elif line[0] == 'C': # Kegg Pathway eg: 01200 Carbon metabolism [PATH:ko01200]\\n pathway_f = re.search(\\\"C +([0-9]*) *(.*)\\\\[PATH\\\", line)\\n if pathway_f is not None:\\n pathway_id = pathway_f.group(1)\\n pathway_name = pathway_f.group(2)\\n else:\\n pathway_id = 'unknown'\\n pathway_name = 'unknown'\\n pathway_dict[pathway_id] = {}\\n pathway_lookup[pathway_id] = pathway_name\\n elif line[0] == 'D': # Kegg term eg: K00844 HK; hexokinase [EC:2.7.1.1]\\n koterm_f = re.search(\\\"(K[0-9]*)\\\", line)\\n if koterm_f is not None:\\n koterm = koterm_f.group(1)\\n else:\\n koterm = 'unknown'\\n pathwaytype_dict[pathtype][koterm] = 1\\n pathway_dict[pathway_id][koterm] = 1\\n\\n\\n print \\\"calculating enrichment...\\\"\\n pathwaytype_ps = {}\\n pathway_ps = {}\\n # count number of degs and negs in each pathway:\\n for pathwaytype in pathwaytype_dict:\\n pwtsize = len(pathwaytype_dict)\\n degs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in deg_keggs])\\n negs_in_path = sum([1 for ko in pathwaytype_dict[pathwaytype] if ko in neg_keggs])\\n degs_not_in = len(deg_keggs) - degs_in_path\\n negs_not_in = len(neg_keggs) - negs_in_path\\n\\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\\n [negs_in_path, negs_not_in] ],\\n alternative='greater')\\n pathwaytype_ps[pathwaytype] = pval\\n\\n if pval < pthresh:\\n print \\\"%s\\\\n \\\\\\n In Path Not in Path\\\\n\\\\\\n DEG : %-7d %d\\\\n\\\\\\n non-DEG: %-7d %d\\\\n\\\\\\n Odds Ratio:%.3f\\\\n\\\\\\n P-value:%.4f\\\\n\\\" % (pathwaytype,degs_in_path,degs_not_in,negs_in_path,negs_not_in,\\n oddrat, pval)\\n\\n\\n for pathway in pathway_dict:\\n pwtsize = len(pathway_dict)\\n degs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in deg_keggs])\\n negs_in_path = sum([1 for ko in pathway_dict[pathway] if ko in neg_keggs])\\n degs_not_in = len(deg_keggs) - degs_in_path\\n negs_not_in = len(neg_keggs) - negs_in_path\\n\\n oddrat, pval = fisher_exact([ [degs_in_path, degs_not_in],\\n [negs_in_path, negs_not_in] ],\\n alternative='greater')\\n pathway_ps[pathway + ' ' + pathway_lookup[pathway]] = pval\\n\\n ## Fisher's Exact Test:\\n # In Pathway: Not in Pathway:\\n # DEG : degs_in_path degs_not_in\\n # non-DEG : negs_in_path negs_not_in\\n #\\n\\n return pathwaytype_ps, pathway_ps\",\n \"def _generate_graph(self) -> None:\\n self.g_ = nx.random_partition_graph(list(self._community_sizes),\\n p_in=self.community_p_in,\\n p_out=self.community_p_out,\\n seed=self.seed)\\n\\n for _, nv in self.g_.nodes.data():\\n nv[\\\"infected\\\"] = 0\\n nv[\\\"immune\\\"] = False\\n nv[\\\"alive\\\"] = True\\n nv[\\\"_edges\\\"] = []\\n nv[\\\"isolated\\\"] = False\\n nv[\\\"mask\\\"] = 0.0\",\n \"def construct_H_with_KNN(X, K_neigs=[10], is_probH=False, m_prob=1):\\n if len(X.shape) != 2:\\n X = X.reshape(-1, X.shape[-1])\\n\\n if type(K_neigs) == int:\\n K_neigs = [K_neigs]\\n\\n dis_mat = cos_dis(X)\\n H = None\\n for k_neig in K_neigs:\\n H_tmp = construct_H_with_KNN_from_distance(dis_mat, k_neig, is_probH, m_prob)\\n H = hyperedge_concat(H, H_tmp)\\n return H\",\n \"def example_graph():\\n g = nx.Graph()\\n g.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D'), ('D', 'E'), ('D', 'F'), ('D', 'G'), ('E', 'F'), ('G', 'F')])\\n return g\",\n \"def communityGraph(graph):\\n\\n lapgr = nx.laplacian_matrix(graph)\\n\\n # Get the eigenvalues and eigenvectors of the Laplacian matrix\\n evals, evec = np.linalg.eigh(lapgr.todense())\\n\\n fiedler = evec[1]\\n results = []\\n ## \\\"Fiedler\\\", fiedler\\n median = np.median(fiedler, axis=1) # median of the second eigenvalue\\n for i in range(0, fiedler.size): # divide the graph nodes into two\\n if(fiedler[0, i] < median):\\n results.append(0)\\n else:\\n results.append(1)\\n return results, evals, evec\",\n \"def wsngraph():\\n G = nx.Graph()\\n G.add_node(1)\\n G.add_node(2)\\n G.add_node(3)\\n G.add_node(4)\\n G.add_node(5)\\n G.add_node(6)\\n G.add_node(7)\\n G.add_node(8)\\n G.add_node(9)\\n G.add_node(10)\\n G.add_node(11)\\n G.add_node(12)\\n G.add_edge(1,3,weight=1)\\n G.add_edge(1,2,weight=6)\\n G.add_edge(1,12,weight=16)\\n G.add_edge(2,11,weight=12)\\n G.add_edge(2,6,weight=10)\\n G.add_edge(2,5,weight=11)\\n G.add_edge(3,4,weight=10)\\n G.add_edge(3,7,weight=11)\\n G.add_edge(3,8,weight=14)\\n G.add_edge(3,9,weight=11)\\n G.add_edge(4,7,weight=9)\\n G.add_edge(5,6,weight=7)\\n G.add_edge(5,9,weight=12)\\n G.add_edge(6,9,weight=9)\\n G.add_edge(7,10,weight=10)\\n G.add_edge(8,10,weight=2)\\n G.add_edge(8,11,weight=11)\\n G.add_edge(8,9,weight=12)\\n G.add_edge(9,11,weight=8)\\n G.add_edge(10,12,weight=3)\\n G.pos={}\\n G.pos[1]=(6,4)\\n G.pos[2]=(-1,3.7)\\n G.pos[3]=(4.7,3.5)\\n G.pos[4]=(5.3,3.2)\\n G.pos[5]=(0,3)\\n G.pos[6]=(1.4,3.4)\\n G.pos[7]=(5,2.6)\\n G.pos[8]=(4.7,0)\\n G.pos[9]=(1.4,2.4)\\n G.pos[10]=(5.2,0.5)\\n G.pos[11]=(1.3,0)\\n G.pos[12]=(6,2.4)\\n elarge=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] > 8]\\n esmall=[(u,v) for (u,v,d) in G.edges(data=True) if d['weight'] <= 8]\\n nx.draw_networkx_nodes(G,G.pos,node_color='w')\\n nx.draw_networkx_edges(G,G.pos,elarge,width=3,edge_color='r',alpha=0.3)\\n nx.draw_networkx_edges(G,G.pos,esmall,width=1,edge_color='b',alpha=0.3)\\n nx.draw_networkx_labels(G,G.pos)\\n ax=plt.gca()\\n ax.axison = False\\n label = {} \\n for (u,v) in G.edges():\\n d = G.get_edge_data(u,v)\\n label[(u,v)]=d['weight']\\n edge_label=nx.draw_networkx_edge_labels(G,G.pos,edge_labels=label)\\n\\n return(G)\",\n \"def graph_search(self, node, query):\\n\\n\\t\\t\\\"\\\"\\\"\\n\\t\\t<query> ::= <n_query> | <g_query>\\n\\t\\t<n_query> ::= \\\"NEIGHBOURS WHO HAVE\\\" <n_conditions> | \\\"ALL NEIGHBOURS\\\"\\n\\t\\t<n_conditions> ::= <n_and_condition> | <n_and_condition> \\\"OR\\\" <n_and_condition>\\n\\t\\t<n_and_condition> ::= <n_condition> | <n_condition> \\\"AND\\\" <n_condition>\\n\\t\\t<n_condition> ::= <label_condition> | <node_label_condition> | <neighbour_num_condition> | \\\"(\\\" <n_conditions> \\\")\\\"\\n\\n\\t\\t<label_condition> ::= \\\"LABEL\\\" <label>\\n\\t\\t<node_label_condition> ::= \\\"NEIGHBOUR LABEL\\\" <label>\\n\\t\\t<neighbour_num_condition> ::= <num_condition> | <num_label_condition>\\n\\t\\t<num_operator> ::= \\\"EXACTLY\\\" | \\\"LESS THAN\\\" | \\\"MORE THAN\\\"\\n\\t\\t<num_condition> ::= <num_operator> <num> \\\"NEIGHBOURS\\\"\\n\\t\\t<num_label_condition> ::= <num_operator> <num> \\\"NEIGHBOURS WITH LABEL\\\" <label>\\n\\n\\t\\t<g_query> ::= \\\"PEOPLE WHO HAVE\\\" <g_conditions>\\n\\t\\t<g_conditions> ::= <g_and_condition> | <g_and_condition> \\\"OR\\\" <g_and_condition>\\n\\t\\t<g_and_condition> ::= <g_condition> | <g_condition> \\\"AND\\\" <g_condition>\\n\\t\\t<g_condition> ::= <neighbour_num_condition> | <degrees_condition> | \\\"(\\\" <g_conditions> \\\")\\\"\\n\\t\\t<degrees_condition> ::= <num> \\\"DEGREES OF SEPARATION FROM ME\\\"\\n\\t\\t\\\"\\\"\\\"\\n\\n\\t\\tdef pop(tokens, legal, off=0):\\n\\t\\t\\tif tokens:\\n\\t\\t\\t\\tfor t in legal:\\n\\t\\t\\t\\t\\tn = len(t.split())\\n\\n\\t\\t\\t\\t\\ttoken = ' '.join(tokens[off:n+off])\\n\\n\\t\\t\\t\\t\\tif token.lower() == t.lower():\\n\\t\\t\\t\\t\\t\\tfor x in range(n):\\n\\t\\t\\t\\t\\t\\t\\tif len(tokens) > off:\\n\\t\\t\\t\\t\\t\\t\\t\\ttokens.pop(off)\\n\\t\\t\\t\\t\\t\\treturn t\\n\\n\\t\\t# overall query\\n\\t\\tdef q(tokens):\\n\\t\\t\\ta = g_query(tokens)\\n\\n\\t\\t\\tif a == None:\\n\\t\\t\\t\\ta = n_query(tokens)\\n\\n\\t\\t\\tif a == None or tokens:\\n\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn sorted(a, key=lambda n:n.id)\\n\\n\\t\\t# N queries\\n\\t\\tdef n_query(tokens):\\n\\t\\t\\tcond = None\\n\\n\\t\\t\\tif pop(tokens, [\\\"NEIGHBOURS WHO HAVE\\\"]) and tokens:\\n\\t\\t\\t\\tcond = n_conds(tokens)\\n\\t\\t\\t\\tif not cond:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\telif pop(tokens, [\\\"ALL NEIGHBOURS\\\"]):\\n\\t\\t\\t\\tcond = lambda n1,n2:True\\n\\t\\t\\t\\tif tokens:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\tif cond:\\n\\t\\t\\t\\treturn [N for n in node.neighbours.values() for N in n if cond(node, N)]\\n\\n\\t\\tdef n_conds(tokens):\\n\\t\\t\\tcond = n_and_cond(tokens)\\n\\n\\t\\t\\tif cond and pop(tokens, [\\\"OR\\\"]):\\n\\t\\t\\t\\ta = n_and_cond(tokens)\\n\\t\\t\\t\\tif a:\\n\\t\\t\\t\\t\\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) or cond(n1, n2))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn cond\\n\\n\\t\\tdef n_and_cond(tokens):\\n\\t\\t\\tcond = n_cond(tokens)\\n\\n\\t\\t\\tif cond and pop(tokens, [\\\"AND\\\"]):\\n\\t\\t\\t\\ta = n_cond(tokens)\\n\\t\\t\\t\\tif a:\\n\\t\\t\\t\\t\\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) and cond(n1, n2))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn cond\\n\\n\\t\\tdef n_cond(tokens):\\n\\t\\t\\tcond = label_cond(tokens) or node_label_cond(tokens) or neighbour_num_cond(tokens)\\n\\n\\t\\t\\tif not cond and pop(tokens, [\\\"(\\\"]):\\n\\t\\t\\t\\ttmp = n_conds(tokens)\\n\\t\\t\\t\\tif tmp and pop(tokens, [\\\")\\\"]):\\n\\t\\t\\t\\t\\tcond = tmp\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn cond\\n\\n\\t\\tdef num_operator(tokens):\\n\\t\\t\\treturn pop(tokens, [\\\"EXACTLY\\\"]) or pop(tokens, [\\\"LESS THAN\\\"]) or pop(tokens, [\\\"MORE THAN\\\"])\\n\\n\\t\\tdef num_label_cond(tokens):\\n\\t\\t\\top = {\\n\\t\\t\\t\\t\\\"EXACTLY\\\" : lambda a,b:a==b,\\n\\t\\t\\t\\t\\\"LESS THAN\\\" : lambda a,b:a<b,\\n\\t\\t\\t\\t\\\"MORE THAN\\\" : lambda a,b:a>b\\n\\t\\t\\t}.get(num_operator(tokens), None)\\n\\t\\t\\tnum = None\\n\\n\\t\\t\\tif op and tokens:\\n\\t\\t\\t\\tg = tokens.pop(0)\\n\\t\\t\\t\\tif g.isnumeric():\\n\\t\\t\\t\\t\\tnum = int(g)\\n\\t\\t\\t\\t\\tif pop(tokens, [\\\"NEIGHBOURS WITH LABEL\\\"]) and tokens:\\n\\t\\t\\t\\t\\t\\tl = tokens.pop(0)\\n\\t\\t\\t\\t\\t\\treturn lambda n1,n2,num=num,l=l:op(len(n2.neighbours.get(l, [])), num)\\n\\t\\t\\t\\t\\telif pop(tokens, [\\\"NEIGHBOURS\\\"]):\\n\\t\\t\\t\\t\\t\\treturn lambda n1,n2,num=num:op(len([y for x in n2.neighbours.values() for y in x]), num)\\n\\n\\t\\tdef neighbour_num_cond(tokens):\\n\\t\\t\\treturn num_label_cond(tokens)\\n\\n\\t\\t# General conditions\\n\\t\\tdef label_cond(tokens):\\n\\t\\t\\tif pop(tokens, [\\\"LABEL\\\"]) and tokens:\\n\\t\\t\\t\\tl = tokens.pop(0)\\n\\t\\t\\t\\treturn lambda n1,n2,l=l:(n2.label == l)\\n\\n\\t\\tdef node_label_cond(tokens):\\n\\t\\t\\tif pop(tokens, [\\\"NEIGHBOUR LABEL\\\"]) and tokens:\\n\\t\\t\\t\\tl = tokens.pop(0)\\n\\t\\t\\t\\treturn lambda n1,n2,l=l:(n2 in n1.neighbours.get(l, []))\\n\\n\\t\\t# G queries\\n\\t\\tdef g_query(tokens):\\n\\t\\t\\tcond = None\\n\\n\\t\\t\\tif pop(tokens, [\\\"PEOPLE WHO HAVE\\\"]) and tokens:\\n\\t\\t\\t\\tcond = g_conds(tokens)\\n\\t\\t\\t\\tif not cond:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\tif cond:\\n\\t\\t\\t\\treturn [N for N in self.nodes.values() if cond(node, N)]\\n\\n\\t\\tdef g_conds(tokens):\\n\\t\\t\\tcond = g_and_cond(tokens)\\n\\n\\t\\t\\tif cond and pop(tokens, [\\\"OR\\\"]):\\n\\t\\t\\t\\ta = g_and_cond(tokens)\\n\\t\\t\\t\\tif a:\\n\\t\\t\\t\\t\\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) or cond(n1, n2))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn cond\\n\\n\\t\\tdef g_and_cond(tokens):\\n\\t\\t\\tcond = g_cond(tokens)\\n\\n\\t\\t\\tif cond and pop(tokens, [\\\"AND\\\"]):\\n\\t\\t\\t\\ta = g_cond(tokens)\\n\\t\\t\\t\\tif a:\\n\\t\\t\\t\\t\\tcond = lambda n1,n2,a=a,cond=cond:(a(n1, n2) and cond(n1, n2))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn cond\\n\\n\\t\\tdef g_cond(tokens):\\n\\t\\t\\tcond = neighbour_num_cond(tokens) or deg_cond(tokens)\\n\\n\\t\\t\\tif not cond and pop(tokens, [\\\"(\\\"]) and tokens:\\n\\t\\t\\t\\ttmp = g_conds(tokens)\\n\\t\\t\\t\\tif tmp and pop(tokens, [\\\")\\\"]):\\n\\t\\t\\t\\t\\tcond = tmp\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\traise ParseException\\n\\n\\t\\t\\treturn cond\\n\\n\\t\\tdef deg_cond(tokens):\\n\\t\\t\\tif pop(tokens, [\\\"DEGREES OF SEPARATION FROM ME\\\"], 1) and tokens:\\n\\t\\t\\t\\tt = int(tokens.pop(0))\\n\\t\\t\\t\\treturn lambda n1,n2:(self.degrees_of_separation(n2.id, n1.id) == t)\\n\\n\\t\\treturn q(query.split())\",\n \"def get_shortest_paths(G):\\n \\n shortest_paths = {}\\n \\n for origin in list(G.nodes):\\n for destination in list(G.nodes):\\n \\n if origin != destination:\\n shortest_path = nx.shortest_path(G, origin, destination, weight='length')\\n shortest_paths[f'{origin}-{destination}'] = shortest_path\\n \\n return shortest_paths\",\n \"def nx2gt(nxG):\\n # Phase 0: Create a directed or undirected graph-tool Graph\\n gtG = Graph(directed=nxG.is_directed())\\n\\n # Add the Graph properties as \\\"internal properties\\\"\\n for key, value in list(nxG.graph.items()):\\n # Convert the value and key into a type for graph-tool\\n tname, value, key = get_prop_type(value, key)\\n\\n prop = gtG.new_graph_property(tname) # Create the PropertyMap\\n \\n gtG.graph_properties[key] = prop # Set the PropertyMap\\n gtG.graph_properties[key] = value # Set the actual value\\n\\n # Phase 1: Add the vertex and edge property maps\\n # Go through all nodes and edges and add seen properties\\n # Add the node properties first\\n nprops = set() # cache keys to only add properties once\\n for node, data in nxG.nodes(data=True):\\n\\n # Go through all the properties if not seen and add them.\\n for key, val in list(data.items()): \\n if key in nprops: continue # Skip properties already added\\n\\n # Convert the value and key into a type for graph-tool\\n tname, _, key = get_prop_type(val, key)\\n\\n prop = gtG.new_vertex_property(tname) # Create the PropertyMap\\n gtG.vertex_properties[key] = prop # Set the PropertyMap\\n\\n # Add the key to the already seen properties\\n nprops.add(key)\\n\\n # Also add the node id: in NetworkX a node can be any hashable type, but\\n # in graph-tool node are defined as indices. So we capture any strings\\n # in a special PropertyMap called 'id' -- modify as needed!\\n gtG.vertex_properties['id'] = gtG.new_vertex_property('string')\\n\\n # Add the edge properties second\\n eprops = set() # cache keys to only add properties once\\n for src, dst, data in nxG.edges(data=True):\\n\\n # Go through all the edge properties if not seen and add them.\\n for key, val in list(data.items()): \\n if key in eprops: continue # Skip properties already added\\n\\n # Convert the value and key into a type for graph-tool\\n tname, _, key = get_prop_type(val, key)\\n \\n prop = gtG.new_edge_property(tname) # Create the PropertyMap\\n gtG.edge_properties[key] = prop # Set the PropertyMap\\n\\n # Add the key to the already seen properties\\n eprops.add(key)\\n\\n # Phase 2: Actually add all the nodes and vertices with their properties\\n # Add the nodes\\n vertices = {} # vertex mapping for tracking edges later\\n for node, data in nxG.nodes(data=True):\\n\\n # Create the vertex and annotate for our edges later\\n v = gtG.add_vertex()\\n vertices[node] = v\\n\\n # Set the vertex properties, not forgetting the id property\\n data['id'] = str(node)\\n for key, value in list(data.items()):\\n gtG.vp[key][v] = value # vp is short for vertex_properties\\n\\n # Add the edges\\n for src, dst, data in nxG.edges(data=True):\\n\\n # Look up the vertex structs from our vertices mapping and add edge.\\n e = gtG.add_edge(vertices[src], vertices[dst])\\n\\n # Add the edge properties\\n for key, value in list(data.items()):\\n gtG.ep[key][e] = value # ep is short for edge_properties\\n\\n # Done, finally!\\n return gtG\",\n \"def graph_hash(self):\\n return weisfeiler_lehman_graph_hash(self.graph.graph)\",\n \"def difference(G, H):\\n\\n if G.order() != H.order():\\n msg = \\\"Node sets of the two directed graphs are not equal!\\\"\\n raise StaticGraphNotEqNodesException(msg)\\n \\n n_nodes = G.order()\\n edges = ((u, v) for u in G.nodes()\\n for v in set(G.successors(u)) - set(H.successors(u)))\\n deg = make_deg(n_nodes, edges)\\n edges = ((u, v) for u in G.nodes()\\n for v in set(G.successors(u)) - set(H.successors(u)))\\n D = make(n_nodes, G.size(), edges, deg)\\n return D\",\n \"def construct_network_from_neighbours_list(related_characters: list):\\n graph = nx.Graph()\\n for edge in related_characters:\\n sentiment = edge[1]\\n color = ''\\n if sentiment == 'Positive':\\n color = 'g'\\n elif sentiment == 'Negative':\\n color = 'r'\\n elif sentiment == 'Neutral':\\n color = 'k'\\n # graph.add_node(edge[0][0], popularity=\\n graph.add_edge(edge[0][0], edge[0][1], color=color, weight=edge[2])\\n\\n return graph\",\n \"def lexicographic_product(G, H):\\n GH = _init_product_graph(G, H)\\n GH.add_nodes_from(_node_product(G, H))\\n # Edges in G regardless of H designation\\n GH.add_edges_from(_edges_cross_nodes_and_nodes(G, H))\\n # For each x in G, only if there is an edge in H\\n GH.add_edges_from(_nodes_cross_edges(G, H))\\n return GH\",\n \"def prepare_graph(label, nodes, edges, graphID):\\n features = {'label': label}\\n\\n G = nx.DiGraph()\\n nodes[\\\"id\\\"] = nodes[\\\"id\\\"].apply(lambda x : str(x))\\n features['num_nodes'] = nodes.shape[0]\\n op_node = None\\n times = []\\n friends = []\\n followers = []\\n for index, row in nodes.iterrows():\\n G.add_node(row['id'], time=row['time'], friends=row['friends'], followers = row['followers'])\\n times.append(row['time'])\\n friends.append(2**row['friends'])\\n followers.append(2**row['followers'])\\n if row['time'] == 0:\\n features['poster_friend_cnt'] = 2**row['friends']\\n features['poster_follower_cnt'] = 2**row['followers']\\n tweeter_id = row['id']\\n op_node = row['id']\\n features['avg_time'] = np.mean(times)\\n features['avg_friends'] = np.mean(friends)\\n features['avg_followers'] = np.mean(followers)\\n features['max_followers'] = max(followers)\\n features['max_friends'] = max(friends)\\n features['friends_25th_percentile'] = np.percentile(friends, 25)\\n features['friends_75th_percentile'] = np.percentile(friends, 75)\\n features['followers_25th_percentile'] = np.percentile(followers, 25)\\n features['followers_75th_percentile'] = np.percentile(followers, 75)\\n node_list = []\\n edge_count = 0\\n for pair in edges:\\n node1, node2 = pair.split()[0], pair.split()[1]\\n node_list.append(node1)\\n node_list.append(node2)\\n G.add_edge(node1, node2)\\n edge_count += 1\\n features['num_edges'] = edge_count\\n sum_users_without_followers = sum([1 for (node, val) in G.in_degree() if val==0])\\n features['ratio_users_w/out_followers'] = sum_users_without_followers / len(G.nodes)\\n features['num_connected_components'] = nx.number_strongly_connected_components(G)\\n features['number_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id)\\n features['percentage_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id) / features['poster_follower_cnt']\\n features['avg_clustering'] = nx.average_clustering(G)\\n features['op_clustering'] = nx.clustering(G,op_node)\\n features['transitivity'] = nx.transitivity(G)\\n node_list = list(set(node_list))\\n features['nodeID_list'] = np.array(node_list)\\n features['graph_id'] = graphID\\n return features, G\",\n \"def algorithm(df, params):\\n\\n output = {}\\n\\n # algorithm specific code\\n # construct network analysis\\n NW = Network(df, params['relations'])\\n output['d3js'] = NW.export_json()\\n output['gephi'] = NW.export_gephi()\\n output['pajek'] = NW.export_pajek()\\n output['assortativity'] = NW.assortativity()\\n output['node_attributes'] = NW.node_attributes()\\n output['edge_attributes'] = NW.edge_attributes()\\n output['strong_components'] = NW.strong_components()\\n output['weak_components'] = NW.weak_components()\\n output['triads'] = NW.triads()\\n\\n # plot network\\n pruned_network = NW.prune_network()\\n output['div'] = plot.plot_network(pruned_network, params['layout'],\\n params['relations'],\\n title=params['relations']\\n + ' Network graph of 500 nodes with highest degree centrality')\\n\\n return output\",\n \"def get_matching_mwpm(graph):\\n\\n nxgraph = nx.Graph()\\n\\n def edge_func(nxgraph, e0, e1, weight):\\n nxgraph.add_edge(e0, e1, weight=-weight)\\n\\n all_anyons, nxgraph = get_graph_edges(graph, edge_func, nxgraph)\\n\\n matching = nx.algorithms.matching.max_weight_matching(nxgraph, maxcardinality=True)\\n return [[all_anyons[i0], all_anyons[i1]] for i0, i1 in matching]\",\n \"def find_girth(self):\\r\\n girth = sys.maxint\\r\\n face = []\\r\\n vertices = list(self.graph.vertices)\\r\\n shift = random.randint(0,len(vertices)-1)\\r\\n vertices = vertices[shift:] + vertices[:shift]\\r\\n random.shuffle(vertices)\\r\\n \\r\\n for vertex in vertices:\\r\\n s = set() # set of explored edge id\\r\\n distance = {}\\r\\n distance[vertex.id] = 0\\r\\n father = {}\\r\\n father[vertex.id] = (None, None) # (a,b) a is v_id, b is edge id\\r\\n nodes = [vertex.id] # stack for the vertices to start with\\r\\n while len(nodes) > 0:\\r\\n node = nodes.pop(0)\\r\\n v_a = self.graph.get_vertex(node)\\r\\n nbrs = list(v_a.neighbors)\\r\\n random.shuffle(nbrs)\\r\\n for edge in nbrs:\\r\\n if not edge.id in s:\\r\\n another = edge.get_another_vertex(node)\\r\\n if not distance.has_key(another):\\r\\n nodes.append(another)\\r\\n s.add(edge.id)\\r\\n father[another] = (node, edge.id)\\r\\n distance[another] = distance[node] + 1\\r\\n elif distance[another] + distance[node] + 1 < girth:\\r\\n girth = distance[another] + distance[node] + 1\\r\\n\\r\\n face = list()\\r\\n face.append(edge.id)\\r\\n start = father[another]\\r\\n while start[0] is not None:\\r\\n face.append(start[1])\\r\\n start = father[start[0]]\\r\\n face.reverse()\\r\\n start = father[node]\\r\\n while start[0] is not None:\\r\\n face.append(start[1])\\r\\n start = father[start[0]]\\r\\n\\r\\n cycle = []\\r\\n edge0 = self.graph.get_edge(face[0])\\r\\n edge1 = self.graph.get_edge(face[1])\\r\\n (a, b) = edge0.get_endpoints()\\r\\n if a in edge1.get_endpoints():\\r\\n a, b = b, a\\r\\n for e in face:\\r\\n cycle.append(a)\\r\\n a = self.graph.get_edge(e).get_another_vertex(a)\\r\\n # logger.info(\\\"girth: %s\\\",cycle)\\r\\n return (face, cycle)\",\n \"def construct_H_with_KNN_from_distance(dis_mat, k_neig, is_probH=False, m_prob=1):\\n n_obj = dis_mat.shape[0]\\n # construct hyperedge from the central feature space of each node\\n n_edge = n_obj\\n H = np.zeros((n_obj, n_edge))\\n for center_idx in range(n_obj):\\n dis_mat[center_idx, center_idx] = 0\\n dis_vec = dis_mat[center_idx]\\n nearest_idx = np.array(np.argsort(dis_vec)).squeeze()\\n avg_dis = np.average(dis_vec)\\n if not np.any(nearest_idx[:k_neig] == center_idx):\\n nearest_idx[k_neig - 1] = center_idx\\n\\n for node_idx in nearest_idx[:k_neig]:\\n if is_probH:\\n H[node_idx, center_idx] = np.exp(-dis_vec[0, node_idx] ** 2 / (m_prob * avg_dis) ** 2)\\n else:\\n H[node_idx, center_idx] = 1.0\\n return H\",\n \"def diminished_disjunctive(G, H):\\n if G == 0 or H == 0:\\n return Game(0)\\n else:\\n left_1 = {diminished_disjunctive(G_L, H) for G_L in G._left}\\n left_2 = {diminished_disjunctive(G, H_L) for H_L in H._left}\\n right_1 = {diminished_disjunctive(G_R, H) for G_R in G._right}\\n right_2 = {diminished_disjunctive(G, H_R) for H_R in H._right}\\n return Game(left_1 | left_2, right_1 | right_2)\",\n \"def solve(G):\\n\\n dominatingSet = nx.algorithms.approximation.dominating_set.min_weighted_dominating_set(G, weight=\\\"weight\\\")\\n\\n # Create the graph T and input the dominating set.\\n T = nx.Graph()\\n T.add_nodes_from(dominatingSet)\\n\\n # When the graph is fully dominated by one node, the cost is zero.\\n if len(dominatingSet) == 1:\\n return T\\n\\n # The variable defined below, apsp, stands for all pairs shortest paths from calling NetworkX built-in Dijkstra's algorithm.\\n apsp = dict(nx.algorithms.shortest_paths.weighted.all_pairs_dijkstra(G, weight = \\\"weight\\\"))\\n\\n # In each iteration of the following for loop, we connect node to node2.\\n node2 = None\\n for node in dominatingSet:\\n\\n connected_nodes = nx.dfs_preorder_nodes(T, source=node2)\\n\\n print(\\\"Connecting \\\", node, \\\"to\\\", node2)\\n print(node2, \\\"descendants: \\\", [n for n in connected_nodes])\\n\\n if node2 is not None and node2 not in list(connected_nodes):\\n\\n # We want to connect node to node2 in the cheapest way possible.\\n # Thus, we search from all nodes connected to node2.\\n # By default, we choose the shortest path from node to node2.\\n shortest_path = apsp[node2][1][node]\\n path_cost = apsp[node2][0][node]\\n\\n # Now, evaluate if there is a shorter, cheaper path from a different vertex.\\n for connected_node in list(nx.dfs_preorder_nodes(T, source=node2)):\\n print(\\\" Cheapest path from \\\" + str(connected_node) + \\\": \\\" + str(apsp[connected_node][0][node]))\\n if apsp[connected_node][0][node] < path_cost:\\n shortest_path = apsp[connected_node][1][node]\\n path_cost = apsp[connected_node][0][node]\\n print(\\\"Updating best path to \\\" + str(shortest_path) + \\\", cost \\\" + str(path_cost))\\n\\n print(\\\"Found path via \\\" + str(shortest_path) + \\\" of cost \\\" + str(path_cost))\\n\\n # Add all necessary vertices.\\n for vertex in shortest_path:\\n if vertex not in dominatingSet:\\n T.add_node(vertex)\\n\\n # Add all necessary edges.\\n for i in range(len(shortest_path) - 1):\\n origin = shortest_path[i]\\n terminus = shortest_path[i+1]\\n T.add_edge(origin, terminus, weight=G.get_edge_data(origin, terminus)['weight'])\\n #T[origin][terminus]['weight'] = G.get_edge_data(origin, terminus)['weight']\\n\\n node2 = node\\n print()\\n\\n current_average = average_pairwise_distance(T)\\n last_average = 4000\\n print(current_average)\\n\\n # Until adding more edges doesn't improve the average pairwise cost\\n while current_average < last_average:\\n last_average = current_average\\n # For every node in T\\n for node in nx.dfs_preorder_nodes(T, source=list(T.nodes)[0]):\\n neighbors = nx.algorithms.traversal.breadth_first_search.bfs_tree(G, node, reverse=False, depth_limit=1)\\n # Get one of its neighbors NOT in T\\n for node2 in neighbors:\\n # and add the edge between that vertex and its neighbor\\n # if it decreases the average pairwise cost.\\n if node2 not in T and G.get_edge_data(node, node2)\\\\\\n and G[node][node2]['weight'] < current_average:\\n T.add_node(node2)\\n T.add_edge(node, node2, weight=G.get_edge_data(node, node2)['weight'])\\n new_average = average_pairwise_distance(T)\\n if new_average > current_average:\\n T.remove_node(node2)\\n #T.remove_edge(node, node2)\\n else:\\n current_average = new_average\\n print(\\\"Adding an edge between\\\", node, \\\"and\\\", node2, \\\"yields average\\\", new_average)\\n\\n\\n\\n print(\\\"Dominating vertices:\\\", [node for node in T])\\n\\n return T\",\n \"def dhom(src, tgt):\\n\\n # the stack to hold recursive networks\\n stk = [(src, tgt)]\\n while len(stk) > 0:\\n # pop up the networks at the top\\n s, t = stk.pop()\\n\\n # homogeneity test:\\n if not s.__homo__(t):\\n return False\\n\\n # push in child networks\\n stk.extend(zip(s, t))\\n\\n # source and target are deeply homogenuous.\\n return True\",\n \"def greedy_build(nodes, priors=None, cutoff=200, considered=set(), uniq='', targets=[]):\\n\\n\\t# Tracks frequency of states for each character in nodes\\n\\tcharacter_mutation_mapping = defaultdict(int)\\n\\n\\t# G models the network that is returned recursively\\n\\tG = nx.DiGraph()\\n\\n\\troot = root_finder(nodes)\\n\\n\\t# Base case check for recursion, returns a graph with one node corresponding to the root of the remaining nodes\\n\\tif len(nodes) <= cutoff or len(nodes) == 1:\\n\\t\\troot = root_finder(nodes)\\n\\t\\tG.add_node(root)\\n\\t\\treturn G, [[root, nodes]]\\n\\n\\t# Accounting for frequency of mutated states per character, in order to choose the best split\\n\\tfor node in nodes:\\n\\t\\tnode_list = node.split(\\\"_\\\")[0].split('|')\\n\\t\\tfor i in range(0, len(node_list)):\\n\\t\\t\\tchar = node_list[i]\\n\\t\\t\\tif char != '0' and char != '-':\\n\\t\\t\\t\\tcharacter_mutation_mapping[(str(i), char)] += 1\\n #if char != '0':\\n # if char == \\\"-\\\":\\n # character_mutation_mapping[(str(i), char)] -= 1\\n # else:\\n # character_mutation_mapping[(str(i), char)] += 1\\n\\n\\t# Choosing the best mutation to split on (ie character and state)\\n\\tcharacter, state = 0, 0\\n\\tmax_cost = 0\\n\\n\\tmin_prior = 1\\n\\tif priors:\\n\\t\\tfor i in priors.keys():\\n\\t\\t\\tfor j in priors[i].keys():\\n\\t\\t\\t\\tmin_prior = min(min_prior, priors[i][j])\\n\\n\\tfor i,j in character_mutation_mapping:\\n\\t\\tif not (i,j) in considered:\\n\\t\\t\\tif not priors:\\n\\t\\t\\t\\tif max_cost < character_mutation_mapping[(i, j)]:\\n\\t\\t\\t\\t\\tmax_cost = character_mutation_mapping[(i, j)]\\n\\t\\t\\t\\t\\tcharacter, state = i, j\\n\\t\\t\\telse:\\n\\t\\t\\t\\tif j not in priors[int(i)]:\\n\\t\\t\\t\\t\\tpriors[int(i)][j] = min_prior\\n\\t\\t\\t\\tif max_cost < -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]:\\n\\t\\t\\t\\t\\tmax_cost = -np.log(priors[int(i)][j]) * character_mutation_mapping[(i, j)]\\n\\t\\t\\t\\t\\tcharacter, state = i, j\\n\\tcharacter = int(character)\\n\\n\\n\\t# If there is no good split left, stop the process and return a graph with the remainder of nodes\\n\\tif character == 0 and state == 0:\\n\\t\\tif len(nodes) == 1:\\n\\t\\t\\tG.add_node(nodes[0])\\n\\t\\telse:\\n\\t\\t\\tfor i in range(0, len(nodes)):\\n\\t\\t\\t\\tif nodes[i] != root:\\n\\t\\t\\t\\t\\tG.add_edge(root, nodes[i])\\n\\t\\treturn G, []\\n\\n\\t# Splitting nodes based on whether they have the mutation, don't have the mutation, or are NA('-') in that character\\n\\t# Right split is where nodes with the mutation go, everyone else goes to left split or NA chars\\n\\tleft_split, right_split, NA_chars = [], [], []\\n\\tright_split_temp = []\\n\\tleft_split_temp = []\\n\\tfor node in nodes:\\n\\t\\tnode_list = node.split('|')\\n\\t\\tif node_list[character] == state:\\n\\t\\t\\tright_split.append(node)\\n\\t\\telif node_list[character] == '-':\\n\\t\\t\\tNA_chars.append(node)\\n\\t\\telse:\\n\\t\\t\\tleft_split.append(node)\\n\\n\\n\\t# Seperates all nodes with NA in the character chosen to be split upon\\n\\t# Puts in right split or left split based on which list shares more mutated characters with this string\\n\\tfor node in NA_chars:\\n\\t\\tright_split_score = 0\\n\\t\\tleft_split_score = 0\\n\\t\\tnode_list = node.split('|')\\n\\t\\tnum_not_missing = len([n for n in node_list if n != \\\"-\\\"])\\n\\t\\tfor i in range(0, len(node_list)):\\n\\t\\t\\tif node_list[i] != '0' and node_list[i] != '-':\\n\\t\\t\\t\\tfor node_2 in left_split:\\n\\t\\t\\t\\t\\tnode2_list = node_2.split('|')\\n\\t\\t\\t\\t\\tif node_list[i] == node2_list[i]:\\n\\t\\t\\t\\t\\t\\tleft_split_score += 1\\n\\t\\t\\t\\tfor node_2 in right_split:\\n\\t\\t\\t\\t\\tnode2_list = node_2.split('|')\\n\\t\\t\\t\\t\\tif node_list[i] == node2_list[i]:\\n\\t\\t\\t\\t\\t\\tright_split_score += 1\\n\\n\\t\\tavg_left_split_score = left_split_score / float(len(left_split) * num_not_missing + 1)\\n\\t\\tavg_right_split_score = right_split_score / float(len(right_split) * num_not_missing + 1)\\n\\n\\t\\tif avg_left_split_score < avg_right_split_score:\\n\\t\\t\\tright_split_temp.append(node)\\n\\t\\telse:\\n\\t\\t\\tleft_split_temp.append(node)\\n\\n\\tright_split += right_split_temp\\n\\tleft_split += left_split_temp\\n\\n\\t# Add character, state that split occurred to already considered mutations\\n\\tconsidered.add((str(character), state))\\n\\tG = nx.DiGraph()\\n\\t#splitter = str(character) + \\\" \\\" + str(state) + \\\" (\\\" + uniq + \\\")\\\"\\n\\tsplitter = root\\n\\n\\t# Recursively build left side of network (ie side that did not mutation at the character with the specific state)\\n\\tG.add_node(splitter)\\n\\tleft_subproblems = []\\n\\tleft_network = None\\n\\tif len(left_split) != 0:\\n\\t\\tleft_root = root_finder(left_split)\\n\\t\\t# if left_root not in left_split and left_root in targets:\\n\\t\\t# \\tleft_root = left_root + \\\"_unique\\\"\\n\\n\\t\\tleft_network, left_subproblems = greedy_build(left_split, priors, cutoff, considered.copy(), uniq + \\\"0\\\", targets=targets)\\n\\n\\t\\tleft_nodes = [node for node in left_network.nodes() if left_network.in_degree(node) == 0]\\n\\t\\tdup_dict = {}\\n\\t\\tfor n in left_network:\\n\\t\\t\\tif n in list(G.nodes()) and n != left_root:\\n\\t\\t\\t\\tdup_dict[n] = n + \\\"_\\\" + str(hashlib.md5(left_root.encode('utf-8')).hexdigest())\\n\\t\\tleft_network = nx.relabel_nodes(left_network, dup_dict)\\n\\t\\tG = nx.compose(G, left_network)\\n\\t\\tif root != left_root:\\n\\t\\t\\tG.add_edge(splitter, left_root, weight=0, label=\\\"None\\\")\\n\\n\\t# Recursively build right side of network\\n\\tright_network, right_subproblems = greedy_build(right_split, priors, cutoff, considered.copy(), uniq + \\\"1\\\", targets=targets)\\n\\tright_nodes = [node for node in right_network.nodes() if right_network.in_degree(node) == 0]\\n\\tright_root = root_finder(right_split)\\n\\n\\tdup_dict = {}\\n\\tfor n in right_network:\\n\\t\\tif n in list(G.nodes()) and n != right_root:\\n\\t\\t\\tdup_dict[n] = n + \\\"_\\\" + str(hashlib.md5(right_root.encode('utf-8')).hexdigest())\\n\\tfor n in dup_dict:\\n\\t\\trename_dict = {n: dup_dict[n]}\\n\\t\\tif right_network.out_degree(n) != 0:\\n\\t\\t\\tright_network = nx.relabel_nodes(right_network, rename_dict)\\n\\t\\telse:\\n\\t\\t\\trename_dict = {n: dup_dict[n]}\\n\\t\\t\\tG = nx.relabel_nodes(G, rename_dict)\\n\\n\\tG = nx.compose(G, right_network)\\n\\t# if right_root not in right_split and right_root in targets:\\n\\t# \\tright_root = right_root + \\\"_unique\\\"\\n\\t#for node in right_nodes:\\n\\tif root != right_root:\\n\\t\\tif not priors:\\n\\t\\t\\tG.add_edge(splitter, right_root, weight=1, label = str(character) + \\\": 0 -> \\\" + str(state))\\n\\t\\telse:\\n\\t\\t\\tG.add_edge(splitter, right_root, weight=-np.log(priors[int(character)][state]), label=str(character) + \\\": 0 -> \\\" + str(state))\\n\\n\\n\\treturn G, left_subproblems + right_subproblems\",\n \"def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\\n if nbunch is None:\\n nbunch = G\\n else:\\n nbunch = set(nbunch)\\n\\n directed = G.is_directed()\\n if directed:\\n iter_func = itertools.permutations\\n else:\\n iter_func = itertools.combinations\\n\\n all_pairs = {n: {} for n in nbunch}\\n\\n for u, v in iter_func(nbunch, 2):\\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\\n all_pairs[u][v] = k\\n if not directed:\\n all_pairs[v][u] = k\\n\\n return all_pairs\",\n \"def stupid_current_distance(G):\\n\\n T = prepotential(G)\\n edge_dict = {e:0 for e in G.edges}\\n N = G.number_of_nodes()\\n\\n for s in range(N):\\n for t in range(s+1,N):\\n p = T[:,s] - T[:,t]\\n for (v,w) in edge_dict:\\n edge_dict[(v,w)] += abs(p[v]-p[w])\\n return edge_dict\",\n \"def make_mammalian_n_glycan_neighborhoods():\\n neighborhoods = NeighborhoodCollection()\\n\\n _neuraminic = \\\"(%s)\\\" % ' + '.join(map(str, (\\n FrozenMonosaccharideResidue.from_iupac_lite(\\\"NeuAc\\\"),\\n FrozenMonosaccharideResidue.from_iupac_lite(\\\"NeuGc\\\")\\n )))\\n _terminal = _neuraminic + \\\\\\n \\\" + max(%s - %%d, 0)\\\" % FrozenMonosaccharideResidue.from_iupac_lite(\\\"Hex\\\")\\n _hexose = \\\"(%s)\\\" % ' + '.join(\\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['Hex', ])))\\n _hexnac = \\\"(%s)\\\" % ' + '.join(\\n map(str, map(FrozenMonosaccharideResidue.from_iupac_lite, ['HexNAc', ])))\\n\\n high_mannose = CompositionRangeRule(\\n _hexose, 3, 12) & CompositionRangeRule(\\n _hexnac, 2, 2) & CompositionRangeRule(\\n _neuraminic, 0, 0)\\n high_mannose.name = \\\"high-mannose\\\"\\n neighborhoods.add(high_mannose)\\n\\n base_hexnac = 3\\n base_terminal_groups = 2\\n for i, spec in enumerate(['hybrid', 'bi', 'tri', 'tetra', 'penta', \\\"hexa\\\", \\\"hepta\\\"]):\\n if spec == 'hybrid':\\n rule = CompositionRangeRule(\\n _hexnac, base_hexnac - 1, base_hexnac + 1\\n ) & CompositionRangeRule(\\n _neuraminic, 0, base_terminal_groups) & CompositionRangeRule(\\n _hexose, base_hexnac + i - 1,\\n base_hexnac + i + 3)\\n rule.name = spec\\n neighborhoods.add(rule)\\n else:\\n sialo = CompositionRangeRule(\\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\\n ) & CompositionRangeRule(\\n (_neuraminic), 1, base_terminal_groups + i\\n ) & CompositionExpressionRule(\\n \\\"(Hex > %d) & (Hex < (%d - (NeuAc + NeuGc)))\\\" % (base_hexnac + i - 2, base_hexnac + (2 * i) + 3))\\n\\n sialo.name = \\\"%s-antennary\\\" % spec\\n asialo = CompositionRangeRule(\\n _hexnac, base_hexnac + i - 1, base_hexnac + i + 1\\n ) & CompositionRangeRule(\\n _neuraminic, 0, 1 if i < 2 else 0\\n ) & CompositionRangeRule(\\n _hexose, base_hexnac + i - 1,\\n base_hexnac + (2 * i) + 3)\\n asialo.name = \\\"asialo-%s-antennary\\\" % spec\\n neighborhoods.add(sialo)\\n neighborhoods.add(asialo)\\n return neighborhoods\",\n \"def prim(network_graph):\\n seen_nodes = set()\\n mst = set()\\n edges = set()\\n\\n # Using the first node in the network graph as the root of the tree\\n current_node = list(network_graph.keys())[0]\\n\\n while True:\\n # Adding all edges from the root to the list of edges\\n for current_neighbor in network_graph[current_node]:\\n # Edge represented as (weight, [node, neighbor])\\n edge = (network_graph[current_node][current_neighbor],\\n frozenset([current_node, current_neighbor]))\\n if edge in mst:\\n continue\\n edges.remove(edge) if edge in edges else edges.add(edge)\\n\\n if edges:\\n # Get the smallest edge in the list, remove & add to MST\\n smallest_edge = min(edges)\\n edges.remove(smallest_edge)\\n mst.add(smallest_edge)\\n\\n # Get the next node to examine\\n _, (new_node, new_neighbor) = smallest_edge\\n seen_nodes.add(current_node)\\n current_node = (new_node if new_neighbor in\\n seen_nodes else new_neighbor)\\n else:\\n break\\n\\n # Convert from sets to dictionary of {edge: weight}\\n # 'final_weight' indicates the smallest weight for the given 'final_edge'\\n # between two nodes that doesn't create a cycle\\n return dict((final_edge, final_weight) for (final_weight, final_edge) in\\n mst)\",\n \"def generate_homography_nn_sgd(self):\\n # Create the NN\\n self.set_optimizer_sgd()\\n self.set_callback(utils.lr_callback)\\n self.build_model()\\n self.compile()\",\n \"def hypergraph_homology_basis(h, k, shortest=False, log=None):\\n max_dim = np.max([len(e) for e in h.edges()]) - 1\\n\\n if k > max_dim or k < 1:\\n return 'wrong dim'\\n C = dict()\\n for i in range(k - 1, k + 2):\\n C[i] = kchainbasis(h, i)\\n bd = dict()\\n for i in range(k, k + 2):\\n bd[i] = bkMatrix(C[i - 1], C[i])\\n if log:\\n try:\\n logdict = pickle.load(open(log, 'rb'))\\n except:\\n logdict = dict()\\n logdict.update({'maxdim': max_dim,\\n 'kchains': C,\\n 'bd': bd, })\\n pickle.dump(logdict, open(log, 'wb'))\\n return homology_basis(bd, k, C=C[k], shortest=shortest, log=log)\",\n \"def get_graph_karateclub():\\n all_members = set(range(34))\\n club1 = {0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 11, 12, 13, 16, 17, 19, 21}\\n # club2 = all_members - club1\\n\\n G = eg.Graph(name=\\\"Zachary's Karate Club\\\")\\n for node in all_members:\\n G.add_node(node+1)\\n\\n zacharydat = \\\"\\\"\\\"\\\\\\n0 1 1 1 1 1 1 1 1 0 1 1 1 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 0 1 0 0\\n1 0 1 1 0 0 0 1 0 0 0 0 0 1 0 0 0 1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0 0\\n1 1 0 1 0 0 0 1 1 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 1 0\\n1 1 1 0 0 0 0 1 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 0 0 1 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 1\\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\\n1 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 1 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n1 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 1 0 0 1 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 1 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 1 0 0\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 1\\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 0 0 0 0 0 0 1\\n0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1\\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 1 0 0 0 0 0 1 1\\n0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1\\n1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 0 0 1 0 0 0 1 1\\n0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 1 0 1 1 0 0 0 0 0 1 1 1 0 1\\n0 0 0 0 0 0 0 0 1 1 0 0 0 1 1 1 0 0 1 1 1 0 1 1 0 0 1 1 1 1 1 1 1 0\\\"\\\"\\\"\\n\\n for row, line in enumerate(zacharydat.split('\\\\n')):\\n thisrow = [int(b) for b in line.split()]\\n for col, entry in enumerate(thisrow):\\n if entry == 1:\\n G.add_edge(row+1, col+1)\\n\\n # Add the name of each member's club as a node attribute.\\n for v in G:\\n G.nodes[v]['club'] = 'Mr. Hi' if v in club1 else 'Officer'\\n return G\",\n \"def er(num_nodes,p) :\\n complete_graph = {}\\n if (num_nodes <= 0):\\n return complete_graph\\n for node_index in range(num_nodes) :\\n # Loop through all possible nodes and edges, adding edges to set\\n complete_graph[node_index] = set([])\\n for edge_index in range(num_nodes) :\\n if (node_index != edge_index) :\\n val = random.random()\\n if (val < p):\\n complete_graph[node_index].add(edge_index)\\n return complete_graph\",\n \"def SetHomoplasy(tree, skip=0):\\n population = tree.size if 'size' in vars(tree) else (len(tree) * 2) - 1\\n order = tree.traverse()\\n root = next(order)\\n homoplasy_hist = sp.csr_matrix(np.zeros(root.genotype.shape[1] - skip))\\n for cur_node in tqdm.tqdm(order, total=population + 1):\\n homoplasy_hist += (cur_node.genotype[0, skip:] != cur_node.up.genotype[0, skip:])\\n homoplasy_dist = pd.Series(homoplasy_hist.data).value_counts(normalize=True)\\n fit_dist = rv_discrete(values=(homoplasy_dist.index.astype(int), homoplasy_dist.values.astype(float)))\\n root.homoplasy = fit_dist\\n root.homoplasy_hist = homoplasy_hist.toarray()[0].astype(np.int)\\n return tree\",\n \"def generate_mapping(g: Graph, h: Graph):\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\",\n \"def BFTM_(adj_list,labels):\\n G_prime = nx.Graph()\\n num_clusters = list(np.unique(labels))\\n clusters = {i:[] for i in num_clusters}\\n hood = {n.id:[i for i in num_clusters if i != labels[n.id]] for n in adj_list}\\n \\n #Add nodes to clusters\\n for idx,n in enumerate(adj_list):\\n clusters[labels[idx]].append(n.id)\\n \\n root_cluster = random.choice(num_clusters)\\n root_id = random.choice(list(clusters[root_cluster]))\\n queue = [adj_list[root_id]]\\n clusters[labels[root_id]].remove(root_id)\\n \\n \\n #BFTM\\n while len(queue) > 0:\\n node = queue.pop(0)\\n for c_id in hood[node.id]:\\n if len(clusters[c_id]) > 0:\\n sample_id = random.choice(clusters[c_id])\\n clusters[labels[sample_id]].remove(sample_id)\\n queue.append(adj_list[sample_id])\\n hood[sample_id].remove(labels[node.id])\\n G_prime.add_edge(node,adj_list[sample_id])\\n hood[node.id] = None\\n #Handle leftover nodes\\n if len(queue) == 0:\\n remaining = [c for i,c in clusters.items() if len(c) > 0]\\n for rem_cluster in remaining:\\n for n in rem_cluster:\\n added = False\\n while not added:\\n rand_n = random.choice(list(G_prime.nodes))\\n if labels[rand_n.id] != labels[n.id]:\\n G_prime.add_edge(n,rand_n)\\n added = True\\n \\n \\n #Cliqify\\n for node in list(G_prime.nodes):\\n if G_prime.degree(node) < len(num_clusters) - 1:\\n for _1_hop in list(G_prime.neighbors(node)):\\n for _2_hop in list(G_prime.neighbors(_1_hop)):\\n if _2_hop != node and G_prime.degree(_2_hop) < len(num_clusters) - 1:\\n G_prime.add_edge(node,_2_hop)\\n \\n return G_prime\",\n \"def smallClosNetwork():\\n \\n # Build a graph for Jupiter topo\\n switch_nodes, edges = tp.tree_topo()\\n G = build_graph(edges)\\n nodes, host_nodes, tors, anodes, snodes = tp.getnodes()\\n\\n print('**** is_connected(G)', nx.is_connected(G))\\n \\n \\n # Get the routing path of all nodes\\n table_file_name = '../outputs/tree_routing_table.txt'\\n if((os.path.isfile(table_file_name)) == False):\\n table = all_routing(G, tors+['e1'], table_file_name)\\n else:\\n json_data = open(table_file_name).read()\\n table = json.loads(json_data)\\n \\n print('**** Got routing table!')\\n\\n seeds, polys = cf.get_seeds_table_tree(switch_nodes) #\\n \\n return G, tors, edges, table, seeds, polys\",\n \"def kAnonymit(g,k):\\n rlist=list()\\n degreeH=nx.degree_histogram(g)\\n## print degreeH\\n li=[[] for i in range(len(degreeH))]\\n uNode=dict(zip(range(len(degreeH)),li))\\n \\n gd=g.degree()\\n for e in gd:\\n uNode[gd[e]].append(e)\\n ad=list()\\n mi=list()\\n su=list() \\n sel3(g,3,ad,mi,su)\\n nodeAd=list()\\n nodeMi=list()\\n nodeSu=list() \\n for i in ad:\\n nodeAd=nodeAd+uNode[i]\\n #nodeAd store the graph ID\\n for i in mi:\\n nodeMi=nodeMi+uNode[i]\\n for i in su:\\n nodeSu=nodeSu+uNode[i]\\n\\n print nodeAd,nodeMi,nodeSu\\n\\n\\n i=0#Add edge \\n while i<len(nodeAd)-1:\\n j=i+1\\n while j<len(nodeAd):\\n if not g.has_edge(nodeAd[i],nodeAd[j]):\\n g.add_edge(nodeAd[i],nodeAd[j])\\n rlist.append(nodeAd[i])\\n rlist.append(nodeAd[j])\\n nodeAd.pop(j)\\n nodeAd.pop(i)\\n i=i-1\\n break\\n else:\\n j=j+1\\n i=i+1\\n print nodeAd\\n \\n i=0#delet edge\\n while i<len(nodeMi)-1:\\n j=i+1\\n while j<len(nodeMi):\\n if g.has_edge(nodeMi[i],nodeMi[j]):\\n g.remove_edge(nodeMi[i],nodeMi[j])\\n rlist.append(nodeMi[i])\\n rlist.append(nodeMi[j])\\n nodeMi.pop(j)\\n nodeMi.pop(i)\\n i=i-1\\n break\\n else:\\n j=j+1\\n i=i+1\\n print nodeMi\\n \\n i=0#Add edge \\n while i<len(nodeSu):\\n j=0\\n while j<len(nodeAd):\\n if not g.has_edge(nodeSu[i],nodeAd[j]):\\n g.add_edge(nodeSu[i],nodeAd[j])\\n rlist.append(nodeSu[i])\\n rlist.append(nodeAd[j])\\n nodeAd.pop(j)\\n nodeSu.pop(i)\\n \\n i=i-1\\n break\\n else:\\n j=j+1\\n i=i+1\\n print nodeSu\\n \\n i=0#delet edge\\n while i<len(nodeSu):\\n j=0\\n while j<len(nodeMi):\\n if g.has_edge(nodeSu[i],nodeMi[j]):\\n g.remove_edge(nodeSu[i],nodeMi[j])\\n rlist.append(nodeSu[i])\\n rlist.append(nodeMi[j])\\n nodeMi.pop(j)\\n nodeSu.pop(i)\\n i=i-1\\n break\\n else:\\n j=j+1\\n i=i+1\\n print nodeSu\\n return rlist\",\n \"def erdos_rennie_like(num_nodes, num_hedges, max_hedge_width, self_loops=False):\\n if max_hedge_width > num_nodes:\\n print(\\\"Error: the requested construction is flawed! There are not enoough nodes to support the requested max_hedge_width!\\\")\\n return -1\\n \\n if ((max_hedge_width * 2) > num_nodes) and (self_loops == False):\\n print(\\\"Error: the requested construction is flawed! There are not enough nodes to support the requested max_hedge_width without self loops!\\\")\\n return -1\\n \\n node_ls = [] \\n hedge_ls = [] #hedges will be encoded as ordered lists, where entry 0 is a list containing nodes in the tail and entry 1 is a list containing nodes in the head\\n hedge_set = set() #to avoid repeated edges I use a set to keep track of the edges. The set will be converted back to a list when it is returned.\\n \\n for n in range(num_nodes): #initializes nodes\\n node_ls.append(str(n))\\n \\n hedges_full = False\\n while hedges_full == False:\\n tail_width = random.randint(1,max_hedge_width)\\n head_width = random.randint(1,max_hedge_width)\\n new_hedge = hedge_maker(tail_width, head_width, node_ls, self_loops)\\n hedge_set.add(new_hedge)\\n if len(hedge_set) >= num_hedges:\\n hedges_full = True\\n \\n for hedge in hedge_set: #formats the hedges into lists instead of tuples containing frozensets\\n tail_ls = []\\n head_ls = []\\n for node in hedge[0]:\\n tail_ls.append(node)\\n \\n for node in hedge[1]:\\n head_ls.append(node)\\n \\n formatted_hedge = [tail_ls, head_ls]\\n hedge_ls.append(formatted_hedge)\\n \\n return node_ls, hedge_ls\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.63757825","0.61899877","0.60356104","0.6001322","0.59994","0.5963691","0.59627503","0.5926058","0.5918671","0.59054536","0.582346","0.5799736","0.5697312","0.5679989","0.5668","0.5662608","0.5636551","0.5565752","0.5540963","0.553925","0.5511987","0.54930174","0.540495","0.5378348","0.5375783","0.53687096","0.5360217","0.5347609","0.53394026","0.531343","0.5311436","0.5303339","0.52842647","0.5274074","0.5273301","0.5258117","0.5256158","0.5247184","0.52431893","0.52427006","0.52247185","0.52210355","0.5204626","0.5201474","0.52007884","0.5186553","0.5174909","0.5147282","0.5145329","0.5137465","0.5136214","0.5133877","0.51063037","0.509943","0.5098204","0.5096441","0.5090549","0.50795543","0.50708145","0.5068305","0.50675195","0.50622785","0.5055148","0.5054323","0.5053627","0.5051578","0.50513494","0.50498515","0.5045101","0.5042262","0.5041041","0.5031613","0.5030892","0.50297225","0.502617","0.5024173","0.5023253","0.5021211","0.5019138","0.50159967","0.50145197","0.50143754","0.50112516","0.5011158","0.5004198","0.5003088","0.5001169","0.49962878","0.49918747","0.49916318","0.49902695","0.4988574","0.49860024","0.49816498","0.4981161","0.49706286","0.49650455","0.49591774","0.4958412","0.49583608"],"string":"[\n \"0.63757825\",\n \"0.61899877\",\n \"0.60356104\",\n \"0.6001322\",\n \"0.59994\",\n \"0.5963691\",\n \"0.59627503\",\n \"0.5926058\",\n \"0.5918671\",\n \"0.59054536\",\n \"0.582346\",\n \"0.5799736\",\n \"0.5697312\",\n \"0.5679989\",\n \"0.5668\",\n \"0.5662608\",\n \"0.5636551\",\n \"0.5565752\",\n \"0.5540963\",\n \"0.553925\",\n \"0.5511987\",\n \"0.54930174\",\n \"0.540495\",\n \"0.5378348\",\n \"0.5375783\",\n \"0.53687096\",\n \"0.5360217\",\n \"0.5347609\",\n \"0.53394026\",\n \"0.531343\",\n \"0.5311436\",\n \"0.5303339\",\n \"0.52842647\",\n \"0.5274074\",\n \"0.5273301\",\n \"0.5258117\",\n \"0.5256158\",\n \"0.5247184\",\n \"0.52431893\",\n \"0.52427006\",\n \"0.52247185\",\n \"0.52210355\",\n \"0.5204626\",\n \"0.5201474\",\n \"0.52007884\",\n \"0.5186553\",\n \"0.5174909\",\n \"0.5147282\",\n \"0.5145329\",\n \"0.5137465\",\n \"0.5136214\",\n \"0.5133877\",\n \"0.51063037\",\n \"0.509943\",\n \"0.5098204\",\n \"0.5096441\",\n \"0.5090549\",\n \"0.50795543\",\n \"0.50708145\",\n \"0.5068305\",\n \"0.50675195\",\n \"0.50622785\",\n \"0.5055148\",\n \"0.5054323\",\n \"0.5053627\",\n \"0.5051578\",\n \"0.50513494\",\n \"0.50498515\",\n \"0.5045101\",\n \"0.5042262\",\n \"0.5041041\",\n \"0.5031613\",\n \"0.5030892\",\n \"0.50297225\",\n \"0.502617\",\n \"0.5024173\",\n \"0.5023253\",\n \"0.5021211\",\n \"0.5019138\",\n \"0.50159967\",\n \"0.50145197\",\n \"0.50143754\",\n \"0.50112516\",\n \"0.5011158\",\n \"0.5004198\",\n \"0.5003088\",\n \"0.5001169\",\n \"0.49962878\",\n \"0.49918747\",\n \"0.49916318\",\n \"0.49902695\",\n \"0.4988574\",\n \"0.49860024\",\n \"0.49816498\",\n \"0.4981161\",\n \"0.49706286\",\n \"0.49650455\",\n \"0.49591774\",\n \"0.4958412\",\n \"0.49583608\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6105953"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":88366,"cells":{"query":{"kind":"string","value":"Agent which implements Q Learning"},"document":{"kind":"string","value":"def __init__(self, state_shape: tuple, action_shape: tuple, name: str, side: str = \"up\", epsilon: float = 0.0,\n intervall_turns_train: int = np.Inf, intervall_turns_load: int = np.Inf,\n save_path: str = \"../data/modeldata/q/model.ckpt\", caching: bool = False,\n config: Config = None, cache: RedisCache = None, channel: RedisChannel = None):\n\n # tensorflow related stuff\n self.name = name\n self._batch_size = 512\n self._learning_rate = 0.01\n self._gamma = 0.99\n\n # calculate number actions from actionshape\n self.number_actions = np.product(action_shape)\n self._intervall_actions_train = intervall_turns_train\n self._intervall_turns_load = intervall_turns_load\n\n self.network = self._configure_network(state_shape)\n self.target_network = self._configure_network(state_shape)\n\n self.epsilon = epsilon\n self.exp_buffer = ReplayBuffer(100000)\n\n self._save_path = save_path\n if os.path.isfile(self._save_path + \".index\"):\n self.network.load_weights(self._save_path)\n\n # copy weight to target weights\n self.load_weigths_into_target_network()\n\n super().__init__(state_shape, action_shape, name, side, config, caching, cache, channel)"},"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 __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n QLearningAgent.__init__(self, **args)","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n #self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)","def qlearning(env, iterations=1000, gamma=0.9, alpha=0.1):\n nS = env.nS # number of states\n nA = env.nA # number of actions\n Q_value = np.zeros((nS, nA))\n policy = np.ones((env.nS,env.nA))/env.nA\n epsilon = 1\n s_t1 = env.reset() # reset the environment and place the agent in the start square\n ############################\n # YOUR IMPLEMENTATION HERE #\n # HINT: Don't forget to decay epsilon according to GLIE\n\n curr_state = s_t1\n \n start = time.time() # to time how long convergence takes\n print(\"---Q Learning---\\nTraining Started.\")\n \n for k in range (1, iterations):\n # if (k%10000) == 0:\n # print(\"Now playing iteration: \", k)\n epsilon = 1/k\n curr_action, reward, new_state, done = take_one_step(env, policy, curr_state)\n new_action = sample_action(policy, new_state)\n Q_value[curr_state, curr_action] = Q_value[curr_state, curr_action] + alpha * (reward + gamma * (Q_value[new_state, np.argmax(Q_value[new_state])]) - Q_value[curr_state, curr_action])\n \n # epsilon-greedy policy update\n Q_list = np.argwhere(Q_value[curr_state] == np.amax(Q_value[curr_state])).flatten() # get a list of all indices where Q is maximum, (argmax(Q))\n max_Q = np.random.choice(Q_list.flatten()) # randomly pick from those indices. Picking each index is equally likely.\n for a in range (nA):\n if a == max_Q:\n policy[curr_state][a] = epsilon/nA + (1 - epsilon) # for the chosen maximal index of Q, set the policy to epsilon/m + 1 - epsilon\n else:\n policy[curr_state][a] = epsilon/nA \n \n # print(\"Q_value = {0}\".format(Q_value))\n # print(\"policy = {0}\".format(policy))\n \n if done:\n curr_state = env.reset() # reset the environment and place the agent in the start square\n curr_action = sample_action(policy, curr_state)\n else:\n curr_state = new_state\n curr_action = new_action\n \n stop = time.time()\n print(\"Training Completed.\")\n print(\"It took: {0} iterations and {1} minutes\".format(k,(stop-start)/60))\n \n ############################\n det_policy = np.argmax(Q_value, axis=1)\n return Q_value, det_policy","def learn(self):\n batch = self.agent.replay_buffer.sample(self.batch_size)\n states = torch.tensor([x.state for x in batch], dtype=torch.float32).to(self.agent.device) # shape == (batch_size, 3, 6, 7)\n actions = [x.action for x in batch]\n rewards = torch.tensor([x.reward for x in batch], dtype=torch.float32).to(self.agent.device)\n next_states = torch.tensor([x.next_state for x in batch], dtype=torch.float32).to(self.agent.device)\n dones = [x.done for x in batch]\n\n self.optimizer.zero_grad()\n\n\n q_vals = self.agent.policy_net(states)[range(len(actions)), actions] # Q vals for actions taken\n q_next_vals = self.agent.target_net(next_states).detach() # we don't care about grad wrt target net\n q_next_vals[dones] = 0.0 # terminal states have no future expected value\n q_targets = rewards + self.gamma * torch.max(q_next_vals, dim=1)[0]\n\n # all_q_vals = self.agent.policy_net(states)\n # print()\n # print('actions')\n # print(actions)\n # print()\n # print('original all q vals')\n # print(self.agent.policy_net(states)) \n # print(self.agent.policy_net(states).shape)\n # print()\n # print('QVALS:', q_vals)\n # print(q_vals.shape)\n # print('\\n\\n')\n # print('QTARGETS:', q_targets)\n # print(q_targets.shape)\n\n # breakpoint()\n\n loss = self.loss_fn(q_targets, q_vals).to(self.agent.device)\n loss.backward()\n \n # for layer in self.agent.policy_net.named_parameters():\n \n # # print(f'layer: {layer[0]}')\n # # print(f'grad:', layer[1].grad)\n\n # # print('loss', loss)\n # # print('q_vals grad:', q_vals.grad)\n # # print('states:', )\n\n self.optimizer.step()\n\n self.agent.learning_iters += 1\n if self.agent.learning_iters % self.target_update_freq == 0:\n self.agent.update_target_net()\n # logger.info('Updated target net')","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)","def learn(self):\n if self.learn_step_counter % self.target_q_update_step == 0:\n self.target_net.load_state_dict(self.eval_net.state_dict()) #update target_net's parameters\n logging.info(\"updtate target q\")\n self.learn_step_counter += 1\n\n rgbs,depths, rgbs_1, depths_1,questions,actions,rewards,terminals = self.memory.sample()\n\n rgbs_var = Variable(torch.FloatTensor(rgbs).cuda())\n depths_var = Variable(torch.FloatTensor(depths).cuda())\n rgbs_1_var = Variable(torch.FloatTensor(rgbs_1).cuda())\n depths_1_var = Variable(torch.FloatTensor(depths_1).cuda())\n questions_var = Variable(torch.LongTensor(questions).cuda())\n actions_var = Variable(torch.LongTensor(actions).cuda())\n rewards_var = Variable(torch.FloatTensor(rewards).cuda())\n terminals_var = Variable(torch.FloatTensor(terminals).cuda())\n\n q_eval_matrix = self.eval_net(rgbs_var,depths_var,questions_var)\n q_eval_matrix = q_eval_matrix.view(-1,9*28*28)\n actions_var = actions_var.view(-1,1)\n q_eval = torch.gather(q_eval_matrix, 1, actions_var) \n q_eval = q_eval.squeeze(1)\n\n q_next_matrix = self.target_net(rgbs_1_var,depths_1_var,questions_var).detach() #don't backward\n q_next_matrix = q_next_matrix.view(-1,9*28*28)\n q_next = torch.max(q_next_matrix,1)[0]\n\n one_var = Variable(torch.ones_like(terminals_var))\n\n q_target = rewards_var + (one_var- terminals_var)*self.discount * q_next\n \n loss = self.loss_func(q_eval, q_target)\n\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n self.task_total_loss += loss.item()\n self.task_total_q += q_target.mean()\n self.update_count += 1","def batch_q_learning(self):\n\n if(self.memory.get_usage() > Parameters.AGENT_HISTORY_LENGTH):\n\n state_t, action, reward, state_t_plus_1, terminal, i_s_weights, memory_indices = self.memory.bring_back_memories()\n\n q_t_plus_1 = self.tf_session.run(\n self.target_dqn.q_values, {\n self.target_dqn_input: state_t_plus_1})\n max_q_t_plus_1 = np.max(q_t_plus_1, axis=1)\n\n target_q_t = (1. - terminal) * \\\n Parameters.DISCOUNT_FACTOR * max_q_t_plus_1 + reward\n\n _, q_t, losses = self.tf_session.run([self.dqn.optimize, self.dqn.q_values, self.dqn.errors],\n {\n self.dqn.target_q: target_q_t,\n self.dqn.action: action,\n self.dqn_input: state_t,\n self.dqn.i_s_weights: i_s_weights\n })\n\n self.memory.update(\n memory_indices,\n np.squeeze(q_t),\n losses,\n self.get_learning_completion())\n input_shape = (1, Parameters.IMAGE_HEIGHT, Parameters.IMAGE_WIDTH, Parameters.AGENT_HISTORY_LENGTH)\n dqn_input = self.environment.get_input().reshape(input_shape)\n q_values = self.tf_session.run(\n self.dqn.q_values, {\n self.dqn_input: dqn_input})\n Plotter.add_q_values_at_t(q_values)\n else:\n print('[WARNING] Not enough memory for a batch')","def create_memory_qlearner(\n dqn: nn.Module, # Callable[[Observation], QValues]\n random_action: Callable[[Observation], Action],\n optimizer: optim.Optimizer,\n discount: float = 0.99,\n epsilon: Union[float, num.Stepable] = 0.05,\n evaluation_mode: trainers.QLearningMode = trainers.QLearningMode.DOUBLE,\n optimizing_steps: int = 4,\n double_target_weight_copy_steps: int = 1000,\n memory_capacity: int = 10000,\n batch_size: int = 32,\n clip_grad_norm: Optional[float] = None,\n dtype: Optional[torch.dtype] = None,\n device: Optional[torch.device] = None,\n) -> Explorer:\n # Enable converting from string\n evaluation_mode = trainers.QLearningMode(evaluation_mode)\n dqn.to(device=device, dtype=dtype)\n if evaluation_mode == trainers.QLearningMode.SIMPLE:\n target_dqn = None\n else:\n target_dqn = copy.deepcopy(dqn)\n\n def select_action(engine, observation):\n \"\"\"Epsilon greedy action selection.\"\"\"\n with torch.no_grad():\n dqn.eval()\n if torch.rand(1).item() < epsilon:\n return random_action(observation)\n else:\n return dqn(observation).greedy()\n\n agent = Explorer(select_action=select_action, dtype=dtype, device=device)\n trainer = trainers.create_qlearning_trainer(\n dqn=dqn,\n target_dqn=target_dqn,\n optimizer=optimizer,\n discount=discount,\n evaluation_mode=evaluation_mode,\n clip_grad_norm=clip_grad_norm,\n dtype=dtype,\n device=device,\n )\n\n @agent.on(Events.STARTED)\n def add_memory_and_trainer_to_agent(engine):\n engine.state.memory = MemoryReplay(\n T.PinIfCuda(device=device), capacity=memory_capacity\n )\n engine.state.trainer = trainer\n\n @agent.on(Events.ITERATION_COMPLETED)\n def append_transition_and_step_epsilon(engine):\n engine.state.memory.append(engine.state.transition.cpu())\n if isinstance(epsilon, num.Stepable):\n epsilon.step()\n\n @agent.on(Events.ITERATION_COMPLETED)\n @utils.every(optimizing_steps)\n def optimize(engine):\n sample_elem = engine.state.memory[0]\n dataloader = DataLoader(\n dataset=engine.state.memory,\n batch_size=batch_size,\n collate_fn=sample_elem.__class__.collate,\n shuffle=True,\n drop_last=True,\n )\n engine.state.trainer.run(dataloader)\n\n @agent.on(Events.ITERATION_COMPLETED)\n @utils.every(double_target_weight_copy_steps)\n def copy_weights(engine):\n if target_dqn is not None:\n dqn.zero_grad() # Avoid copying the gradients\n target_dqn.load_state_dict(copy.deepcopy(dqn.state_dict()))\n\n return agent","def learn(self):\n ## obtain sample batch using priority based sampling.\n states, actions, rewards, next_states, dones, weights, sample_inds = self.buffer.sample_batch(BETA)\n \n ## obtain the discounted sum of rewards from reward list\n ## also obtain final gamma multiplier\n reduced_rewards, gamma_multipliers = self.reduce_rewards(rewards)\n \n ## convert to tensors\n states = np_to_tensor(states)\n actions = np_to_tensor(actions)\n reduced_rewards = np_to_tensor(reduced_rewards)\n gamma_multipliers = np_to_tensor(gamma_multipliers)\n next_states = np_to_tensor(next_states)\n dones = np_to_tensor(dones)\n weights = np_to_tensor(np.array(weights))\n \n #### Updating Qnet\n \n ## actions from the target actor network\n greedy_actions = self.actor_target(next_states)\n ## compute temporal difference\n targets = reduced_rewards + torch.mul( torch.mul(gamma_multipliers , self.QNetwork_target(next_states, greedy_actions)) , (1-dones).unsqueeze(1))\n Q_sa = self.QNetwork_local(states, actions)\n \n td_error = targets - Q_sa\n \n ## update the priorities using temporal differences\n self.buffer.update_priority(sample_inds,\n (td_error).detach().abs().squeeze().cpu().data.numpy()+REPLAY_EPS)\n \n ## compute the loss, importance sampling weights are used\n loss = ((td_error).pow(2)*weights).mean()\n \n self.QNet_optim.zero_grad()\n loss.backward()\n self.QNet_optim.step()\n \n ### Updating Actor\n pred_actions = self.actor_local(states)\n actor_loss = - self.QNetwork_local(states, pred_actions).mean()\n \n self.actor_optim.zero_grad()\n actor_loss.backward()\n self.actor_optim.step()\n \n #### Polyak Updates\n self.soft_update(self.QNetwork_local, self.QNetwork_target, TAU)\n self.soft_update(self.actor_local, self.actor_target, TAU)","def learn(self):\n \n # target parameter update\n # target parameter update\n if self.learn_step_counter % self.nu_iter == 0:\n self.target_net.load_state_dict(self.eval_net.state_dict())\n #testing the preformace of the network\n if self.learn_step_counter == 0:\n print('As referece this first test on dev data. Is maded with the Q networks, initialized randomly : ' )\n else:\n print(\"\\n Lets copy the Q-value Net in to Q-target net!. And test the performace on the dev data: \")\n \n current_bleu = self.dev_network()\n print(\"Current Bleu score is: \", current_bleu)\n \n self.learn_step_counter += 1\n\n \n long_Batch = self.sample_size*3\n # Sampling the higgest rewards values\n b_memory_big = self.memory[np.argsort(-self.memory[:-self.max_output_length, self.state_size+1])][:long_Batch]\n \n sample_index = np.random.choice(long_Batch, self.sample_size)\n b_memory = b_memory_big[sample_index, :]\n\n b_s = torch.FloatTensor(b_memory[:, :self.state_size])\n b_a = torch.LongTensor(b_memory[:, self.state_size:self.state_size+1].astype(int))\n b_r = torch.FloatTensor(b_memory[:, self.state_size+1:self.state_size+2])\n b_s_ = torch.FloatTensor(b_memory[:, self.state_size+2: self.state_size+2 + self.state_size])\n\n b_is_eos = torch.FloatTensor(b_memory[:, self.size_memory1-1:]).view(self.sample_size, 1)\n #print(b_a, b_a.size)\n #print(b_is_eos)\n #Activate the eval_net\n unfreeze_model(self.eval_net)\n \n # q_eval w.r.t the action in experience\n q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)\n q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate\n #taking the most likely action.\n b_a_ = torch.LongTensor(q_next.max(1)[1].view(self.sample_size, 1).long())\n #b_a_ = q_next.max(1)[0].view(self.sample_size, 1).long() # shape (batch, 1)\n q_eval_next = self.eval_net(b_s_).gather(1, b_a_) # shape (batch, 1)\n \n #If eos q_target = reward. \n q_target = b_r + self.gamma * b_is_eos* q_eval_next.view(self.sample_size, 1) # shape (batch, 1)\n #version 0\n #q_target = b_r + self.gamma * q_next.max(1)[0].view(self.sample_size, 1) # shape (batch, 1)\n \n loss = self.loss_func(q_eval, q_target)\n \n self.tb_writer.add_scalar(\"learn/learn_batch_loss\",\n loss.data, self.learn_step_counter)\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n #desctivate the eval_net\n freeze_model(self.eval_net)","def choose_action( self):\n \"\"\"greedy, random, e-greedy, boltzmann, bayesian\"\"\"\n\tif self.exploration == \"greedy\":\n #Choose an action with the maximum expected value.\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\n a = a[0]\n return a\n if self.exploration == \"random\":\n #Choose an action randomly.\n a = env.action_space.sample()\n if self.exploration == \"e-greedy\":\n #Choose an action by greedily (with e chance of random action) from the Q-network\n if np.random.rand(1) < e or total_steps < pre_train_steps:\n a = env.action_space.sample()\n else:\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\n a = a[0]\n return a\n if self.exploration == \"boltzmann\":\n #Choose an action probabilistically, with weights relative to the Q-values.\n Q_d,allQ = sess.run([q_net.Q_dist,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.Temp:e,q_net.keep_per:1.0})\n a = np.random.choice(Q_d[0],p=Q_d[0])\n a = np.argmax(Q_d[0] == a)\n return a\n if self.exploration == \"bayesian\":\n #Choose an action using a sample from a dropout approximation of a bayesian q-network.\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:(1-e)+0.1})\n a = a[0]\n return a","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n #simple implementation of a python noob to implement DDQN\n bla = torch.from_numpy(np.zeros(64)).float().to(device)\n for i in range(64):\n bla[i] = self.qnetwork_target(next_states[i]).detach()[self.qnetwork_local(next_states).detach().argmax(1)[i]]\n Q_targets_next = bla.unsqueeze(1)\n #this was my first try of ddqn in python style, but as i said i'm a noob and didn't get it working\n #Q_targets_next = [self.qnetwork_target(next_states).detach()[i] for i in self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)]\n \n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def __init__(self, epsilon=0.05, gamma=0.9, alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n RQLearningAgent.__init__(self, **args)","def q_learning(env, learning, discount, epsilon, min_eps, episodes):\n # [18.00000072 14.00000006]\n num_states = (env.observation_space.high - env.observation_space.low) * \\\n np.array([10, 100]) # >> [18.00000072 14.00000006]\n num_states = np.round(num_states, 0).astype(int) + 1 # >> [19 15]\n\n # Initialize Q table\n # env.action_space.n return the number of action that our agent can make (here 3, left, cease, right)\n Q = np.random.uniform(low=-1, high=1, size=(num_states[0], num_states[1], env.action_space.n))\n\n # Initialize variable to track rewards\n reward_list = []\n ave_reward_list = []\n\n # Calculate episodic reduction in epsilon\n reduction = (epsilon - min_eps) / (episodes / 2)\n\n for i in range(episodes):\n # Initialize parameters\n done = False\n tot_reward, reward = 0, 0\n state = env.reset()\n\n # Discretize state\n state_adj = adjust_state(state)\n\n while done != True:\n # Render env for last five eps\n if i >= (episodes - 20):\n env.render()\n\n # Determine next action - epsilon greedy strategy\n if np.random.random() < 1 - epsilon:\n action = np.argmax(Q[state_adj[0], state_adj[1]])\n else:\n action = np.random.randint(0, env.action_space.n)\n\n # Get next state and reward\n state2, reward, done, info = env.step(action)\n\n # Discretize state2\n state2_adj = adjust_state(state2)\n\n # Allow for terminal states // .5 on env_space[0] represent the flag position\n if done and state2[0] >= .5:\n Q[state_adj[0], state_adj[1], action] = reward\n\n # adjust Q value for current state\n else:\n '''work on this, it's complicated but far from non-understandable'''\n delta = learning*(reward + discount*np.max(Q[state2_adj[0], state2_adj[1]]) -\n Q[state_adj[0], state_adj[1], action])\n Q[state_adj[0], state_adj[1], action] += delta\n\n tot_reward += reward\n state_adj = state2_adj\n\n # Decay epsilon\n if epsilon > min_eps:\n epsilon -= reduction\n\n # Track rewards\n reward_list.append(tot_reward)\n\n if (i+1) % 100 == 0:\n ave_reward = np.mean(reward_list)\n ave_reward_list.append(ave_reward)\n reward_list = []\n print(f'Episode {i+1} Average Reward: {ave_reward}')\n\n env.close()\n\n return ave_reward_list","def learn(self, state, action, reward, next_state):\r\n\r\n \"\"\"Please Fill Your Code Here.\r\n \"\"\"\r\n self.Q[state][action] = self.Q[state][action] + self.alpha * (reward + self.gamma * max(self.Q[next_state]) - self.Q[state][action])\r\n\r\n return 0","def __init__(self, epsilon=0.05,gamma=0.6, alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n F1QLearningAgent.__init__(self, **args)","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones, weights, indexes = experiences\n\n q_expected, q_targets = self.get_target_and_expected(states, \n actions, \n rewards, \n next_states, \n dones, \n gamma)\n\n #print('q_expected.shape', q_expected.shape)\n #print('q_targets.shape', q_targets.shape)\n \n # Compute loss\n ##### deltas = F.mse_loss(q_expected, q_targets)\n deltas = q_expected - q_targets\n #print('loss.shape', loss.data.cpu().numpy().shape)\n #print('loss', loss)\n \n _sampling_weights = (torch.Tensor(weights)\n .view((-1, 1)))\n \n # mean square error\n loss = torch.mean((deltas * _sampling_weights)**2)\n\n # importance sampling weights used to correct bias introduced \n # by prioritisation experience replay\n # See Annealing the bias https://arxiv.org/abs/1511.05952\n #with torch.no_grad():\n # weight = sum(np.multiply(weights, loss.data.cpu().numpy()))\n # print('weight', weight)\n # loss *= weight\n # print('weights.shape', weights.shape)\n # print('loss type', type(loss))\n # print('loss shape', loss.size())\n # loss *= weights\n # Minimize the loss\n # call zero_grad before calling backward() \n # o.w. gradients are accumulated from multiple passes\n self.optimizer.zero_grad()\n # backward computes dloss/dx for every parameter x\n loss.backward()\n # updates parameters\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \n \n # ------------------- update priorities ------------------- # \n priorities = abs(deltas.detach()).numpy()\n #priorities = abs(q_expected.detach() - q_targets.detach()).numpy()\n self.memory.update_priorities(priorities, indexes)","def q_learning_simulation(env, N=1000):\n env.reset()\n agent = QLearningAgent(env, use_sklearn=True)\n total_rewards = np.empty(N)\n\n for n in tqdm(range(N)):\n # There are 3 different kinds of epsilon to try\n #eps = 1.0/np.sqrt(n+1)\n #eps = 0.3\n eps = 0.1*(0.97**n)\n total_reward = agent.play(epsilon=eps, env=env, gamma=0.99)\n total_rewards[n] = total_reward\n if (n + 1) % 100 == 0:\n telegram_send.send(messages=[\"episode: {}, total reward: {}\".format(n, total_reward)])\n\n avgReward = total_rewards[-100:].mean()\n totalsteps = -total_rewards.sum()\n telegram_send.send(messages=[\n \"Agent training complete! Please check your plots.\",\n \"Average reward for last 100 episodes: {}.\".format(avgReward),\n \"Total steps: {}\".format(totalsteps)\n ])\n\n # Sanity check on training\n plt.plot(total_rewards)\n plt.title(\"Rewards\")\n plt.show()\n plot_running_avg(total_rewards)\n\n # Test if the agent is properly trained\n agent.play(epsilon=0, env=env, gamma=0.99, render=True)","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)\n\n # loading an existing q-table\n # self.loadTableFromFile('approxQweights.pkl')","def __init__(self, alpha = 0.4, gamma=0.2, n=1):\n self.epsilon = 0.3 # chance of taking a random action instead of the best\n\n # stats part\n\n self.reward=[]\n self.totalCount=0\n self.totalOnTarget=0\n self.shootCount=0\n\n\n self.phasesTemp=0\n self.phasesOnTarget=[]\n\n self.arrowAngleCount=dict()\n self.arrowAngleOn=dict()\n self.loadStats()\n\n ##QLearning varaibles\n self.q_table = {}\n self.loadTrainedData()\n self.n, self.alpha, self.gamma = n, alpha, gamma","def learn(self):\r\n \r\n # take a mini-batch from replay experience\r\n cur_batch_size = min(len(self.replay_exp), self.batch_size)\r\n mini_batch = random.sample(self.replay_exp, cur_batch_size)\r\n \r\n # batch data\r\n sample_states = np.ndarray(shape = (cur_batch_size, self.state_size)) # replace 128 with cur_batch_size\r\n sample_actions = np.ndarray(shape = (cur_batch_size, 1))\r\n sample_rewards = np.ndarray(shape = (cur_batch_size, 1))\r\n sample_next_states = np.ndarray(shape = (cur_batch_size, self.state_size))\r\n sample_dones = np.ndarray(shape = (cur_batch_size, 1))\r\n\r\n temp=0\r\n for exp in mini_batch:\r\n sample_states[temp] = exp[0]\r\n sample_actions[temp] = exp[1]\r\n sample_rewards[temp] = exp[2]\r\n sample_next_states[temp] = exp[3]\r\n sample_dones[temp] = exp[4]\r\n temp += 1\r\n \r\n \r\n sample_qhat_next = self.brain_target.predict(sample_next_states)\r\n \r\n # set all Q values terminal states to 0\r\n sample_qhat_next = sample_qhat_next * (np.ones(shape = sample_dones.shape) - sample_dones)\r\n # choose max action for each state\r\n sample_qhat_next = np.max(sample_qhat_next, axis=1)\r\n \r\n sample_qhat = self.brain_policy.predict(sample_states)\r\n \r\n for i in range(cur_batch_size):\r\n a = sample_actions[i,0]\r\n sample_qhat[i,int(a)] = sample_rewards[i] + self.gamma * sample_qhat_next[i]\r\n \r\n q_target = sample_qhat\r\n \r\n self.brain_policy.fit(sample_states, q_target, epochs = 1, verbose = 0)\r\n \r\n \r\n \r\n \"\"\"\r\n \r\n for state, action, reward, next_state, done in mini_batch:\r\n target_Q_s_a = 0 # new target for Q(s,a)\r\n state = np.reshape(state, [1, state_size])\r\n next_state = np.reshape(next_state, [1, state_size])\r\n \r\n # if it is not the terminal state\r\n if not done:\r\n qhat_next = self.brain_target.predict(next_state) # estimate Q(s',a')\r\n target_Q_s_a = reward + self.gamma * np.amax(qhat_next[0]) # because the output is m * n, so we need to consider the dimension [0]\r\n else:\r\n target_Q_s_a = reward\r\n \r\n target_output = self.brain_policy.predict(state) # we will replace target of Q(s,a) for specific a later\r\n target_output[0][action] = target_Q_s_a # new target for state s and action a\r\n \r\n self.brain_policy.fit(state, target_output, epochs = 1, verbose = 0)\r\n \r\n \"\"\"","def update(self, state, action, nextState, reward):\n \"\"\"Description:\n Use Q-Learning algoritm in slide 58 of MDP\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n maxQns = self.getValue(nextState) # get max q-value of next state\n if maxQns == None:\n maxQns = 0\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\n difference = reward + self.discountRate * maxQns - Qsa\n self.qValues[(state, action)] += self.alpha * difference\n \n self.vitCount[(state, action)] += 1\n \"\"\" END CODE \"\"\"","def main():\n\t# GET THE DIALOG CONTENT\n\tpolicyFlag = int(sys.argv[3])\n\tif policyFlag == 0:\n\t\texistedIterNum = 15000\n\t\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05'\n\telif policyFlag == 1:\n\t\texistedIterNum = 10000\n\t\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05Retroflex'\n\n\tqLearnOpts = {'gamma': 1.0, \n\t\t\t\t 'alpha': 0.0, \n\t\t\t\t 'epsilon': 0.0}\n\tnumOfTurn = util.returnConvertedIndexListCount('b','cycle_tree')\n\tnumofgauss = 5\n\tvar = 0.0625\n\tlamda = 0.05\n\tunitNum = 101\n\ta = qlearningAgents.FittedQLearningAgent(numOfTurn,numofgauss,var,lamda,unitNum, **qLearnOpts)\t\t\n\ta.openThetaFile(existedThetaFileName,existedIterNum)\n\n\tturnNum = int(sys.argv[1])\n\tuserUnitScore = []\n\tuserUnitScoreVector = sys.argv[2].split(',')\n\tfor i in userUnitScoreVector:\n\t\t\tuserUnitScore.append(float(i)/100.0)\n\n\tstate = State.State(turnNum, userUnitScore)\n\tprint a.getAction(state)","def q_human(episodes = 1000, fill_table = False):\n path = os.getcwd()\n grid = AdvGridworld()\n os.chdir(path)\n print(grid.name + ' with Q-Learning Human Agent')\n gamma = 0.95\n learning_rate = 0.01\n agent = QLearning(8, gamma, learning_rate)\n\n liRewards = []\n\n for i in range(episodes):\n grid.reset()\n state = grid.state\n width = grid.getBoardDim()[0]\n top_right_unex = True\n bottom_left_unex = True\n while not grid.isEnd:\n state_ind = state[1]*(width+1)+state[0]\n if fill_table:\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\n action = np.random.choice(actions, 1)[0]\n else:\n action = agent.get_action(state_ind)\n next_state, reward, is_end = grid.step(action)\n next_state_ind = next_state[1]*(width+1)+next_state[0]\n #makes a 2 shape\n if (next_state_ind not in [0,1,2,3,10,17,24,23,22,21,28,35,42,43,44,45,46,47,48]):\n reward = -10\n\n agent.train(state_ind, action, reward, next_state_ind)\n state = next_state\n #print(i, grid.reward)\n liRewards.append(grid.reward)\n rewards = np.array(liRewards)\n print(\"Rewards Info for \", episodes, ' Episodes')\n print('Size', rewards.size)\n print('Mean', np.mean(rewards, axis=0))\n print('Stdev', np.std(rewards, axis=0))\n print('Min', np.min(rewards))\n print('Max', np.max(rewards))\n\n return rewards, agent","def run_q_agent(policy='ε–greedy', save=False):\n\tagent = Q_Agent()\n\tall_iterations, all_rewards, step_count = agent.train(env, iter_n=1000, policy=policy)\n\tplot_reward(all_iterations, all_rewards)\n\tplot_steps(all_iterations, step_count)\n\t# print(\"best route is {}\".format(agent.test(env)))\n\t# if save:\n\t# \tsave_results(all_iterations, all_rewards, step_count)\n\t# optimum_route = agent.test(env, stations)\n\t# print(optimum_route)","def _transition_q_learning(self):\n if self.state.as_tuple() not in self.qstore.q:\n self.enum.enumerate_state(self.state, self.qstore.q)\n\n action_values = self.qstore.q[self.state.as_tuple()]\n # epsilon greedy choice\n if np.random.random() < self.epsilon:\n action = State(*action_values['actions'][np.random.randint(len(action_values['actions']))])\n else:\n max_q_value = max(action_values['utilities'])\n max_q_indexes = [i for i in range(len(action_values['actions'])) if\n action_values['utilities'][i] == max_q_value]\n max_actions = [action_values['actions'][i] for i in max_q_indexes]\n action = State(*max_actions[np.random.randint(len(max_actions))])\n\n self.state = action.copy()\n\n self._post_transition_updates()","def __init__(self, state_size, action_size, seed, verbose=False, **kwargs):\n\n # Set agent class variables\n self.t_step = 0\n self.name = kwargs.get('name', 'dqn_agent')\n self.run_id = kwargs.get('run_id', int(time.time()))\n self.output = kwargs.get('output', \n Path('./output/' + str(self.run_id) + '/'))\n self.rng = None\n self.rng_seed = None\n self.verbose = verbose\n\n # Set environment variables\n self.state_size = state_size\n self.action_size = action_size\n \n # Set agent training hyperparameters\n self.hidden = kwargs.get('hidden', [256,128,64]) # hidden layer architecture\n self.buffer_size = kwargs.get('buffer_size', int(1e5)) # replay buffer size\n self.batch_size = kwargs.get('batch_size', 64) # minibatch size\n self.gamma = kwargs.get('gamma', 0.99) # discount factor\n self.tau = kwargs.get('tau', 1e-3) # for soft update of target parameters\n self.lr = kwargs.get('lr', 5e-4) # learning rate \n self.update_every = kwargs.get('update_every', 4) # how often to update the network \n self.device = torch.device(\n \"cuda:0\" if torch.cuda.is_available() else \"cpu\"\n )\n\n # Set seed\n self.seed(seed)\n\n # Set agent q-networks & optimizer\n self.qnetwork_local = QNetwork(\n self.state_size, self.action_size, self.rng_seed, self.hidden\n ).to(self.device)\n self.qnetwork_target = QNetwork(\n self.state_size, self.action_size, self.rng_seed, self.hidden\n ).to(self.device)\n self.optimizer = optim.Adam(\n self.qnetwork_local.parameters(), lr=self.lr)\n\n # Replay memory\n self.memory = ReplayBuffer(\n action_size=self.action_size, \n buffer_size=self.buffer_size, \n batch_size=self.batch_size, \n seed=self.rng_seed,\n device=self.device\n )\n\n # Log class parameters\n self._log_parameters()\n\n return","def __init__(self, env, agent_config: Munch):\n\n super(Agent_DQN, self).__init__(env=env, agent_config=agent_config)\n\n ###########################\n # YOUR IMPLEMENTATION HERE #\n self.state = Munch({**self.state,\n \"step\": 0,\n \"num_actions\": env.action_space.n,\n \"metrics_capture_window\": agent_config.metrics_capture_window,\n \"replay_size\": agent_config.replay_size,\n \"position\": 0,\n \"total_num_steps\": agent_config.total_num_steps,\n \"episodes\": agent_config.episodes,\n \"gamma\": agent_config.gamma,\n \"learning_rate\": agent_config.learning_rate,\n \"initial_epsilon\": agent_config.initial_epsilon,\n \"final_epsilon\": agent_config.final_epsilon,\n \"epsilon\": agent_config.initial_epsilon,\n \"steps_to_explore\": agent_config.steps_to_explore,\n \"network_update_interval\": agent_config.network_update_interval,\n \"network_train_interval\": agent_config.network_train_interval,\n \"batch_size\": agent_config.batch_size,\n \"mode\": \"Random\",\n \"state_counter_while_testing\": 0,\n \"beta\": agent_config.beta,\n \"lambda_val\": agent_config.lambda_val,\n \"eta\": agent_config.eta\n })\n # self.run_name = agent_config.run_name\n # self.state.model_save_path = agent_config.model_save_path\n # self.state.model_save_interval = agent_config.model_save_interval\n # self.log_path = agent_config.log_path\n # self.tensorboard_summary_path = agent_config.tensorboard_summary_path\n self.is_cuda_available = torch.cuda.is_available()\n self.device = torch.device(\"cuda\" if self.is_cuda_available else \"cpu\")\n # self.state.model_test_path = agent_config.model_test_path\n # self.state.step = 0\n\n # Environment and network parameters\n # self.env = env\n # self.state.num_actions = env.action_space.n\n self.action_list = np.arange(self.state.num_actions)\n self.input_shape = [4, 84, 84]\n # self.state.metrics_capture_window = agent_config.metrics_capture_window\n # self.state.replay_size = agent_config.replay_size\n self.replay_memory = []\n # self.state.position = 0\n # self.state.total_num_steps = agent_config.total_num_steps\n # self.state.episodes = agent_config.episodes\n # self.state.gamma = agent_config.gamma\n # self.state.learning_rate = agent_config.learning_rate\n # self.state.initial_epsilon = agent_config.initial_epsilon\n # self.state.final_epsilon = agent_config.final_epsilon\n # self.state.epsilon = self.state.initial_epsilon\n # self.state.steps_to_explore = agent_config.steps_to_explore\n self.state.epsilon_step = (self.state.initial_epsilon - self.state.final_epsilon) / self.state.steps_to_explore\n\n # self.state.network_update_interval = agent_config.network_update_interval\n # self.state.network_train_interval = agent_config.network_train_interval\n\n self.last_n_rewards = deque([], self.state.metrics_capture_window)\n self.start_to_learn = agent_config.start_to_learn\n self.ddqn = agent_config.ddqn\n self.use_icm = agent_config.use_icm\n self.intrinsic_episode_reward = []\n self.last_n_intrinsic_rewards = deque([], self.state.metrics_capture_window)\n\n # self.state.batch_size = agent_config.batch_size\n # self.state.mode = \"Random\"\n # self.state.state_counter_while_testing = 0\n self.q_network = DQN(env=env, args=self.state.config).to(self.device)\n self.target_network = DQN(env=env, args=self.state.config).to(self.device)\n self.loss_function = F.smooth_l1_loss\n self.optimiser = optim.Adam(self.q_network.parameters(), lr=agent_config.learning_rate)\n self.probability_list = np.zeros(env.action_space.n, np.float32)\n self.q_network.train()\n self.target_network.eval()\n\n self.icm_model = ICM(env=env, num_actions=self.state.num_actions, args=self.state.config).to(self.device)\n\n self.inverse_loss_fn = nn.CrossEntropyLoss()\n self.forward_loss_fn = nn.MSELoss()\n\n # self.state.beta = agent_config.beta\n # self.state.lambda_val = agent_config.lambda_val\n # self.state.eta = agent_config.eta\n\n # create necessary paths\n # self.create_dirs()\n self.meta = None\n\n if agent_config.test_dqn:\n print('loading trained model')\n self.q_network.load_state_dict(torch.load(self.state.model_test_path, map_location=self.device))\n\n # self.log_file = open(self.state.model_save_path + '/' + self.run_name + '.log', 'w') if not agent_config.test_dqn else None\n\n # Set target_network weight\n self.target_network.load_state_dict(self.q_network.state_dict())\n\n # self.writer = SummaryWriter(agent_config.tensorboard_summary_path)","def agentTraining(noOfDecks,\r\n sampleSpaceSearching,\r\n sampleSpaceExploitation,\r\n method,\r\n gamma,\r\n qTable=None):\r\n deckSize = noOfDecks*52\r\n optimalScore = 0 # winning score and losing Score\r\n egreedyScore = 0\r\n pO = [0,0,0]\r\n pe = [0,0,0]\r\n\r\n gamePlay = Dealing(noOfDecks)\r\n gamePlay.newRound()\r\n \r\n agent = adp(deckSize,\r\n gamePlay.deck,\r\n gamePlay.hitScore,\r\n gamePlay.partialDealerScore,\r\n gamePlay.dealerScore,\r\n gamePlay.aceCount,\r\n gamePlay.aceCriticalHit,\r\n gamma)\r\n \r\n # for iterating \r\n if qTable !=None:\r\n if type(qTable) == int:\r\n agent.QList = []\r\n else: \r\n for trajectory in range(len(qTable)):\r\n agent.QList.append(qTable[trajectory])\r\n # for qtable, expect form: [[(trajector1)], [(initialSize,remainingAmount,agentScore,dealerScore',\r\n # NoOfAces,twoAcesOrMore,reward,decision),...]]\r\n \r\n for trajectoryNumber in range(sampleSpaceSearching + sampleSpaceExploitation):\r\n exploredStateAction = []\r\n while gamePlay.ifGameEnd() == False: \r\n \r\n if trajectoryNumber < sampleSpaceSearching: # condition for still exploring \r\n \r\n e = 100 / (100+len(exploredStateAction)) # as explore more, more likely to\r\n # stick to optimal policy\r\n action = agent.eGreedyPolicyQTable(e, \r\n deckSize,\r\n gamePlay.remainingDeckSize,\r\n gamePlay.hitScore, # true cards\r\n gamePlay.partialDealerScore, # visible to agent\r\n gamePlay.dealerScore, # true cards\r\n gamePlay.aceCount,#8\r\n gamePlay.aceCriticalHit)#8\r\n else: # if in exploitation phase \r\n action = agent.optimalPolicyQTable(deckSize,\r\n gamePlay.remainingDeckSize,\r\n gamePlay.hitScore,\r\n gamePlay.partialDealerScore,#8\r\n gamePlay.dealerScore,\r\n gamePlay.aceCount,#8\r\n gamePlay.aceCriticalHit)#8\r\n\r\n numRemaining = gamePlay.remainingDeckSize\r\n agentScore = gamePlay.hitScore\r\n agentVisScore = gamePlay.partialDealerScore\r\n actualDealerScore = gamePlay.dealerScore\r\n numOfaces = gamePlay.aceCount\r\n criticalAce = gamePlay.aceCriticalHit # boolean \r\n reward = gamePlay.actionOutcome(action)\r\n # if gamePlay.actionOutcome(action) method executed, newround or hit method is \r\n # also exectued. this inturn updates gameplay details. Hence assigned \r\n # variables prior to method excecution\r\n stateAction = (deckSize, numRemaining,\r\n agentScore,agentVisScore,\r\n actualDealerScore, numOfaces,\r\n criticalAce, reward,\r\n action)\r\n\r\n if stateAction not in agent.QList and (agentScore >= actualDealerScore\r\n and agentScore <= gamePlay.blackJack):\r\n # if not a repeated state-action anywhere in my searchedSpace, save it\r\n exploredStateAction.append(stateAction)\r\n \r\n if gamePlay.ifGameEnd() == True:\r\n agent.QList.append(exploredStateAction)\r\n agent.QTableUpdate(method,\r\n reward,\r\n gamma)\r\n break\r\n\r\n if trajectoryNumber > sampleSpaceSearching: # optimal policy \r\n if reward > 0: \r\n optimalScore += gamePlay.hitScore**2\r\n pO[0] +=1 # winning points\r\n if reward ==0:\r\n pO[1] +=1 \r\n if reward < 0:\r\n pO[2] += 1\r\n \r\n else: # eGreedy policy \r\n if reward > 0: \r\n egreedyScore += gamePlay.hitScore**2\r\n pe[0] +=1 # winning points\r\n if reward ==0:\r\n pe[1] +=1\r\n if reward < 0:\r\n pe[2] +=1\r\n \r\n print(\"Deck size = {} deck(s) using policy\"\r\n \" search method: {}\".format(gamePlay.deckSize,\r\n method)) \r\n \r\n print(\"The agent exploration period = {} rounds.Followed by {}\"\r\n \" rounds of exploitation\".format(sampleSpaceSearching,sampleSpaceExploitation))\r\n\r\n print(\"The Agent average quadratic score per game exploration phase = {}\"\r\n \" The exploitation quadratic score per game = {}\"\r\n \" In terms of winning and loosing against the house,\"\r\n \" the Agent wins {}% draws {}% and loses {}% on the training (explore) stage, followed by \"\r\n \" wins {}% draws {}% and loses {}% on the\"\r\n \" testing (exploitation) stage \".format((egreedyScore/sampleSpaceSearching),\r\n (optimalScore/sampleSpaceExploitation),\r\n np.round(pe[0]/sum(pe)*100,1 ),\r\n np.round(pe[1]/sum(pe)*100,1 ),\r\n np.round(pe[2]/sum(pe)*100,1 ),\r\n np.round(pO[0]/sum(pO)*100,1 ),\r\n np.round(pO[1]/sum(pO)*100,1 ),\r\n np.round(pO[2]/sum(pO)*100,1 ))) \r\n\r\n return agent.QList, pe, pO, egreedyScore, optimalScore","def q_learning(env, model, episodes, gamma=0.9,\n epsilon=0.3, eps_decay=0.99,\n replay=False, replay_size=20,\n title='DQL', double=False,\n n_update=10, soft=False, verbose=True):\n final = []\n memory = []\n episode_i = 0\n sum_total_replay_time = 0\n for episode in range(episodes):\n episode_i += 1\n if double and not soft:\n # Update target network every n_update steps\n if episode % n_update == 0:\n model.target_update()\n if double and soft:\n model.target_update()\n\n # Reset state\n state = env.reset()\n done = False\n total = 0\n\n while not done:\n # Implement greedy search policy to explore the state space\n if random.random() < epsilon:\n action = env.action_space.sample()\n else:\n q_values = model.predict(state)\n action = torch.argmax(q_values).item()\n\n # Take action and add reward to total\n next_state, reward, done, _ = env.step(action)\n\n # Update total and memory\n total += reward\n memory.append((state, action, next_state, reward, done))\n q_values = model.predict(state).tolist()\n\n if done:\n if not replay:\n q_values[action] = reward\n # Update network weights\n model.update(state, q_values)\n break\n\n if replay:\n t0 = time.time()\n # Update network weights using replay memory\n model.replay(memory, replay_size, gamma)\n t1 = time.time()\n sum_total_replay_time += (t1 - t0)\n else:\n # Update network weights using the last step only\n q_values_next = model.predict(next_state)\n q_values[action] = reward + gamma * torch.max(q_values_next).item()\n model.update(state, q_values)\n\n state = next_state\n\n # Update epsilon\n epsilon = max(epsilon * eps_decay, 0.01)\n final.append(total)\n plot_res(final, title)\n\n if verbose:\n print(\"episode: {}, total reward: {}\".format(episode_i, total))\n if replay:\n print(\"Average replay time:\", sum_total_replay_time / episode_i)\n\n return final","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # Get max predicted Q values (for next states) from target model\n Q_targets_next = self.qnetwork_target(\n next_states).detach().max(1)[0].unsqueeze(1)\n \n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, self.tau) \n\n return","def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n QLearningAgent.__init__(self, **args)\n\n self.tf = OverfeatTransformer(output_layers = [-1], force_reshape = False)\n self.weights = util.Counter()","def __init__(self,\n num_actions,\n\n tau,\n alpha=1,\n clip_value_min=-10,\n\n net_conf = None,\n env = \"CartPole\", \n normalize_obs = True,\n hidden_layer=2, \n neurons=512,\n replay_scheme='prioritized',\n noisy = False,\n dueling = False,\n initzer = 'xavier_uniform',\n target_opt=0,\n mse_inf=False,\n network=networks.NatureDQNNetwork,\n optimizer='adam',\n epsilon_fn=dqn_agent.linearly_decaying_epsilon,\n seed=None):\n # We need this because some tools convert round floats into ints.\n seed = int(time.time() * 1e6) if seed is None else seed\n self._net_conf = net_conf\n self._env = env \n self._normalize_obs = normalize_obs\n self._hidden_layer = hidden_layer\n self._neurons=neurons \n self._noisy = noisy\n self._dueling = dueling\n self._initzer = initzer\n self._target_opt = target_opt\n self._mse_inf = mse_inf\n self._tau = tau\n self._alpha = alpha\n self._clip_value_min = clip_value_min\n self._rng = jax.random.PRNGKey(seed)\n\n super(JaxDQNAgentNew, self).__init__(\n num_actions= num_actions,\n network= functools.partial(network, \n num_actions=num_actions,\n net_conf=self._net_conf,\n env=self._env,\n normalize_obs=self._normalize_obs,\n hidden_layer=self._hidden_layer, \n neurons=self._neurons,\n noisy=self._noisy,\n dueling=self._dueling,\n initzer=self._initzer),\n optimizer=optimizer,\n epsilon_fn=dqn_agent.identity_epsilon if self._noisy == True else epsilon_fn)\n\n \n self._replay_scheme = replay_scheme","def __init__(self, epsilon=0.05,gamma=0.6, alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n FQLearningAgent.__init__(self, **args)","def learn(self, experiences, gamma):\n\n states, actions, rewards, next_states, dones = experiences\n\n Q_targets = self.get_dqg_target(next_states, rewards, gamma, dones)\n\n # Get expected Q values\n q_exp = self.qnetwork_local(states)\n\n # gets the q values along dimention 1 according to the actions, which is used as index\n # >>> t = torch.tensor([[1,2],[3,4]])\n # >>> torch.gather(t, 1, torch.tensor([[0],[1]]))\n # tensor([[ 1],\n # [ 4]])\n q_exp = q_exp.gather(1, actions)\n\n # compute loss\n loss = F.mse_loss(q_exp, Q_targets)\n\n # reset optimizer gradient\n self.optimizer.zero_grad()\n # do backpropagation\n loss.backward()\n # do optimize step\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, PARAM.TAU)","def perform_q_learning(self, prev_state: str, state: str, action: Action, reward):\n max_future_q = max(self.Qs[state].values())\n self.Qs[prev_state][action] = (1.0 - self.alpha) * self.Qs[prev_state][\n action] + self.alpha * (reward + self.gamma * max_future_q)\n self.Vs[prev_state] = max(self.Qs[prev_state].values())","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones, idxs, weights = experiences\n \n\n # Get max predicted Q values (for next states) from target model\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss MSE\n loss = (Q_expected - Q_targets.detach()).pow(2)\n # Add weights to loss\n loss = loss * weights\n # Add noise to loss to arrive at prior weights\n prios = loss + 1e-6\n # Take mean\n loss = loss.mean()\n\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # Update buffer priorities\n self.memory.update_priorities(zip(idxs, prios.data.cpu().numpy()))\n\n\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def qlearning(alpha, gamma, epsilon, episodes, max_steps, n_tests, render = False, test=False):\n env = gym.make('Taxi-v2')\n n_states, n_actions = env.observation_space.n, env.action_space.n\n Q = init_q(n_states, n_actions, type=\"ones\")\n timestep_reward = []\n for episode in range(episodes):\n print(f\"Episode: {episode}\")\n s = env.reset()\n a = epsilon_greedy(Q, epsilon, n_actions, s)\n t = 0\n total_reward = 0\n done = False\n while t < max_steps:\n if render:\n env.render()\n t += 1\n s_, reward, done, info = env.step(a)\n total_reward += reward\n a_ = np.argmax(Q[s_, :])\n if done:\n Q[s, a] += alpha * ( reward - Q[s, a] )\n else:\n Q[s, a] += alpha * ( reward + (gamma * Q[s_, a_]) - Q[s, a] )\n s, a = s_, a_\n if done:\n if render:\n print(f\"This episode took {t} timesteps and reward: {total_reward}\")\n timestep_reward.append(total_reward)\n break\n if render:\n print(f\"Here are the Q values:\\n{Q}\\nTesting now:\")\n if test:\n test_agent(Q, env, n_tests, n_actions)\n return timestep_reward","def learn(env,\n env_test,\n env_test1,\n q_func,\n optimizer_spec,\n optimizer_spec_omega,\n optimizer_spec_term,\n session,\n options,\n exploration=LinearSchedule(1000000, 0.1),\n stopping_criterion=None,\n replay_buffer_size=1000000,\n batch_size=32,\n gamma=0.99,\n xi=None,\n learning_starts=50000,\n learning_freq=4,\n frame_history_len=4,\n target_update_freq=10000,\n grad_norm_clipping=10,\n eval_obs_array=None,\n room_q_interval=1e5,\n epoch_size=5e4,\n log_dir=None,\n transfer_config=None,\n random_length=1000):\n\n Costs = []\n loss_term_log = []\n average_loss_term = []\n loss_omega_log = []\n average_loss_omega = []\n Average_costs = []\n test_rewards = []\n test_rewards1= []\n none_discount = []\n none_discount1 = []\n short_average = []\n short_average1 = []\n short_average_none = []\n short_average_none1 = []\n test_q_max_log = []\n test_u_log = []\n test_omega_log = []\n Episode_num = 0\n\n online_q_omega = False\n online_termination = True\n q_omega_uniform_sample = False\n four_to_two = False\n no_share_para = False\n target_beta = False\n termination_stop = False\n beta_no_bias = False\n\n debug_no_term_train = False\n\n obs_random_batch = None\n\n if transfer_config:\n if transfer_config.has_key('online_q_omega'):\n online_q_omega = transfer_config['online_q_omega']\n if transfer_config.has_key('online_termination'):\n online_termination = transfer_config['online_termination']\n if transfer_config.has_key('q_omega_uniform_sample'):\n q_omega_uniform_sample = transfer_config['q_omega_uniform_sample']\n if transfer_config.has_key('four_to_two'):\n four_to_two = transfer_config['four_to_two']\n if transfer_config.has_key('no_share_para'):\n no_share_para = transfer_config['no_share_para']\n if transfer_config.has_key('target_beta'):\n target_beta = transfer_config['target_beta']\n if transfer_config.has_key('xi'):\n xi = transfer_config['xi']\n if transfer_config.has_key('termination_stop'):\n termination_stop = transfer_config['termination_stop']\n if transfer_config.has_key('beta_no_bias'):\n beta_no_bias = transfer_config['beta_no_bias']\n\n if transfer_config.has_key('debug_no_term_train'):\n debug_no_term_train = transfer_config['debug_no_term_train']\n\n assert type(env.observation_space) == gym.spaces.Box\n assert type(env.action_space) == gym.spaces.Discrete\n if four_to_two:\n assert frame_history_len == 4\n\n ###############\n # BUILD MODEL #\n ###############\n\n img_h, img_w, img_c = env.observation_space.shape\n input_history_len = 2 if four_to_two else frame_history_len\n input_shape = (img_h, img_w, input_history_len * img_c)\n num_actions = env.action_space.n\n # source + primitive\n num_options = len(options)\n\n # set up placeholders\n # placeholder for current observation (or state)\n obs_t_ph = tf.placeholder(tf.uint8, [None] + list(input_shape))\n # placeholder for current action\n act_t_ph = tf.placeholder(tf.int32, [None])\n # placeholder for current option\n opt_t_ph = tf.placeholder(tf.int32, [None])\n # placeholder for current options whose actions are the same as action taken (k-hot)\n opa_t_ph = tf.placeholder(tf.float32, [None] + [num_options])\n # placeholder for current reward\n rew_t_ph = tf.placeholder(tf.float32, [None])\n # placeholder for next observation (or state)\n obs_tp1_ph = tf.placeholder(tf.uint8, [None] + list(input_shape))\n # placeholder for end of episode mask\n # this value is 1 if the next state corresponds to the end of an episode,\n # in which case there is no Q-value at the next state; at the end of an\n # episode, only the current state reward contributes to the target, not the\n # next state Q-value (i.e. target is just rew_t_ph, not rew_t_ph + gamma * q_tp1)\n done_mask_ph = tf.placeholder(tf.float32, [None])\n Episode_reward = tf.placeholder(tf.float32)\n\n # casting to float on GPU ensures lower data transfer times.\n obs_t_float = tf.cast(obs_t_ph, tf.float32) / 255.0\n obs_tp1_float = tf.cast(obs_tp1_ph, tf.float32) / 255.0\n\n # Here, you should fill in your own code to compute the Bellman error. This requires\n # evaluating the current and next Q-values and constructing the corresponding error.\n # TensorFlow will differentiate this error for you, you just need to pass it to the\n # optimizer. See assignment text for details.\n # Your code should produce one scalar-valued tensor: total_error\n # This will be passed to the optimizer in the provided code below.\n # Your code should also produce two collections of variables:\n # q_func_vars\n # target_q_func_vars\n # These should hold all of the variables of the Q-function network and target network,\n # respectively. A convenient way to get these is to make use of TF's \"scope\" feature.\n # For example, you can create your Q-function network with the scope \"q_func\" like this:\n # <something> = q_func(obs_t_float, num_actions, scope=\"q_func\", reuse=False)\n # And then you can obtain the variables like this:\n # q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='q_func')\n # Older versions of TensorFlow may require using \"VARIABLES\" instead of \"GLOBAL_VARIABLES\"\n ######\n \n # YOUR CODE HERE\n q_current, q_omega_current, term_current = q_func(obs_t_float, num_actions, num_options, scope='q_func', reuse=False, no_share_para=no_share_para, termination_stop=termination_stop, beta_no_bias=beta_no_bias)\n q_target, q_omega_target, term_target = q_func(obs_tp1_float, num_actions, num_options, scope='target_q_func', reuse=False, no_share_para=no_share_para, termination_stop=termination_stop, beta_no_bias=beta_no_bias)\n q_next_current, q_omega_next_current, term_next_current = q_func(obs_tp1_float, num_actions, num_options, scope='q_func', reuse=True, no_share_para=no_share_para, termination_stop=termination_stop, beta_no_bias=beta_no_bias)\n if debug_no_term_train:\n term_next_current_old = term_next_current = term_current = term_target = tf.constant(1.0, dtype=tf.float32, shape=(1, num_options))\n\n\n\n # q_value\n q_val_current = tf.reduce_sum(q_current * tf.one_hot(act_t_ph, num_actions), axis=-1)\n q_val_next_raw = tf.reduce_sum(q_target * tf.one_hot(tf.argmax(q_next_current, axis=-1), num_actions), axis=-1)\n q_val_next = q_val_next_raw * (1 - done_mask_ph)\n\n # q_value error\n total_error_q = tf.reduce_mean(tf.losses.mean_squared_error(rew_t_ph + gamma * q_val_next, q_val_current))\n # q_omega_value\n term_val_next = tf.reduce_sum(term_next_current * tf.one_hot(opt_t_ph, num_options), axis=-1)\n q_omega_val_next = tf.reduce_sum(q_omega_next_current * tf.one_hot(opt_t_ph, num_options), axis=-1)\n max_q_omega_next = tf.reduce_max(q_omega_next_current, axis=-1)\n max_q_omega_next_targ = tf.reduce_sum(q_omega_target * tf.one_hot(tf.argmax(q_omega_next_current, axis=-1), num_options), axis=-1)\n\n if target_beta: # change var\n term_next_current_old = term_next_current\n term_next_current = term_target\n\n u_next_raw = (1 - term_next_current) * q_omega_target + term_next_current * max_q_omega_next_targ[..., None]\n u_next = tf.stop_gradient(u_next_raw * (1 - done_mask_ph)[..., None])\n\n if target_beta: # row back\n term_next_current = term_next_current_old\n\n # q_omega_value error\n total_error_q_omega = tf.reduce_mean(tf.reduce_sum(\n opa_t_ph *\n tf.losses.mean_squared_error(rew_t_ph[..., None] + gamma * u_next, q_omega_current, reduction=tf.losses.Reduction.NONE),\n axis=-1\n ))\n\n # optimize termination\n if xi == None:\n xi = 0.8 * (max_q_omega_next - tf.nn.top_k(q_omega_next_current, 2)[0][:, 1])\n advantage_go = q_omega_val_next - max_q_omega_next + xi\n advantage = tf.stop_gradient(advantage_go)\n # total_error_term = term_val_next * advantage * (1 - done_mask_ph)\n total_error_term = term_val_next * advantage #修改\n tf.summary.scalar('total_error_term', total_error_term)\n # def term_grad(optimizer, objective, var_list, clip_val=10):\n # gradients = optimizer.compute_gradients(objective, var_list=var_list)\n # for i, (grad, var) in enumerate(gradients):\n # if grad is not None:\n # gradients[i] = (tf.clip_by_norm(grad, clip_val) * advantage_go, var)\n # return optimizer.apply_gradients(gradients)\n\n q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='q_func')\n # print len(q_func_vars)\n target_q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='target_q_func')\n # print len(target_q_func_vars)\n\n\n # for log purposes\n # add some tensor for logs\n u_current = (tf.cast(tf.constant(np.ones(num_options)),\n tf.float32) - term_current) * q_omega_current + term_current * (tf.reduce_max(q_omega_current,\n axis=-1))[:, None]\n max_q_omega = tf.reduce_max(q_omega_current, axis=-1)\n values1 = tf.nn.top_k(q_omega_current, 2)[0]\n advantage_current = q_omega_current - max_q_omega[:, None] + 0.8 * (max_q_omega - values1[:, 1])[:, None]\n term_loss = term_current * advantage_current\n tf.summary.histogram('u_current', u_current)\n tf.summary.histogram('advantage_current', advantage_current)\n tf.summary.histogram('term_loss', term_loss)\n tf.summary.histogram('term_current', term_current, family='term_current')\n [tf.summary.histogram('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_current') for i in range(num_options)]\n [tf.summary.scalar('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_vals') for i in range(num_options)]\n # summaries_first = [tf.summary.histogram('u_current', u_current),\n # tf.summary.histogram('advantage_current', advantage_current),\n # tf.summary.histogram('term_loss', term_loss),\n # tf.summary.histogram('term_current', term_current, family='term_current'),\n # [tf.summary.histogram('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_current') for i in range(num_options)],\n # [tf.summary.scalar('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_vals') for i in range(num_options)]]\n # summaries_diff = [tf.summary.histogram('u_current11', u_current),\n # tf.summary.histogram('advantage_current1', advantage_current),\n # tf.summary.histogram('term_loss1', term_loss),\n # tf.summary.histogram('term_current1', term_current, family='term_current1'),\n # [tf.summary.histogram('term_current1_%d' % (i), tf.reduce_mean(term_current[:, i]),\n # family='term_current1') for i in range(num_options)],\n # [tf.summary.scalar('term_current1_%d' % (i), tf.reduce_mean(term_current[:, i]),\n # family='term_vals1') for i in range(num_options)]]\n # merged_summary_diff=tf.summary.merge(summaries_diff)\n # merged_summary_op = tf.summary.merge(summaries_first)\n merged_summary_op = tf.summary.merge_all()\n # summary_second = [tf.summary.scalar(\"my_second_graph_loss\", Episode_reward)]\n # merged_summary_op1 = tf.summary.merge(summary_second)\n summary_writer = tf.summary.FileWriter(log_dir + 'tfb', session.graph)\n\n q_max = tf.reduce_max(q_current, 1)\n u_max = tf.reduce_max(u_current, 1)\n omega_max = tf.reduce_max(q_omega_current, 1)\n average_Q = tf.reduce_mean(q_max)\n average_U = tf.reduce_mean(u_max)\n average_omega = tf.reduce_mean(omega_max)\n ######\n\n # construct optimization op (with gradient clipping)\n learning_rate = tf.placeholder(tf.float32, (), name=\"learning_rate\")\n learning_rate_omega = tf.placeholder(tf.float32, (), name=\"learning_rate_omega\")\n learning_rate_term = tf.placeholder(tf.float32, (), name=\"learning_rate_term\")\n optimizer = optimizer_spec.constructor(learning_rate=learning_rate, **optimizer_spec.kwargs)\n optimizer_omega = optimizer_spec_omega.constructor(learning_rate=learning_rate_omega, **optimizer_spec_omega.kwargs)\n optimizer_term = optimizer_spec_term.constructor(learning_rate=learning_rate_term, **optimizer_spec_term.kwargs)\n train_fn = minimize_and_clip(optimizer, total_error_q, var_list=q_func_vars, clip_val=grad_norm_clipping)\n train_fn_omega = minimize_and_clip(optimizer_omega, total_error_q_omega, var_list=q_func_vars, clip_val=grad_norm_clipping)\n\n if debug_no_term_train:\n train_fn_term = tf.no_op()\n else:\n train_fn_term = minimize_and_clip(optimizer_term, total_error_term, var_list=q_func_vars, clip_val=grad_norm_clipping)\n # train_fn_term = term_grad(optimizer_term, term_val_next, var_list=q_func_vars, clip_val=grad_norm_clipping)\n\n # update_target_fn will be called periodically to copy Q network to target Q network\n update_target_fn = []\n for var, var_target in zip(sorted(q_func_vars, key=lambda v: v.name),\n sorted(target_q_func_vars, key=lambda v: v.name)):\n update_target_fn.append(var_target.assign(var))\n update_target_fn = tf.group(*update_target_fn)\n\n # construct the replay buffer\n replay_buffer = ReplayBuffer(replay_buffer_size, frame_history_len)\n\n # for log purposes\n replay_buffer_test = ReplayBuffer(10000, frame_history_len)\n replay_buffer_test1 = ReplayBuffer(10000, frame_history_len)\n\n ###############\n # RUN ENV #\n ###############\n model_initialized = False\n q_model_initialized = False\n option_activated = False\n option_running = None\n num_param_updates = 0\n mean_episode_reward = -float('nan')\n best_mean_episode_reward = -float('inf')\n last_obs = env.reset()\n next_recent_obs = None\n idx = replay_buffer.store_frame(last_obs)\n LOG_EVERY_N_STEPS = 10000\n running_time = [0, time.time()]\n\n for t in itertools.count():\n ### 1. Check stopping criterion\n if stopping_criterion is not None and stopping_criterion(env, t):\n break\n\n ### 2. Step the env and store the transition\n # At this point, \"last_obs\" contains the latest observation that was\n # recorded from the simulator. Here, your code needs to store this\n # observation and its outcome (reward, next observation, etc.) into\n # the replay buffer while stepping the simulator forward one step.\n # At the end of this block of code, the simulator should have been\n # advanced one step, and the replay buffer should contain one more\n # transition.\n # Specifically, last_obs must point to the new latest observation.\n # Useful functions you'll need to call:\n # obs, reward, done, info = env.step(action)\n # this steps the environment forward one step\n # obs = env.reset()\n # this resets the environment if you reached an episode boundary.\n # Don't forget to call env.reset() to get a new observation if done\n # is true!!\n # Note that you cannot use \"last_obs\" directly as input\n # into your network, since it needs to be processed to include context\n # from previous frames. You should check out the replay buffer\n # implementation in dqn_utils.py to see what functionality the replay\n # buffer exposes. The replay buffer has a function called\n # encode_recent_observation that will take the latest observation\n # that you pushed into the buffer and compute the corresponding\n # input that should be given to a Q network by appending some\n # previous frames.\n # Don't forget to include epsilon greedy exploration!\n # And remember that the first time you enter this loop, the model\n # may not yet have been initialized (but of course, the first step\n # might as well be random, since you haven't trained your net...)\n\n #####\n \n # YOUR CODE HERE\n\n\n # store the first random_length frames to calculate the average Q\n epsilon = exploration.value(t / learning_freq)\n if next_recent_obs is not None:\n recent_obs = next_recent_obs\n else:\n recent_obs = replay_buffer.encode_recent_observation()\n\n # pick an option\n if not option_activated:\n if random.random() > epsilon and model_initialized:\n q_omega_vals = session.run(q_omega_current, {obs_t_ph: recent_obs[None, ..., -input_history_len:]})\n option_running = np.argmax(q_omega_vals)\n else:\n option_running = random.choice(range(num_options))\n option_activated = True\n\n # choose action\n action = options[option_running].act(recent_obs)\n\n # take a step in the environment\n new_obs, r, done, _ = env.step(action)\n if done:\n new_obs = env.reset()\n\n # TODO: change replay_buffer to support option storage\n opa = np.array(\n [1 if i == option_running or options[i].act(recent_obs) == action else 0 for i in range(num_options)]\n )\n # opa[option_running] = 2\n replay_buffer.store_effect(idx, action, r, done, opa)\n idx = replay_buffer.store_frame(new_obs)\n next_recent_obs = replay_buffer.encode_recent_observation()\n\n if not model_initialized:\n initialize_interdependent_variables(session, tf.global_variables(), {\n obs_t_ph: recent_obs[None, ..., -input_history_len:],\n obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:],\n })\n session.run(update_target_fn)\n model_initialized = True\n saver = tf.train.Saver()\n # checkpoint = tf.train.get_checkpoint_state(\n # \"/home/lsy/PycharmProjects/ple-monstrerkong/examples/dqn_transfer_option/logs/12_16off1c_12_16_17_20:38:47/dqn\")\n # if checkpoint and checkpoint.model_checkpoint_path:\n # saver.restore(session, checkpoint.model_checkpoint_path)\n # print(\"Successfully loaded: \", checkpoint.model_checkpoint_path)\n # Load = True\n # else:\n # print(\"Could not find old network weights\")\n\n # online update q_omega & termination\n if t > learning_starts and not debug_no_term_train and not done:\n loss_term, _ = session.run([total_error_term, train_fn_term], feed_dict={\n obs_t_ph: recent_obs[None, ..., -input_history_len:],\n opt_t_ph: [option_running],\n # opa_t_ph: [option_running],\n # rew_t_ph: [r],\n obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:],\n done_mask_ph: [1.0 if done == True else 0.0],\n learning_rate_omega: optimizer_spec_omega.lr_schedule.value(t / learning_freq),\n learning_rate_term: optimizer_spec_term.lr_schedule.value(t / learning_freq)\n })\n loss_term_log.append(loss_term)\n if online_q_omega:\n for i in range(num_options):\n if opa[i] > 0:\n _, loss_omega = session.run([train_fn_omega, total_error_q_omega], feed_dict={\n obs_t_ph: recent_obs[None, ..., -input_history_len:],\n opa_t_ph: [i],\n rew_t_ph: [r],\n obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:],\n done_mask_ph: [1.0 if done == True else 0.0],\n learning_rate_omega: optimizer_spec_omega.lr_schedule.value(t / learning_freq),\n })\n loss_omega_log.append(loss_omega)\n\n\n term_probs = session.run(term_next_current, {obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:]})\n # print \"term_probs\", term_probs\n if done or not random.random() > term_probs[0][option_running]: # will re-pick an option\n option_activated = False\n\n\n #####\n\n # at this point, the environment should have been advanced one step (and\n # reset if done was true), and last_obs should point to the new latest\n # observation\n\n ### 3. Perform experience replay and train the network.\n # note that this is only done if the replay buffer contains enough samples\n # for us to learn something useful -- until then, the model will not be\n # initialized and random actions should be taken\n if (t > learning_starts and\n t % learning_freq == 0 and\n replay_buffer.can_sample(batch_size)):\n # Here, you should perform training. Training consists of four steps:\n # 3.a: use the replay buffer to sample a batch of transitions (see the\n # replay buffer code for function definition, each batch that you sample\n # should consist of current observations, current actions, rewards,\n # next observations, and done indicator).\n # 3.b: initialize the model if it has not been initialized yet; to do\n # that, call\n # initialize_interdependent_variables(session, tf.global_variables(), {\n # obs_t_ph: obs_t_batch,\n # obs_tp1_ph: obs_tp1_batch,\n # })\n # where obs_t_batch and obs_tp1_batch are the batches of observations at\n # the current and next time step. The boolean variable q_model_initialized\n # indicates whether or not the model has been initialized.\n # Remember that you have to update the target network too (see 3.d)!\n # 3.c: train the model. To do this, you'll need to use the train_fn and\n # total_error ops that were created earlier: total_error is what you\n # created to compute the total Bellman error in a batch, and train_fn\n # will actually perform a gradient step and update the network parameters\n # to reduce total_error. When calling session.run on these you'll need to\n # populate the following placeholders:\n # obs_t_ph\n # act_t_ph\n # rew_t_ph\n # obs_tp1_ph\n # done_mask_ph\n # (this is needed for computing total_error)\n # learning_rate -- you can get this from optimizer_spec.lr_schedule.value(t)\n # (this is needed by the optimizer to choose the learning rate)\n # 3.d: periodically update the target network by calling\n # session.run(update_target_fn)\n # you should update every target_update_freq steps, and you may find the\n # variable num_param_updates useful for this (it was initialized to 0)\n #####\n \n # YOUR CODE HERE\n\n # step a\n obs_t_batch, act_t_batch, rew_t_batch, obs_tp1_batch, done_mask_batch, opa_batch = replay_buffer.sample(batch_size)\n\n # step b\n if not q_model_initialized:\n session.run(update_target_fn)\n q_model_initialized = True\n\n # step c --also log cost(loss) TODO: off-policy update q_omega & termination\n # run_list = [train_fn, total_error_q]\n run_list = []\n feed_dict = {\n obs_t_ph: obs_t_batch[..., -input_history_len:],\n act_t_ph: act_t_batch,\n rew_t_ph: rew_t_batch,\n obs_tp1_ph: obs_tp1_batch[..., -input_history_len:],\n done_mask_ph: done_mask_batch,\n learning_rate: optimizer_spec.lr_schedule.value(t / learning_freq)\n }\n if not online_q_omega and not q_omega_uniform_sample:\n run_list.append(train_fn_omega)\n run_list.append(total_error_q_omega)\n feed_dict[opa_t_ph] = opa_batch\n\n feed_dict[learning_rate_omega] = optimizer_spec_omega.lr_schedule.value(t / learning_freq)\n # if q_omega_uniform_sample:\n # _, cost = session.run(run_list, feed_dict=feed_dict)\n # else:\n _, loss_omega = session.run(run_list, feed_dict=feed_dict)\n # Costs.append(cost)\n if not online_q_omega and q_omega_uniform_sample:\n obs_t_batch, act_t_batch, rew_t_batch, obs_tp1_batch, done_mask_batch, opa_batch = replay_buffer.sample(batch_size, opa_uniform=True)\n opa_t_batch = opa_batch\n _, loss_omega = session.run([train_fn_omega, total_error_q_omega], feed_dict={\n obs_t_ph: obs_t_batch[..., -input_history_len:],\n opa_t_ph: opa_t_batch,\n rew_t_ph: rew_t_batch,\n obs_tp1_ph: obs_tp1_batch[..., -input_history_len:],\n done_mask_ph: done_mask_batch,\n learning_rate_omega: optimizer_spec_omega.lr_schedule.value(t / learning_freq)\n })\n\n loss_omega_log.append(loss_omega)\n # step d\n if t % target_update_freq == 0 and q_model_initialized:\n num_param_updates += 1\n session.run(update_target_fn)\n\n #####\n\n ### 4. Log progress\n if (t > 0) and (t % epoch_size == 0) and (t > learning_starts):\n average_loss_omega.append(np.mean(np.array(loss_omega_log)[int(-epoch_size):]))\n average_loss_term.append(np.mean(np.array(loss_term_log)[int(-epoch_size):]))\n plt.figure(8)\n plt.plot(average_loss_omega)\n plt.grid()\n plt.savefig(log_dir + 'average_loss_omega.png')\n plt.figure(9)\n plt.plot(average_loss_term)\n plt.grid()\n plt.savefig(log_dir + 'average_loss_term.png')\n if t % 1e3 == 0 and t > 0:\n if eval_obs_array:\n if obs_random_batch is None:\n # print len(eval_obs_array)\n if len(eval_obs_array) == 1:\n if len(eval_obs_array[0]) < 6:\n obs_random_batch = np.array(eval_obs_array)[0, 0,... , -input_history_len:]\n else:\n obs_random_batch = np.array(eval_obs_array)[0, 0:100, 0,..., -input_history_len:]\n else:\n obs_random_batch = eval_obs_array[0][0]\n diff_batch = eval_obs_array[1][0]\n summary_str = session.run(merged_summary_op, feed_dict={obs_t_ph: obs_random_batch})\n summary_writer.add_summary(summary_str, t)\n # summary_str_diff = session.run(merged_summary_diff, feed_dict={obs_t_ph: diff_batch})\n # summary_writer.add_summary(summary_str_diff, t)\n # else:\n # print \"no eval_obs_array\"\n episode_rewards = get_wrapper_by_name(env, \"Monitor\").get_episode_rewards()\n if len(episode_rewards) > 0:\n mean_episode_reward = np.mean(episode_rewards[-100:])\n if len(episode_rewards) > 100:\n best_mean_episode_reward = max(best_mean_episode_reward, mean_episode_reward)\n if t % LOG_EVERY_N_STEPS == 0 and q_model_initialized:\n last_t, last_time = running_time\n new_t , new_time = t / LOG_EVERY_N_STEPS, time.time()\n running_time = [new_t, new_time]\n print \"###########################################\"\n print(\"Timestep %d\" % (t,))\n print(\"Training time per %d timesteps %.2fs\" %\n (LOG_EVERY_N_STEPS, (new_time - last_time) / (new_t - last_t)))\n print(\"mean reward (100 episodes) %f\" % mean_episode_reward)\n print(\"best mean reward %f\" % best_mean_episode_reward)\n print(\"episodes %d\" % len(episode_rewards))\n print(\"exploration %f\" % exploration.value(t / learning_freq))\n print(\"learning_rate %f\" % optimizer_spec.lr_schedule.value(t / learning_freq))\n # evaluate q functions for different rooms (log_dir should exist!)\n if t % epoch_size == 0 and log_dir != None and t > learning_starts:\n saver.save(session, log_dir + 'dqn/', global_step=t)\n if eval_obs_array:\n Q_current, U_max, Omega_max = session.run([average_Q, average_U, average_omega], feed_dict={obs_t_ph: obs_random_batch})\n print(\"evaluated q values for eval_obs_array\")\n test_q_max_log.append(Q_current)\n test_u_log.append(U_max)\n test_omega_log.append(Omega_max)\n plt.figure(10)\n plt.plot(test_u_log)\n plt.grid()\n plt.savefig(log_dir + 'test_u_max.png')\n plt.figure(11)\n plt.plot(test_omega_log)\n plt.grid()\n plt.savefig(log_dir + 'test_omega_max.png')\n else:\n print(\"no eval_obs_array! q values are not evaluated! check your config\")\n sys.stdout.flush()\n\n # tests & log cost\n # add a step: test 10000 step after 50000 step\n if t % epoch_size == 0 and log_dir != None and q_model_initialized:\n\n # test Q_omega and beta\n option_activated_test = False\n option_running_test = None\n last_obs_test1 = env_test1.reset()\n replay_buffer_test1.store_frame(last_obs_test1)\n h = 0\n episode_num1 = 1\n test_step1 = 0\n done_test1 = False\n next_recent_obs_test = None\n while test_step1 < 5000 or done_test1 == False:\n if next_recent_obs_test is not None:\n recent_obs_test = next_recent_obs_test\n else:\n recent_obs_test = replay_buffer_test1.encode_recent_observation()\n # pick an option\n if not option_activated_test:\n if random.random() > 0.05:\n q_omega_test = session.run(q_omega_current,\n {obs_t_ph: recent_obs_test[None, ..., -input_history_len:]})\n option_running_test = np.argmax(q_omega_test)\n else:\n option_running_test = random.choice(range(num_options))\n option_activated_test = True\n\n # choose action\n action_test1 = options[option_running_test].act(recent_obs_test)\n\n new_obs_test, r_test1, done_test1, _ = env_test1.step(action_test1)\n h += 1\n test_step1 += 1\n if done_test1:\n # option_activated_test = False\n reward = r_test1 * (gamma ** h)\n h = 0\n # summary_str1 = session.run(merged_summary_op1, feed_dict={Episode_reward: reward})\n # summary_writer.add_summary(summary_str1, global_step=Episode_num)\n Episode_num += 1\n if test_step1 < 5000:\n new_obs_test = env_test1.reset()\n episode_num1 += 1\n\n replay_buffer_test1.store_frame(new_obs_test)\n next_recent_obs_test = replay_buffer_test1.encode_recent_observation()\n term_probs_test = session.run(term_next_current,\n {obs_tp1_ph: next_recent_obs_test[None, ..., -input_history_len:]})\n if done_test1 or not random.random() > term_probs_test[0][option_running_test]: # will re-pick an option\n option_activated_test = False\n\n episode_rewards_test1 = get_wrapper_by_name(env_test1, \"Monitor\").get_episode_rewards()\n episode_lengths_test1 = get_wrapper_by_name(env_test1, \"Monitor\").get_episode_lengths()\n evaluation_metric1 = np.array(episode_rewards_test1) * (gamma ** np.array(episode_lengths_test1))\n test_reward1 = np.mean(evaluation_metric1)\n none_discount_average1 = np.mean(episode_rewards_test1)\n none_discount1.append(none_discount_average1)\n short_average1.append(np.mean(evaluation_metric1[-episode_num1:]))\n short_average_none1.append(np.mean(episode_rewards_test1[-episode_num1:]))\n test_rewards1.append(test_reward1)\n plt.figure(12)\n plt.plot(test_rewards1)\n plt.grid()\n plt.savefig(log_dir + 'test_rewards1.png')\n plt.figure(13)\n plt.plot(none_discount1)\n plt.grid()\n plt.savefig(log_dir + 'none_discount1.png')\n plt.figure(14)\n plt.plot(short_average1)\n plt.grid()\n plt.savefig(log_dir + 'short_average1.png')\n plt.figure(15)\n plt.plot(short_average_none1)\n plt.grid()\n plt.savefig(log_dir + 'short_average_none1.png')\n plt.figure(1)\n plt.plot(evaluation_metric1)\n plt.grid()\n plt.savefig(log_dir + 'episode_reward.png')\n\n with open(log_dir + '/pkl/test_rewards1.pkl', 'wb') as output:\n pickle.dump(test_rewards1, output)\n with open(log_dir + '/pkl/none_discount1.pkl', 'wb') as output:\n pickle.dump(none_discount1, output)\n with open(log_dir + '/pkl/short_average1.pkl', 'wb') as output:\n pickle.dump(short_average1, output)\n with open(log_dir + '/pkl/short_average_none1.pkl', 'wb') as output:\n pickle.dump(short_average_none1, output)\n with open(log_dir + '/pkl/episode_reward.pkl', 'wb') as output:\n pickle.dump(evaluation_metric1, output)\n with open(log_dir + '/pkl/test_omega_log.pkl', 'wb') as output:\n pickle.dump(test_omega_log, output)","def learn(self, experiences, gamma):\n \n states, actions, rewards, next_states, dones = experiences\n\n # Get max predicted Q values (for next states) from target model\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def initiate_agent(self, env):\n from keras import Sequential\n from keras.optimizers import Adam\n from keras.layers import Dense, Dropout\n from rl.memory import SequentialMemory\n from rl.agents import DQNAgent\n\n self.env = env\n\n nb_actions = self.env.action_space.n\n\n model = Sequential()\n model.add(Dense(512, activation='relu', input_shape=env.observation_space))\n model.add(Dropout(0.2))\n model.add(Dense(512, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(512, activation='relu'))\n model.add(Dropout(0.2))\n model.add(Dense(nb_actions, activation='linear'))\n\n # Finally, we configure and compile our agent. You can use every built-in Keras optimizer and\n # even the metrics!\n memory = SequentialMemory(limit=memory_limit, window_length=window_length)\n policy = TrumpPolicy()\n from rl.core import Processor\n\n class CustomProcessor(Processor):\n \"\"\"he agent and the environment\"\"\"\n\n def process_state_batch(self, batch):\n \"\"\"\n Given a state batch, I want to remove the second dimension, because it's\n useless and prevents me from feeding the tensor into my CNN\n \"\"\"\n return np.squeeze(batch, axis=1)\n\n def process_info(self, info):\n processed_info = info['player_data']\n if 'stack' in processed_info:\n processed_info = {'x': 1}\n return processed_info\n\n nb_actions = env.action_space.n\n\n self.dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=nb_steps_warmup,\n target_model_update=1e-2, policy=policy,\n processor=CustomProcessor(),\n batch_size=batch_size, train_interval=train_interval, enable_double_dqn=enable_double_dqn)\n self.dqn.compile(Adam(lr=1e-3), metrics=['mae'])","def interact(env, agent, num_episodes=30, window=1):\r\n # initialize average rewards\r\n average_reward_per_100_episodes = []\r\n best_average_reward_per_100_episodes = []\r\n avg_rewards = deque(maxlen=num_episodes)\r\n # initialize best average reward\r\n best_avg_reward = -math.inf\r\n # initialize monitor for most recent rewards\r\n samp_rewards = deque(maxlen=window)\r\n\r\n\r\n answer = input(\"Load QTable? (y/n) ?\")\r\n if answer == \"y\":\r\n # Do this.\r\n an = input(\"Name ?\")\r\n agent.q_table.readQ(an)\r\n agent.q_table.readStateList(an)\r\n agent.observation_space = np.size(agent.q_table.q, 0)\r\n agent.q_table.stateCount = len(agent.q_table.stateList)\r\n #print(\"files not found\")\r\n elif answer == \"n\":\r\n # Do that.\r\n pass\r\n else:\r\n print(\"Please enter y or n\")\r\n\r\n start_time = time.time()\r\n # for each episode\r\n for i_episode in range(1, num_episodes+1):\r\n # begin the episode\r\n state_array,state, state_with_act = env.reset()\r\n #if state <= agent.q_table.observation_space -1:\r\n #print('next state is in q table')\r\n y = agent.q_table.addStateList(state_with_act[state][4], state_with_act[state][1], state_with_act[state][2])\r\n if y != -1:\r\n print (\"state is in the stateList\")\r\n else : \r\n #agent.addState(state)\r\n y= agent.q_table.stateCount\r\n # initialize the sampled reward\r\n samp_reward = 0\r\n while True:\r\n #print(\"new action starts\")\r\n # agent selects an action\r\n action = agent.select_action(y)\r\n # agent performs the selected action\r\n next_state, reward,done, indices, stateENV, action_count = env.step(action)\r\n time.sleep(0.3)\r\n #print(\"indices =\")\r\n #print(indices)\r\n # agent performs internal updates based on sampled experience\r\n \r\n #if next_state <= agent.q_table.observation_space -1:\r\n #print('next state is in q table')\r\n x = agent.q_table.addStateList(stateENV[next_state][4], stateENV[next_state][1], stateENV[next_state][2])\r\n if x != -1:\r\n print (\"state is in the stateList\")\r\n else : \r\n #agent.addState(state)\r\n x= agent.q_table.stateCount\r\n #print (\"next state =\"+str(next_state))\r\n #print (\"observation_space\" + str(agent.q_table.observation_space-1))\r\n #agent.step(state, action, reward, next_state, indices)\r\n agent.step(y, action, reward, x, indices)\r\n #print('stateList = ')\r\n #print(agent.q_table.stateList)\r\n # update the sampled reward\r\n samp_reward += reward\r\n # update the state (s <- s') to next time step\r\n y = x\r\n agent.update_epsilon()\r\n if done:\r\n # save final sampled reward\r\n samp_rewards.append(samp_reward)\r\n break\r\n \r\n lenStateCOunt = len(agent.q_table.stateList)\r\n time_end = time.time()\r\n saveEpisodeResult(start_time,time_end,i_episode, lenStateCOunt)\r\n\r\n\r\n \r\n\r\n if (i_episode >= 100):\r\n # get average reward from last 100 episodes\r\n avg_reward = np.mean(samp_rewards)\r\n # append to deque\r\n avg_rewards.append(avg_reward)\r\n # update best average reward\r\n print('episode average reward {}'.format(avg_reward))\r\n average_reward_per_100_episodes.append(avg_reward)\r\n best_average_reward_per_100_episodes.append(best_avg_reward)\r\n if avg_reward > best_avg_reward:\r\n best_avg_reward = avg_reward\r\n print (\"State with activities =\")\r\n for key,value in stateENV.items():\r\n print(str(key) + '. ')\r\n print(str(stateENV[key][0]) + ', ' + str(stateENV[key][1])+ ', ' + str(stateENV[key][2]) + ', ' + str(stateENV[key][4]))\r\n \r\n # monitor progress\r\n print(\"\\rEpisode {}/{} || Best average reward {} || eps {} \".format(i_episode, num_episodes, best_avg_reward, agent.epsilon), end=\"\")\r\n sys.stdout.flush()\r\n \r\n # check if task is solved (according to OpenAI Gym)\r\n if best_avg_reward >= 9.7:\r\n print('\\nEnvironment solved in {} episodes.'.format(i_episode), end=\"\")\r\n agent.q_table.saveQ(best_avg_reward,appName)\r\n agent.q_table.saveStateList(appName)\r\n print(\"width = \"+ str(action_count))\r\n saveEpToCSV()\r\n save_rewards_csv(average_reward_per_100_episodes, best_average_reward_per_100_episodes)\r\n break\r\n if i_episode == num_episodes: \r\n agent.q_table.saveQ(best_avg_reward,appName)\r\n agent.q_table.saveStateList(appName)\r\n print(\"width = \"+ str(action_count))\r\n saveEpToCSV()\r\n save_rewards_csv(average_reward_per_100_episodes, best_average_reward_per_100_episodes)\r\n print('\\n')\r\n\r\n end_time = time.time()\r\n time_lapsed = end_time - start_time\r\n time_convert(time_lapsed)\r\n return avg_rewards, best_avg_reward\r\n print(\"width = \"+ str(action_count))","def getAction1(self, state):\n action = QLearningAgent.getAction1(self,state)\n################################################################################################################################ Eric Changed Stuff Below\n #print \"ACTION IN PACMANQAGENT: \", action\n self.doAction(state,action)\n return action","def q_learning(env, agent, num_episodes, batch_size, epsilon, epsilon_min, epsilon_decay, folder):\n \n # Keeps track of useful statistics\n stats = plotting.EpisodeStats(\n episode_lengths=np.zeros(num_episodes),\n episode_rewards=np.zeros(num_episodes))\n\n\n for i_episode in range(num_episodes):\n if epsilon > epsilon_min and i_episode > 500:\n # complete random exploration 500 episodes, \n # then decrase exploration till epsilon less than epsilon_min\n epsilon *= epsilon_decay\n sys.stdout.flush()\n\n state = env.reset()\n state = np.reshape(state, [1, env.nS])\n\n \n for t in range(MAX_STEP):\n\n ## Decide action\n action = agent.act(state, epsilon)\n ## Advance the game to the next frame based on the action\n next_state, reward, done, _ = env.step(action)\n\n env.my_render(folder)\n\n stats.episode_rewards[i_episode] += reward\n stats.episode_lengths[i_episode] = t+1\n\n next_state = np.reshape(next_state, [1, env.nS])\n ## Remember the previous state, action, reward, and done\n agent.remember(state, action, reward, next_state, done)\n ## make next_state the new current state for the next frame.\n state = next_state ## change to copy.copy(next_state), if it is a array\n\n if len(agent.memory) > batch_size:\n agent.replay(batch_size) \n\n if done: \n break\n \n mean_score = stats.episode_rewards[i_episode]/stats.episode_lengths[i_episode]\n print(\"episode: {}/{}, score: {}, e: {:.2}, steps:{}, mean score:{:.2}\"\n .format(i_episode, num_episodes, stats.episode_rewards[i_episode], epsilon, \n stats.episode_lengths[i_episode], \n mean_score))\n #if(i_episode > 200):\n write_csv(folder, i_episode, stats.episode_lengths[i_episode], mean_score)\n if(i_episode%50 == 0):\n agent.save(folder + \"_qn\" + str(i_episode) + \".h5\") \n agent.save(folder + \"_qn-final\" + \".h5\") \n\n return stats","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n # print('learn states.shape', states.shape)\n # print('learn next_states.shape', next_states.shape)\n \n q_expected, q_targets = self.get_target_and_expected(states, \n actions, \n rewards, \n next_states, \n dones, \n gamma)\n\n\n # Compute loss\n loss = F.mse_loss(q_expected, q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def __init__(self,\n sess,\n num_actions,\n observation_shape=base_dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,\n gamma=0.99,\n update_horizon=1,\n min_replay_history=20000,\n update_period=4,\n target_update_period=8000,\n epsilon_fn=linearly_decaying_epsilon,\n epsilon_train=0.01,\n epsilon_eval=0.001,\n epsilon_decay_period=250000,\n tf_device='/cpu:*',\n use_staging=True,\n max_tf_checkpoints_to_keep=3,\n optimizer=tf.train.RMSPropOptimizer(\n learning_rate=0.00025,\n decay=0.95,\n momentum=0.0,\n epsilon=0.00001,\n centered=True),\n summary_writer=None,\n summary_writing_frequency=500,\n clip_reward=False):\n self._clip_reward = clip_reward\n self.intrinsic_model = intrinsic_rewards.RNDIntrinsicReward(\n sess=sess,\n tf_device=tf_device,\n summary_writer=summary_writer)\n super(RNDDQNAgent, self).__init__(\n sess=sess,\n num_actions=num_actions,\n observation_shape=observation_shape,\n gamma=gamma,\n update_horizon=update_horizon,\n min_replay_history=min_replay_history,\n update_period=update_period,\n target_update_period=target_update_period,\n epsilon_fn=epsilon_fn,\n epsilon_train=epsilon_train,\n epsilon_eval=epsilon_eval,\n epsilon_decay_period=epsilon_decay_period,\n tf_device=tf_device,\n use_staging=use_staging,\n optimizer=optimizer,\n summary_writer=summary_writer,\n summary_writing_frequency=summary_writing_frequency)","def learn(self):\n Qsa = self.evalQsa(self.features)[self.chosenA]\n print Qsa\n dQ = self.alpha*(self.reward + self.gamma * self.maxQsa(self.next_features) - Qsa)\n self.thetas += dQ*self.features[:,self.chosenA]\n print self.thetas\n # self.thetas /= np.sqrt(np.sum(np.power(self.thetas,2)))","def learn(self):\r\n last_experience = self.memory[-1]\r\n Q_target = np.zeros(self.action_size)\r\n Q_target[last_experience[1]] = last_experience[2]\r\n self.model.fit(last_experience[0], Q_target[None,:], epochs=5, verbose=0)\r\n minibatch = random.sample(self.memory, self.minibatch_size)\r\n for obs, action, reward, next_obs, done in minibatch:\r\n Q_target = np.zeros(self.action_size)\r\n if done:\r\n Q_target[action] = reward\r\n if not done:\r\n Q_target[action] = reward + self.gamma*np.amax(self.model.predict(next_obs)[0])\r\n self.model.fit(obs, Q_target[None,:], epochs=1, verbose=0)\r\n if (self.epsilon > self.epsilon_min):\r\n self.epsilon *= self.epsilon_decay","def __init__(self, state_size, action_size, fc1_units, fc2_units, buffer_size, batch_size, alpha, gamma, tau,\n local_update_every, target_update_every, seed, a, b, b_increase, b_end, dbl_dqn=False, priority_rpl=False, duel_dqn=False):\n self.state_size = state_size\n self.action_size = action_size\n self.seed = random.seed(seed)\n\n # Hyperparameters\n self.alpha = alpha # Learning rate\n self.gamma = gamma # Discount parameter\n self.tau = tau # Interpolation parameter\n self.local_update_every = local_update_every # Number of actions to take before updating local net weights\n self.target_update_every = target_update_every # Number of actions to take before updating target net weights\n self.batch_size = batch_size # Number of experiences to sample during learning\n self.buffer_size = buffer_size # Size of memory buffer\n self.a = a # Sampling probability (0=random | 1=priority)\n self.b = b # Influence of importance sampling weights over learning\n self.b_increase = b_increase # Amount to increase b by every learning step\n self.b_end = b_end # Maximum value for b\n\n # Agent modifications\n self.dbl_dqn = dbl_dqn # Double Q Learning\n self.priority_rpl = priority_rpl # Prioritised Experience Replay\n self.duel_dqn = duel_dqn # Duelling Q Networks\n\n # Q-Network\n if self.duel_dqn:\n self.qnetwork_local = DuellingQNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\n self.qnetwork_target = DuellingQNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\n else:\n self.qnetwork_local = QNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\n self.qnetwork_target = QNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\n self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=self.alpha)\n\n # Replay memory\n self.memory = ReplayBuffer(action_size, buffer_size, batch_size, seed, priority_rpl)\n # Initialize time step (for updating every local_update_every/target_update_every steps)\n self.t_step = 0","def __init__(self, epsilon=0.05, gamma=0.95, alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n self.index = 0 # This is always Pacman\n PQLearningAgent.__init__(self, **args)","def rl_alone(episodes = 1000, fill_table = False):\n path = os.getcwd()\n grid = AdvGridworld()\n os.chdir(path)\n print(grid.name + ' with Q-Learning Agent')\n gamma = 0.95\n learning_rate = 0.01\n agent = QLearning(8, gamma, learning_rate)\n\n liRewards = []\n\n #action_index = {\"up\":0,\"right\":1,\"down\":2,\"left\":3,\"upri\":4,\"dori\":5,\"dole\":6,\"uple\":7}\n\n for i in range(episodes):\n grid.reset()\n state = grid.state\n width = grid.getBoardDim()[0]\n while not grid.isEnd:\n state_ind = state[1]*(width+1)+state[0]\n #If we want a filled Q-tables, we can't let the agent be optimal\n #or else we wouldn't know the q-values for never reached state-action pairs\n if fill_table:\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\n action = np.random.choice(actions, 1)[0]\n else:\n action = agent.get_action(state_ind)\n next_state, reward, is_end = grid.step(action)\n next_state_ind = next_state[1]*(width+1)+next_state[0]\n agent.train(state_ind, action, reward, next_state_ind)\n state = next_state\n\n liRewards.append(grid.reward)\n rewards = np.array(liRewards)\n print(\"Rewards Info for \", episodes, ' Episodes')\n print('Size', rewards.size)\n print('Mean', np.mean(rewards, axis=0))\n print('Stdev', np.std(rewards, axis=0))\n print('Min', np.min(rewards))\n print('Max', np.max(rewards))\n\n return rewards, agent","def q_learning_episode(self, policy):\n state = self.env.reset(self.agent_start_pos)\n done = False\n\n while not done:\n action = policy(state, self.q_values)\n next_cell = self.env.move(self.env.agent_position, action)\n s_next, rew, done, _ = self.env.step(next_cell)\n greedy_action_next = actions_dict[np.argmax(self.q_values[s_next])]\n self.update_q_values(state, action, rew, s_next, greedy_action_next)\n state = s_next","def learn(self, experiences, gamma):\n self.optimizer.zero_grad()\n\n states, actions, rewards, next_states, dones = experiences\n\n best_actions = self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)\n q_values_target = self.qnetwork_target(next_states).detach()\n q_expected = rewards + (gamma * q_values_target.gather(1, best_actions)) * (1 - dones)\n q_current = self.qnetwork_local(states).gather(1, actions)\n\n loss = F.mse_loss(q_expected, q_current)\n\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, dqn_agent.TAU)","def __init__(self, n_trials, v0, n_options, probs, r_mag, l_mag, params, gamble, \\\n\t\tUCB=False, UCB_samplemean=False, gamma=0, anneal=False):\n\n\t\tsz = n_trials\n\t\tself.n_options = n_options\t\t\t\t\t# number of choices\n\t\tself.Q = np.zeros((sz+1,n_options)) +\tv0\t# critic\n\t\tself.alpha, self.beta = params\t\t\t\t# learning rate, softmax\n\t\tself.SM = np.zeros((sz, n_options))\t\t# Softmax values\n\t\tself.rho = np.zeros(sz)\t\t\t\t\t\t# DA at choice\n\t\tself.C = np.zeros(sz,dtype=np.int)\t\t\t# choice\n\t\tself.R = np.zeros(sz,dtype=np.int)\t\t\t# indicator variable of reward\n\t\tself.probs = probs\t\t\t\t\t\t\t# prob of reward for choice\n\t\tself.r_mag = r_mag\t\t\t\t\t\t\t# magnitude of reward for choice\n\t\tself.l_mag = l_mag\t\t\t\t\t\t\t# magnitude of loss for choice\n\t\tself.PE = np.zeros(sz)\t\t\t\t\t\t# choice PE\n\t\tself.idx = 0\t\t\t\t\t\t\t\t# idx of trial in state \n\t\tself.gamble = gamble\t\t\t\t\t\t# gamble paradigm?\n\t\tself.UCB = UCB\t\t\t\t\t\t\t\t# Use UCB for policy?\t\n\t\tself.UCB_samplemean = UCB_samplemean\t\t# Use sample mean instead of Q value\n\t\tself.gamma = gamma\t\t\t\t\t\t\t# Exploration parameter\t\n\t\tself.N = np.zeros((sz+1, n_options))\t\t# number of times action selected\n\t\tself.R_by_a = np.zeros((sz+1, n_options))\t# number of times rewarded for action\n\t\tself.Acts = np.zeros((sz+1,n_options))\t\t# act values","def train_q_learner(board: Board, num_rounds: int,\n ignorance_bias: float = 0,\n discount_rate: float = 0.9,\n learning_rate: float = 0.1,\n title: str = '') -> dict:\n labels = [DRAW, TabularQLearning.name, Random.name]\n outcome_counts = {label: 0 for label in labels}\n percentages = {label: [] for label in labels}\n q_table_a = None\n #q_table_b = None\n for idx in range(num_rounds):\n board_clone = board.clone()\n q_learning_agent = TabularQLearning(board_clone, player_idx=0,\n q_table_a=q_table_a,\n #q_table_b=q_table_b,\n use_double_q_table=True,\n ignorance_bias=ignorance_bias,\n discount_rate=discount_rate,\n learning_rate=learning_rate,\n #counter=idx,\n #max_counter=num_rounds\n )\n random_agent = Random(board_clone, player_idx=1)\n outcome = play_mnk(board_clone, q_learning_agent, random_agent, verbose=False)\n outcome_counts[outcome] += 1\n q_table_a = q_learning_agent.q_table_a\n #q_table_b = q_learning_agent.q_table_b\n\n total = sum(outcome_counts.values())\n for label in labels:\n percentages[label].append(outcome_counts[label] / total)\n\n x_axis = list(range(num_rounds))[PLOT_DELAY:]\n for label in labels:\n plt.plot(x_axis, percentages[label][PLOT_DELAY:], label=label)\n plt.title(title)\n plt.legend()\n plt.show()\n return percentages","def q_learning_minibatch(self):\n if self.experience.count <= self.history_length:\n # Cannot train because not enough experiences.\n return [], 0, False\n else:\n # Sample experience.\n s_t, action, reward, s_t_plus_1, terminal = self.experience.sample()\n\n terminal = np.array(terminal) + 0.\n\n # Predicted and target q-values for time t+1.\n max_q_t_plus_1 = self.target_network.eval_max_outputs(s_t_plus_1)\n target_q_t = (1. - terminal) * self.discount_r * max_q_t_plus_1 + reward\n\n # Run training ops.\n _, q_t, loss = self.sess.run([self.optim, self.pred_network.outputs, self.loss], {\n self.targets: target_q_t,\n self.actions: action,\n self.pred_network.inputs: s_t,\n })\n\n return q_t, loss, True","def __init__(self, state_size, action_size, **kwargs):\n super(DQNAgent, self).__init__(state_size, action_size, **kwargs)\n self.state_size = state_size\n self.action_size = action_size\n\n # Q-Network\n self.main_network = DQN(state_size, action_size).to(device)\n self.target_network = DQN(state_size, action_size).to(device)\n self.optimizer = optim.Adam(self.main_network.parameters(), lr=LR)\n\n # Replay memory\n self.memory = Replay(BUFFER_SIZE, BATCH_SIZE)\n\n # Initialize time step (for updating every UPDATE_EVERY steps)\n self.t_step = 0","def experience_replay(self):\n s,a,r,sp,done = self.memory.sample(self.batch_size)\n # TODO: 5 lines missing.\n raise NotImplementedError(\"\")\n self.Q.fit(s, target=target)","def Q_learning_train(env,alpha,gamma,epsilon,episodes):\n %time\n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n if random.uniform(0, 1) < epsilon:\n action = env.action_space.sample() # Explore action space randomly\n else:\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n\n next_state, reward, done, info = env.step(action) \n\n old_value = q_table[state, action]\n next_max = np.max(q_table[next_state])\n\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\n q_table[state, action] = new_value\n\n if reward == -10:\n penalties += 1\n \n\n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n rewards.append(np.sum(episode_rewards))\n \n if i % 1000 == 0:\n clear_output(wait=True)\n print(f\"Episode: {i}\")\n \n \n print(\"Training finished.\\n\")\n \n plt.plot(savgol_filter(rewards, 1001, 3, mode = \"interp\"))\n plt.title(\"Smoothened training reward per episode\", pad = 30, size = BIGGER_SIZE)\n plt.legend()\n plt.xlabel('Episodes', labelpad = 20);\n plt.ylabel('Total Reward', labelpad = 20);\n plt.tick_params(axis='both', which='major');\n plt.tick_params(axis='both', which='minor');\n #plt.xlim(0, 60000);\n #plt.ylim(0,50)\n #plt.xticks(np.arange(0, episodes+1, 5000));\n #plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));","def learn(self):\n pass","def learn(self):\n pass","def q_learn(scores, num_timesteps, sarsa=False, gamma=0.99):\n\n # Per-timestep non-discounted rewards\n rewards = [tf.placeholder(tf.float32, (None,), name=\"rewards_%i\" % t)\n for t in range(num_timesteps)]\n # Mask learning for those examples which stop early\n masks = [tf.placeholder(tf.float32, (None,), name=\"mask_%i\" % t)\n for t in range(num_timesteps)]\n\n # By default, actions are just argmax; this can/should be overridden\n actions = [tf.to_int32(tf.argmax(scores_t, 1), name=\"actions_%i\" % t)\n for t, scores_t in enumerate(scores)]\n\n # metadata\n batch_size = tf.shape(scores[0])[0]\n n_actions = tf.shape(scores[0])[1]\n\n # Q(s, a) for states visited, actions taken\n # easiest to do this lookup as Gather on a flattened scores array\n q_a_pred = [tf.gather(tf.reshape(scores_t, (-1,)),\n actions_t + tf.range(batch_size) * n_actions)\n for scores_t, actions_t in zip(scores, actions)]\n # max_a' Q(s, a') for states visited\n q_max_pred = [tf.reduce_max(scores_t, 1) for scores_t in scores]\n\n q_targets = []\n for t in range(num_timesteps):\n target = rewards[t]\n if t < num_timesteps - 1:\n # Bootstrap with Q-learning or SARSA update\n backup = q_a_pred[t + 1] if sarsa else q_max_pred[t + 1]\n target += gamma * backup\n\n q_targets.append(target)\n\n # Summary: mean and variance of Q targets at this timestep\n targets_mean, targets_var = tf.nn.moments(target, [0])\n tf.scalar_summary(\"q/%i/target/mean\" % t, targets_mean)\n tf.scalar_summary(\"q/%i/target/var\" % t, targets_var)\n\n # Summary: mean and variance of predicted Q values for optimal\n # actions at this timestep\n q_a_pred_mean, q_a_pred_var = tf.nn.moments(q_a_pred[t], [0])\n tf.scalar_summary(\"q/%i/pred_max/mean\" % t, q_a_pred_mean)\n tf.scalar_summary(\"q/%i/pred_max/var\" % t, q_a_pred_var)\n\n # Summary: mean and variance of all Q values in batch\n q_pred_mean, q_pred_var = tf.nn.moments(scores[t], [0, 1])\n tf.scalar_summary(\"q/%i/pred/mean\" % t, q_pred_mean)\n tf.scalar_summary(\"q/%i/pred/var\" % t, q_pred_var)\n\n losses = [tf.reduce_mean(tf.square(mask_t * (q_target_t - q_a_pred_t)))\n for q_target_t, q_a_pred_t, mask_t\n in zip(q_targets, q_a_pred, masks)]\n loss = tf.add_n(losses) / float(len(losses))\n\n tf.scalar_summary(\"loss\", loss)\n\n inputs = (actions, rewards, masks)\n outputs = (losses, loss)\n return inputs, outputs","def __init__(self,\n sess,\n num_actions,\n observation_shape=base_dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,\n observation_dtype=base_dqn_agent.NATURE_DQN_DTYPE,\n stack_size=base_dqn_agent.NATURE_DQN_STACK_SIZE,\n network=base_dqn_agent.nature_dqn_network,\n gamma=0.99,\n update_horizon=1,\n min_replay_history=20000,\n update_period=4,\n target_update_period=8000,\n epsilon_fn=linearly_decaying_epsilon,\n epsilon_train=0.01,\n epsilon_eval=0.001,\n epsilon_decay_period=250000,\n tf_device='/cpu:*',\n use_staging=True,\n max_tf_checkpoints_to_keep=3,\n optimizer=tf.train.RMSPropOptimizer(\n learning_rate=0.00025,\n decay=0.95,\n momentum=0.0,\n epsilon=0.00001,\n centered=True),\n summary_writer=None,\n summary_writing_frequency=500):\n self.intrinsic_model = intrinsic_rewards.PixelCNNIntrinsicReward(sess=sess)\n super(PixelCNNDQNAgent, self).__init__(\n sess=sess,\n num_actions=num_actions,\n observation_shape=observation_shape,\n observation_dtype=observation_dtype,\n stack_size=stack_size,\n network=network,\n gamma=gamma,\n update_horizon=update_horizon,\n min_replay_history=min_replay_history,\n update_period=update_period,\n target_update_period=target_update_period,\n epsilon_fn=epsilon_fn,\n epsilon_train=epsilon_train,\n epsilon_eval=epsilon_eval,\n epsilon_decay_period=epsilon_decay_period,\n tf_device=tf_device,\n use_staging=use_staging,\n optimizer=optimizer,\n summary_writer=summary_writer,\n summary_writing_frequency=summary_writing_frequency)","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # Double DQN. Uses local network for action selection and target network for value estimation\n # see: https://arxiv.org/pdf/1509.06461.pdf\n Q_actions_next = self.dqn_local(next_states).detach().argmax(1).unsqueeze(1)\n Q_targets_next = self.dqn_target(next_states).gather(1, Q_actions_next)\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n # Standard DQN\n # Get max predicted Q values (for next states) from target model\n # Q_targets_next = self.dqn_target(next_states).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states\n # Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.dqn_local(states).gather(1, actions)\n\n # Compute loss\n loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.dqn_local, self.dqn_target, TAU)","def learn(self, experiences, gamma):\n states, actions, rewards, next_states = experiences\n\n # Get max predicted Q values (for next states) from target model\n next_action_targets = self.target_model(next_states)\n next_action = next_action_targets.max(1)[0].unsqueeze(-1)\n targets = rewards + (gamma * torch.Tensor(next_action))\n#\n # Get expected Q values from policy model\n action_policy = self.policy_model(states)\n policy = action_policy.gather(1, actions)\n # Compute loss\n loss = F.mse_loss(policy, targets)\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.policy_model, self.target_model, self.tau)","def trainAgent(self):\r\n\t\tfor episode in range(self.TOT_EPISODES):\r\n\t\t\t#reset environment, stacked frames every episode.\r\n\t\t\tstate = self.env.reset()\r\n\t\t\trewards = 0\r\n\t\t\t#preprocess and stack the frame/state.\r\n\t\t\tstate, self.stacked_frames = stack_frames(self.stack_size,\r\n\t\t\t\t\t\t\t\t\tself.stacked_frames, state, True)\r\n\t\t\t\r\n\t\t\tfor step in range(self.MAX_STEPS):\r\n\t\t\t#for every step in episode:\r\n\t\t\t\r\n\t\t\t\tif (step%100==0):\r\n\t\t\t\t\tprint(\"Episode No.: \", episode, \"Step No.: \", step)\r\n\t\t\t\t\r\n\t\t\t\t#agent acts - explores or exploitation of the model\r\n\t\t\t\taction = self.dqn.predictAction(state)\r\n\t\t\t\t#reduce epsilon for more exploitation later.\r\n\t\t\t\tself.dqn.decayEpsilon()\r\n\t\t\t\t#Perform the action and get the next_state, reward, and done vals.\r\n\t\t\t\tnext_state, reward, done, _ = self.env.step(action)\r\n\t\t\t\t#append this state to the frame. Pass the previous stacked frame.\r\n\t\t\t\tnext_state, self.stacked_frames = stack_frames(self.stack_size,\r\n\t\t\t\t\t\t\t\t\t\tself.stacked_frames, next_state, False)\r\n\t\t\t\trewards+=reward\r\n\t\t\t\t\r\n\t\t\t\t#add this experience into memory (experience buffer)\r\n\t\t\t\tself.dqn.remember(state, action, reward, next_state, done)\r\n\t\t\t\t\r\n\t\t\t\tstate = next_state\r\n\t\t\t\t\r\n\t\t\t\tif done:\r\n\t\t\t\t\tprint(\"took %d steps\" %step)\r\n\t\t\t\t\tprint(\"Earned a total of reward equal to \", rewards)\r\n\t\t\t\t\tbreak\r\n\t\t\t\r\n\t\t\t\t# TRAIN\r\n\t\t\t\tself.dqn.replay()\r\n\t\t\t\t#sync target_model and model weights every 10k steps.\r\n\t\t\t\tif step % 10000 == 9999:\r\n\t\t\t\t\tself.dqn.target_train()\r\n\t\t\t\r\n\t\t\t# Save the network every 1000 iterations\r\n\t\t\tif episode % 5 == 4:\r\n\t\t\t\tprint(\"Saving Network\")\r\n\t\t\t\tself.dqn.save_network(self.path)","def Q_learning_test(env,alpha,gamma,episodes, q_table):\n %time\n \n # For plotting metrics\n all_epochs = []\n all_penalties = []\n rewards = []\n \n total_reward = 0\n \n for i in range(1, episodes+1):\n state = env.reset()\n episode_rewards = []\n\n epochs, penalties, reward, = 0, 0, 0\n done = False\n\n while not done:\n \n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\n next_state, reward, done, info = env.step(action) \n\n\n if reward == -10:\n penalties += 1\n \n state = next_state\n episode_rewards.append(reward)\n epochs += 1\n \n if done == True:\n break \n if epochs == 1000:\n break \n \n total_reward += reward\n rewards.append(np.sum(episode_rewards))\n \n if i % 1000 == 0:\n clear_output(wait=True)\n print(f\"Episode: {i}\")\n\n \n print(\"Training finished.\\n\")\n \n \n plt.plot(savgol_filter(rewards, 1001, 3, mode = \"interp\"))\n plt.title(\"Smoothened testing reward per episode\", pad = 30 , size = BIGGER_SIZE)\n plt.xlabel('Episodes', labelpad = 20);\n plt.ylabel('Total Reward', labelpad = 20);\n plt.tick_params(axis='both', which='major', labelsize=16);\n plt.tick_params(axis='both', which='minor', labelsize=16);\n #plt.xlim(100000, 200000);\n #plt.ylim(0,50)\n # plt.xticks(np.arange(0, episodes+1, 5000));\n # plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));","def train(network_def, target_params, optimizer, states, actions, next_states, rewards,\n terminals, loss_weights, cumulative_gamma, target_opt, mse_inf,tau,alpha,clip_value_min, rng):\n online_params = optimizer.target\n def loss_fn(params, rng_input, target, loss_multipliers):\n def q_online(state):\n return network_def.apply(params, state, rng=rng_input)\n\n q_values = jax.vmap(q_online)(states).q_values\n q_values = jnp.squeeze(q_values)\n replay_chosen_q = jax.vmap(lambda x, y: x[y])(q_values, actions)\n \n if mse_inf:\n loss = jax.vmap(mse_loss)(target, replay_chosen_q)\n else:\n loss = jax.vmap(dqn_agent.huber_loss)(target, replay_chosen_q)\n\n mean_loss = jnp.mean(loss_multipliers * loss)\n return mean_loss, loss\n\n rng, rng2, rng3, rng4 = jax.random.split(rng, 4)\n\n def q_target(state):\n return network_def.apply(target_params, state, rng=rng2)\n\n def q_target_online(state):\n return network_def.apply(online_params, state, rng=rng4)\n\n if target_opt == 0:\n target = dqn_agent.target_q(q_target, next_states, rewards, terminals, cumulative_gamma) \n elif target_opt == 1:\n #Double DQN\n target = target_DDQN(q_target_online, q_target, next_states, rewards, terminals, cumulative_gamma)\n\n elif target_opt == 2:\n #Munchausen\n target = target_m_dqn(q_target_online, q_target, states,next_states,actions,rewards,terminals,\n cumulative_gamma,tau,alpha,clip_value_min)\n else:\n print('error')\n\n grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\n (mean_loss, loss), grad = grad_fn(online_params, rng3, target, loss_weights)\n optimizer = optimizer.apply_gradient(grad)\n return optimizer, loss, mean_loss","def __init__(self, observation_space, valid_actions: callable, q_source: QEstimator):\n super().__init__(observation_space, valid_actions)\n self.q = q_source","def learn(self, experiences, gamma):\n states_and_prev_recurrents, actions, recurrents, rewards, next_states, dones = experiences\n\n # Get max predicted Q values (for next states) from target model\n next_states_and_recurrents = torch.cat([next_states, recurrents], dim=1)\n Q_targets_next = self.qnetwork_target(next_states_and_recurrents).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states_and_prev_recurrents).gather(1, actions)\n\n # Compute loss\n loss_rl = F.mse_loss(Q_expected, Q_targets)\n\n states = states_and_prev_recurrents[:, :8]\n target_recurrents = map_observation_to_recurrent_state(states)\n recurrent_pred = self.qnetwork_local(states_and_prev_recurrents)[:, -5:]\n\n loss_internal_states = F.multilabel_soft_margin_loss(recurrent_pred, target_recurrents)\n\n loss = loss_rl + loss_internal_states\n\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)","def q_update(self):\n\n # exit if the experience buffer is not yet large enough\n if self.experience_buffer.size < self.batch_size:\n return\n \n # get the random batch\n states, action_indices, rewards, not_terminals, succ_states, succ_players, succ_legal_moves = self.experience_buffer.random_batch(self.batch_size)\n states = states.to(Globals.device)\n action_indices = action_indices.to(Globals.device)\n rewards = rewards.to(Globals.device)\n not_terminals = not_terminals.to(Globals.device)\n succ_states = succ_states.to(Globals.device)\n succ_players = succ_players.to(Globals.device)\n\n # prepare the training data\n q_values = self.target_network(succ_states)\n target = torch.empty(1, self.batch_size)\n for i in range(self.batch_size):\n if not_terminals[i] == 0:\n target[0, i] = rewards[i]\n continue\n\n if succ_players[i] == CONST.WHITE_MOVE:\n legal_q_values = q_values[0, 0:9][succ_legal_moves[i]]\n q_value, _ = legal_q_values.max(0)\n else:\n legal_q_values = q_values[0, 9:18][succ_legal_moves[i]]\n q_value, _ = legal_q_values.min(0)\n\n target[0, i] = rewards[i] + self.disc*not_terminals[i]*q_value\n\n # execute the training step of the network\n self.training_network.train_step(states, target, action_indices) # the eligibility trace is used as td target","def __init__(self,\n qnn,\n optimizer,\n session,\n state_shape,\n actions_count,\n reply_memory_size=100,\n minibatch_size=32,\n final_exploration_probability=0.05,\n exploration_period=1000,\n discount_factor=0.95,\n unrollings_num=16,\n target_freeze_period=1000,\n ):\n\n self.prediction_nn = qnn\n self.target_nn = qnn.clone()\n self.optimizer = optimizer\n\n self.state_shape = state_shape\n self.actions_count = actions_count\n\n self.experience = deque()\n self.reply_memory_size = reply_memory_size\n self.current_episode = []\n self.unrollings_num = unrollings_num\n self.minibatch_size = minibatch_size\n\n self.epsilon_initial = 1.0\n self.epsilon_final = final_exploration_probability\n self.exploration_period = exploration_period\n self.discount = discount_factor\n self.freeze_period = target_freeze_period\n\n self.action_requests = 0\n self.iteration = 0\n\n self.session = session\n\n self.build_graph()","def train_dqn(env, learn_dict, agent, log_results=True):\n scores = [] # list containing scores from each episode\n scores_window = deque(maxlen=100) # last 100 scores\n eps = learn_dict['eps_start']\n brain_name = learn_dict['brain_name']\n n_episodes=learn_dict['n_episodes']\n max_t= learn_dict['max_t']\n eps_start= learn_dict['eps_start']\n eps_end= learn_dict['eps_end']\n eps_decay= learn_dict['eps_decay']\n early_stop = learn_dict['early_stop']\n\n for i_episode in range(1, n_episodes+1):\n env_info = env.reset(train_mode=True)[brain_name] # reset the environment\n state = env_info.vector_observations[0] # get the current state\n score = 0\n for t in range(max_t):\n \n action = agent.act(state, eps).astype(int)\n env_info = env.step(action)[brain_name] # send the action to the environment\n next_state = env_info.vector_observations[0] # get the next state\n reward = env_info.rewards[0] # get the reward\n done = env_info.local_done[0] # see if episode has finished\n # have the agent learn a step\n agent.step(state, action, reward, next_state, done)\n state = next_state\n score += reward\n if done:\n break \n scores_window.append(score) # save most recent score\n scores.append(score) # save most recent score\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\n if log_results: print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\"\")\n if i_episode % 100 == 0:\n if log_results: print('\\rEpisode {}\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\n if np.mean(scores_window)>=early_stop:\n if log_results: print('\\nEnvironment solved in {:d} episodes!\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\n break\n return scores","def run(self):\n if self.pp['net']:\n space = {\n # Qlearnnet\n 'net_lr': hp.loguniform('net_lr', np.log(5e-7), np.log(1e-4)),\n 'net_lr_decay': hp.loguniform('net_lr_decay', np.log(0.90), np.log(0.99)),\n # Singh\n # 'net_lr': hp.loguniform('net_lr', np.log(1e-7), np.log(5e-4)),\n 'beta': hp.uniform('beta', 16, 30),\n # Double\n 'net_copy_iter': hp.loguniform('net_copy_iter', np.log(5), np.log(150)),\n 'net_creep_tau': hp.loguniform('net_creep_tau', np.log(0.01),\n np.log(0.7)),\n # Exp. replay\n 'batch_size': scope.int(hp.uniform('batch_size', 8, 16)),\n 'buffer_size': scope.int(hp.uniform('buffer_size', 2000, 10000)),\n # N-step\n 'n_step': scope.int(hp.uniform('n_step', 3, 40)),\n # Policy\n 'vf_coeff': hp.uniform('vf_coeff', 0.005, 0.5),\n 'entropy_coeff': hp.uniform('entropy_coeff', 1.0, 100.0)\n }\n else:\n space = {\n 'beta': hp.uniform('beta', 7, 23),\n 'alpha': hp.uniform('alpha', 0.0001, 0.4),\n 'alpha_decay': hp.uniform('alpha_decay', 0.9999, 0.9999999),\n 'epsilon': hp.loguniform('epsilon', np.log(0.2), np.log(0.8)),\n 'epsilon_decay': hp.uniform('epsilon_decay', 0.9995, 0.9999999),\n 'gamma': hp.uniform('gamma', 0.7, 0.90),\n 'lambda': hp.uniform('lambda', 0.0, 1.0)\n }\n # Only optimize parameters specified in args\n space = {param: space[param] for param in self.pp['hopt']}\n if self.pp['hopt_fname'].startswith('mongo:'):\n self._hopt_mongo(space)\n else:\n self._hopt_pickle(space)","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones, indices = experiences\n\n # Get max predicted Q values (for next states) from target model\n if self.dbl_dqn:\n local_best_actions = self.qnetwork_local(next_states).detach().argmax(1)\n Q_next_states = self.qnetwork_target(next_states)\n Q_targets_next = Q_next_states.gather(1, local_best_actions.unsqueeze(1))\n else:\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\n\n # Compute Q targets for current states\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.qnetwork_local(states).gather(1, actions)\n\n # Compute loss\n if self.priority_rpl:\n errors = abs(Q_expected - Q_targets)\n self.memory.update_priorities(indices, errors)\n importance = self.memory.get_importance(indices, self.a, self.b)\n importance = np.array(importance)\n loss = torch.mean(torch.mul(errors.float(), torch.from_numpy(importance).float().to(device)))\n else:\n loss = F.mse_loss(Q_expected, Q_targets)\n\n # Minimize the loss\n self.optimizer.zero_grad()\n loss.backward()\n self.optimizer.step()","def _learn(self, state):\n p_state, p_action = self.prev\n if p_state is None:\n return\n self.Q[p_state][p_action] = self.learning_rate * (self.R(state) + self.discount * max(self.Q[state].values())) - self.Q[p_state][p_action]","def inverse_q_learning(feature_matrix,nA, gamma, transitions, alpha_r, alpha_q, alpha_sh, epochs, real_distribution):\n nS = feature_matrix.shape[0]\n\n \n # initialize tables for reward function, value functions and state-action visitation counter.\n r = np.zeros((nS, nA))\n q = np.zeros((nS, nA))\n q_sh = np.zeros((nS, nA))\n state_action_visitation = np.zeros((nS, nA))\n\n for i in range(epochs):\n if i%10 == 0:\n print(\"Epoch %s/%s\" %(i+1, epochs))\n \n for traj in transitions:\n for (s, a, _, ns) in traj:\n state_action_visitation[s][a] += 1\n d = False # no terminal state\n\n # compute shifted q-function.\n q_sh[s, a] = (1-alpha_sh) * q_sh[s, a] + alpha_sh * (gamma * (1-d) * np.max(q[ns]))\n \n # compute log probabilities.\n sum_of_state_visitations = np.sum(state_action_visitation[s])\n log_prob = np.log((state_action_visitation[s]/sum_of_state_visitations) + epsilon)\n \n # compute eta_a and eta_b for Eq. (9).\n eta_a = log_prob[a] - q_sh[s][a]\n other_actions = [oa for oa in range(nA) if oa != a]\n eta_b = log_prob[other_actions] - q_sh[s][other_actions]\n sum_oa = (1/(nA-1)) * np.sum(r[s][other_actions] - eta_b)\n\n # update reward-function.\n r[s][a] = (1-alpha_r) * r[s][a] + alpha_r * (eta_a + sum_oa)\n\n # update value-function.\n q[s, a] = (1-alpha_q) * q[s, a] + alpha_q * (r[s, a] + gamma * (1-d) * np.max(q[ns]))\n s = ns\n\n # compute Boltzmann distribution.\n boltzman_distribution = []\n for s in range(nS):\n boltzman_distribution.append([])\n for a in range(nA):\n boltzman_distribution[-1].append(np.exp(q[s][a]))\n boltzman_distribution = np.array(boltzman_distribution)\n boltzman_distribution /= np.sum(boltzman_distribution, axis=1).reshape(-1, 1)\n return q, r, boltzman_distribution","def learn(self, experiences, gamma):\n\n states, all_state, action, all_actions, rewards, next_state, all_next_state, dones = experiences\n batch_size = all_next_state.shape[0]\n\n all_next_actions = self.actor_target(all_next_state.view(batch_size * 2, -1)).view(batch_size, -1)\n\n critic_target_input = torch.cat((all_next_state, all_next_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(\n device)\n with torch.no_grad():\n Q_target_next = self.critic_target(critic_target_input, all_next_actions.view(batch_size * 2, -1)[::2])\n Q_targets = rewards + (gamma * Q_target_next * (1 - dones))\n\n critic_local_input = torch.cat((all_state, all_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(device)\n Q_expected = self.critic_local(critic_local_input, action)\n\n # critic loss\n huber_loss = torch.nn.SmoothL1Loss()\n\n loss = huber_loss(Q_expected, Q_targets.detach())\n\n self.optimizer_critic.zero_grad()\n loss.backward()\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1)\n self.optimizer_critic.step()\n\n # actor loss\n\n action_pr_self = self.actor_local(states)\n action_pr_other = self.actor_local(all_next_state.view(batch_size * 2, -1)[1::2]).detach()\n\n # critic_local_input2=torch.cat((all_state,torch.cat((action_pr_self,action_pr_other),dim=1)),dim=1)\n critic_local_input2 = torch.cat((all_state, action_pr_other), dim=1)\n p_loss = -self.critic_local(critic_local_input2, action_pr_self).mean()\n\n self.optimizer_actor.zero_grad()\n p_loss.backward()\n\n self.optimizer_actor.step()\n\n # ------------------- update target network ------------------- #\n self.TAU = min(5e-1, self.TAU * 1.001)\n self.soft_update(self.critic_local, self.critic_target, self.TAU)\n self.soft_update(self.actor_local, self.actor_target, self.TAU)","def buildQ(self):\r\n\r\n print 'Building Q ...'\r\n\r\n self.y = T.matrix('y')\r\n\r\n mlp = MLP(activations=self.hyper['q_activs'],\r\n dims=self.hyper['q_dims'],\r\n weights_init=self.hyper['q_W_init'],\r\n biases_init=Constant(0))\r\n\r\n q_parameters = mlp.apply(self.y)\r\n mlp.initialize()\r\n\r\n # self.qxgy_mu.shape == (minibatch size, num of dimension of x)\r\n self.qxgy_mu = q_parameters[:,:self.hyper['x_dim']]\r\n\r\n # self.qxgy_var.shape == (minibatch size, num of dimension of x)\r\n self.qxgy_var = T.exp( q_parameters[:,self.hyper['x_dim']:2*self.hyper['x_dim']] )\r\n\r\n # self.qwgy_mu.shape == (minibatch size, num of dimension of w)\r\n self.qwgy_mu = q_parameters[:,2*self.hyper['x_dim']:2*self.hyper['x_dim']+self.hyper['w_dim']]\r\n\r\n # self.qwgy_var.shape == (minibatch size, num of dimension of w)\r\n self.qwgy_var = T.exp( q_parameters[:,2*self.hyper['x_dim']+self.hyper['w_dim']:] )\r\n\r\n\r\n #---Will be useful to compute samples from q(x|y)---#\r\n #self.eps_x.shape == (minibatch size, # of x samples , # of dimension of x)\r\n self.eps_x = self.srng.normal((self.qxgy_mu.shape[0] ,self.hyper['L_x'] ,self.hyper['x_dim']))\r\n\r\n #self.x corresponds roughly to the function g(\\epsilon,y) (see reparametrization trick in Kingma 2014)\r\n #self.x.shape == (minibatch size, # of x samples , # of dimension of x)\r\n self.x = self.qxgy_mu.dimshuffle(0,'x',1) + T.sqrt(self.qxgy_var).dimshuffle(0,'x',1)*self.eps_x\r\n\r\n #---Will be useful to compute samples from q(w|y)---#\r\n #self.eps_w.shape == (minibatch size, # of w samples , # of dimension of w)\r\n self.eps_w = self.srng.normal((self.qwgy_mu.shape[0] ,self.hyper['L_w'] ,self.hyper['w_dim']))\r\n\r\n #self.w corresponds roughly to the function g(\\epsilon,y) (see reparametrization trick in Kingma 2014)\r\n #self.w.shape == (minibatch size, # of w samples , # of dimension of w)\r\n self.w = self.qwgy_mu.dimshuffle(0,'x',1) + T.sqrt(self.qwgy_var).dimshuffle(0,'x',1)*self.eps_w\r\n\r\n\r\n #---Building the log density q(x|y)---#\r\n little_num = 10**(-32)\r\n inside_exp = -T.sum((self.x - self.qxgy_mu.dimshuffle(0,'x',1))**2/(2*self.qxgy_var.dimshuffle(0,'x',1)), axis=2)\r\n norm_cst = (2*np.pi)**(-self.hyper['x_dim']/2.)*T.exp(T.sum(T.log(self.qxgy_var), axis=1))**(-1/2.)\r\n\r\n # shape == (minibatch size, # of x samples)\r\n qxgy = norm_cst.dimshuffle(0,'x')*T.exp(inside_exp)\r\n\r\n # shape == (minibatch size, # of x samples)\r\n self.log_qxgy = T.log(qxgy + little_num)","def qUpdate(self,state,action,reward,next_state):\r\n #add to experience\r\n if next_state != \"end\":\r\n self.experience.append([self.feat_funct(state),action,\r\n reward,self.feat_funct(next_state)])\r\n else:\r\n self.experience.append([self.feat_funct(state),action,\r\n reward,next_state]) \r\n #print(state,action,reward,next_state)\r\n #get minibatch\r\n sample = np.random.randint(0,len(self.experience),self.batch_size)\r\n d = np.zeros((self.batch_size,self.size))\r\n y = np.zeros((self.batch_size,1))\r\n for i,row in enumerate(sample):\r\n state,action,reward,next_state = self.experience[row]\r\n #get feature vector\r\n d[i,:] = self.comb_feat_action(state,action)\r\n #get target\r\n #check if end of episoe\r\n if next_state == 'end':\r\n y[i] = reward\r\n else:\r\n y[i] = reward + self.gamma * self.maxOldQ(next_state)\r\n #print(row,next_state)\r\n #print(self.maxOldQ(next_state))\r\n \r\n loss = self.train(d,y)\r\n \r\n #update old learner if greater than num_update\r\n if self.iteration % self.num_update == 0:\r\n self.old_learn = copy.deepcopy(self.learner)\r\n self.iteration += 1\r\n \r\n return(loss)","def __init__(self, env, args):\n super(Agent_PG,self).__init__(env)\n\n ##################\n # YOUR CODE HERE #\n ##################\n self.print_every = args.print_every\n self.n_episode = args.episode\n self.gamma = args.gamma\n self.episode_len = args.episode_len\n self.update_every = args.update_every\n self.var_reduce = args.var_reduce\n self.gae = args.gae\n self.step_upd = args.step_upd\n self.max_step = args.step_train\n self.clip = args.clip\n\n if not self.gae:\n if args.cnn:\n self.model = Model2()\n else:\n self.model = Model()\n else:\n if args.cnn:\n self.model = ModelGAE2()\n else:\n self.model = ModelGAE()\n\n print(self.model)\n\n if args.cnn:\n self.opt = optim.RMSprop(self.model.parameters(), lr=args.learning_rate, weight_decay=0.99)\n else:\n self.opt = optim.Adam(self.model.parameters(), lr=args.learning_rate)\n\n self.state = np.zeros((1, 80, 80))\n self.log_probs = []\n self.rewards = []\n if self.gae:\n self.values = []\n self.entropies = []\n\n self.model_fn = args.model\n if self.model_fn == '':\n self.model_fn = 'agent_pg.pt'\n if args.test_pg:\n self.model_fn = 'pg.baseline.pt'\n\n if args.test_pg:\n #you can load your model here\n print('loading trained model :%s.' % self.model_fn)\n state_dict = torch.load(self.model_fn, map_location=lambda storage, location: storage)\n self.model.load_state_dict(state_dict)\n if USE_CUDA:\n self.model.cuda()","def learn(self, experiences, gamma):\n states, actions, rewards, next_states, dones = experiences\n\n # ------------------- update critic ------------------- #\n next_actions = self.actor_target(next_states)\n # Get Q targets (for next states) from target model (on CPU)\n Q_targets_next = self.critic_target(next_states, next_actions).detach().max(1)[0].unsqueeze(1)\n # Compute Q targets for current states \n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\n\n # Get expected Q values from local model\n Q_expected = self.critic_local(states, actions)\n\n # Compute critic loss\n critic_loss = F.mse_loss(Q_expected, Q_targets)\n # Minimize the critic loss\n self.critic_optimizer.zero_grad()\n critic_loss.backward()\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1) # As mentioned on project page\n self.critic_optimizer.step()\n\n # ------------------- update actor ------------------- #\n actions_expected = self.actor_local(states)\n # Compute actor loss based on expectation from actions_expected\n actor_loss = -self.critic_local(states, actions_expected).mean()\n # Minimize the actor loss\n self.actor_optimizer.zero_grad()\n actor_loss.backward()\n self.actor_optimizer.step()\n\n\n # ------------------- update target network ------------------- #\n self.soft_update(self.critic_local, self.critic_target, TAU) \n self.soft_update(self.actor_local, self.actor_target, TAU)","def add_evidence( \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n self, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n symbol=\"IBM\", \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sd=dt.datetime(2008, 1, 1), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ed=dt.datetime(2009, 1, 1), \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n sv=10000, \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n ): \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n \t\t \t \t\t \t \t\t\t \t\t \t\t\t \t \t \t\t \t\t \t\n # add your code to do learning here\n\n converged = False\n x = np.zeros((3,1))\n dates = pd.date_range(sd,ed)\n df_prices = ind.get_price(symbol, dates)\n\n daily_rets = (df_prices / df_prices.shift(1)) - 1\n daily_rets = daily_rets[1:]\n\n\n sd_older = sd - dt.timedelta(days=365)\n dates_older = pd.date_range(sd_older,ed)\n df_prices_older = ind.get_price(symbol, dates_older)\n sd_key = df_prices.index[0]\n sd_index = df_prices_older.index.get_loc(sd_key)\n\n num_bins = len(self.bins)\n max_state_idx = num_bins + num_bins*10 + num_bins*100\n\n # Call Q-Learner Constructor\n self.learner = QLearner( \n num_states=(max_state_idx + 1), \n num_actions=3, \n alpha=0.01, \n gamma=0.0, \n rar=0.98, \n radr=0.9995, \n dyna=0, \n verbose=False, \n )\n\n # df_trades = df_prices.copy()\n df_holdings = df_prices.copy()\n df_holdings['Holdings'] = np.nan\n del df_holdings[symbol] # print(df_holdings)\n\n # Initlialize Vars\n cum_ret_prev = 0\n iters = 0\n conv_counter = 0\n Q_prev = np.copy(self.learner.Q)\n\n # Get Indicator Values\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\n _,_,ind5 = ind.get_MACD(df_prices_older)\n BB = ind1.iloc[sd_index:].values\n CCI = ind2.iloc[sd_index:].values\n SMA_Cross = ind3.iloc[sd_index:].values\n Momentum = ind4.iloc[sd_index:].values\n MACD = ind5.iloc[sd_index:].values\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\n state = x_0 + x_3*10 + x_4*100\n\n \n while not converged:\n\n action = self.learner.querysetstate(state[0])\n daily_return = daily_rets.iloc[0][symbol]\n cur_price = df_prices.iloc[0][symbol]\n next_price = df_prices.iloc[1][symbol]\n df_holdings.iloc[0]['Holdings'], reward = self.take_action(0, action, cur_price, next_price)\n\n\n\n for day_idx in range(1,daily_rets.shape[0]):\n\n\n daily_return = daily_rets.iloc[day_idx][symbol]\n cur_price = df_prices.iloc[day_idx-1][symbol]\n next_price = df_prices.iloc[day_idx][symbol]\n df_holdings.iloc[day_idx]['Holdings'], reward = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\n action = self.learner.query(state[day_idx], reward)\n\n df_holdings.iloc[-1]['Holdings'] = 0\n df_trades = df_holdings.diff()\n df_trades['Trades'] = df_trades['Holdings']\n del df_trades['Holdings']\n df_trades.iloc[0]['Trades'] = 0\n\n\n portvals = msc.compute_portvals( \n df_trades,\n symbol, \n sv, \n self.commission, \n self.impact, \n )\n\n cum_ret = (portvals[-1] / portvals[0]) - 1\n Q_diff = np.abs(self.learner.Q - Q_prev)\n Q_max_diff = Q_diff.max()\n\n if iters > 20:\n\n # if abs(cum_ret - cum_ret_prev) < 0.0001:\n if Q_max_diff < 0.001:\n conv_counter += 1\n else:\n conv_counter = 0\n\n if conv_counter > 5 or iters > 20000:\n converged = True\n # if iters > 100:\n # if iters % 100 == 0:\n # print(\"Iteration #\", iters)\n print(\"----------------------------------------------\")\n print(\"-- --\")\n print(\"Iteration #\", iters)\n print(\"Error = \", abs(cum_ret - cum_ret_prev))\n print(\"Q Diff: \", Q_max_diff)\n print(\"Epsilon: \", self.learner.rar)\n\n cum_ret_prev = cum_ret\n Q_prev = np.copy(self.learner.Q)\n iters += 1\n self.learner.rar *= self.learner.radr\n # print(\"Iters = \", iters)\n print(\"Mode Trained in \", iters, \" iterations!\")\n np.savetxt('Q_Table.csv', self.learner.Q, delimiter=',')","def __init__(self, quant_arc_interface):\n\n super().__init__()\n self.args = quant_arc_interface.args \n self.q_params = nn.Parameter(self.args.q_delta * torch.randn(self.args.q_depth * self.args.n_qubits))\n self.qai = quant_arc_interface","def learn(self, state, action, reward, state_):\n self.Q.optimizer.zero_grad()\n states = T.tensor(state, dtype=T.float).to(self.Q.device)\n action = T.tensor(action).to(self.Q.device)\n reward = T.tensor(reward).to(self.Q.device)\n states_ = T.tensor(state_, dtype=T.float).to(self.Q.device)\n\n q_pred = self.Q.forward(states)[action]\n\n q_next = self.Q.forward(states_).max()\n\n q_target = reward + self.gamma*q_next\n\n loss = self.Q.loss(q_target, q_pred).to(self.Q.device)\n loss.backward()\n self.Q.optimizer.step()\n self.decrement_epsilon()","def learn(self, experience):\n\n # Convert experiences to separate list\n states = np.vstack([e.state for e in experience if e is not None])\n actions = np.array([e.action for e in experience if e is not None]).astype(np.float32).reshape(-1, self.action_size)\n rewards = np.array([e.reward for e in experience if e is not None]).astype(np.float32).reshape(-1, 1)\n dones = np.array([e.done for e in experience if e is not None]).astype(np.uint8).reshape(-1, 1)\n next_states = np.vstack([e.next_state for e in experience if e is not None])\n\n # Get predicted next-state actions and Q values from target models\n # Q_targets_next = critic_target(next_state, actor_target(next_state))\n actions_next = self.actor_target.model.predict_on_batch(next_states)\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next])\n\n # Compute Q targets for current states and train critic model (local)\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones)\n self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\n\n # Train actor model (local)\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\n self.actor_local.train_fn([states, action_gradients, 1])\n\n # soft-update target models\n self.soft_update(self.critic_local.model, self.critic_target.model)\n self.soft_update(self.actor_local.model, self.actor_target.model)","def __init__(self, **args):\n self.featExtractor = util.lookup(\"SimpleExtractor\", globals())()\n PacmanQAgent.__init__(self, **args)\n self.sess = tf.Session()\n self.allFeats = list(self.featExtractor.getFeatures(None, None))\n numDims = len(self.allFeats)\n self.x = tf.placeholder(\"float\", shape=[None, numDims])\n self.y_ = tf.placeholder(\"float\", shape=[None, 1])\n self.W1 = tf.Variable(tf.truncated_normal([numDims, 5], stddev=0.01))\n self.b1 = tf.Variable(tf.constant(0.01, shape=[5]))\n self.W2 = tf.Variable(tf.truncated_normal([5, 1]))\n self.b2 = tf.Variable(tf.constant(0.01, shape=[1]))\n self.h = tf.nn.relu(tf.matmul(self.x, self.W1) + self.b1)\n self.out = tf.nn.relu(tf.matmul(self.h, self.W2) + self.b2)\n self.l2_loss = tf.reduce_sum(tf.square(self.y_ - self.out))\n self.train_step = tf.train.AdamOptimizer(1e-4).minimize(self.l2_loss)\n self.sess.run(tf.initialize_all_variables())","def __init__(self, args, quant_arc_interface):\n\n super().__init__()\n self.args = args \n\n self.q_params = nn.Parameter(self.args.q_delta * torch.randn(self.args.q_depth * self.args.n_qubits))\n self.qai = quant_arc_interface","def __init__(self,\n num_actions,\n\n tau,\n alpha=1,\n clip_value_min=-10,\n target_opt=0,\n\n net_conf = None,\n env = \"CartPole\",\n hidden_layer=2, \n neurons=512,\n noisy = False,\n dueling = False,\n initzer = 'variance_scaling',\n\n observation_shape=dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,\n observation_dtype=dqn_agent.NATURE_DQN_DTYPE,\n stack_size=dqn_agent.NATURE_DQN_STACK_SIZE,\n network=networks.ImplicitQuantileNetwork,\n kappa=1.0,\n num_tau_samples=32,\n num_tau_prime_samples=32,\n num_quantile_samples=32,\n quantile_embedding_dim=64,\n double_dqn=False,\n gamma=0.99,\n update_horizon=1,\n min_replay_history=20000,\n update_period=4,\n target_update_period=8000,\n epsilon_fn=dqn_agent.linearly_decaying_epsilon,\n epsilon_train=0.01,\n epsilon_eval=0.001,\n epsilon_decay_period=250000,\n replay_scheme='prioritized',\n optimizer='adam',\n summary_writer=None,\n summary_writing_frequency=500,\n seed=None):\n \n seed = int(time.time() * 1e6) if seed is None else seed\n self._net_conf = net_conf\n self._env = env\n self._hidden_layer = hidden_layer\n self._neurons=neurons \n self._noisy = noisy\n self._dueling = dueling\n self._initzer = initzer\n\n self._tau = tau\n self._alpha = alpha\n self._clip_value_min = clip_value_min\n self._target_opt = target_opt\n self._rng = jax.random.PRNGKey(seed)\n\n self.kappa = kappa\n self._replay_scheme = replay_scheme\n\n # num_tau_samples = N below equation (3) in the paper.\n self.num_tau_samples = num_tau_samples\n # num_tau_prime_samples = N' below equation (3) in the paper.\n self.num_tau_prime_samples = num_tau_prime_samples\n # num_quantile_samples = k below equation (3) in the paper.\n self.num_quantile_samples = num_quantile_samples\n # quantile_embedding_dim = n above equation (4) in the paper.\n self.quantile_embedding_dim = quantile_embedding_dim\n # option to perform double dqn.\n self.double_dqn = double_dqn\n\n\n super(JaxImplicitQuantileAgentNew, self).__init__(\n num_actions=num_actions,\n observation_shape=observation_shape,\n observation_dtype=observation_dtype,\n stack_size=stack_size,\n network=functools.partial(network,\n \t num_actions=num_actions,\n net_conf=self._net_conf,\n env=self._env,\n hidden_layer=self._hidden_layer, \n neurons=self._neurons,\n noisy=self._noisy,\n dueling=self._dueling,\n initzer=self._initzer,\n quantile_embedding_dim=quantile_embedding_dim),\n gamma=gamma,\n update_horizon=update_horizon,\n min_replay_history=min_replay_history,\n update_period=update_period,\n target_update_period=target_update_period,\n epsilon_fn=epsilon_fn,\n epsilon_train=epsilon_train,\n epsilon_eval=epsilon_eval,\n epsilon_decay_period=epsilon_decay_period,\n optimizer=optimizer,\n summary_writer=summary_writer,\n summary_writing_frequency=summary_writing_frequency)\n\n self._num_actions=num_actions\n self._replay = self._build_replay_buffer()","def OSK_Q_MultiProcess_Ave(ave_times=20,\n learning_rate=0.1,\n eligibility_factor=0.9,\n observation_dim=4,\n mu_1=0.04,\n mu_2=0.08):\n # Learning Parameter\n discount_factor = 0.9\n discount_of_learning_rate = 0.999\n epsilon = 0.1\n\n # Parameter OSK-Q\n sigma = 1\n\n # Macro\n NUM_EPISODE = 600\n AVE_TIMES = ave_times\n REWARD_THREASHOLD = 40\n # Definition of dependencies\n env = gym.make('CartPole-v0')\n\n # Run algorithm\n for ave_times in range(AVE_TIMES):\n learning_agent_OSKQ = OSKQ(\n mu_1,\n mu_2,\n learning_rate,\n discount_factor,\n eligibility_factor,\n [0, 1],\n observation_dim,\n sigma\n )\n learning_agent = learning_agent_OSKQ\n\n Qfunc_error_history_3 = []\n total_reward_episode_3 = []\n time_history_3 = []\n max_reward = -float(\"inf\")\n for i_episode in range(NUM_EPISODE):\n time_start = time.clock()\n observation = env.reset()\n action = learning_agent._m_GreedyPolicy(observation, epsilon)\n\n total_reward = 0\n done = False\n step = 0\n while not done:\n step += 1\n observation_bar, step_reward, done, info = env.step(action)\n\n action_bar = learning_agent._m_GreedyPolicy(\n observation_bar,\n epsilon\n )\n\n learning_agent._m_Learn(\n observation,\n action,\n observation_bar,\n action_bar,\n step_reward\n )\n\n observation = observation_bar\n action = action_bar\n total_reward += step_reward\n print \"Episode finished after {} timesteps in OSK-Q(lambda)\".format(step), \"in \", ave_times + 1, \"times\"\n time_end = time.clock()\n time_consumed = time_end - time_start\n time_history_3.append(time_consumed)\n\n if total_reward > max_reward:\n if total_reward > REWARD_THREASHOLD:\n epsilon *= 0.999\n max_reward = total_reward\n\n total_reward_episode_3.append(total_reward) # Add total reward to reward history\n\n if i_episode % 10 == 0:\n print i_episode, \"th episode completed\"\n print \"Maximal reward is\", max_reward, \"\\n\"\n\n total_reward_episode_3 = np.array(total_reward_episode_3)\n if 'total_reward_episode_ave_3' not in locals():\n total_reward_episode_ave_3 = total_reward_episode_3\n else:\n total_reward_episode_ave_3 = total_reward_episode_ave_3 + (total_reward_episode_3 - total_reward_episode_ave_3) / (ave_times * 1.0)\n\n time_history_3 = np.array(time_history_3)\n if 'time_history_ave_3' not in locals():\n time_history_ave_3 = time_history_3\n else:\n time_history_ave_3 = time_history_ave_3 + (time_history_3 - time_history_ave_3) / (ave_times * 1.0)\n\n total_reward_episode_3 = total_reward_episode_ave_3\n time_history_3 = time_history_ave_3\n\n with open(\n path + \"total_reward_OSKQ-\" + str(learning_rate) + \"-\" +\n str(eligibility_factor) + \"-\" + str(mu_1) + \"-\" + str(mu_2), 'wb') as f:\n pickle.dump(total_reward_episode_3, f)\n with open(\n path + \"time_history_OSKQ-\" + str(learning_rate) + \"-\" +\n str(eligibility_factor) + \"-\" + str(mu_1) + \"-\" + str(mu_2), 'wb') as f:\n pickle.dump(time_history_3, f)","def policies(self, QTable, epsilon, state, next_states, action_to_do): # Inspiration from https://www.geeksforgeeks.org/q-learning-in-python/?fbclid=IwAR1UXR88IuJBhhTakjxNq_gcf3nCmJB0puuoA46J8mZnEan_qx9hhoFzhK8\r\n num_actions = 5 # 5 actions-value, [moved_out, into_goal, send_opp_home, send_self_home, move_token] \r\n def epsilonGreedyPolicy(): \r\n tmp_state = str(state.state[0])\r\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\r\n valid_act_len = len(np.where(valid_actions==True)[0])\r\n\r\n Action_probabilities = np.ones(num_actions, dtype = float) * epsilon / valid_act_len # divides probability based on number of valid actions and epsilon (each 0.025 if 4 actions) \r\n Action_probabilities = np.multiply(Action_probabilities, valid_actions)\r\n\r\n # If same values in QTable choose random valid action \r\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\r\n # Check if valid action else find new best action\r\n if not valid_actions[best_action]:\r\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\r\n for i in range(len(valid_actions)):\r\n if valid_actions[actions[i]]:\r\n best_action = actions[i]\r\n break\r\n\r\n Action_probabilities[best_action] += (1.0 - epsilon) # Assigns rest probability to best action so probability sums to 1\r\n\r\n return Action_probabilities \r\n\r\n def greedyPolicy():\r\n tmp_state = str(state.state[0])\r\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\r\n\r\n Action_probabilities = np.zeros(num_actions, dtype = float)\r\n\r\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\r\n # Check if valid action else find new best action\r\n if not valid_actions[best_action]:\r\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\r\n for i in range(len(valid_actions)):\r\n if valid_actions[actions[i]]:\r\n best_action = actions[i]\r\n break\r\n\r\n\r\n Action_probabilities[best_action] += 1.0\r\n return Action_probabilities\r\n\r\n\r\n if(self.__chosenPolicy == \"epsilon greedy\"):\r\n return epsilonGreedyPolicy \r\n if(self.__chosenPolicy == \"greedy\"):\r\n return greedyPolicy","def agent_init(self, agent_config):\n if agent_config.get('name') is None or not (agent_config.get('name').lower() == 'q-learning' or agent_config.get('name').lower() == 'expected_sarsa'):\n raise AssertionError(\"Invalid agent name. Accepted agents: 'q-learning', 'expected_sarsa'\")\n self.name = agent_config['name']\n self.device = agent_config['device']\n self.replay_buffer = ReplayBuffer(agent_config['replay_buffer_size'],\n agent_config['minibatch_size'],\n agent_config.get('seed'))\n self.network = DQN(agent_config['network_config']).to(self.device) # The latest state of the network that is getting replay updates\n self.network_target = DQN(agent_config['network_config']).to(self.device)\n\n optim_config = agent_config['optimizer_config']\n self.optimizer = optim.Adam(self.network.parameters(), lr=optim_config['step_size'], betas=optim_config['betas'])\n self.num_actions = agent_config['network_config']['action_dim']\n self.num_replay = agent_config['num_replay_updates_per_step']\n self.discount = agent_config['gamma']\n self.tau = agent_config['tau']\n\n self.rand_generator = np.random.RandomState(agent_config.get('seed'))\n\n self.last_state = None\n self.last_action = None\n\n self.sum_rewards = 0\n self.epsiode_steps = 0\n\n checkpoint_dir = agent_config.get('checkpoint_dir')\n if checkpoint_dir is None:\n self.checkpoint_dir = 'model_weights'\n else:\n self.checkpoint_dir = checkpoint_dir\n \n if not os.path.isdir(self.checkpoint_dir):\n os.makedirs(self.checkpoint_dir)","def update1(self, state, action, nextState, reward):\n #print \"update1 in ApproximateQAgent\"\n \"*** YOUR CODE HERE ***\"\n ##################################################################################################################################Eric Did Stuff\n actionList = nextState.getLegalActions(self.index)\n\n\n #print \"Action List\", actionList\n\n\n\n\n weights = self.getWeights()\n\n features = self.featExtractor.getFeatures(state, action, self)\n #self.myFeats = features\n if self.index == 0:\n print \"FEATURES: \",features\n value = self.computeValueFromQValues(nextState)\n qValue = self.getQValue(state,action)\n #print \"value\", value, \"qValue\", qValue\n for feature in features:\n if len(actionList) != 0:\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\n else:\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\n #print \"feature\", feature, \"weights\", weights[feature]\n #print \"weights\", weights\n\n #util.raiseNotDefined()","def getQValue(self, state, action):\n \"\"\"Description:\n [Enter a description of what you did here.]\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\n \n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\n it did not change even a ghost is closing.\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n # if weight is empty, then weight will need to initial to 1 for all features\n # According to which Extractor user choose, weight counter will have equal number of keys.\n if len(self.weight) == 0:\n feat = self.featExtractor.getFeatures(state, action)\n self.weight.incrementAll(feat.keys(), 1)\n \n qValue = self.weight * self.featExtractor.getFeatures(state,action)\n return qValue\n \"\"\" END CODE \"\"\"","def main():\n\n # The X's represent the boundaries of the maze.\n # Reaching state G results in a reward of +1.\n # Reaching state E results in a reward of -1.\n grid = [ # 4 x 3 maze.\n \"XXXXXX\",\n \"X GX\",\n \"X X EX\",\n \"X X\",\n \"XXXXXX\"\n ]\n\n grid2 = [ # 10 x 8 maze.\n \"XXXXXXXXXXXX\",\n \"X X X\",\n \"X X XXXXXX X\",\n \"X EX\",\n \"XX XXXXXX X\",\n \"X X X X\",\n \"X XX XGXX X\",\n \"X XX X X\",\n \"XXXX XX\",\n \"XXXXXXXXXXXX\"\n ]\n\n maze = Maze(grid, (2, 1))\n maze.display()\n\n agent = QAgent(maze)\n agent.qlearn(250)\n path = agent.solve_maze()\n\n while path:\n move = path.pop(0)\n maze = maze.neighbor(move)\n time.sleep(0.50)\n maze.display()\n\n print(\"path: \" + str(path))\n print(\"Q table:\")\n print(agent.get_qtable_str())","def step(self, state, action, next_state, reward, is_done):\n state = state.astype('float32')\n next_state = next_state.astype('float32')\n self.memory.push(state, action, next_state, reward, is_done*1.)\n\n if len(self.memory) > self.batch_size:\n experience = self.memory.sample(self.batch_size)\n batch = Transition(*zip(*experience))\n\n if self.is_conv_agent:\n state = torch.tensor(batch.state).permute(0, 3, 1, 2).to(self.device)\n next_state = torch.tensor(batch.next_state).permute(0, 3, 1, 2).to(self.device)\n else:\n state = torch.tensor(batch.state).to(self.device)\n next_state = torch.tensor(batch.next_state).to(self.device)\n action = torch.tensor(batch.action).to(self.device)\n reward = torch.tensor(batch.reward).to(self.device)\n is_done = torch.tensor(batch.done).to(self.device)\n\n q_targets_next = self.q_target_net(next_state).max(1)[0].detach() # Q(s', a)\n q_targets = reward + (self.gamma * q_targets_next * (1 - is_done)) # R + gamma*Q(s',a)\n\n q_expected = self.q_policy_net(state).gather(1, action.unsqueeze(1)) # Q(s,a)\n\n # optimize: l = R + gamma*Q(s', a) - Q(s, a)\n #loss = F.smooth_l1_loss(q_expected, q_targets.unsqueeze(1)) # batch x 1\n loss = self.loss_fn(q_expected, q_targets.unsqueeze(1)) # batch x 1\n\n self.optimizer.zero_grad()\n loss.backward()\n # Gradient clip\n for params in self.q_policy_net.parameters():\n params.grad.data.clamp_(-3, 3)\n self.optimizer.step()\n\n self.t_step = (self.t_step + 1) % self.update_every\n if self.t_step == 0:\n self._soft_update(target_model=self.q_target_net,\n local_model=self.q_policy_net,\n tau=self.soft_update_ratio)","def learn(self, s, a, reward, sprime, done):\n pass","def learn(self, s, a, reward, sprime, done):\n pass"],"string":"[\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n QLearningAgent.__init__(self, **args)\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n #self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\",\n \"def qlearning(env, iterations=1000, gamma=0.9, alpha=0.1):\\n nS = env.nS # number of states\\n nA = env.nA # number of actions\\n Q_value = np.zeros((nS, nA))\\n policy = np.ones((env.nS,env.nA))/env.nA\\n epsilon = 1\\n s_t1 = env.reset() # reset the environment and place the agent in the start square\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n # HINT: Don't forget to decay epsilon according to GLIE\\n\\n curr_state = s_t1\\n \\n start = time.time() # to time how long convergence takes\\n print(\\\"---Q Learning---\\\\nTraining Started.\\\")\\n \\n for k in range (1, iterations):\\n # if (k%10000) == 0:\\n # print(\\\"Now playing iteration: \\\", k)\\n epsilon = 1/k\\n curr_action, reward, new_state, done = take_one_step(env, policy, curr_state)\\n new_action = sample_action(policy, new_state)\\n Q_value[curr_state, curr_action] = Q_value[curr_state, curr_action] + alpha * (reward + gamma * (Q_value[new_state, np.argmax(Q_value[new_state])]) - Q_value[curr_state, curr_action])\\n \\n # epsilon-greedy policy update\\n Q_list = np.argwhere(Q_value[curr_state] == np.amax(Q_value[curr_state])).flatten() # get a list of all indices where Q is maximum, (argmax(Q))\\n max_Q = np.random.choice(Q_list.flatten()) # randomly pick from those indices. Picking each index is equally likely.\\n for a in range (nA):\\n if a == max_Q:\\n policy[curr_state][a] = epsilon/nA + (1 - epsilon) # for the chosen maximal index of Q, set the policy to epsilon/m + 1 - epsilon\\n else:\\n policy[curr_state][a] = epsilon/nA \\n \\n # print(\\\"Q_value = {0}\\\".format(Q_value))\\n # print(\\\"policy = {0}\\\".format(policy))\\n \\n if done:\\n curr_state = env.reset() # reset the environment and place the agent in the start square\\n curr_action = sample_action(policy, curr_state)\\n else:\\n curr_state = new_state\\n curr_action = new_action\\n \\n stop = time.time()\\n print(\\\"Training Completed.\\\")\\n print(\\\"It took: {0} iterations and {1} minutes\\\".format(k,(stop-start)/60))\\n \\n ############################\\n det_policy = np.argmax(Q_value, axis=1)\\n return Q_value, det_policy\",\n \"def learn(self):\\n batch = self.agent.replay_buffer.sample(self.batch_size)\\n states = torch.tensor([x.state for x in batch], dtype=torch.float32).to(self.agent.device) # shape == (batch_size, 3, 6, 7)\\n actions = [x.action for x in batch]\\n rewards = torch.tensor([x.reward for x in batch], dtype=torch.float32).to(self.agent.device)\\n next_states = torch.tensor([x.next_state for x in batch], dtype=torch.float32).to(self.agent.device)\\n dones = [x.done for x in batch]\\n\\n self.optimizer.zero_grad()\\n\\n\\n q_vals = self.agent.policy_net(states)[range(len(actions)), actions] # Q vals for actions taken\\n q_next_vals = self.agent.target_net(next_states).detach() # we don't care about grad wrt target net\\n q_next_vals[dones] = 0.0 # terminal states have no future expected value\\n q_targets = rewards + self.gamma * torch.max(q_next_vals, dim=1)[0]\\n\\n # all_q_vals = self.agent.policy_net(states)\\n # print()\\n # print('actions')\\n # print(actions)\\n # print()\\n # print('original all q vals')\\n # print(self.agent.policy_net(states)) \\n # print(self.agent.policy_net(states).shape)\\n # print()\\n # print('QVALS:', q_vals)\\n # print(q_vals.shape)\\n # print('\\\\n\\\\n')\\n # print('QTARGETS:', q_targets)\\n # print(q_targets.shape)\\n\\n # breakpoint()\\n\\n loss = self.loss_fn(q_targets, q_vals).to(self.agent.device)\\n loss.backward()\\n \\n # for layer in self.agent.policy_net.named_parameters():\\n \\n # # print(f'layer: {layer[0]}')\\n # # print(f'grad:', layer[1].grad)\\n\\n # # print('loss', loss)\\n # # print('q_vals grad:', q_vals.grad)\\n # # print('states:', )\\n\\n self.optimizer.step()\\n\\n self.agent.learning_iters += 1\\n if self.agent.learning_iters % self.target_update_freq == 0:\\n self.agent.update_target_net()\\n # logger.info('Updated target net')\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\",\n \"def learn(self):\\n if self.learn_step_counter % self.target_q_update_step == 0:\\n self.target_net.load_state_dict(self.eval_net.state_dict()) #update target_net's parameters\\n logging.info(\\\"updtate target q\\\")\\n self.learn_step_counter += 1\\n\\n rgbs,depths, rgbs_1, depths_1,questions,actions,rewards,terminals = self.memory.sample()\\n\\n rgbs_var = Variable(torch.FloatTensor(rgbs).cuda())\\n depths_var = Variable(torch.FloatTensor(depths).cuda())\\n rgbs_1_var = Variable(torch.FloatTensor(rgbs_1).cuda())\\n depths_1_var = Variable(torch.FloatTensor(depths_1).cuda())\\n questions_var = Variable(torch.LongTensor(questions).cuda())\\n actions_var = Variable(torch.LongTensor(actions).cuda())\\n rewards_var = Variable(torch.FloatTensor(rewards).cuda())\\n terminals_var = Variable(torch.FloatTensor(terminals).cuda())\\n\\n q_eval_matrix = self.eval_net(rgbs_var,depths_var,questions_var)\\n q_eval_matrix = q_eval_matrix.view(-1,9*28*28)\\n actions_var = actions_var.view(-1,1)\\n q_eval = torch.gather(q_eval_matrix, 1, actions_var) \\n q_eval = q_eval.squeeze(1)\\n\\n q_next_matrix = self.target_net(rgbs_1_var,depths_1_var,questions_var).detach() #don't backward\\n q_next_matrix = q_next_matrix.view(-1,9*28*28)\\n q_next = torch.max(q_next_matrix,1)[0]\\n\\n one_var = Variable(torch.ones_like(terminals_var))\\n\\n q_target = rewards_var + (one_var- terminals_var)*self.discount * q_next\\n \\n loss = self.loss_func(q_eval, q_target)\\n\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n self.task_total_loss += loss.item()\\n self.task_total_q += q_target.mean()\\n self.update_count += 1\",\n \"def batch_q_learning(self):\\n\\n if(self.memory.get_usage() > Parameters.AGENT_HISTORY_LENGTH):\\n\\n state_t, action, reward, state_t_plus_1, terminal, i_s_weights, memory_indices = self.memory.bring_back_memories()\\n\\n q_t_plus_1 = self.tf_session.run(\\n self.target_dqn.q_values, {\\n self.target_dqn_input: state_t_plus_1})\\n max_q_t_plus_1 = np.max(q_t_plus_1, axis=1)\\n\\n target_q_t = (1. - terminal) * \\\\\\n Parameters.DISCOUNT_FACTOR * max_q_t_plus_1 + reward\\n\\n _, q_t, losses = self.tf_session.run([self.dqn.optimize, self.dqn.q_values, self.dqn.errors],\\n {\\n self.dqn.target_q: target_q_t,\\n self.dqn.action: action,\\n self.dqn_input: state_t,\\n self.dqn.i_s_weights: i_s_weights\\n })\\n\\n self.memory.update(\\n memory_indices,\\n np.squeeze(q_t),\\n losses,\\n self.get_learning_completion())\\n input_shape = (1, Parameters.IMAGE_HEIGHT, Parameters.IMAGE_WIDTH, Parameters.AGENT_HISTORY_LENGTH)\\n dqn_input = self.environment.get_input().reshape(input_shape)\\n q_values = self.tf_session.run(\\n self.dqn.q_values, {\\n self.dqn_input: dqn_input})\\n Plotter.add_q_values_at_t(q_values)\\n else:\\n print('[WARNING] Not enough memory for a batch')\",\n \"def create_memory_qlearner(\\n dqn: nn.Module, # Callable[[Observation], QValues]\\n random_action: Callable[[Observation], Action],\\n optimizer: optim.Optimizer,\\n discount: float = 0.99,\\n epsilon: Union[float, num.Stepable] = 0.05,\\n evaluation_mode: trainers.QLearningMode = trainers.QLearningMode.DOUBLE,\\n optimizing_steps: int = 4,\\n double_target_weight_copy_steps: int = 1000,\\n memory_capacity: int = 10000,\\n batch_size: int = 32,\\n clip_grad_norm: Optional[float] = None,\\n dtype: Optional[torch.dtype] = None,\\n device: Optional[torch.device] = None,\\n) -> Explorer:\\n # Enable converting from string\\n evaluation_mode = trainers.QLearningMode(evaluation_mode)\\n dqn.to(device=device, dtype=dtype)\\n if evaluation_mode == trainers.QLearningMode.SIMPLE:\\n target_dqn = None\\n else:\\n target_dqn = copy.deepcopy(dqn)\\n\\n def select_action(engine, observation):\\n \\\"\\\"\\\"Epsilon greedy action selection.\\\"\\\"\\\"\\n with torch.no_grad():\\n dqn.eval()\\n if torch.rand(1).item() < epsilon:\\n return random_action(observation)\\n else:\\n return dqn(observation).greedy()\\n\\n agent = Explorer(select_action=select_action, dtype=dtype, device=device)\\n trainer = trainers.create_qlearning_trainer(\\n dqn=dqn,\\n target_dqn=target_dqn,\\n optimizer=optimizer,\\n discount=discount,\\n evaluation_mode=evaluation_mode,\\n clip_grad_norm=clip_grad_norm,\\n dtype=dtype,\\n device=device,\\n )\\n\\n @agent.on(Events.STARTED)\\n def add_memory_and_trainer_to_agent(engine):\\n engine.state.memory = MemoryReplay(\\n T.PinIfCuda(device=device), capacity=memory_capacity\\n )\\n engine.state.trainer = trainer\\n\\n @agent.on(Events.ITERATION_COMPLETED)\\n def append_transition_and_step_epsilon(engine):\\n engine.state.memory.append(engine.state.transition.cpu())\\n if isinstance(epsilon, num.Stepable):\\n epsilon.step()\\n\\n @agent.on(Events.ITERATION_COMPLETED)\\n @utils.every(optimizing_steps)\\n def optimize(engine):\\n sample_elem = engine.state.memory[0]\\n dataloader = DataLoader(\\n dataset=engine.state.memory,\\n batch_size=batch_size,\\n collate_fn=sample_elem.__class__.collate,\\n shuffle=True,\\n drop_last=True,\\n )\\n engine.state.trainer.run(dataloader)\\n\\n @agent.on(Events.ITERATION_COMPLETED)\\n @utils.every(double_target_weight_copy_steps)\\n def copy_weights(engine):\\n if target_dqn is not None:\\n dqn.zero_grad() # Avoid copying the gradients\\n target_dqn.load_state_dict(copy.deepcopy(dqn.state_dict()))\\n\\n return agent\",\n \"def learn(self):\\n ## obtain sample batch using priority based sampling.\\n states, actions, rewards, next_states, dones, weights, sample_inds = self.buffer.sample_batch(BETA)\\n \\n ## obtain the discounted sum of rewards from reward list\\n ## also obtain final gamma multiplier\\n reduced_rewards, gamma_multipliers = self.reduce_rewards(rewards)\\n \\n ## convert to tensors\\n states = np_to_tensor(states)\\n actions = np_to_tensor(actions)\\n reduced_rewards = np_to_tensor(reduced_rewards)\\n gamma_multipliers = np_to_tensor(gamma_multipliers)\\n next_states = np_to_tensor(next_states)\\n dones = np_to_tensor(dones)\\n weights = np_to_tensor(np.array(weights))\\n \\n #### Updating Qnet\\n \\n ## actions from the target actor network\\n greedy_actions = self.actor_target(next_states)\\n ## compute temporal difference\\n targets = reduced_rewards + torch.mul( torch.mul(gamma_multipliers , self.QNetwork_target(next_states, greedy_actions)) , (1-dones).unsqueeze(1))\\n Q_sa = self.QNetwork_local(states, actions)\\n \\n td_error = targets - Q_sa\\n \\n ## update the priorities using temporal differences\\n self.buffer.update_priority(sample_inds,\\n (td_error).detach().abs().squeeze().cpu().data.numpy()+REPLAY_EPS)\\n \\n ## compute the loss, importance sampling weights are used\\n loss = ((td_error).pow(2)*weights).mean()\\n \\n self.QNet_optim.zero_grad()\\n loss.backward()\\n self.QNet_optim.step()\\n \\n ### Updating Actor\\n pred_actions = self.actor_local(states)\\n actor_loss = - self.QNetwork_local(states, pred_actions).mean()\\n \\n self.actor_optim.zero_grad()\\n actor_loss.backward()\\n self.actor_optim.step()\\n \\n #### Polyak Updates\\n self.soft_update(self.QNetwork_local, self.QNetwork_target, TAU)\\n self.soft_update(self.actor_local, self.actor_target, TAU)\",\n \"def learn(self):\\n \\n # target parameter update\\n # target parameter update\\n if self.learn_step_counter % self.nu_iter == 0:\\n self.target_net.load_state_dict(self.eval_net.state_dict())\\n #testing the preformace of the network\\n if self.learn_step_counter == 0:\\n print('As referece this first test on dev data. Is maded with the Q networks, initialized randomly : ' )\\n else:\\n print(\\\"\\\\n Lets copy the Q-value Net in to Q-target net!. And test the performace on the dev data: \\\")\\n \\n current_bleu = self.dev_network()\\n print(\\\"Current Bleu score is: \\\", current_bleu)\\n \\n self.learn_step_counter += 1\\n\\n \\n long_Batch = self.sample_size*3\\n # Sampling the higgest rewards values\\n b_memory_big = self.memory[np.argsort(-self.memory[:-self.max_output_length, self.state_size+1])][:long_Batch]\\n \\n sample_index = np.random.choice(long_Batch, self.sample_size)\\n b_memory = b_memory_big[sample_index, :]\\n\\n b_s = torch.FloatTensor(b_memory[:, :self.state_size])\\n b_a = torch.LongTensor(b_memory[:, self.state_size:self.state_size+1].astype(int))\\n b_r = torch.FloatTensor(b_memory[:, self.state_size+1:self.state_size+2])\\n b_s_ = torch.FloatTensor(b_memory[:, self.state_size+2: self.state_size+2 + self.state_size])\\n\\n b_is_eos = torch.FloatTensor(b_memory[:, self.size_memory1-1:]).view(self.sample_size, 1)\\n #print(b_a, b_a.size)\\n #print(b_is_eos)\\n #Activate the eval_net\\n unfreeze_model(self.eval_net)\\n \\n # q_eval w.r.t the action in experience\\n q_eval = self.eval_net(b_s).gather(1, b_a) # shape (batch, 1)\\n q_next = self.target_net(b_s_).detach() # detach from graph, don't backpropagate\\n #taking the most likely action.\\n b_a_ = torch.LongTensor(q_next.max(1)[1].view(self.sample_size, 1).long())\\n #b_a_ = q_next.max(1)[0].view(self.sample_size, 1).long() # shape (batch, 1)\\n q_eval_next = self.eval_net(b_s_).gather(1, b_a_) # shape (batch, 1)\\n \\n #If eos q_target = reward. \\n q_target = b_r + self.gamma * b_is_eos* q_eval_next.view(self.sample_size, 1) # shape (batch, 1)\\n #version 0\\n #q_target = b_r + self.gamma * q_next.max(1)[0].view(self.sample_size, 1) # shape (batch, 1)\\n \\n loss = self.loss_func(q_eval, q_target)\\n \\n self.tb_writer.add_scalar(\\\"learn/learn_batch_loss\\\",\\n loss.data, self.learn_step_counter)\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n #desctivate the eval_net\\n freeze_model(self.eval_net)\",\n \"def choose_action( self):\\n \\\"\\\"\\\"greedy, random, e-greedy, boltzmann, bayesian\\\"\\\"\\\"\\n\\tif self.exploration == \\\"greedy\\\":\\n #Choose an action with the maximum expected value.\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\\n a = a[0]\\n return a\\n if self.exploration == \\\"random\\\":\\n #Choose an action randomly.\\n a = env.action_space.sample()\\n if self.exploration == \\\"e-greedy\\\":\\n #Choose an action by greedily (with e chance of random action) from the Q-network\\n if np.random.rand(1) < e or total_steps < pre_train_steps:\\n a = env.action_space.sample()\\n else:\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\\n a = a[0]\\n return a\\n if self.exploration == \\\"boltzmann\\\":\\n #Choose an action probabilistically, with weights relative to the Q-values.\\n Q_d,allQ = sess.run([q_net.Q_dist,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.Temp:e,q_net.keep_per:1.0})\\n a = np.random.choice(Q_d[0],p=Q_d[0])\\n a = np.argmax(Q_d[0] == a)\\n return a\\n if self.exploration == \\\"bayesian\\\":\\n #Choose an action using a sample from a dropout approximation of a bayesian q-network.\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:(1-e)+0.1})\\n a = a[0]\\n return a\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n #simple implementation of a python noob to implement DDQN\\n bla = torch.from_numpy(np.zeros(64)).float().to(device)\\n for i in range(64):\\n bla[i] = self.qnetwork_target(next_states[i]).detach()[self.qnetwork_local(next_states).detach().argmax(1)[i]]\\n Q_targets_next = bla.unsqueeze(1)\\n #this was my first try of ddqn in python style, but as i said i'm a noob and didn't get it working\\n #Q_targets_next = [self.qnetwork_target(next_states).detach()[i] for i in self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)]\\n \\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def __init__(self, epsilon=0.05, gamma=0.9, alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n RQLearningAgent.__init__(self, **args)\",\n \"def q_learning(env, learning, discount, epsilon, min_eps, episodes):\\n # [18.00000072 14.00000006]\\n num_states = (env.observation_space.high - env.observation_space.low) * \\\\\\n np.array([10, 100]) # >> [18.00000072 14.00000006]\\n num_states = np.round(num_states, 0).astype(int) + 1 # >> [19 15]\\n\\n # Initialize Q table\\n # env.action_space.n return the number of action that our agent can make (here 3, left, cease, right)\\n Q = np.random.uniform(low=-1, high=1, size=(num_states[0], num_states[1], env.action_space.n))\\n\\n # Initialize variable to track rewards\\n reward_list = []\\n ave_reward_list = []\\n\\n # Calculate episodic reduction in epsilon\\n reduction = (epsilon - min_eps) / (episodes / 2)\\n\\n for i in range(episodes):\\n # Initialize parameters\\n done = False\\n tot_reward, reward = 0, 0\\n state = env.reset()\\n\\n # Discretize state\\n state_adj = adjust_state(state)\\n\\n while done != True:\\n # Render env for last five eps\\n if i >= (episodes - 20):\\n env.render()\\n\\n # Determine next action - epsilon greedy strategy\\n if np.random.random() < 1 - epsilon:\\n action = np.argmax(Q[state_adj[0], state_adj[1]])\\n else:\\n action = np.random.randint(0, env.action_space.n)\\n\\n # Get next state and reward\\n state2, reward, done, info = env.step(action)\\n\\n # Discretize state2\\n state2_adj = adjust_state(state2)\\n\\n # Allow for terminal states // .5 on env_space[0] represent the flag position\\n if done and state2[0] >= .5:\\n Q[state_adj[0], state_adj[1], action] = reward\\n\\n # adjust Q value for current state\\n else:\\n '''work on this, it's complicated but far from non-understandable'''\\n delta = learning*(reward + discount*np.max(Q[state2_adj[0], state2_adj[1]]) -\\n Q[state_adj[0], state_adj[1], action])\\n Q[state_adj[0], state_adj[1], action] += delta\\n\\n tot_reward += reward\\n state_adj = state2_adj\\n\\n # Decay epsilon\\n if epsilon > min_eps:\\n epsilon -= reduction\\n\\n # Track rewards\\n reward_list.append(tot_reward)\\n\\n if (i+1) % 100 == 0:\\n ave_reward = np.mean(reward_list)\\n ave_reward_list.append(ave_reward)\\n reward_list = []\\n print(f'Episode {i+1} Average Reward: {ave_reward}')\\n\\n env.close()\\n\\n return ave_reward_list\",\n \"def learn(self, state, action, reward, next_state):\\r\\n\\r\\n \\\"\\\"\\\"Please Fill Your Code Here.\\r\\n \\\"\\\"\\\"\\r\\n self.Q[state][action] = self.Q[state][action] + self.alpha * (reward + self.gamma * max(self.Q[next_state]) - self.Q[state][action])\\r\\n\\r\\n return 0\",\n \"def __init__(self, epsilon=0.05,gamma=0.6, alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n F1QLearningAgent.__init__(self, **args)\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones, weights, indexes = experiences\\n\\n q_expected, q_targets = self.get_target_and_expected(states, \\n actions, \\n rewards, \\n next_states, \\n dones, \\n gamma)\\n\\n #print('q_expected.shape', q_expected.shape)\\n #print('q_targets.shape', q_targets.shape)\\n \\n # Compute loss\\n ##### deltas = F.mse_loss(q_expected, q_targets)\\n deltas = q_expected - q_targets\\n #print('loss.shape', loss.data.cpu().numpy().shape)\\n #print('loss', loss)\\n \\n _sampling_weights = (torch.Tensor(weights)\\n .view((-1, 1)))\\n \\n # mean square error\\n loss = torch.mean((deltas * _sampling_weights)**2)\\n\\n # importance sampling weights used to correct bias introduced \\n # by prioritisation experience replay\\n # See Annealing the bias https://arxiv.org/abs/1511.05952\\n #with torch.no_grad():\\n # weight = sum(np.multiply(weights, loss.data.cpu().numpy()))\\n # print('weight', weight)\\n # loss *= weight\\n # print('weights.shape', weights.shape)\\n # print('loss type', type(loss))\\n # print('loss shape', loss.size())\\n # loss *= weights\\n # Minimize the loss\\n # call zero_grad before calling backward() \\n # o.w. gradients are accumulated from multiple passes\\n self.optimizer.zero_grad()\\n # backward computes dloss/dx for every parameter x\\n loss.backward()\\n # updates parameters\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU) \\n \\n # ------------------- update priorities ------------------- # \\n priorities = abs(deltas.detach()).numpy()\\n #priorities = abs(q_expected.detach() - q_targets.detach()).numpy()\\n self.memory.update_priorities(priorities, indexes)\",\n \"def q_learning_simulation(env, N=1000):\\n env.reset()\\n agent = QLearningAgent(env, use_sklearn=True)\\n total_rewards = np.empty(N)\\n\\n for n in tqdm(range(N)):\\n # There are 3 different kinds of epsilon to try\\n #eps = 1.0/np.sqrt(n+1)\\n #eps = 0.3\\n eps = 0.1*(0.97**n)\\n total_reward = agent.play(epsilon=eps, env=env, gamma=0.99)\\n total_rewards[n] = total_reward\\n if (n + 1) % 100 == 0:\\n telegram_send.send(messages=[\\\"episode: {}, total reward: {}\\\".format(n, total_reward)])\\n\\n avgReward = total_rewards[-100:].mean()\\n totalsteps = -total_rewards.sum()\\n telegram_send.send(messages=[\\n \\\"Agent training complete! Please check your plots.\\\",\\n \\\"Average reward for last 100 episodes: {}.\\\".format(avgReward),\\n \\\"Total steps: {}\\\".format(totalsteps)\\n ])\\n\\n # Sanity check on training\\n plt.plot(total_rewards)\\n plt.title(\\\"Rewards\\\")\\n plt.show()\\n plot_running_avg(total_rewards)\\n\\n # Test if the agent is properly trained\\n agent.play(epsilon=0, env=env, gamma=0.99, render=True)\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\\n\\n # loading an existing q-table\\n # self.loadTableFromFile('approxQweights.pkl')\",\n \"def __init__(self, alpha = 0.4, gamma=0.2, n=1):\\n self.epsilon = 0.3 # chance of taking a random action instead of the best\\n\\n # stats part\\n\\n self.reward=[]\\n self.totalCount=0\\n self.totalOnTarget=0\\n self.shootCount=0\\n\\n\\n self.phasesTemp=0\\n self.phasesOnTarget=[]\\n\\n self.arrowAngleCount=dict()\\n self.arrowAngleOn=dict()\\n self.loadStats()\\n\\n ##QLearning varaibles\\n self.q_table = {}\\n self.loadTrainedData()\\n self.n, self.alpha, self.gamma = n, alpha, gamma\",\n \"def learn(self):\\r\\n \\r\\n # take a mini-batch from replay experience\\r\\n cur_batch_size = min(len(self.replay_exp), self.batch_size)\\r\\n mini_batch = random.sample(self.replay_exp, cur_batch_size)\\r\\n \\r\\n # batch data\\r\\n sample_states = np.ndarray(shape = (cur_batch_size, self.state_size)) # replace 128 with cur_batch_size\\r\\n sample_actions = np.ndarray(shape = (cur_batch_size, 1))\\r\\n sample_rewards = np.ndarray(shape = (cur_batch_size, 1))\\r\\n sample_next_states = np.ndarray(shape = (cur_batch_size, self.state_size))\\r\\n sample_dones = np.ndarray(shape = (cur_batch_size, 1))\\r\\n\\r\\n temp=0\\r\\n for exp in mini_batch:\\r\\n sample_states[temp] = exp[0]\\r\\n sample_actions[temp] = exp[1]\\r\\n sample_rewards[temp] = exp[2]\\r\\n sample_next_states[temp] = exp[3]\\r\\n sample_dones[temp] = exp[4]\\r\\n temp += 1\\r\\n \\r\\n \\r\\n sample_qhat_next = self.brain_target.predict(sample_next_states)\\r\\n \\r\\n # set all Q values terminal states to 0\\r\\n sample_qhat_next = sample_qhat_next * (np.ones(shape = sample_dones.shape) - sample_dones)\\r\\n # choose max action for each state\\r\\n sample_qhat_next = np.max(sample_qhat_next, axis=1)\\r\\n \\r\\n sample_qhat = self.brain_policy.predict(sample_states)\\r\\n \\r\\n for i in range(cur_batch_size):\\r\\n a = sample_actions[i,0]\\r\\n sample_qhat[i,int(a)] = sample_rewards[i] + self.gamma * sample_qhat_next[i]\\r\\n \\r\\n q_target = sample_qhat\\r\\n \\r\\n self.brain_policy.fit(sample_states, q_target, epochs = 1, verbose = 0)\\r\\n \\r\\n \\r\\n \\r\\n \\\"\\\"\\\"\\r\\n \\r\\n for state, action, reward, next_state, done in mini_batch:\\r\\n target_Q_s_a = 0 # new target for Q(s,a)\\r\\n state = np.reshape(state, [1, state_size])\\r\\n next_state = np.reshape(next_state, [1, state_size])\\r\\n \\r\\n # if it is not the terminal state\\r\\n if not done:\\r\\n qhat_next = self.brain_target.predict(next_state) # estimate Q(s',a')\\r\\n target_Q_s_a = reward + self.gamma * np.amax(qhat_next[0]) # because the output is m * n, so we need to consider the dimension [0]\\r\\n else:\\r\\n target_Q_s_a = reward\\r\\n \\r\\n target_output = self.brain_policy.predict(state) # we will replace target of Q(s,a) for specific a later\\r\\n target_output[0][action] = target_Q_s_a # new target for state s and action a\\r\\n \\r\\n self.brain_policy.fit(state, target_output, epochs = 1, verbose = 0)\\r\\n \\r\\n \\\"\\\"\\\"\",\n \"def update(self, state, action, nextState, reward):\\n \\\"\\\"\\\"Description:\\n Use Q-Learning algoritm in slide 58 of MDP\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n maxQns = self.getValue(nextState) # get max q-value of next state\\n if maxQns == None:\\n maxQns = 0\\n Qsa = self.getQValue(state, action) #self.qValues[(state, action)]\\n difference = reward + self.discountRate * maxQns - Qsa\\n self.qValues[(state, action)] += self.alpha * difference\\n \\n self.vitCount[(state, action)] += 1\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def main():\\n\\t# GET THE DIALOG CONTENT\\n\\tpolicyFlag = int(sys.argv[3])\\n\\tif policyFlag == 0:\\n\\t\\texistedIterNum = 15000\\n\\t\\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05'\\n\\telif policyFlag == 1:\\n\\t\\texistedIterNum = 10000\\n\\t\\texistedThetaFileName = 'algorithms/theta/cycle_tree/of0w1.0g5v0.0625l0.05Retroflex'\\n\\n\\tqLearnOpts = {'gamma': 1.0, \\n\\t\\t\\t\\t 'alpha': 0.0, \\n\\t\\t\\t\\t 'epsilon': 0.0}\\n\\tnumOfTurn = util.returnConvertedIndexListCount('b','cycle_tree')\\n\\tnumofgauss = 5\\n\\tvar = 0.0625\\n\\tlamda = 0.05\\n\\tunitNum = 101\\n\\ta = qlearningAgents.FittedQLearningAgent(numOfTurn,numofgauss,var,lamda,unitNum, **qLearnOpts)\\t\\t\\n\\ta.openThetaFile(existedThetaFileName,existedIterNum)\\n\\n\\tturnNum = int(sys.argv[1])\\n\\tuserUnitScore = []\\n\\tuserUnitScoreVector = sys.argv[2].split(',')\\n\\tfor i in userUnitScoreVector:\\n\\t\\t\\tuserUnitScore.append(float(i)/100.0)\\n\\n\\tstate = State.State(turnNum, userUnitScore)\\n\\tprint a.getAction(state)\",\n \"def q_human(episodes = 1000, fill_table = False):\\n path = os.getcwd()\\n grid = AdvGridworld()\\n os.chdir(path)\\n print(grid.name + ' with Q-Learning Human Agent')\\n gamma = 0.95\\n learning_rate = 0.01\\n agent = QLearning(8, gamma, learning_rate)\\n\\n liRewards = []\\n\\n for i in range(episodes):\\n grid.reset()\\n state = grid.state\\n width = grid.getBoardDim()[0]\\n top_right_unex = True\\n bottom_left_unex = True\\n while not grid.isEnd:\\n state_ind = state[1]*(width+1)+state[0]\\n if fill_table:\\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\\n action = np.random.choice(actions, 1)[0]\\n else:\\n action = agent.get_action(state_ind)\\n next_state, reward, is_end = grid.step(action)\\n next_state_ind = next_state[1]*(width+1)+next_state[0]\\n #makes a 2 shape\\n if (next_state_ind not in [0,1,2,3,10,17,24,23,22,21,28,35,42,43,44,45,46,47,48]):\\n reward = -10\\n\\n agent.train(state_ind, action, reward, next_state_ind)\\n state = next_state\\n #print(i, grid.reward)\\n liRewards.append(grid.reward)\\n rewards = np.array(liRewards)\\n print(\\\"Rewards Info for \\\", episodes, ' Episodes')\\n print('Size', rewards.size)\\n print('Mean', np.mean(rewards, axis=0))\\n print('Stdev', np.std(rewards, axis=0))\\n print('Min', np.min(rewards))\\n print('Max', np.max(rewards))\\n\\n return rewards, agent\",\n \"def run_q_agent(policy='ε–greedy', save=False):\\n\\tagent = Q_Agent()\\n\\tall_iterations, all_rewards, step_count = agent.train(env, iter_n=1000, policy=policy)\\n\\tplot_reward(all_iterations, all_rewards)\\n\\tplot_steps(all_iterations, step_count)\\n\\t# print(\\\"best route is {}\\\".format(agent.test(env)))\\n\\t# if save:\\n\\t# \\tsave_results(all_iterations, all_rewards, step_count)\\n\\t# optimum_route = agent.test(env, stations)\\n\\t# print(optimum_route)\",\n \"def _transition_q_learning(self):\\n if self.state.as_tuple() not in self.qstore.q:\\n self.enum.enumerate_state(self.state, self.qstore.q)\\n\\n action_values = self.qstore.q[self.state.as_tuple()]\\n # epsilon greedy choice\\n if np.random.random() < self.epsilon:\\n action = State(*action_values['actions'][np.random.randint(len(action_values['actions']))])\\n else:\\n max_q_value = max(action_values['utilities'])\\n max_q_indexes = [i for i in range(len(action_values['actions'])) if\\n action_values['utilities'][i] == max_q_value]\\n max_actions = [action_values['actions'][i] for i in max_q_indexes]\\n action = State(*max_actions[np.random.randint(len(max_actions))])\\n\\n self.state = action.copy()\\n\\n self._post_transition_updates()\",\n \"def __init__(self, state_size, action_size, seed, verbose=False, **kwargs):\\n\\n # Set agent class variables\\n self.t_step = 0\\n self.name = kwargs.get('name', 'dqn_agent')\\n self.run_id = kwargs.get('run_id', int(time.time()))\\n self.output = kwargs.get('output', \\n Path('./output/' + str(self.run_id) + '/'))\\n self.rng = None\\n self.rng_seed = None\\n self.verbose = verbose\\n\\n # Set environment variables\\n self.state_size = state_size\\n self.action_size = action_size\\n \\n # Set agent training hyperparameters\\n self.hidden = kwargs.get('hidden', [256,128,64]) # hidden layer architecture\\n self.buffer_size = kwargs.get('buffer_size', int(1e5)) # replay buffer size\\n self.batch_size = kwargs.get('batch_size', 64) # minibatch size\\n self.gamma = kwargs.get('gamma', 0.99) # discount factor\\n self.tau = kwargs.get('tau', 1e-3) # for soft update of target parameters\\n self.lr = kwargs.get('lr', 5e-4) # learning rate \\n self.update_every = kwargs.get('update_every', 4) # how often to update the network \\n self.device = torch.device(\\n \\\"cuda:0\\\" if torch.cuda.is_available() else \\\"cpu\\\"\\n )\\n\\n # Set seed\\n self.seed(seed)\\n\\n # Set agent q-networks & optimizer\\n self.qnetwork_local = QNetwork(\\n self.state_size, self.action_size, self.rng_seed, self.hidden\\n ).to(self.device)\\n self.qnetwork_target = QNetwork(\\n self.state_size, self.action_size, self.rng_seed, self.hidden\\n ).to(self.device)\\n self.optimizer = optim.Adam(\\n self.qnetwork_local.parameters(), lr=self.lr)\\n\\n # Replay memory\\n self.memory = ReplayBuffer(\\n action_size=self.action_size, \\n buffer_size=self.buffer_size, \\n batch_size=self.batch_size, \\n seed=self.rng_seed,\\n device=self.device\\n )\\n\\n # Log class parameters\\n self._log_parameters()\\n\\n return\",\n \"def __init__(self, env, agent_config: Munch):\\n\\n super(Agent_DQN, self).__init__(env=env, agent_config=agent_config)\\n\\n ###########################\\n # YOUR IMPLEMENTATION HERE #\\n self.state = Munch({**self.state,\\n \\\"step\\\": 0,\\n \\\"num_actions\\\": env.action_space.n,\\n \\\"metrics_capture_window\\\": agent_config.metrics_capture_window,\\n \\\"replay_size\\\": agent_config.replay_size,\\n \\\"position\\\": 0,\\n \\\"total_num_steps\\\": agent_config.total_num_steps,\\n \\\"episodes\\\": agent_config.episodes,\\n \\\"gamma\\\": agent_config.gamma,\\n \\\"learning_rate\\\": agent_config.learning_rate,\\n \\\"initial_epsilon\\\": agent_config.initial_epsilon,\\n \\\"final_epsilon\\\": agent_config.final_epsilon,\\n \\\"epsilon\\\": agent_config.initial_epsilon,\\n \\\"steps_to_explore\\\": agent_config.steps_to_explore,\\n \\\"network_update_interval\\\": agent_config.network_update_interval,\\n \\\"network_train_interval\\\": agent_config.network_train_interval,\\n \\\"batch_size\\\": agent_config.batch_size,\\n \\\"mode\\\": \\\"Random\\\",\\n \\\"state_counter_while_testing\\\": 0,\\n \\\"beta\\\": agent_config.beta,\\n \\\"lambda_val\\\": agent_config.lambda_val,\\n \\\"eta\\\": agent_config.eta\\n })\\n # self.run_name = agent_config.run_name\\n # self.state.model_save_path = agent_config.model_save_path\\n # self.state.model_save_interval = agent_config.model_save_interval\\n # self.log_path = agent_config.log_path\\n # self.tensorboard_summary_path = agent_config.tensorboard_summary_path\\n self.is_cuda_available = torch.cuda.is_available()\\n self.device = torch.device(\\\"cuda\\\" if self.is_cuda_available else \\\"cpu\\\")\\n # self.state.model_test_path = agent_config.model_test_path\\n # self.state.step = 0\\n\\n # Environment and network parameters\\n # self.env = env\\n # self.state.num_actions = env.action_space.n\\n self.action_list = np.arange(self.state.num_actions)\\n self.input_shape = [4, 84, 84]\\n # self.state.metrics_capture_window = agent_config.metrics_capture_window\\n # self.state.replay_size = agent_config.replay_size\\n self.replay_memory = []\\n # self.state.position = 0\\n # self.state.total_num_steps = agent_config.total_num_steps\\n # self.state.episodes = agent_config.episodes\\n # self.state.gamma = agent_config.gamma\\n # self.state.learning_rate = agent_config.learning_rate\\n # self.state.initial_epsilon = agent_config.initial_epsilon\\n # self.state.final_epsilon = agent_config.final_epsilon\\n # self.state.epsilon = self.state.initial_epsilon\\n # self.state.steps_to_explore = agent_config.steps_to_explore\\n self.state.epsilon_step = (self.state.initial_epsilon - self.state.final_epsilon) / self.state.steps_to_explore\\n\\n # self.state.network_update_interval = agent_config.network_update_interval\\n # self.state.network_train_interval = agent_config.network_train_interval\\n\\n self.last_n_rewards = deque([], self.state.metrics_capture_window)\\n self.start_to_learn = agent_config.start_to_learn\\n self.ddqn = agent_config.ddqn\\n self.use_icm = agent_config.use_icm\\n self.intrinsic_episode_reward = []\\n self.last_n_intrinsic_rewards = deque([], self.state.metrics_capture_window)\\n\\n # self.state.batch_size = agent_config.batch_size\\n # self.state.mode = \\\"Random\\\"\\n # self.state.state_counter_while_testing = 0\\n self.q_network = DQN(env=env, args=self.state.config).to(self.device)\\n self.target_network = DQN(env=env, args=self.state.config).to(self.device)\\n self.loss_function = F.smooth_l1_loss\\n self.optimiser = optim.Adam(self.q_network.parameters(), lr=agent_config.learning_rate)\\n self.probability_list = np.zeros(env.action_space.n, np.float32)\\n self.q_network.train()\\n self.target_network.eval()\\n\\n self.icm_model = ICM(env=env, num_actions=self.state.num_actions, args=self.state.config).to(self.device)\\n\\n self.inverse_loss_fn = nn.CrossEntropyLoss()\\n self.forward_loss_fn = nn.MSELoss()\\n\\n # self.state.beta = agent_config.beta\\n # self.state.lambda_val = agent_config.lambda_val\\n # self.state.eta = agent_config.eta\\n\\n # create necessary paths\\n # self.create_dirs()\\n self.meta = None\\n\\n if agent_config.test_dqn:\\n print('loading trained model')\\n self.q_network.load_state_dict(torch.load(self.state.model_test_path, map_location=self.device))\\n\\n # self.log_file = open(self.state.model_save_path + '/' + self.run_name + '.log', 'w') if not agent_config.test_dqn else None\\n\\n # Set target_network weight\\n self.target_network.load_state_dict(self.q_network.state_dict())\\n\\n # self.writer = SummaryWriter(agent_config.tensorboard_summary_path)\",\n \"def agentTraining(noOfDecks,\\r\\n sampleSpaceSearching,\\r\\n sampleSpaceExploitation,\\r\\n method,\\r\\n gamma,\\r\\n qTable=None):\\r\\n deckSize = noOfDecks*52\\r\\n optimalScore = 0 # winning score and losing Score\\r\\n egreedyScore = 0\\r\\n pO = [0,0,0]\\r\\n pe = [0,0,0]\\r\\n\\r\\n gamePlay = Dealing(noOfDecks)\\r\\n gamePlay.newRound()\\r\\n \\r\\n agent = adp(deckSize,\\r\\n gamePlay.deck,\\r\\n gamePlay.hitScore,\\r\\n gamePlay.partialDealerScore,\\r\\n gamePlay.dealerScore,\\r\\n gamePlay.aceCount,\\r\\n gamePlay.aceCriticalHit,\\r\\n gamma)\\r\\n \\r\\n # for iterating \\r\\n if qTable !=None:\\r\\n if type(qTable) == int:\\r\\n agent.QList = []\\r\\n else: \\r\\n for trajectory in range(len(qTable)):\\r\\n agent.QList.append(qTable[trajectory])\\r\\n # for qtable, expect form: [[(trajector1)], [(initialSize,remainingAmount,agentScore,dealerScore',\\r\\n # NoOfAces,twoAcesOrMore,reward,decision),...]]\\r\\n \\r\\n for trajectoryNumber in range(sampleSpaceSearching + sampleSpaceExploitation):\\r\\n exploredStateAction = []\\r\\n while gamePlay.ifGameEnd() == False: \\r\\n \\r\\n if trajectoryNumber < sampleSpaceSearching: # condition for still exploring \\r\\n \\r\\n e = 100 / (100+len(exploredStateAction)) # as explore more, more likely to\\r\\n # stick to optimal policy\\r\\n action = agent.eGreedyPolicyQTable(e, \\r\\n deckSize,\\r\\n gamePlay.remainingDeckSize,\\r\\n gamePlay.hitScore, # true cards\\r\\n gamePlay.partialDealerScore, # visible to agent\\r\\n gamePlay.dealerScore, # true cards\\r\\n gamePlay.aceCount,#8\\r\\n gamePlay.aceCriticalHit)#8\\r\\n else: # if in exploitation phase \\r\\n action = agent.optimalPolicyQTable(deckSize,\\r\\n gamePlay.remainingDeckSize,\\r\\n gamePlay.hitScore,\\r\\n gamePlay.partialDealerScore,#8\\r\\n gamePlay.dealerScore,\\r\\n gamePlay.aceCount,#8\\r\\n gamePlay.aceCriticalHit)#8\\r\\n\\r\\n numRemaining = gamePlay.remainingDeckSize\\r\\n agentScore = gamePlay.hitScore\\r\\n agentVisScore = gamePlay.partialDealerScore\\r\\n actualDealerScore = gamePlay.dealerScore\\r\\n numOfaces = gamePlay.aceCount\\r\\n criticalAce = gamePlay.aceCriticalHit # boolean \\r\\n reward = gamePlay.actionOutcome(action)\\r\\n # if gamePlay.actionOutcome(action) method executed, newround or hit method is \\r\\n # also exectued. this inturn updates gameplay details. Hence assigned \\r\\n # variables prior to method excecution\\r\\n stateAction = (deckSize, numRemaining,\\r\\n agentScore,agentVisScore,\\r\\n actualDealerScore, numOfaces,\\r\\n criticalAce, reward,\\r\\n action)\\r\\n\\r\\n if stateAction not in agent.QList and (agentScore >= actualDealerScore\\r\\n and agentScore <= gamePlay.blackJack):\\r\\n # if not a repeated state-action anywhere in my searchedSpace, save it\\r\\n exploredStateAction.append(stateAction)\\r\\n \\r\\n if gamePlay.ifGameEnd() == True:\\r\\n agent.QList.append(exploredStateAction)\\r\\n agent.QTableUpdate(method,\\r\\n reward,\\r\\n gamma)\\r\\n break\\r\\n\\r\\n if trajectoryNumber > sampleSpaceSearching: # optimal policy \\r\\n if reward > 0: \\r\\n optimalScore += gamePlay.hitScore**2\\r\\n pO[0] +=1 # winning points\\r\\n if reward ==0:\\r\\n pO[1] +=1 \\r\\n if reward < 0:\\r\\n pO[2] += 1\\r\\n \\r\\n else: # eGreedy policy \\r\\n if reward > 0: \\r\\n egreedyScore += gamePlay.hitScore**2\\r\\n pe[0] +=1 # winning points\\r\\n if reward ==0:\\r\\n pe[1] +=1\\r\\n if reward < 0:\\r\\n pe[2] +=1\\r\\n \\r\\n print(\\\"Deck size = {} deck(s) using policy\\\"\\r\\n \\\" search method: {}\\\".format(gamePlay.deckSize,\\r\\n method)) \\r\\n \\r\\n print(\\\"The agent exploration period = {} rounds.Followed by {}\\\"\\r\\n \\\" rounds of exploitation\\\".format(sampleSpaceSearching,sampleSpaceExploitation))\\r\\n\\r\\n print(\\\"The Agent average quadratic score per game exploration phase = {}\\\"\\r\\n \\\" The exploitation quadratic score per game = {}\\\"\\r\\n \\\" In terms of winning and loosing against the house,\\\"\\r\\n \\\" the Agent wins {}% draws {}% and loses {}% on the training (explore) stage, followed by \\\"\\r\\n \\\" wins {}% draws {}% and loses {}% on the\\\"\\r\\n \\\" testing (exploitation) stage \\\".format((egreedyScore/sampleSpaceSearching),\\r\\n (optimalScore/sampleSpaceExploitation),\\r\\n np.round(pe[0]/sum(pe)*100,1 ),\\r\\n np.round(pe[1]/sum(pe)*100,1 ),\\r\\n np.round(pe[2]/sum(pe)*100,1 ),\\r\\n np.round(pO[0]/sum(pO)*100,1 ),\\r\\n np.round(pO[1]/sum(pO)*100,1 ),\\r\\n np.round(pO[2]/sum(pO)*100,1 ))) \\r\\n\\r\\n return agent.QList, pe, pO, egreedyScore, optimalScore\",\n \"def q_learning(env, model, episodes, gamma=0.9,\\n epsilon=0.3, eps_decay=0.99,\\n replay=False, replay_size=20,\\n title='DQL', double=False,\\n n_update=10, soft=False, verbose=True):\\n final = []\\n memory = []\\n episode_i = 0\\n sum_total_replay_time = 0\\n for episode in range(episodes):\\n episode_i += 1\\n if double and not soft:\\n # Update target network every n_update steps\\n if episode % n_update == 0:\\n model.target_update()\\n if double and soft:\\n model.target_update()\\n\\n # Reset state\\n state = env.reset()\\n done = False\\n total = 0\\n\\n while not done:\\n # Implement greedy search policy to explore the state space\\n if random.random() < epsilon:\\n action = env.action_space.sample()\\n else:\\n q_values = model.predict(state)\\n action = torch.argmax(q_values).item()\\n\\n # Take action and add reward to total\\n next_state, reward, done, _ = env.step(action)\\n\\n # Update total and memory\\n total += reward\\n memory.append((state, action, next_state, reward, done))\\n q_values = model.predict(state).tolist()\\n\\n if done:\\n if not replay:\\n q_values[action] = reward\\n # Update network weights\\n model.update(state, q_values)\\n break\\n\\n if replay:\\n t0 = time.time()\\n # Update network weights using replay memory\\n model.replay(memory, replay_size, gamma)\\n t1 = time.time()\\n sum_total_replay_time += (t1 - t0)\\n else:\\n # Update network weights using the last step only\\n q_values_next = model.predict(next_state)\\n q_values[action] = reward + gamma * torch.max(q_values_next).item()\\n model.update(state, q_values)\\n\\n state = next_state\\n\\n # Update epsilon\\n epsilon = max(epsilon * eps_decay, 0.01)\\n final.append(total)\\n plot_res(final, title)\\n\\n if verbose:\\n print(\\\"episode: {}, total reward: {}\\\".format(episode_i, total))\\n if replay:\\n print(\\\"Average replay time:\\\", sum_total_replay_time / episode_i)\\n\\n return final\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n Q_targets_next = self.qnetwork_target(\\n next_states).detach().max(1)[0].unsqueeze(1)\\n \\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, self.tau) \\n\\n return\",\n \"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n QLearningAgent.__init__(self, **args)\\n\\n self.tf = OverfeatTransformer(output_layers = [-1], force_reshape = False)\\n self.weights = util.Counter()\",\n \"def __init__(self,\\n num_actions,\\n\\n tau,\\n alpha=1,\\n clip_value_min=-10,\\n\\n net_conf = None,\\n env = \\\"CartPole\\\", \\n normalize_obs = True,\\n hidden_layer=2, \\n neurons=512,\\n replay_scheme='prioritized',\\n noisy = False,\\n dueling = False,\\n initzer = 'xavier_uniform',\\n target_opt=0,\\n mse_inf=False,\\n network=networks.NatureDQNNetwork,\\n optimizer='adam',\\n epsilon_fn=dqn_agent.linearly_decaying_epsilon,\\n seed=None):\\n # We need this because some tools convert round floats into ints.\\n seed = int(time.time() * 1e6) if seed is None else seed\\n self._net_conf = net_conf\\n self._env = env \\n self._normalize_obs = normalize_obs\\n self._hidden_layer = hidden_layer\\n self._neurons=neurons \\n self._noisy = noisy\\n self._dueling = dueling\\n self._initzer = initzer\\n self._target_opt = target_opt\\n self._mse_inf = mse_inf\\n self._tau = tau\\n self._alpha = alpha\\n self._clip_value_min = clip_value_min\\n self._rng = jax.random.PRNGKey(seed)\\n\\n super(JaxDQNAgentNew, self).__init__(\\n num_actions= num_actions,\\n network= functools.partial(network, \\n num_actions=num_actions,\\n net_conf=self._net_conf,\\n env=self._env,\\n normalize_obs=self._normalize_obs,\\n hidden_layer=self._hidden_layer, \\n neurons=self._neurons,\\n noisy=self._noisy,\\n dueling=self._dueling,\\n initzer=self._initzer),\\n optimizer=optimizer,\\n epsilon_fn=dqn_agent.identity_epsilon if self._noisy == True else epsilon_fn)\\n\\n \\n self._replay_scheme = replay_scheme\",\n \"def __init__(self, epsilon=0.05,gamma=0.6, alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n FQLearningAgent.__init__(self, **args)\",\n \"def learn(self, experiences, gamma):\\n\\n states, actions, rewards, next_states, dones = experiences\\n\\n Q_targets = self.get_dqg_target(next_states, rewards, gamma, dones)\\n\\n # Get expected Q values\\n q_exp = self.qnetwork_local(states)\\n\\n # gets the q values along dimention 1 according to the actions, which is used as index\\n # >>> t = torch.tensor([[1,2],[3,4]])\\n # >>> torch.gather(t, 1, torch.tensor([[0],[1]]))\\n # tensor([[ 1],\\n # [ 4]])\\n q_exp = q_exp.gather(1, actions)\\n\\n # compute loss\\n loss = F.mse_loss(q_exp, Q_targets)\\n\\n # reset optimizer gradient\\n self.optimizer.zero_grad()\\n # do backpropagation\\n loss.backward()\\n # do optimize step\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, PARAM.TAU)\",\n \"def perform_q_learning(self, prev_state: str, state: str, action: Action, reward):\\n max_future_q = max(self.Qs[state].values())\\n self.Qs[prev_state][action] = (1.0 - self.alpha) * self.Qs[prev_state][\\n action] + self.alpha * (reward + self.gamma * max_future_q)\\n self.Vs[prev_state] = max(self.Qs[prev_state].values())\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones, idxs, weights = experiences\\n \\n\\n # Get max predicted Q values (for next states) from target model\\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss MSE\\n loss = (Q_expected - Q_targets.detach()).pow(2)\\n # Add weights to loss\\n loss = loss * weights\\n # Add noise to loss to arrive at prior weights\\n prios = loss + 1e-6\\n # Take mean\\n loss = loss.mean()\\n\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # Update buffer priorities\\n self.memory.update_priorities(zip(idxs, prios.data.cpu().numpy()))\\n\\n\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def qlearning(alpha, gamma, epsilon, episodes, max_steps, n_tests, render = False, test=False):\\n env = gym.make('Taxi-v2')\\n n_states, n_actions = env.observation_space.n, env.action_space.n\\n Q = init_q(n_states, n_actions, type=\\\"ones\\\")\\n timestep_reward = []\\n for episode in range(episodes):\\n print(f\\\"Episode: {episode}\\\")\\n s = env.reset()\\n a = epsilon_greedy(Q, epsilon, n_actions, s)\\n t = 0\\n total_reward = 0\\n done = False\\n while t < max_steps:\\n if render:\\n env.render()\\n t += 1\\n s_, reward, done, info = env.step(a)\\n total_reward += reward\\n a_ = np.argmax(Q[s_, :])\\n if done:\\n Q[s, a] += alpha * ( reward - Q[s, a] )\\n else:\\n Q[s, a] += alpha * ( reward + (gamma * Q[s_, a_]) - Q[s, a] )\\n s, a = s_, a_\\n if done:\\n if render:\\n print(f\\\"This episode took {t} timesteps and reward: {total_reward}\\\")\\n timestep_reward.append(total_reward)\\n break\\n if render:\\n print(f\\\"Here are the Q values:\\\\n{Q}\\\\nTesting now:\\\")\\n if test:\\n test_agent(Q, env, n_tests, n_actions)\\n return timestep_reward\",\n \"def learn(env,\\n env_test,\\n env_test1,\\n q_func,\\n optimizer_spec,\\n optimizer_spec_omega,\\n optimizer_spec_term,\\n session,\\n options,\\n exploration=LinearSchedule(1000000, 0.1),\\n stopping_criterion=None,\\n replay_buffer_size=1000000,\\n batch_size=32,\\n gamma=0.99,\\n xi=None,\\n learning_starts=50000,\\n learning_freq=4,\\n frame_history_len=4,\\n target_update_freq=10000,\\n grad_norm_clipping=10,\\n eval_obs_array=None,\\n room_q_interval=1e5,\\n epoch_size=5e4,\\n log_dir=None,\\n transfer_config=None,\\n random_length=1000):\\n\\n Costs = []\\n loss_term_log = []\\n average_loss_term = []\\n loss_omega_log = []\\n average_loss_omega = []\\n Average_costs = []\\n test_rewards = []\\n test_rewards1= []\\n none_discount = []\\n none_discount1 = []\\n short_average = []\\n short_average1 = []\\n short_average_none = []\\n short_average_none1 = []\\n test_q_max_log = []\\n test_u_log = []\\n test_omega_log = []\\n Episode_num = 0\\n\\n online_q_omega = False\\n online_termination = True\\n q_omega_uniform_sample = False\\n four_to_two = False\\n no_share_para = False\\n target_beta = False\\n termination_stop = False\\n beta_no_bias = False\\n\\n debug_no_term_train = False\\n\\n obs_random_batch = None\\n\\n if transfer_config:\\n if transfer_config.has_key('online_q_omega'):\\n online_q_omega = transfer_config['online_q_omega']\\n if transfer_config.has_key('online_termination'):\\n online_termination = transfer_config['online_termination']\\n if transfer_config.has_key('q_omega_uniform_sample'):\\n q_omega_uniform_sample = transfer_config['q_omega_uniform_sample']\\n if transfer_config.has_key('four_to_two'):\\n four_to_two = transfer_config['four_to_two']\\n if transfer_config.has_key('no_share_para'):\\n no_share_para = transfer_config['no_share_para']\\n if transfer_config.has_key('target_beta'):\\n target_beta = transfer_config['target_beta']\\n if transfer_config.has_key('xi'):\\n xi = transfer_config['xi']\\n if transfer_config.has_key('termination_stop'):\\n termination_stop = transfer_config['termination_stop']\\n if transfer_config.has_key('beta_no_bias'):\\n beta_no_bias = transfer_config['beta_no_bias']\\n\\n if transfer_config.has_key('debug_no_term_train'):\\n debug_no_term_train = transfer_config['debug_no_term_train']\\n\\n assert type(env.observation_space) == gym.spaces.Box\\n assert type(env.action_space) == gym.spaces.Discrete\\n if four_to_two:\\n assert frame_history_len == 4\\n\\n ###############\\n # BUILD MODEL #\\n ###############\\n\\n img_h, img_w, img_c = env.observation_space.shape\\n input_history_len = 2 if four_to_two else frame_history_len\\n input_shape = (img_h, img_w, input_history_len * img_c)\\n num_actions = env.action_space.n\\n # source + primitive\\n num_options = len(options)\\n\\n # set up placeholders\\n # placeholder for current observation (or state)\\n obs_t_ph = tf.placeholder(tf.uint8, [None] + list(input_shape))\\n # placeholder for current action\\n act_t_ph = tf.placeholder(tf.int32, [None])\\n # placeholder for current option\\n opt_t_ph = tf.placeholder(tf.int32, [None])\\n # placeholder for current options whose actions are the same as action taken (k-hot)\\n opa_t_ph = tf.placeholder(tf.float32, [None] + [num_options])\\n # placeholder for current reward\\n rew_t_ph = tf.placeholder(tf.float32, [None])\\n # placeholder for next observation (or state)\\n obs_tp1_ph = tf.placeholder(tf.uint8, [None] + list(input_shape))\\n # placeholder for end of episode mask\\n # this value is 1 if the next state corresponds to the end of an episode,\\n # in which case there is no Q-value at the next state; at the end of an\\n # episode, only the current state reward contributes to the target, not the\\n # next state Q-value (i.e. target is just rew_t_ph, not rew_t_ph + gamma * q_tp1)\\n done_mask_ph = tf.placeholder(tf.float32, [None])\\n Episode_reward = tf.placeholder(tf.float32)\\n\\n # casting to float on GPU ensures lower data transfer times.\\n obs_t_float = tf.cast(obs_t_ph, tf.float32) / 255.0\\n obs_tp1_float = tf.cast(obs_tp1_ph, tf.float32) / 255.0\\n\\n # Here, you should fill in your own code to compute the Bellman error. This requires\\n # evaluating the current and next Q-values and constructing the corresponding error.\\n # TensorFlow will differentiate this error for you, you just need to pass it to the\\n # optimizer. See assignment text for details.\\n # Your code should produce one scalar-valued tensor: total_error\\n # This will be passed to the optimizer in the provided code below.\\n # Your code should also produce two collections of variables:\\n # q_func_vars\\n # target_q_func_vars\\n # These should hold all of the variables of the Q-function network and target network,\\n # respectively. A convenient way to get these is to make use of TF's \\\"scope\\\" feature.\\n # For example, you can create your Q-function network with the scope \\\"q_func\\\" like this:\\n # <something> = q_func(obs_t_float, num_actions, scope=\\\"q_func\\\", reuse=False)\\n # And then you can obtain the variables like this:\\n # q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='q_func')\\n # Older versions of TensorFlow may require using \\\"VARIABLES\\\" instead of \\\"GLOBAL_VARIABLES\\\"\\n ######\\n \\n # YOUR CODE HERE\\n q_current, q_omega_current, term_current = q_func(obs_t_float, num_actions, num_options, scope='q_func', reuse=False, no_share_para=no_share_para, termination_stop=termination_stop, beta_no_bias=beta_no_bias)\\n q_target, q_omega_target, term_target = q_func(obs_tp1_float, num_actions, num_options, scope='target_q_func', reuse=False, no_share_para=no_share_para, termination_stop=termination_stop, beta_no_bias=beta_no_bias)\\n q_next_current, q_omega_next_current, term_next_current = q_func(obs_tp1_float, num_actions, num_options, scope='q_func', reuse=True, no_share_para=no_share_para, termination_stop=termination_stop, beta_no_bias=beta_no_bias)\\n if debug_no_term_train:\\n term_next_current_old = term_next_current = term_current = term_target = tf.constant(1.0, dtype=tf.float32, shape=(1, num_options))\\n\\n\\n\\n # q_value\\n q_val_current = tf.reduce_sum(q_current * tf.one_hot(act_t_ph, num_actions), axis=-1)\\n q_val_next_raw = tf.reduce_sum(q_target * tf.one_hot(tf.argmax(q_next_current, axis=-1), num_actions), axis=-1)\\n q_val_next = q_val_next_raw * (1 - done_mask_ph)\\n\\n # q_value error\\n total_error_q = tf.reduce_mean(tf.losses.mean_squared_error(rew_t_ph + gamma * q_val_next, q_val_current))\\n # q_omega_value\\n term_val_next = tf.reduce_sum(term_next_current * tf.one_hot(opt_t_ph, num_options), axis=-1)\\n q_omega_val_next = tf.reduce_sum(q_omega_next_current * tf.one_hot(opt_t_ph, num_options), axis=-1)\\n max_q_omega_next = tf.reduce_max(q_omega_next_current, axis=-1)\\n max_q_omega_next_targ = tf.reduce_sum(q_omega_target * tf.one_hot(tf.argmax(q_omega_next_current, axis=-1), num_options), axis=-1)\\n\\n if target_beta: # change var\\n term_next_current_old = term_next_current\\n term_next_current = term_target\\n\\n u_next_raw = (1 - term_next_current) * q_omega_target + term_next_current * max_q_omega_next_targ[..., None]\\n u_next = tf.stop_gradient(u_next_raw * (1 - done_mask_ph)[..., None])\\n\\n if target_beta: # row back\\n term_next_current = term_next_current_old\\n\\n # q_omega_value error\\n total_error_q_omega = tf.reduce_mean(tf.reduce_sum(\\n opa_t_ph *\\n tf.losses.mean_squared_error(rew_t_ph[..., None] + gamma * u_next, q_omega_current, reduction=tf.losses.Reduction.NONE),\\n axis=-1\\n ))\\n\\n # optimize termination\\n if xi == None:\\n xi = 0.8 * (max_q_omega_next - tf.nn.top_k(q_omega_next_current, 2)[0][:, 1])\\n advantage_go = q_omega_val_next - max_q_omega_next + xi\\n advantage = tf.stop_gradient(advantage_go)\\n # total_error_term = term_val_next * advantage * (1 - done_mask_ph)\\n total_error_term = term_val_next * advantage #修改\\n tf.summary.scalar('total_error_term', total_error_term)\\n # def term_grad(optimizer, objective, var_list, clip_val=10):\\n # gradients = optimizer.compute_gradients(objective, var_list=var_list)\\n # for i, (grad, var) in enumerate(gradients):\\n # if grad is not None:\\n # gradients[i] = (tf.clip_by_norm(grad, clip_val) * advantage_go, var)\\n # return optimizer.apply_gradients(gradients)\\n\\n q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='q_func')\\n # print len(q_func_vars)\\n target_q_func_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES, scope='target_q_func')\\n # print len(target_q_func_vars)\\n\\n\\n # for log purposes\\n # add some tensor for logs\\n u_current = (tf.cast(tf.constant(np.ones(num_options)),\\n tf.float32) - term_current) * q_omega_current + term_current * (tf.reduce_max(q_omega_current,\\n axis=-1))[:, None]\\n max_q_omega = tf.reduce_max(q_omega_current, axis=-1)\\n values1 = tf.nn.top_k(q_omega_current, 2)[0]\\n advantage_current = q_omega_current - max_q_omega[:, None] + 0.8 * (max_q_omega - values1[:, 1])[:, None]\\n term_loss = term_current * advantage_current\\n tf.summary.histogram('u_current', u_current)\\n tf.summary.histogram('advantage_current', advantage_current)\\n tf.summary.histogram('term_loss', term_loss)\\n tf.summary.histogram('term_current', term_current, family='term_current')\\n [tf.summary.histogram('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_current') for i in range(num_options)]\\n [tf.summary.scalar('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_vals') for i in range(num_options)]\\n # summaries_first = [tf.summary.histogram('u_current', u_current),\\n # tf.summary.histogram('advantage_current', advantage_current),\\n # tf.summary.histogram('term_loss', term_loss),\\n # tf.summary.histogram('term_current', term_current, family='term_current'),\\n # [tf.summary.histogram('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_current') for i in range(num_options)],\\n # [tf.summary.scalar('term_current_%d' % (i), tf.reduce_mean(term_current[:, i]), family='term_vals') for i in range(num_options)]]\\n # summaries_diff = [tf.summary.histogram('u_current11', u_current),\\n # tf.summary.histogram('advantage_current1', advantage_current),\\n # tf.summary.histogram('term_loss1', term_loss),\\n # tf.summary.histogram('term_current1', term_current, family='term_current1'),\\n # [tf.summary.histogram('term_current1_%d' % (i), tf.reduce_mean(term_current[:, i]),\\n # family='term_current1') for i in range(num_options)],\\n # [tf.summary.scalar('term_current1_%d' % (i), tf.reduce_mean(term_current[:, i]),\\n # family='term_vals1') for i in range(num_options)]]\\n # merged_summary_diff=tf.summary.merge(summaries_diff)\\n # merged_summary_op = tf.summary.merge(summaries_first)\\n merged_summary_op = tf.summary.merge_all()\\n # summary_second = [tf.summary.scalar(\\\"my_second_graph_loss\\\", Episode_reward)]\\n # merged_summary_op1 = tf.summary.merge(summary_second)\\n summary_writer = tf.summary.FileWriter(log_dir + 'tfb', session.graph)\\n\\n q_max = tf.reduce_max(q_current, 1)\\n u_max = tf.reduce_max(u_current, 1)\\n omega_max = tf.reduce_max(q_omega_current, 1)\\n average_Q = tf.reduce_mean(q_max)\\n average_U = tf.reduce_mean(u_max)\\n average_omega = tf.reduce_mean(omega_max)\\n ######\\n\\n # construct optimization op (with gradient clipping)\\n learning_rate = tf.placeholder(tf.float32, (), name=\\\"learning_rate\\\")\\n learning_rate_omega = tf.placeholder(tf.float32, (), name=\\\"learning_rate_omega\\\")\\n learning_rate_term = tf.placeholder(tf.float32, (), name=\\\"learning_rate_term\\\")\\n optimizer = optimizer_spec.constructor(learning_rate=learning_rate, **optimizer_spec.kwargs)\\n optimizer_omega = optimizer_spec_omega.constructor(learning_rate=learning_rate_omega, **optimizer_spec_omega.kwargs)\\n optimizer_term = optimizer_spec_term.constructor(learning_rate=learning_rate_term, **optimizer_spec_term.kwargs)\\n train_fn = minimize_and_clip(optimizer, total_error_q, var_list=q_func_vars, clip_val=grad_norm_clipping)\\n train_fn_omega = minimize_and_clip(optimizer_omega, total_error_q_omega, var_list=q_func_vars, clip_val=grad_norm_clipping)\\n\\n if debug_no_term_train:\\n train_fn_term = tf.no_op()\\n else:\\n train_fn_term = minimize_and_clip(optimizer_term, total_error_term, var_list=q_func_vars, clip_val=grad_norm_clipping)\\n # train_fn_term = term_grad(optimizer_term, term_val_next, var_list=q_func_vars, clip_val=grad_norm_clipping)\\n\\n # update_target_fn will be called periodically to copy Q network to target Q network\\n update_target_fn = []\\n for var, var_target in zip(sorted(q_func_vars, key=lambda v: v.name),\\n sorted(target_q_func_vars, key=lambda v: v.name)):\\n update_target_fn.append(var_target.assign(var))\\n update_target_fn = tf.group(*update_target_fn)\\n\\n # construct the replay buffer\\n replay_buffer = ReplayBuffer(replay_buffer_size, frame_history_len)\\n\\n # for log purposes\\n replay_buffer_test = ReplayBuffer(10000, frame_history_len)\\n replay_buffer_test1 = ReplayBuffer(10000, frame_history_len)\\n\\n ###############\\n # RUN ENV #\\n ###############\\n model_initialized = False\\n q_model_initialized = False\\n option_activated = False\\n option_running = None\\n num_param_updates = 0\\n mean_episode_reward = -float('nan')\\n best_mean_episode_reward = -float('inf')\\n last_obs = env.reset()\\n next_recent_obs = None\\n idx = replay_buffer.store_frame(last_obs)\\n LOG_EVERY_N_STEPS = 10000\\n running_time = [0, time.time()]\\n\\n for t in itertools.count():\\n ### 1. Check stopping criterion\\n if stopping_criterion is not None and stopping_criterion(env, t):\\n break\\n\\n ### 2. Step the env and store the transition\\n # At this point, \\\"last_obs\\\" contains the latest observation that was\\n # recorded from the simulator. Here, your code needs to store this\\n # observation and its outcome (reward, next observation, etc.) into\\n # the replay buffer while stepping the simulator forward one step.\\n # At the end of this block of code, the simulator should have been\\n # advanced one step, and the replay buffer should contain one more\\n # transition.\\n # Specifically, last_obs must point to the new latest observation.\\n # Useful functions you'll need to call:\\n # obs, reward, done, info = env.step(action)\\n # this steps the environment forward one step\\n # obs = env.reset()\\n # this resets the environment if you reached an episode boundary.\\n # Don't forget to call env.reset() to get a new observation if done\\n # is true!!\\n # Note that you cannot use \\\"last_obs\\\" directly as input\\n # into your network, since it needs to be processed to include context\\n # from previous frames. You should check out the replay buffer\\n # implementation in dqn_utils.py to see what functionality the replay\\n # buffer exposes. The replay buffer has a function called\\n # encode_recent_observation that will take the latest observation\\n # that you pushed into the buffer and compute the corresponding\\n # input that should be given to a Q network by appending some\\n # previous frames.\\n # Don't forget to include epsilon greedy exploration!\\n # And remember that the first time you enter this loop, the model\\n # may not yet have been initialized (but of course, the first step\\n # might as well be random, since you haven't trained your net...)\\n\\n #####\\n \\n # YOUR CODE HERE\\n\\n\\n # store the first random_length frames to calculate the average Q\\n epsilon = exploration.value(t / learning_freq)\\n if next_recent_obs is not None:\\n recent_obs = next_recent_obs\\n else:\\n recent_obs = replay_buffer.encode_recent_observation()\\n\\n # pick an option\\n if not option_activated:\\n if random.random() > epsilon and model_initialized:\\n q_omega_vals = session.run(q_omega_current, {obs_t_ph: recent_obs[None, ..., -input_history_len:]})\\n option_running = np.argmax(q_omega_vals)\\n else:\\n option_running = random.choice(range(num_options))\\n option_activated = True\\n\\n # choose action\\n action = options[option_running].act(recent_obs)\\n\\n # take a step in the environment\\n new_obs, r, done, _ = env.step(action)\\n if done:\\n new_obs = env.reset()\\n\\n # TODO: change replay_buffer to support option storage\\n opa = np.array(\\n [1 if i == option_running or options[i].act(recent_obs) == action else 0 for i in range(num_options)]\\n )\\n # opa[option_running] = 2\\n replay_buffer.store_effect(idx, action, r, done, opa)\\n idx = replay_buffer.store_frame(new_obs)\\n next_recent_obs = replay_buffer.encode_recent_observation()\\n\\n if not model_initialized:\\n initialize_interdependent_variables(session, tf.global_variables(), {\\n obs_t_ph: recent_obs[None, ..., -input_history_len:],\\n obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:],\\n })\\n session.run(update_target_fn)\\n model_initialized = True\\n saver = tf.train.Saver()\\n # checkpoint = tf.train.get_checkpoint_state(\\n # \\\"/home/lsy/PycharmProjects/ple-monstrerkong/examples/dqn_transfer_option/logs/12_16off1c_12_16_17_20:38:47/dqn\\\")\\n # if checkpoint and checkpoint.model_checkpoint_path:\\n # saver.restore(session, checkpoint.model_checkpoint_path)\\n # print(\\\"Successfully loaded: \\\", checkpoint.model_checkpoint_path)\\n # Load = True\\n # else:\\n # print(\\\"Could not find old network weights\\\")\\n\\n # online update q_omega & termination\\n if t > learning_starts and not debug_no_term_train and not done:\\n loss_term, _ = session.run([total_error_term, train_fn_term], feed_dict={\\n obs_t_ph: recent_obs[None, ..., -input_history_len:],\\n opt_t_ph: [option_running],\\n # opa_t_ph: [option_running],\\n # rew_t_ph: [r],\\n obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:],\\n done_mask_ph: [1.0 if done == True else 0.0],\\n learning_rate_omega: optimizer_spec_omega.lr_schedule.value(t / learning_freq),\\n learning_rate_term: optimizer_spec_term.lr_schedule.value(t / learning_freq)\\n })\\n loss_term_log.append(loss_term)\\n if online_q_omega:\\n for i in range(num_options):\\n if opa[i] > 0:\\n _, loss_omega = session.run([train_fn_omega, total_error_q_omega], feed_dict={\\n obs_t_ph: recent_obs[None, ..., -input_history_len:],\\n opa_t_ph: [i],\\n rew_t_ph: [r],\\n obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:],\\n done_mask_ph: [1.0 if done == True else 0.0],\\n learning_rate_omega: optimizer_spec_omega.lr_schedule.value(t / learning_freq),\\n })\\n loss_omega_log.append(loss_omega)\\n\\n\\n term_probs = session.run(term_next_current, {obs_tp1_ph: next_recent_obs[None, ..., -input_history_len:]})\\n # print \\\"term_probs\\\", term_probs\\n if done or not random.random() > term_probs[0][option_running]: # will re-pick an option\\n option_activated = False\\n\\n\\n #####\\n\\n # at this point, the environment should have been advanced one step (and\\n # reset if done was true), and last_obs should point to the new latest\\n # observation\\n\\n ### 3. Perform experience replay and train the network.\\n # note that this is only done if the replay buffer contains enough samples\\n # for us to learn something useful -- until then, the model will not be\\n # initialized and random actions should be taken\\n if (t > learning_starts and\\n t % learning_freq == 0 and\\n replay_buffer.can_sample(batch_size)):\\n # Here, you should perform training. Training consists of four steps:\\n # 3.a: use the replay buffer to sample a batch of transitions (see the\\n # replay buffer code for function definition, each batch that you sample\\n # should consist of current observations, current actions, rewards,\\n # next observations, and done indicator).\\n # 3.b: initialize the model if it has not been initialized yet; to do\\n # that, call\\n # initialize_interdependent_variables(session, tf.global_variables(), {\\n # obs_t_ph: obs_t_batch,\\n # obs_tp1_ph: obs_tp1_batch,\\n # })\\n # where obs_t_batch and obs_tp1_batch are the batches of observations at\\n # the current and next time step. The boolean variable q_model_initialized\\n # indicates whether or not the model has been initialized.\\n # Remember that you have to update the target network too (see 3.d)!\\n # 3.c: train the model. To do this, you'll need to use the train_fn and\\n # total_error ops that were created earlier: total_error is what you\\n # created to compute the total Bellman error in a batch, and train_fn\\n # will actually perform a gradient step and update the network parameters\\n # to reduce total_error. When calling session.run on these you'll need to\\n # populate the following placeholders:\\n # obs_t_ph\\n # act_t_ph\\n # rew_t_ph\\n # obs_tp1_ph\\n # done_mask_ph\\n # (this is needed for computing total_error)\\n # learning_rate -- you can get this from optimizer_spec.lr_schedule.value(t)\\n # (this is needed by the optimizer to choose the learning rate)\\n # 3.d: periodically update the target network by calling\\n # session.run(update_target_fn)\\n # you should update every target_update_freq steps, and you may find the\\n # variable num_param_updates useful for this (it was initialized to 0)\\n #####\\n \\n # YOUR CODE HERE\\n\\n # step a\\n obs_t_batch, act_t_batch, rew_t_batch, obs_tp1_batch, done_mask_batch, opa_batch = replay_buffer.sample(batch_size)\\n\\n # step b\\n if not q_model_initialized:\\n session.run(update_target_fn)\\n q_model_initialized = True\\n\\n # step c --also log cost(loss) TODO: off-policy update q_omega & termination\\n # run_list = [train_fn, total_error_q]\\n run_list = []\\n feed_dict = {\\n obs_t_ph: obs_t_batch[..., -input_history_len:],\\n act_t_ph: act_t_batch,\\n rew_t_ph: rew_t_batch,\\n obs_tp1_ph: obs_tp1_batch[..., -input_history_len:],\\n done_mask_ph: done_mask_batch,\\n learning_rate: optimizer_spec.lr_schedule.value(t / learning_freq)\\n }\\n if not online_q_omega and not q_omega_uniform_sample:\\n run_list.append(train_fn_omega)\\n run_list.append(total_error_q_omega)\\n feed_dict[opa_t_ph] = opa_batch\\n\\n feed_dict[learning_rate_omega] = optimizer_spec_omega.lr_schedule.value(t / learning_freq)\\n # if q_omega_uniform_sample:\\n # _, cost = session.run(run_list, feed_dict=feed_dict)\\n # else:\\n _, loss_omega = session.run(run_list, feed_dict=feed_dict)\\n # Costs.append(cost)\\n if not online_q_omega and q_omega_uniform_sample:\\n obs_t_batch, act_t_batch, rew_t_batch, obs_tp1_batch, done_mask_batch, opa_batch = replay_buffer.sample(batch_size, opa_uniform=True)\\n opa_t_batch = opa_batch\\n _, loss_omega = session.run([train_fn_omega, total_error_q_omega], feed_dict={\\n obs_t_ph: obs_t_batch[..., -input_history_len:],\\n opa_t_ph: opa_t_batch,\\n rew_t_ph: rew_t_batch,\\n obs_tp1_ph: obs_tp1_batch[..., -input_history_len:],\\n done_mask_ph: done_mask_batch,\\n learning_rate_omega: optimizer_spec_omega.lr_schedule.value(t / learning_freq)\\n })\\n\\n loss_omega_log.append(loss_omega)\\n # step d\\n if t % target_update_freq == 0 and q_model_initialized:\\n num_param_updates += 1\\n session.run(update_target_fn)\\n\\n #####\\n\\n ### 4. Log progress\\n if (t > 0) and (t % epoch_size == 0) and (t > learning_starts):\\n average_loss_omega.append(np.mean(np.array(loss_omega_log)[int(-epoch_size):]))\\n average_loss_term.append(np.mean(np.array(loss_term_log)[int(-epoch_size):]))\\n plt.figure(8)\\n plt.plot(average_loss_omega)\\n plt.grid()\\n plt.savefig(log_dir + 'average_loss_omega.png')\\n plt.figure(9)\\n plt.plot(average_loss_term)\\n plt.grid()\\n plt.savefig(log_dir + 'average_loss_term.png')\\n if t % 1e3 == 0 and t > 0:\\n if eval_obs_array:\\n if obs_random_batch is None:\\n # print len(eval_obs_array)\\n if len(eval_obs_array) == 1:\\n if len(eval_obs_array[0]) < 6:\\n obs_random_batch = np.array(eval_obs_array)[0, 0,... , -input_history_len:]\\n else:\\n obs_random_batch = np.array(eval_obs_array)[0, 0:100, 0,..., -input_history_len:]\\n else:\\n obs_random_batch = eval_obs_array[0][0]\\n diff_batch = eval_obs_array[1][0]\\n summary_str = session.run(merged_summary_op, feed_dict={obs_t_ph: obs_random_batch})\\n summary_writer.add_summary(summary_str, t)\\n # summary_str_diff = session.run(merged_summary_diff, feed_dict={obs_t_ph: diff_batch})\\n # summary_writer.add_summary(summary_str_diff, t)\\n # else:\\n # print \\\"no eval_obs_array\\\"\\n episode_rewards = get_wrapper_by_name(env, \\\"Monitor\\\").get_episode_rewards()\\n if len(episode_rewards) > 0:\\n mean_episode_reward = np.mean(episode_rewards[-100:])\\n if len(episode_rewards) > 100:\\n best_mean_episode_reward = max(best_mean_episode_reward, mean_episode_reward)\\n if t % LOG_EVERY_N_STEPS == 0 and q_model_initialized:\\n last_t, last_time = running_time\\n new_t , new_time = t / LOG_EVERY_N_STEPS, time.time()\\n running_time = [new_t, new_time]\\n print \\\"###########################################\\\"\\n print(\\\"Timestep %d\\\" % (t,))\\n print(\\\"Training time per %d timesteps %.2fs\\\" %\\n (LOG_EVERY_N_STEPS, (new_time - last_time) / (new_t - last_t)))\\n print(\\\"mean reward (100 episodes) %f\\\" % mean_episode_reward)\\n print(\\\"best mean reward %f\\\" % best_mean_episode_reward)\\n print(\\\"episodes %d\\\" % len(episode_rewards))\\n print(\\\"exploration %f\\\" % exploration.value(t / learning_freq))\\n print(\\\"learning_rate %f\\\" % optimizer_spec.lr_schedule.value(t / learning_freq))\\n # evaluate q functions for different rooms (log_dir should exist!)\\n if t % epoch_size == 0 and log_dir != None and t > learning_starts:\\n saver.save(session, log_dir + 'dqn/', global_step=t)\\n if eval_obs_array:\\n Q_current, U_max, Omega_max = session.run([average_Q, average_U, average_omega], feed_dict={obs_t_ph: obs_random_batch})\\n print(\\\"evaluated q values for eval_obs_array\\\")\\n test_q_max_log.append(Q_current)\\n test_u_log.append(U_max)\\n test_omega_log.append(Omega_max)\\n plt.figure(10)\\n plt.plot(test_u_log)\\n plt.grid()\\n plt.savefig(log_dir + 'test_u_max.png')\\n plt.figure(11)\\n plt.plot(test_omega_log)\\n plt.grid()\\n plt.savefig(log_dir + 'test_omega_max.png')\\n else:\\n print(\\\"no eval_obs_array! q values are not evaluated! check your config\\\")\\n sys.stdout.flush()\\n\\n # tests & log cost\\n # add a step: test 10000 step after 50000 step\\n if t % epoch_size == 0 and log_dir != None and q_model_initialized:\\n\\n # test Q_omega and beta\\n option_activated_test = False\\n option_running_test = None\\n last_obs_test1 = env_test1.reset()\\n replay_buffer_test1.store_frame(last_obs_test1)\\n h = 0\\n episode_num1 = 1\\n test_step1 = 0\\n done_test1 = False\\n next_recent_obs_test = None\\n while test_step1 < 5000 or done_test1 == False:\\n if next_recent_obs_test is not None:\\n recent_obs_test = next_recent_obs_test\\n else:\\n recent_obs_test = replay_buffer_test1.encode_recent_observation()\\n # pick an option\\n if not option_activated_test:\\n if random.random() > 0.05:\\n q_omega_test = session.run(q_omega_current,\\n {obs_t_ph: recent_obs_test[None, ..., -input_history_len:]})\\n option_running_test = np.argmax(q_omega_test)\\n else:\\n option_running_test = random.choice(range(num_options))\\n option_activated_test = True\\n\\n # choose action\\n action_test1 = options[option_running_test].act(recent_obs_test)\\n\\n new_obs_test, r_test1, done_test1, _ = env_test1.step(action_test1)\\n h += 1\\n test_step1 += 1\\n if done_test1:\\n # option_activated_test = False\\n reward = r_test1 * (gamma ** h)\\n h = 0\\n # summary_str1 = session.run(merged_summary_op1, feed_dict={Episode_reward: reward})\\n # summary_writer.add_summary(summary_str1, global_step=Episode_num)\\n Episode_num += 1\\n if test_step1 < 5000:\\n new_obs_test = env_test1.reset()\\n episode_num1 += 1\\n\\n replay_buffer_test1.store_frame(new_obs_test)\\n next_recent_obs_test = replay_buffer_test1.encode_recent_observation()\\n term_probs_test = session.run(term_next_current,\\n {obs_tp1_ph: next_recent_obs_test[None, ..., -input_history_len:]})\\n if done_test1 or not random.random() > term_probs_test[0][option_running_test]: # will re-pick an option\\n option_activated_test = False\\n\\n episode_rewards_test1 = get_wrapper_by_name(env_test1, \\\"Monitor\\\").get_episode_rewards()\\n episode_lengths_test1 = get_wrapper_by_name(env_test1, \\\"Monitor\\\").get_episode_lengths()\\n evaluation_metric1 = np.array(episode_rewards_test1) * (gamma ** np.array(episode_lengths_test1))\\n test_reward1 = np.mean(evaluation_metric1)\\n none_discount_average1 = np.mean(episode_rewards_test1)\\n none_discount1.append(none_discount_average1)\\n short_average1.append(np.mean(evaluation_metric1[-episode_num1:]))\\n short_average_none1.append(np.mean(episode_rewards_test1[-episode_num1:]))\\n test_rewards1.append(test_reward1)\\n plt.figure(12)\\n plt.plot(test_rewards1)\\n plt.grid()\\n plt.savefig(log_dir + 'test_rewards1.png')\\n plt.figure(13)\\n plt.plot(none_discount1)\\n plt.grid()\\n plt.savefig(log_dir + 'none_discount1.png')\\n plt.figure(14)\\n plt.plot(short_average1)\\n plt.grid()\\n plt.savefig(log_dir + 'short_average1.png')\\n plt.figure(15)\\n plt.plot(short_average_none1)\\n plt.grid()\\n plt.savefig(log_dir + 'short_average_none1.png')\\n plt.figure(1)\\n plt.plot(evaluation_metric1)\\n plt.grid()\\n plt.savefig(log_dir + 'episode_reward.png')\\n\\n with open(log_dir + '/pkl/test_rewards1.pkl', 'wb') as output:\\n pickle.dump(test_rewards1, output)\\n with open(log_dir + '/pkl/none_discount1.pkl', 'wb') as output:\\n pickle.dump(none_discount1, output)\\n with open(log_dir + '/pkl/short_average1.pkl', 'wb') as output:\\n pickle.dump(short_average1, output)\\n with open(log_dir + '/pkl/short_average_none1.pkl', 'wb') as output:\\n pickle.dump(short_average_none1, output)\\n with open(log_dir + '/pkl/episode_reward.pkl', 'wb') as output:\\n pickle.dump(evaluation_metric1, output)\\n with open(log_dir + '/pkl/test_omega_log.pkl', 'wb') as output:\\n pickle.dump(test_omega_log, output)\",\n \"def learn(self, experiences, gamma):\\n \\n states, actions, rewards, next_states, dones = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def initiate_agent(self, env):\\n from keras import Sequential\\n from keras.optimizers import Adam\\n from keras.layers import Dense, Dropout\\n from rl.memory import SequentialMemory\\n from rl.agents import DQNAgent\\n\\n self.env = env\\n\\n nb_actions = self.env.action_space.n\\n\\n model = Sequential()\\n model.add(Dense(512, activation='relu', input_shape=env.observation_space))\\n model.add(Dropout(0.2))\\n model.add(Dense(512, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(512, activation='relu'))\\n model.add(Dropout(0.2))\\n model.add(Dense(nb_actions, activation='linear'))\\n\\n # Finally, we configure and compile our agent. You can use every built-in Keras optimizer and\\n # even the metrics!\\n memory = SequentialMemory(limit=memory_limit, window_length=window_length)\\n policy = TrumpPolicy()\\n from rl.core import Processor\\n\\n class CustomProcessor(Processor):\\n \\\"\\\"\\\"he agent and the environment\\\"\\\"\\\"\\n\\n def process_state_batch(self, batch):\\n \\\"\\\"\\\"\\n Given a state batch, I want to remove the second dimension, because it's\\n useless and prevents me from feeding the tensor into my CNN\\n \\\"\\\"\\\"\\n return np.squeeze(batch, axis=1)\\n\\n def process_info(self, info):\\n processed_info = info['player_data']\\n if 'stack' in processed_info:\\n processed_info = {'x': 1}\\n return processed_info\\n\\n nb_actions = env.action_space.n\\n\\n self.dqn = DQNAgent(model=model, nb_actions=nb_actions, memory=memory, nb_steps_warmup=nb_steps_warmup,\\n target_model_update=1e-2, policy=policy,\\n processor=CustomProcessor(),\\n batch_size=batch_size, train_interval=train_interval, enable_double_dqn=enable_double_dqn)\\n self.dqn.compile(Adam(lr=1e-3), metrics=['mae'])\",\n \"def interact(env, agent, num_episodes=30, window=1):\\r\\n # initialize average rewards\\r\\n average_reward_per_100_episodes = []\\r\\n best_average_reward_per_100_episodes = []\\r\\n avg_rewards = deque(maxlen=num_episodes)\\r\\n # initialize best average reward\\r\\n best_avg_reward = -math.inf\\r\\n # initialize monitor for most recent rewards\\r\\n samp_rewards = deque(maxlen=window)\\r\\n\\r\\n\\r\\n answer = input(\\\"Load QTable? (y/n) ?\\\")\\r\\n if answer == \\\"y\\\":\\r\\n # Do this.\\r\\n an = input(\\\"Name ?\\\")\\r\\n agent.q_table.readQ(an)\\r\\n agent.q_table.readStateList(an)\\r\\n agent.observation_space = np.size(agent.q_table.q, 0)\\r\\n agent.q_table.stateCount = len(agent.q_table.stateList)\\r\\n #print(\\\"files not found\\\")\\r\\n elif answer == \\\"n\\\":\\r\\n # Do that.\\r\\n pass\\r\\n else:\\r\\n print(\\\"Please enter y or n\\\")\\r\\n\\r\\n start_time = time.time()\\r\\n # for each episode\\r\\n for i_episode in range(1, num_episodes+1):\\r\\n # begin the episode\\r\\n state_array,state, state_with_act = env.reset()\\r\\n #if state <= agent.q_table.observation_space -1:\\r\\n #print('next state is in q table')\\r\\n y = agent.q_table.addStateList(state_with_act[state][4], state_with_act[state][1], state_with_act[state][2])\\r\\n if y != -1:\\r\\n print (\\\"state is in the stateList\\\")\\r\\n else : \\r\\n #agent.addState(state)\\r\\n y= agent.q_table.stateCount\\r\\n # initialize the sampled reward\\r\\n samp_reward = 0\\r\\n while True:\\r\\n #print(\\\"new action starts\\\")\\r\\n # agent selects an action\\r\\n action = agent.select_action(y)\\r\\n # agent performs the selected action\\r\\n next_state, reward,done, indices, stateENV, action_count = env.step(action)\\r\\n time.sleep(0.3)\\r\\n #print(\\\"indices =\\\")\\r\\n #print(indices)\\r\\n # agent performs internal updates based on sampled experience\\r\\n \\r\\n #if next_state <= agent.q_table.observation_space -1:\\r\\n #print('next state is in q table')\\r\\n x = agent.q_table.addStateList(stateENV[next_state][4], stateENV[next_state][1], stateENV[next_state][2])\\r\\n if x != -1:\\r\\n print (\\\"state is in the stateList\\\")\\r\\n else : \\r\\n #agent.addState(state)\\r\\n x= agent.q_table.stateCount\\r\\n #print (\\\"next state =\\\"+str(next_state))\\r\\n #print (\\\"observation_space\\\" + str(agent.q_table.observation_space-1))\\r\\n #agent.step(state, action, reward, next_state, indices)\\r\\n agent.step(y, action, reward, x, indices)\\r\\n #print('stateList = ')\\r\\n #print(agent.q_table.stateList)\\r\\n # update the sampled reward\\r\\n samp_reward += reward\\r\\n # update the state (s <- s') to next time step\\r\\n y = x\\r\\n agent.update_epsilon()\\r\\n if done:\\r\\n # save final sampled reward\\r\\n samp_rewards.append(samp_reward)\\r\\n break\\r\\n \\r\\n lenStateCOunt = len(agent.q_table.stateList)\\r\\n time_end = time.time()\\r\\n saveEpisodeResult(start_time,time_end,i_episode, lenStateCOunt)\\r\\n\\r\\n\\r\\n \\r\\n\\r\\n if (i_episode >= 100):\\r\\n # get average reward from last 100 episodes\\r\\n avg_reward = np.mean(samp_rewards)\\r\\n # append to deque\\r\\n avg_rewards.append(avg_reward)\\r\\n # update best average reward\\r\\n print('episode average reward {}'.format(avg_reward))\\r\\n average_reward_per_100_episodes.append(avg_reward)\\r\\n best_average_reward_per_100_episodes.append(best_avg_reward)\\r\\n if avg_reward > best_avg_reward:\\r\\n best_avg_reward = avg_reward\\r\\n print (\\\"State with activities =\\\")\\r\\n for key,value in stateENV.items():\\r\\n print(str(key) + '. ')\\r\\n print(str(stateENV[key][0]) + ', ' + str(stateENV[key][1])+ ', ' + str(stateENV[key][2]) + ', ' + str(stateENV[key][4]))\\r\\n \\r\\n # monitor progress\\r\\n print(\\\"\\\\rEpisode {}/{} || Best average reward {} || eps {} \\\".format(i_episode, num_episodes, best_avg_reward, agent.epsilon), end=\\\"\\\")\\r\\n sys.stdout.flush()\\r\\n \\r\\n # check if task is solved (according to OpenAI Gym)\\r\\n if best_avg_reward >= 9.7:\\r\\n print('\\\\nEnvironment solved in {} episodes.'.format(i_episode), end=\\\"\\\")\\r\\n agent.q_table.saveQ(best_avg_reward,appName)\\r\\n agent.q_table.saveStateList(appName)\\r\\n print(\\\"width = \\\"+ str(action_count))\\r\\n saveEpToCSV()\\r\\n save_rewards_csv(average_reward_per_100_episodes, best_average_reward_per_100_episodes)\\r\\n break\\r\\n if i_episode == num_episodes: \\r\\n agent.q_table.saveQ(best_avg_reward,appName)\\r\\n agent.q_table.saveStateList(appName)\\r\\n print(\\\"width = \\\"+ str(action_count))\\r\\n saveEpToCSV()\\r\\n save_rewards_csv(average_reward_per_100_episodes, best_average_reward_per_100_episodes)\\r\\n print('\\\\n')\\r\\n\\r\\n end_time = time.time()\\r\\n time_lapsed = end_time - start_time\\r\\n time_convert(time_lapsed)\\r\\n return avg_rewards, best_avg_reward\\r\\n print(\\\"width = \\\"+ str(action_count))\",\n \"def getAction1(self, state):\\n action = QLearningAgent.getAction1(self,state)\\n################################################################################################################################ Eric Changed Stuff Below\\n #print \\\"ACTION IN PACMANQAGENT: \\\", action\\n self.doAction(state,action)\\n return action\",\n \"def q_learning(env, agent, num_episodes, batch_size, epsilon, epsilon_min, epsilon_decay, folder):\\n \\n # Keeps track of useful statistics\\n stats = plotting.EpisodeStats(\\n episode_lengths=np.zeros(num_episodes),\\n episode_rewards=np.zeros(num_episodes))\\n\\n\\n for i_episode in range(num_episodes):\\n if epsilon > epsilon_min and i_episode > 500:\\n # complete random exploration 500 episodes, \\n # then decrase exploration till epsilon less than epsilon_min\\n epsilon *= epsilon_decay\\n sys.stdout.flush()\\n\\n state = env.reset()\\n state = np.reshape(state, [1, env.nS])\\n\\n \\n for t in range(MAX_STEP):\\n\\n ## Decide action\\n action = agent.act(state, epsilon)\\n ## Advance the game to the next frame based on the action\\n next_state, reward, done, _ = env.step(action)\\n\\n env.my_render(folder)\\n\\n stats.episode_rewards[i_episode] += reward\\n stats.episode_lengths[i_episode] = t+1\\n\\n next_state = np.reshape(next_state, [1, env.nS])\\n ## Remember the previous state, action, reward, and done\\n agent.remember(state, action, reward, next_state, done)\\n ## make next_state the new current state for the next frame.\\n state = next_state ## change to copy.copy(next_state), if it is a array\\n\\n if len(agent.memory) > batch_size:\\n agent.replay(batch_size) \\n\\n if done: \\n break\\n \\n mean_score = stats.episode_rewards[i_episode]/stats.episode_lengths[i_episode]\\n print(\\\"episode: {}/{}, score: {}, e: {:.2}, steps:{}, mean score:{:.2}\\\"\\n .format(i_episode, num_episodes, stats.episode_rewards[i_episode], epsilon, \\n stats.episode_lengths[i_episode], \\n mean_score))\\n #if(i_episode > 200):\\n write_csv(folder, i_episode, stats.episode_lengths[i_episode], mean_score)\\n if(i_episode%50 == 0):\\n agent.save(folder + \\\"_qn\\\" + str(i_episode) + \\\".h5\\\") \\n agent.save(folder + \\\"_qn-final\\\" + \\\".h5\\\") \\n\\n return stats\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n # print('learn states.shape', states.shape)\\n # print('learn next_states.shape', next_states.shape)\\n \\n q_expected, q_targets = self.get_target_and_expected(states, \\n actions, \\n rewards, \\n next_states, \\n dones, \\n gamma)\\n\\n\\n # Compute loss\\n loss = F.mse_loss(q_expected, q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def __init__(self,\\n sess,\\n num_actions,\\n observation_shape=base_dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,\\n gamma=0.99,\\n update_horizon=1,\\n min_replay_history=20000,\\n update_period=4,\\n target_update_period=8000,\\n epsilon_fn=linearly_decaying_epsilon,\\n epsilon_train=0.01,\\n epsilon_eval=0.001,\\n epsilon_decay_period=250000,\\n tf_device='/cpu:*',\\n use_staging=True,\\n max_tf_checkpoints_to_keep=3,\\n optimizer=tf.train.RMSPropOptimizer(\\n learning_rate=0.00025,\\n decay=0.95,\\n momentum=0.0,\\n epsilon=0.00001,\\n centered=True),\\n summary_writer=None,\\n summary_writing_frequency=500,\\n clip_reward=False):\\n self._clip_reward = clip_reward\\n self.intrinsic_model = intrinsic_rewards.RNDIntrinsicReward(\\n sess=sess,\\n tf_device=tf_device,\\n summary_writer=summary_writer)\\n super(RNDDQNAgent, self).__init__(\\n sess=sess,\\n num_actions=num_actions,\\n observation_shape=observation_shape,\\n gamma=gamma,\\n update_horizon=update_horizon,\\n min_replay_history=min_replay_history,\\n update_period=update_period,\\n target_update_period=target_update_period,\\n epsilon_fn=epsilon_fn,\\n epsilon_train=epsilon_train,\\n epsilon_eval=epsilon_eval,\\n epsilon_decay_period=epsilon_decay_period,\\n tf_device=tf_device,\\n use_staging=use_staging,\\n optimizer=optimizer,\\n summary_writer=summary_writer,\\n summary_writing_frequency=summary_writing_frequency)\",\n \"def learn(self):\\n Qsa = self.evalQsa(self.features)[self.chosenA]\\n print Qsa\\n dQ = self.alpha*(self.reward + self.gamma * self.maxQsa(self.next_features) - Qsa)\\n self.thetas += dQ*self.features[:,self.chosenA]\\n print self.thetas\\n # self.thetas /= np.sqrt(np.sum(np.power(self.thetas,2)))\",\n \"def learn(self):\\r\\n last_experience = self.memory[-1]\\r\\n Q_target = np.zeros(self.action_size)\\r\\n Q_target[last_experience[1]] = last_experience[2]\\r\\n self.model.fit(last_experience[0], Q_target[None,:], epochs=5, verbose=0)\\r\\n minibatch = random.sample(self.memory, self.minibatch_size)\\r\\n for obs, action, reward, next_obs, done in minibatch:\\r\\n Q_target = np.zeros(self.action_size)\\r\\n if done:\\r\\n Q_target[action] = reward\\r\\n if not done:\\r\\n Q_target[action] = reward + self.gamma*np.amax(self.model.predict(next_obs)[0])\\r\\n self.model.fit(obs, Q_target[None,:], epochs=1, verbose=0)\\r\\n if (self.epsilon > self.epsilon_min):\\r\\n self.epsilon *= self.epsilon_decay\",\n \"def __init__(self, state_size, action_size, fc1_units, fc2_units, buffer_size, batch_size, alpha, gamma, tau,\\n local_update_every, target_update_every, seed, a, b, b_increase, b_end, dbl_dqn=False, priority_rpl=False, duel_dqn=False):\\n self.state_size = state_size\\n self.action_size = action_size\\n self.seed = random.seed(seed)\\n\\n # Hyperparameters\\n self.alpha = alpha # Learning rate\\n self.gamma = gamma # Discount parameter\\n self.tau = tau # Interpolation parameter\\n self.local_update_every = local_update_every # Number of actions to take before updating local net weights\\n self.target_update_every = target_update_every # Number of actions to take before updating target net weights\\n self.batch_size = batch_size # Number of experiences to sample during learning\\n self.buffer_size = buffer_size # Size of memory buffer\\n self.a = a # Sampling probability (0=random | 1=priority)\\n self.b = b # Influence of importance sampling weights over learning\\n self.b_increase = b_increase # Amount to increase b by every learning step\\n self.b_end = b_end # Maximum value for b\\n\\n # Agent modifications\\n self.dbl_dqn = dbl_dqn # Double Q Learning\\n self.priority_rpl = priority_rpl # Prioritised Experience Replay\\n self.duel_dqn = duel_dqn # Duelling Q Networks\\n\\n # Q-Network\\n if self.duel_dqn:\\n self.qnetwork_local = DuellingQNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\\n self.qnetwork_target = DuellingQNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\\n else:\\n self.qnetwork_local = QNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\\n self.qnetwork_target = QNetwork(state_size, action_size, fc1_units, fc2_units, seed).to(device)\\n self.optimizer = optim.Adam(self.qnetwork_local.parameters(), lr=self.alpha)\\n\\n # Replay memory\\n self.memory = ReplayBuffer(action_size, buffer_size, batch_size, seed, priority_rpl)\\n # Initialize time step (for updating every local_update_every/target_update_every steps)\\n self.t_step = 0\",\n \"def __init__(self, epsilon=0.05, gamma=0.95, alpha=0.2, numTraining=0, **args):\\n args['epsilon'] = epsilon\\n args['gamma'] = gamma\\n args['alpha'] = alpha\\n args['numTraining'] = numTraining\\n self.index = 0 # This is always Pacman\\n PQLearningAgent.__init__(self, **args)\",\n \"def rl_alone(episodes = 1000, fill_table = False):\\n path = os.getcwd()\\n grid = AdvGridworld()\\n os.chdir(path)\\n print(grid.name + ' with Q-Learning Agent')\\n gamma = 0.95\\n learning_rate = 0.01\\n agent = QLearning(8, gamma, learning_rate)\\n\\n liRewards = []\\n\\n #action_index = {\\\"up\\\":0,\\\"right\\\":1,\\\"down\\\":2,\\\"left\\\":3,\\\"upri\\\":4,\\\"dori\\\":5,\\\"dole\\\":6,\\\"uple\\\":7}\\n\\n for i in range(episodes):\\n grid.reset()\\n state = grid.state\\n width = grid.getBoardDim()[0]\\n while not grid.isEnd:\\n state_ind = state[1]*(width+1)+state[0]\\n #If we want a filled Q-tables, we can't let the agent be optimal\\n #or else we wouldn't know the q-values for never reached state-action pairs\\n if fill_table:\\n actions = [0, 1, 2, 3, 4, 5, 6, 7]\\n action = np.random.choice(actions, 1)[0]\\n else:\\n action = agent.get_action(state_ind)\\n next_state, reward, is_end = grid.step(action)\\n next_state_ind = next_state[1]*(width+1)+next_state[0]\\n agent.train(state_ind, action, reward, next_state_ind)\\n state = next_state\\n\\n liRewards.append(grid.reward)\\n rewards = np.array(liRewards)\\n print(\\\"Rewards Info for \\\", episodes, ' Episodes')\\n print('Size', rewards.size)\\n print('Mean', np.mean(rewards, axis=0))\\n print('Stdev', np.std(rewards, axis=0))\\n print('Min', np.min(rewards))\\n print('Max', np.max(rewards))\\n\\n return rewards, agent\",\n \"def q_learning_episode(self, policy):\\n state = self.env.reset(self.agent_start_pos)\\n done = False\\n\\n while not done:\\n action = policy(state, self.q_values)\\n next_cell = self.env.move(self.env.agent_position, action)\\n s_next, rew, done, _ = self.env.step(next_cell)\\n greedy_action_next = actions_dict[np.argmax(self.q_values[s_next])]\\n self.update_q_values(state, action, rew, s_next, greedy_action_next)\\n state = s_next\",\n \"def learn(self, experiences, gamma):\\n self.optimizer.zero_grad()\\n\\n states, actions, rewards, next_states, dones = experiences\\n\\n best_actions = self.qnetwork_local(next_states).detach().argmax(1).unsqueeze(1)\\n q_values_target = self.qnetwork_target(next_states).detach()\\n q_expected = rewards + (gamma * q_values_target.gather(1, best_actions)) * (1 - dones)\\n q_current = self.qnetwork_local(states).gather(1, actions)\\n\\n loss = F.mse_loss(q_expected, q_current)\\n\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, dqn_agent.TAU)\",\n \"def __init__(self, n_trials, v0, n_options, probs, r_mag, l_mag, params, gamble, \\\\\\n\\t\\tUCB=False, UCB_samplemean=False, gamma=0, anneal=False):\\n\\n\\t\\tsz = n_trials\\n\\t\\tself.n_options = n_options\\t\\t\\t\\t\\t# number of choices\\n\\t\\tself.Q = np.zeros((sz+1,n_options)) +\\tv0\\t# critic\\n\\t\\tself.alpha, self.beta = params\\t\\t\\t\\t# learning rate, softmax\\n\\t\\tself.SM = np.zeros((sz, n_options))\\t\\t# Softmax values\\n\\t\\tself.rho = np.zeros(sz)\\t\\t\\t\\t\\t\\t# DA at choice\\n\\t\\tself.C = np.zeros(sz,dtype=np.int)\\t\\t\\t# choice\\n\\t\\tself.R = np.zeros(sz,dtype=np.int)\\t\\t\\t# indicator variable of reward\\n\\t\\tself.probs = probs\\t\\t\\t\\t\\t\\t\\t# prob of reward for choice\\n\\t\\tself.r_mag = r_mag\\t\\t\\t\\t\\t\\t\\t# magnitude of reward for choice\\n\\t\\tself.l_mag = l_mag\\t\\t\\t\\t\\t\\t\\t# magnitude of loss for choice\\n\\t\\tself.PE = np.zeros(sz)\\t\\t\\t\\t\\t\\t# choice PE\\n\\t\\tself.idx = 0\\t\\t\\t\\t\\t\\t\\t\\t# idx of trial in state \\n\\t\\tself.gamble = gamble\\t\\t\\t\\t\\t\\t# gamble paradigm?\\n\\t\\tself.UCB = UCB\\t\\t\\t\\t\\t\\t\\t\\t# Use UCB for policy?\\t\\n\\t\\tself.UCB_samplemean = UCB_samplemean\\t\\t# Use sample mean instead of Q value\\n\\t\\tself.gamma = gamma\\t\\t\\t\\t\\t\\t\\t# Exploration parameter\\t\\n\\t\\tself.N = np.zeros((sz+1, n_options))\\t\\t# number of times action selected\\n\\t\\tself.R_by_a = np.zeros((sz+1, n_options))\\t# number of times rewarded for action\\n\\t\\tself.Acts = np.zeros((sz+1,n_options))\\t\\t# act values\",\n \"def train_q_learner(board: Board, num_rounds: int,\\n ignorance_bias: float = 0,\\n discount_rate: float = 0.9,\\n learning_rate: float = 0.1,\\n title: str = '') -> dict:\\n labels = [DRAW, TabularQLearning.name, Random.name]\\n outcome_counts = {label: 0 for label in labels}\\n percentages = {label: [] for label in labels}\\n q_table_a = None\\n #q_table_b = None\\n for idx in range(num_rounds):\\n board_clone = board.clone()\\n q_learning_agent = TabularQLearning(board_clone, player_idx=0,\\n q_table_a=q_table_a,\\n #q_table_b=q_table_b,\\n use_double_q_table=True,\\n ignorance_bias=ignorance_bias,\\n discount_rate=discount_rate,\\n learning_rate=learning_rate,\\n #counter=idx,\\n #max_counter=num_rounds\\n )\\n random_agent = Random(board_clone, player_idx=1)\\n outcome = play_mnk(board_clone, q_learning_agent, random_agent, verbose=False)\\n outcome_counts[outcome] += 1\\n q_table_a = q_learning_agent.q_table_a\\n #q_table_b = q_learning_agent.q_table_b\\n\\n total = sum(outcome_counts.values())\\n for label in labels:\\n percentages[label].append(outcome_counts[label] / total)\\n\\n x_axis = list(range(num_rounds))[PLOT_DELAY:]\\n for label in labels:\\n plt.plot(x_axis, percentages[label][PLOT_DELAY:], label=label)\\n plt.title(title)\\n plt.legend()\\n plt.show()\\n return percentages\",\n \"def q_learning_minibatch(self):\\n if self.experience.count <= self.history_length:\\n # Cannot train because not enough experiences.\\n return [], 0, False\\n else:\\n # Sample experience.\\n s_t, action, reward, s_t_plus_1, terminal = self.experience.sample()\\n\\n terminal = np.array(terminal) + 0.\\n\\n # Predicted and target q-values for time t+1.\\n max_q_t_plus_1 = self.target_network.eval_max_outputs(s_t_plus_1)\\n target_q_t = (1. - terminal) * self.discount_r * max_q_t_plus_1 + reward\\n\\n # Run training ops.\\n _, q_t, loss = self.sess.run([self.optim, self.pred_network.outputs, self.loss], {\\n self.targets: target_q_t,\\n self.actions: action,\\n self.pred_network.inputs: s_t,\\n })\\n\\n return q_t, loss, True\",\n \"def __init__(self, state_size, action_size, **kwargs):\\n super(DQNAgent, self).__init__(state_size, action_size, **kwargs)\\n self.state_size = state_size\\n self.action_size = action_size\\n\\n # Q-Network\\n self.main_network = DQN(state_size, action_size).to(device)\\n self.target_network = DQN(state_size, action_size).to(device)\\n self.optimizer = optim.Adam(self.main_network.parameters(), lr=LR)\\n\\n # Replay memory\\n self.memory = Replay(BUFFER_SIZE, BATCH_SIZE)\\n\\n # Initialize time step (for updating every UPDATE_EVERY steps)\\n self.t_step = 0\",\n \"def experience_replay(self):\\n s,a,r,sp,done = self.memory.sample(self.batch_size)\\n # TODO: 5 lines missing.\\n raise NotImplementedError(\\\"\\\")\\n self.Q.fit(s, target=target)\",\n \"def Q_learning_train(env,alpha,gamma,epsilon,episodes):\\n %time\\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n #Initialize Q table of 22500 x 8 size (22500 states and 8 actions) with all zeroes\\n q_table = np.zeros([env.observation_space.n, env.action_space.n]) \\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n if random.uniform(0, 1) < epsilon:\\n action = env.action_space.sample() # Explore action space randomly\\n else:\\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n\\n next_state, reward, done, info = env.step(action) \\n\\n old_value = q_table[state, action]\\n next_max = np.max(q_table[next_state])\\n\\n new_value = (1 - alpha) * old_value + alpha * (reward + gamma * next_max)\\n q_table[state, action] = new_value\\n\\n if reward == -10:\\n penalties += 1\\n \\n\\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n rewards.append(np.sum(episode_rewards))\\n \\n if i % 1000 == 0:\\n clear_output(wait=True)\\n print(f\\\"Episode: {i}\\\")\\n \\n \\n print(\\\"Training finished.\\\\n\\\")\\n \\n plt.plot(savgol_filter(rewards, 1001, 3, mode = \\\"interp\\\"))\\n plt.title(\\\"Smoothened training reward per episode\\\", pad = 30, size = BIGGER_SIZE)\\n plt.legend()\\n plt.xlabel('Episodes', labelpad = 20);\\n plt.ylabel('Total Reward', labelpad = 20);\\n plt.tick_params(axis='both', which='major');\\n plt.tick_params(axis='both', which='minor');\\n #plt.xlim(0, 60000);\\n #plt.ylim(0,50)\\n #plt.xticks(np.arange(0, episodes+1, 5000));\\n #plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));\",\n \"def learn(self):\\n pass\",\n \"def learn(self):\\n pass\",\n \"def q_learn(scores, num_timesteps, sarsa=False, gamma=0.99):\\n\\n # Per-timestep non-discounted rewards\\n rewards = [tf.placeholder(tf.float32, (None,), name=\\\"rewards_%i\\\" % t)\\n for t in range(num_timesteps)]\\n # Mask learning for those examples which stop early\\n masks = [tf.placeholder(tf.float32, (None,), name=\\\"mask_%i\\\" % t)\\n for t in range(num_timesteps)]\\n\\n # By default, actions are just argmax; this can/should be overridden\\n actions = [tf.to_int32(tf.argmax(scores_t, 1), name=\\\"actions_%i\\\" % t)\\n for t, scores_t in enumerate(scores)]\\n\\n # metadata\\n batch_size = tf.shape(scores[0])[0]\\n n_actions = tf.shape(scores[0])[1]\\n\\n # Q(s, a) for states visited, actions taken\\n # easiest to do this lookup as Gather on a flattened scores array\\n q_a_pred = [tf.gather(tf.reshape(scores_t, (-1,)),\\n actions_t + tf.range(batch_size) * n_actions)\\n for scores_t, actions_t in zip(scores, actions)]\\n # max_a' Q(s, a') for states visited\\n q_max_pred = [tf.reduce_max(scores_t, 1) for scores_t in scores]\\n\\n q_targets = []\\n for t in range(num_timesteps):\\n target = rewards[t]\\n if t < num_timesteps - 1:\\n # Bootstrap with Q-learning or SARSA update\\n backup = q_a_pred[t + 1] if sarsa else q_max_pred[t + 1]\\n target += gamma * backup\\n\\n q_targets.append(target)\\n\\n # Summary: mean and variance of Q targets at this timestep\\n targets_mean, targets_var = tf.nn.moments(target, [0])\\n tf.scalar_summary(\\\"q/%i/target/mean\\\" % t, targets_mean)\\n tf.scalar_summary(\\\"q/%i/target/var\\\" % t, targets_var)\\n\\n # Summary: mean and variance of predicted Q values for optimal\\n # actions at this timestep\\n q_a_pred_mean, q_a_pred_var = tf.nn.moments(q_a_pred[t], [0])\\n tf.scalar_summary(\\\"q/%i/pred_max/mean\\\" % t, q_a_pred_mean)\\n tf.scalar_summary(\\\"q/%i/pred_max/var\\\" % t, q_a_pred_var)\\n\\n # Summary: mean and variance of all Q values in batch\\n q_pred_mean, q_pred_var = tf.nn.moments(scores[t], [0, 1])\\n tf.scalar_summary(\\\"q/%i/pred/mean\\\" % t, q_pred_mean)\\n tf.scalar_summary(\\\"q/%i/pred/var\\\" % t, q_pred_var)\\n\\n losses = [tf.reduce_mean(tf.square(mask_t * (q_target_t - q_a_pred_t)))\\n for q_target_t, q_a_pred_t, mask_t\\n in zip(q_targets, q_a_pred, masks)]\\n loss = tf.add_n(losses) / float(len(losses))\\n\\n tf.scalar_summary(\\\"loss\\\", loss)\\n\\n inputs = (actions, rewards, masks)\\n outputs = (losses, loss)\\n return inputs, outputs\",\n \"def __init__(self,\\n sess,\\n num_actions,\\n observation_shape=base_dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,\\n observation_dtype=base_dqn_agent.NATURE_DQN_DTYPE,\\n stack_size=base_dqn_agent.NATURE_DQN_STACK_SIZE,\\n network=base_dqn_agent.nature_dqn_network,\\n gamma=0.99,\\n update_horizon=1,\\n min_replay_history=20000,\\n update_period=4,\\n target_update_period=8000,\\n epsilon_fn=linearly_decaying_epsilon,\\n epsilon_train=0.01,\\n epsilon_eval=0.001,\\n epsilon_decay_period=250000,\\n tf_device='/cpu:*',\\n use_staging=True,\\n max_tf_checkpoints_to_keep=3,\\n optimizer=tf.train.RMSPropOptimizer(\\n learning_rate=0.00025,\\n decay=0.95,\\n momentum=0.0,\\n epsilon=0.00001,\\n centered=True),\\n summary_writer=None,\\n summary_writing_frequency=500):\\n self.intrinsic_model = intrinsic_rewards.PixelCNNIntrinsicReward(sess=sess)\\n super(PixelCNNDQNAgent, self).__init__(\\n sess=sess,\\n num_actions=num_actions,\\n observation_shape=observation_shape,\\n observation_dtype=observation_dtype,\\n stack_size=stack_size,\\n network=network,\\n gamma=gamma,\\n update_horizon=update_horizon,\\n min_replay_history=min_replay_history,\\n update_period=update_period,\\n target_update_period=target_update_period,\\n epsilon_fn=epsilon_fn,\\n epsilon_train=epsilon_train,\\n epsilon_eval=epsilon_eval,\\n epsilon_decay_period=epsilon_decay_period,\\n tf_device=tf_device,\\n use_staging=use_staging,\\n optimizer=optimizer,\\n summary_writer=summary_writer,\\n summary_writing_frequency=summary_writing_frequency)\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # Double DQN. Uses local network for action selection and target network for value estimation\\n # see: https://arxiv.org/pdf/1509.06461.pdf\\n Q_actions_next = self.dqn_local(next_states).detach().argmax(1).unsqueeze(1)\\n Q_targets_next = self.dqn_target(next_states).gather(1, Q_actions_next)\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n # Standard DQN\\n # Get max predicted Q values (for next states) from target model\\n # Q_targets_next = self.dqn_target(next_states).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states\\n # Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.dqn_local(states).gather(1, actions)\\n\\n # Compute loss\\n loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.dqn_local, self.dqn_target, TAU)\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n next_action_targets = self.target_model(next_states)\\n next_action = next_action_targets.max(1)[0].unsqueeze(-1)\\n targets = rewards + (gamma * torch.Tensor(next_action))\\n#\\n # Get expected Q values from policy model\\n action_policy = self.policy_model(states)\\n policy = action_policy.gather(1, actions)\\n # Compute loss\\n loss = F.mse_loss(policy, targets)\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.policy_model, self.target_model, self.tau)\",\n \"def trainAgent(self):\\r\\n\\t\\tfor episode in range(self.TOT_EPISODES):\\r\\n\\t\\t\\t#reset environment, stacked frames every episode.\\r\\n\\t\\t\\tstate = self.env.reset()\\r\\n\\t\\t\\trewards = 0\\r\\n\\t\\t\\t#preprocess and stack the frame/state.\\r\\n\\t\\t\\tstate, self.stacked_frames = stack_frames(self.stack_size,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tself.stacked_frames, state, True)\\r\\n\\t\\t\\t\\r\\n\\t\\t\\tfor step in range(self.MAX_STEPS):\\r\\n\\t\\t\\t#for every step in episode:\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\tif (step%100==0):\\r\\n\\t\\t\\t\\t\\tprint(\\\"Episode No.: \\\", episode, \\\"Step No.: \\\", step)\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t#agent acts - explores or exploitation of the model\\r\\n\\t\\t\\t\\taction = self.dqn.predictAction(state)\\r\\n\\t\\t\\t\\t#reduce epsilon for more exploitation later.\\r\\n\\t\\t\\t\\tself.dqn.decayEpsilon()\\r\\n\\t\\t\\t\\t#Perform the action and get the next_state, reward, and done vals.\\r\\n\\t\\t\\t\\tnext_state, reward, done, _ = self.env.step(action)\\r\\n\\t\\t\\t\\t#append this state to the frame. Pass the previous stacked frame.\\r\\n\\t\\t\\t\\tnext_state, self.stacked_frames = stack_frames(self.stack_size,\\r\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.stacked_frames, next_state, False)\\r\\n\\t\\t\\t\\trewards+=reward\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\t#add this experience into memory (experience buffer)\\r\\n\\t\\t\\t\\tself.dqn.remember(state, action, reward, next_state, done)\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tstate = next_state\\r\\n\\t\\t\\t\\t\\r\\n\\t\\t\\t\\tif done:\\r\\n\\t\\t\\t\\t\\tprint(\\\"took %d steps\\\" %step)\\r\\n\\t\\t\\t\\t\\tprint(\\\"Earned a total of reward equal to \\\", rewards)\\r\\n\\t\\t\\t\\t\\tbreak\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t\\t# TRAIN\\r\\n\\t\\t\\t\\tself.dqn.replay()\\r\\n\\t\\t\\t\\t#sync target_model and model weights every 10k steps.\\r\\n\\t\\t\\t\\tif step % 10000 == 9999:\\r\\n\\t\\t\\t\\t\\tself.dqn.target_train()\\r\\n\\t\\t\\t\\r\\n\\t\\t\\t# Save the network every 1000 iterations\\r\\n\\t\\t\\tif episode % 5 == 4:\\r\\n\\t\\t\\t\\tprint(\\\"Saving Network\\\")\\r\\n\\t\\t\\t\\tself.dqn.save_network(self.path)\",\n \"def Q_learning_test(env,alpha,gamma,episodes, q_table):\\n %time\\n \\n # For plotting metrics\\n all_epochs = []\\n all_penalties = []\\n rewards = []\\n \\n total_reward = 0\\n \\n for i in range(1, episodes+1):\\n state = env.reset()\\n episode_rewards = []\\n\\n epochs, penalties, reward, = 0, 0, 0\\n done = False\\n\\n while not done:\\n \\n action = np.argmax(q_table[state]) # Exploit learned values by choosing optimal values\\n next_state, reward, done, info = env.step(action) \\n\\n\\n if reward == -10:\\n penalties += 1\\n \\n state = next_state\\n episode_rewards.append(reward)\\n epochs += 1\\n \\n if done == True:\\n break \\n if epochs == 1000:\\n break \\n \\n total_reward += reward\\n rewards.append(np.sum(episode_rewards))\\n \\n if i % 1000 == 0:\\n clear_output(wait=True)\\n print(f\\\"Episode: {i}\\\")\\n\\n \\n print(\\\"Training finished.\\\\n\\\")\\n \\n \\n plt.plot(savgol_filter(rewards, 1001, 3, mode = \\\"interp\\\"))\\n plt.title(\\\"Smoothened testing reward per episode\\\", pad = 30 , size = BIGGER_SIZE)\\n plt.xlabel('Episodes', labelpad = 20);\\n plt.ylabel('Total Reward', labelpad = 20);\\n plt.tick_params(axis='both', which='major', labelsize=16);\\n plt.tick_params(axis='both', which='minor', labelsize=16);\\n #plt.xlim(100000, 200000);\\n #plt.ylim(0,50)\\n # plt.xticks(np.arange(0, episodes+1, 5000));\\n # plt.yticks(np.arange(min(rewards), max(rewards)+1, 1000));\",\n \"def train(network_def, target_params, optimizer, states, actions, next_states, rewards,\\n terminals, loss_weights, cumulative_gamma, target_opt, mse_inf,tau,alpha,clip_value_min, rng):\\n online_params = optimizer.target\\n def loss_fn(params, rng_input, target, loss_multipliers):\\n def q_online(state):\\n return network_def.apply(params, state, rng=rng_input)\\n\\n q_values = jax.vmap(q_online)(states).q_values\\n q_values = jnp.squeeze(q_values)\\n replay_chosen_q = jax.vmap(lambda x, y: x[y])(q_values, actions)\\n \\n if mse_inf:\\n loss = jax.vmap(mse_loss)(target, replay_chosen_q)\\n else:\\n loss = jax.vmap(dqn_agent.huber_loss)(target, replay_chosen_q)\\n\\n mean_loss = jnp.mean(loss_multipliers * loss)\\n return mean_loss, loss\\n\\n rng, rng2, rng3, rng4 = jax.random.split(rng, 4)\\n\\n def q_target(state):\\n return network_def.apply(target_params, state, rng=rng2)\\n\\n def q_target_online(state):\\n return network_def.apply(online_params, state, rng=rng4)\\n\\n if target_opt == 0:\\n target = dqn_agent.target_q(q_target, next_states, rewards, terminals, cumulative_gamma) \\n elif target_opt == 1:\\n #Double DQN\\n target = target_DDQN(q_target_online, q_target, next_states, rewards, terminals, cumulative_gamma)\\n\\n elif target_opt == 2:\\n #Munchausen\\n target = target_m_dqn(q_target_online, q_target, states,next_states,actions,rewards,terminals,\\n cumulative_gamma,tau,alpha,clip_value_min)\\n else:\\n print('error')\\n\\n grad_fn = jax.value_and_grad(loss_fn, has_aux=True)\\n (mean_loss, loss), grad = grad_fn(online_params, rng3, target, loss_weights)\\n optimizer = optimizer.apply_gradient(grad)\\n return optimizer, loss, mean_loss\",\n \"def __init__(self, observation_space, valid_actions: callable, q_source: QEstimator):\\n super().__init__(observation_space, valid_actions)\\n self.q = q_source\",\n \"def learn(self, experiences, gamma):\\n states_and_prev_recurrents, actions, recurrents, rewards, next_states, dones = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n next_states_and_recurrents = torch.cat([next_states, recurrents], dim=1)\\n Q_targets_next = self.qnetwork_target(next_states_and_recurrents).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states_and_prev_recurrents).gather(1, actions)\\n\\n # Compute loss\\n loss_rl = F.mse_loss(Q_expected, Q_targets)\\n\\n states = states_and_prev_recurrents[:, :8]\\n target_recurrents = map_observation_to_recurrent_state(states)\\n recurrent_pred = self.qnetwork_local(states_and_prev_recurrents)[:, -5:]\\n\\n loss_internal_states = F.multilabel_soft_margin_loss(recurrent_pred, target_recurrents)\\n\\n loss = loss_rl + loss_internal_states\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.qnetwork_local, self.qnetwork_target, TAU)\",\n \"def q_update(self):\\n\\n # exit if the experience buffer is not yet large enough\\n if self.experience_buffer.size < self.batch_size:\\n return\\n \\n # get the random batch\\n states, action_indices, rewards, not_terminals, succ_states, succ_players, succ_legal_moves = self.experience_buffer.random_batch(self.batch_size)\\n states = states.to(Globals.device)\\n action_indices = action_indices.to(Globals.device)\\n rewards = rewards.to(Globals.device)\\n not_terminals = not_terminals.to(Globals.device)\\n succ_states = succ_states.to(Globals.device)\\n succ_players = succ_players.to(Globals.device)\\n\\n # prepare the training data\\n q_values = self.target_network(succ_states)\\n target = torch.empty(1, self.batch_size)\\n for i in range(self.batch_size):\\n if not_terminals[i] == 0:\\n target[0, i] = rewards[i]\\n continue\\n\\n if succ_players[i] == CONST.WHITE_MOVE:\\n legal_q_values = q_values[0, 0:9][succ_legal_moves[i]]\\n q_value, _ = legal_q_values.max(0)\\n else:\\n legal_q_values = q_values[0, 9:18][succ_legal_moves[i]]\\n q_value, _ = legal_q_values.min(0)\\n\\n target[0, i] = rewards[i] + self.disc*not_terminals[i]*q_value\\n\\n # execute the training step of the network\\n self.training_network.train_step(states, target, action_indices) # the eligibility trace is used as td target\",\n \"def __init__(self,\\n qnn,\\n optimizer,\\n session,\\n state_shape,\\n actions_count,\\n reply_memory_size=100,\\n minibatch_size=32,\\n final_exploration_probability=0.05,\\n exploration_period=1000,\\n discount_factor=0.95,\\n unrollings_num=16,\\n target_freeze_period=1000,\\n ):\\n\\n self.prediction_nn = qnn\\n self.target_nn = qnn.clone()\\n self.optimizer = optimizer\\n\\n self.state_shape = state_shape\\n self.actions_count = actions_count\\n\\n self.experience = deque()\\n self.reply_memory_size = reply_memory_size\\n self.current_episode = []\\n self.unrollings_num = unrollings_num\\n self.minibatch_size = minibatch_size\\n\\n self.epsilon_initial = 1.0\\n self.epsilon_final = final_exploration_probability\\n self.exploration_period = exploration_period\\n self.discount = discount_factor\\n self.freeze_period = target_freeze_period\\n\\n self.action_requests = 0\\n self.iteration = 0\\n\\n self.session = session\\n\\n self.build_graph()\",\n \"def train_dqn(env, learn_dict, agent, log_results=True):\\n scores = [] # list containing scores from each episode\\n scores_window = deque(maxlen=100) # last 100 scores\\n eps = learn_dict['eps_start']\\n brain_name = learn_dict['brain_name']\\n n_episodes=learn_dict['n_episodes']\\n max_t= learn_dict['max_t']\\n eps_start= learn_dict['eps_start']\\n eps_end= learn_dict['eps_end']\\n eps_decay= learn_dict['eps_decay']\\n early_stop = learn_dict['early_stop']\\n\\n for i_episode in range(1, n_episodes+1):\\n env_info = env.reset(train_mode=True)[brain_name] # reset the environment\\n state = env_info.vector_observations[0] # get the current state\\n score = 0\\n for t in range(max_t):\\n \\n action = agent.act(state, eps).astype(int)\\n env_info = env.step(action)[brain_name] # send the action to the environment\\n next_state = env_info.vector_observations[0] # get the next state\\n reward = env_info.rewards[0] # get the reward\\n done = env_info.local_done[0] # see if episode has finished\\n # have the agent learn a step\\n agent.step(state, action, reward, next_state, done)\\n state = next_state\\n score += reward\\n if done:\\n break \\n scores_window.append(score) # save most recent score\\n scores.append(score) # save most recent score\\n eps = max(eps_end, eps_decay*eps) # decrease epsilon\\n if log_results: print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)), end=\\\"\\\")\\n if i_episode % 100 == 0:\\n if log_results: print('\\\\rEpisode {}\\\\tAverage Score: {:.2f}'.format(i_episode, np.mean(scores_window)))\\n if np.mean(scores_window)>=early_stop:\\n if log_results: print('\\\\nEnvironment solved in {:d} episodes!\\\\tAverage Score: {:.2f}'.format(i_episode-100, np.mean(scores_window)))\\n break\\n return scores\",\n \"def run(self):\\n if self.pp['net']:\\n space = {\\n # Qlearnnet\\n 'net_lr': hp.loguniform('net_lr', np.log(5e-7), np.log(1e-4)),\\n 'net_lr_decay': hp.loguniform('net_lr_decay', np.log(0.90), np.log(0.99)),\\n # Singh\\n # 'net_lr': hp.loguniform('net_lr', np.log(1e-7), np.log(5e-4)),\\n 'beta': hp.uniform('beta', 16, 30),\\n # Double\\n 'net_copy_iter': hp.loguniform('net_copy_iter', np.log(5), np.log(150)),\\n 'net_creep_tau': hp.loguniform('net_creep_tau', np.log(0.01),\\n np.log(0.7)),\\n # Exp. replay\\n 'batch_size': scope.int(hp.uniform('batch_size', 8, 16)),\\n 'buffer_size': scope.int(hp.uniform('buffer_size', 2000, 10000)),\\n # N-step\\n 'n_step': scope.int(hp.uniform('n_step', 3, 40)),\\n # Policy\\n 'vf_coeff': hp.uniform('vf_coeff', 0.005, 0.5),\\n 'entropy_coeff': hp.uniform('entropy_coeff', 1.0, 100.0)\\n }\\n else:\\n space = {\\n 'beta': hp.uniform('beta', 7, 23),\\n 'alpha': hp.uniform('alpha', 0.0001, 0.4),\\n 'alpha_decay': hp.uniform('alpha_decay', 0.9999, 0.9999999),\\n 'epsilon': hp.loguniform('epsilon', np.log(0.2), np.log(0.8)),\\n 'epsilon_decay': hp.uniform('epsilon_decay', 0.9995, 0.9999999),\\n 'gamma': hp.uniform('gamma', 0.7, 0.90),\\n 'lambda': hp.uniform('lambda', 0.0, 1.0)\\n }\\n # Only optimize parameters specified in args\\n space = {param: space[param] for param in self.pp['hopt']}\\n if self.pp['hopt_fname'].startswith('mongo:'):\\n self._hopt_mongo(space)\\n else:\\n self._hopt_pickle(space)\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones, indices = experiences\\n\\n # Get max predicted Q values (for next states) from target model\\n if self.dbl_dqn:\\n local_best_actions = self.qnetwork_local(next_states).detach().argmax(1)\\n Q_next_states = self.qnetwork_target(next_states)\\n Q_targets_next = Q_next_states.gather(1, local_best_actions.unsqueeze(1))\\n else:\\n Q_targets_next = self.qnetwork_target(next_states).detach().max(1)[0].unsqueeze(1)\\n\\n # Compute Q targets for current states\\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.qnetwork_local(states).gather(1, actions)\\n\\n # Compute loss\\n if self.priority_rpl:\\n errors = abs(Q_expected - Q_targets)\\n self.memory.update_priorities(indices, errors)\\n importance = self.memory.get_importance(indices, self.a, self.b)\\n importance = np.array(importance)\\n loss = torch.mean(torch.mul(errors.float(), torch.from_numpy(importance).float().to(device)))\\n else:\\n loss = F.mse_loss(Q_expected, Q_targets)\\n\\n # Minimize the loss\\n self.optimizer.zero_grad()\\n loss.backward()\\n self.optimizer.step()\",\n \"def _learn(self, state):\\n p_state, p_action = self.prev\\n if p_state is None:\\n return\\n self.Q[p_state][p_action] = self.learning_rate * (self.R(state) + self.discount * max(self.Q[state].values())) - self.Q[p_state][p_action]\",\n \"def inverse_q_learning(feature_matrix,nA, gamma, transitions, alpha_r, alpha_q, alpha_sh, epochs, real_distribution):\\n nS = feature_matrix.shape[0]\\n\\n \\n # initialize tables for reward function, value functions and state-action visitation counter.\\n r = np.zeros((nS, nA))\\n q = np.zeros((nS, nA))\\n q_sh = np.zeros((nS, nA))\\n state_action_visitation = np.zeros((nS, nA))\\n\\n for i in range(epochs):\\n if i%10 == 0:\\n print(\\\"Epoch %s/%s\\\" %(i+1, epochs))\\n \\n for traj in transitions:\\n for (s, a, _, ns) in traj:\\n state_action_visitation[s][a] += 1\\n d = False # no terminal state\\n\\n # compute shifted q-function.\\n q_sh[s, a] = (1-alpha_sh) * q_sh[s, a] + alpha_sh * (gamma * (1-d) * np.max(q[ns]))\\n \\n # compute log probabilities.\\n sum_of_state_visitations = np.sum(state_action_visitation[s])\\n log_prob = np.log((state_action_visitation[s]/sum_of_state_visitations) + epsilon)\\n \\n # compute eta_a and eta_b for Eq. (9).\\n eta_a = log_prob[a] - q_sh[s][a]\\n other_actions = [oa for oa in range(nA) if oa != a]\\n eta_b = log_prob[other_actions] - q_sh[s][other_actions]\\n sum_oa = (1/(nA-1)) * np.sum(r[s][other_actions] - eta_b)\\n\\n # update reward-function.\\n r[s][a] = (1-alpha_r) * r[s][a] + alpha_r * (eta_a + sum_oa)\\n\\n # update value-function.\\n q[s, a] = (1-alpha_q) * q[s, a] + alpha_q * (r[s, a] + gamma * (1-d) * np.max(q[ns]))\\n s = ns\\n\\n # compute Boltzmann distribution.\\n boltzman_distribution = []\\n for s in range(nS):\\n boltzman_distribution.append([])\\n for a in range(nA):\\n boltzman_distribution[-1].append(np.exp(q[s][a]))\\n boltzman_distribution = np.array(boltzman_distribution)\\n boltzman_distribution /= np.sum(boltzman_distribution, axis=1).reshape(-1, 1)\\n return q, r, boltzman_distribution\",\n \"def learn(self, experiences, gamma):\\n\\n states, all_state, action, all_actions, rewards, next_state, all_next_state, dones = experiences\\n batch_size = all_next_state.shape[0]\\n\\n all_next_actions = self.actor_target(all_next_state.view(batch_size * 2, -1)).view(batch_size, -1)\\n\\n critic_target_input = torch.cat((all_next_state, all_next_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(\\n device)\\n with torch.no_grad():\\n Q_target_next = self.critic_target(critic_target_input, all_next_actions.view(batch_size * 2, -1)[::2])\\n Q_targets = rewards + (gamma * Q_target_next * (1 - dones))\\n\\n critic_local_input = torch.cat((all_state, all_actions.view(batch_size * 2, -1)[1::2]), dim=1).to(device)\\n Q_expected = self.critic_local(critic_local_input, action)\\n\\n # critic loss\\n huber_loss = torch.nn.SmoothL1Loss()\\n\\n loss = huber_loss(Q_expected, Q_targets.detach())\\n\\n self.optimizer_critic.zero_grad()\\n loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1)\\n self.optimizer_critic.step()\\n\\n # actor loss\\n\\n action_pr_self = self.actor_local(states)\\n action_pr_other = self.actor_local(all_next_state.view(batch_size * 2, -1)[1::2]).detach()\\n\\n # critic_local_input2=torch.cat((all_state,torch.cat((action_pr_self,action_pr_other),dim=1)),dim=1)\\n critic_local_input2 = torch.cat((all_state, action_pr_other), dim=1)\\n p_loss = -self.critic_local(critic_local_input2, action_pr_self).mean()\\n\\n self.optimizer_actor.zero_grad()\\n p_loss.backward()\\n\\n self.optimizer_actor.step()\\n\\n # ------------------- update target network ------------------- #\\n self.TAU = min(5e-1, self.TAU * 1.001)\\n self.soft_update(self.critic_local, self.critic_target, self.TAU)\\n self.soft_update(self.actor_local, self.actor_target, self.TAU)\",\n \"def buildQ(self):\\r\\n\\r\\n print 'Building Q ...'\\r\\n\\r\\n self.y = T.matrix('y')\\r\\n\\r\\n mlp = MLP(activations=self.hyper['q_activs'],\\r\\n dims=self.hyper['q_dims'],\\r\\n weights_init=self.hyper['q_W_init'],\\r\\n biases_init=Constant(0))\\r\\n\\r\\n q_parameters = mlp.apply(self.y)\\r\\n mlp.initialize()\\r\\n\\r\\n # self.qxgy_mu.shape == (minibatch size, num of dimension of x)\\r\\n self.qxgy_mu = q_parameters[:,:self.hyper['x_dim']]\\r\\n\\r\\n # self.qxgy_var.shape == (minibatch size, num of dimension of x)\\r\\n self.qxgy_var = T.exp( q_parameters[:,self.hyper['x_dim']:2*self.hyper['x_dim']] )\\r\\n\\r\\n # self.qwgy_mu.shape == (minibatch size, num of dimension of w)\\r\\n self.qwgy_mu = q_parameters[:,2*self.hyper['x_dim']:2*self.hyper['x_dim']+self.hyper['w_dim']]\\r\\n\\r\\n # self.qwgy_var.shape == (minibatch size, num of dimension of w)\\r\\n self.qwgy_var = T.exp( q_parameters[:,2*self.hyper['x_dim']+self.hyper['w_dim']:] )\\r\\n\\r\\n\\r\\n #---Will be useful to compute samples from q(x|y)---#\\r\\n #self.eps_x.shape == (minibatch size, # of x samples , # of dimension of x)\\r\\n self.eps_x = self.srng.normal((self.qxgy_mu.shape[0] ,self.hyper['L_x'] ,self.hyper['x_dim']))\\r\\n\\r\\n #self.x corresponds roughly to the function g(\\\\epsilon,y) (see reparametrization trick in Kingma 2014)\\r\\n #self.x.shape == (minibatch size, # of x samples , # of dimension of x)\\r\\n self.x = self.qxgy_mu.dimshuffle(0,'x',1) + T.sqrt(self.qxgy_var).dimshuffle(0,'x',1)*self.eps_x\\r\\n\\r\\n #---Will be useful to compute samples from q(w|y)---#\\r\\n #self.eps_w.shape == (minibatch size, # of w samples , # of dimension of w)\\r\\n self.eps_w = self.srng.normal((self.qwgy_mu.shape[0] ,self.hyper['L_w'] ,self.hyper['w_dim']))\\r\\n\\r\\n #self.w corresponds roughly to the function g(\\\\epsilon,y) (see reparametrization trick in Kingma 2014)\\r\\n #self.w.shape == (minibatch size, # of w samples , # of dimension of w)\\r\\n self.w = self.qwgy_mu.dimshuffle(0,'x',1) + T.sqrt(self.qwgy_var).dimshuffle(0,'x',1)*self.eps_w\\r\\n\\r\\n\\r\\n #---Building the log density q(x|y)---#\\r\\n little_num = 10**(-32)\\r\\n inside_exp = -T.sum((self.x - self.qxgy_mu.dimshuffle(0,'x',1))**2/(2*self.qxgy_var.dimshuffle(0,'x',1)), axis=2)\\r\\n norm_cst = (2*np.pi)**(-self.hyper['x_dim']/2.)*T.exp(T.sum(T.log(self.qxgy_var), axis=1))**(-1/2.)\\r\\n\\r\\n # shape == (minibatch size, # of x samples)\\r\\n qxgy = norm_cst.dimshuffle(0,'x')*T.exp(inside_exp)\\r\\n\\r\\n # shape == (minibatch size, # of x samples)\\r\\n self.log_qxgy = T.log(qxgy + little_num)\",\n \"def qUpdate(self,state,action,reward,next_state):\\r\\n #add to experience\\r\\n if next_state != \\\"end\\\":\\r\\n self.experience.append([self.feat_funct(state),action,\\r\\n reward,self.feat_funct(next_state)])\\r\\n else:\\r\\n self.experience.append([self.feat_funct(state),action,\\r\\n reward,next_state]) \\r\\n #print(state,action,reward,next_state)\\r\\n #get minibatch\\r\\n sample = np.random.randint(0,len(self.experience),self.batch_size)\\r\\n d = np.zeros((self.batch_size,self.size))\\r\\n y = np.zeros((self.batch_size,1))\\r\\n for i,row in enumerate(sample):\\r\\n state,action,reward,next_state = self.experience[row]\\r\\n #get feature vector\\r\\n d[i,:] = self.comb_feat_action(state,action)\\r\\n #get target\\r\\n #check if end of episoe\\r\\n if next_state == 'end':\\r\\n y[i] = reward\\r\\n else:\\r\\n y[i] = reward + self.gamma * self.maxOldQ(next_state)\\r\\n #print(row,next_state)\\r\\n #print(self.maxOldQ(next_state))\\r\\n \\r\\n loss = self.train(d,y)\\r\\n \\r\\n #update old learner if greater than num_update\\r\\n if self.iteration % self.num_update == 0:\\r\\n self.old_learn = copy.deepcopy(self.learner)\\r\\n self.iteration += 1\\r\\n \\r\\n return(loss)\",\n \"def __init__(self, env, args):\\n super(Agent_PG,self).__init__(env)\\n\\n ##################\\n # YOUR CODE HERE #\\n ##################\\n self.print_every = args.print_every\\n self.n_episode = args.episode\\n self.gamma = args.gamma\\n self.episode_len = args.episode_len\\n self.update_every = args.update_every\\n self.var_reduce = args.var_reduce\\n self.gae = args.gae\\n self.step_upd = args.step_upd\\n self.max_step = args.step_train\\n self.clip = args.clip\\n\\n if not self.gae:\\n if args.cnn:\\n self.model = Model2()\\n else:\\n self.model = Model()\\n else:\\n if args.cnn:\\n self.model = ModelGAE2()\\n else:\\n self.model = ModelGAE()\\n\\n print(self.model)\\n\\n if args.cnn:\\n self.opt = optim.RMSprop(self.model.parameters(), lr=args.learning_rate, weight_decay=0.99)\\n else:\\n self.opt = optim.Adam(self.model.parameters(), lr=args.learning_rate)\\n\\n self.state = np.zeros((1, 80, 80))\\n self.log_probs = []\\n self.rewards = []\\n if self.gae:\\n self.values = []\\n self.entropies = []\\n\\n self.model_fn = args.model\\n if self.model_fn == '':\\n self.model_fn = 'agent_pg.pt'\\n if args.test_pg:\\n self.model_fn = 'pg.baseline.pt'\\n\\n if args.test_pg:\\n #you can load your model here\\n print('loading trained model :%s.' % self.model_fn)\\n state_dict = torch.load(self.model_fn, map_location=lambda storage, location: storage)\\n self.model.load_state_dict(state_dict)\\n if USE_CUDA:\\n self.model.cuda()\",\n \"def learn(self, experiences, gamma):\\n states, actions, rewards, next_states, dones = experiences\\n\\n # ------------------- update critic ------------------- #\\n next_actions = self.actor_target(next_states)\\n # Get Q targets (for next states) from target model (on CPU)\\n Q_targets_next = self.critic_target(next_states, next_actions).detach().max(1)[0].unsqueeze(1)\\n # Compute Q targets for current states \\n Q_targets = rewards + (gamma * Q_targets_next * (1 - dones))\\n\\n # Get expected Q values from local model\\n Q_expected = self.critic_local(states, actions)\\n\\n # Compute critic loss\\n critic_loss = F.mse_loss(Q_expected, Q_targets)\\n # Minimize the critic loss\\n self.critic_optimizer.zero_grad()\\n critic_loss.backward()\\n torch.nn.utils.clip_grad_norm_(self.critic_local.parameters(), 1) # As mentioned on project page\\n self.critic_optimizer.step()\\n\\n # ------------------- update actor ------------------- #\\n actions_expected = self.actor_local(states)\\n # Compute actor loss based on expectation from actions_expected\\n actor_loss = -self.critic_local(states, actions_expected).mean()\\n # Minimize the actor loss\\n self.actor_optimizer.zero_grad()\\n actor_loss.backward()\\n self.actor_optimizer.step()\\n\\n\\n # ------------------- update target network ------------------- #\\n self.soft_update(self.critic_local, self.critic_target, TAU) \\n self.soft_update(self.actor_local, self.actor_target, TAU)\",\n \"def add_evidence( \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n self, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n symbol=\\\"IBM\\\", \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sd=dt.datetime(2008, 1, 1), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ed=dt.datetime(2009, 1, 1), \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n sv=10000, \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n ): \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n \\t\\t \\t \\t\\t \\t \\t\\t\\t \\t\\t \\t\\t\\t \\t \\t \\t\\t \\t\\t \\t\\n # add your code to do learning here\\n\\n converged = False\\n x = np.zeros((3,1))\\n dates = pd.date_range(sd,ed)\\n df_prices = ind.get_price(symbol, dates)\\n\\n daily_rets = (df_prices / df_prices.shift(1)) - 1\\n daily_rets = daily_rets[1:]\\n\\n\\n sd_older = sd - dt.timedelta(days=365)\\n dates_older = pd.date_range(sd_older,ed)\\n df_prices_older = ind.get_price(symbol, dates_older)\\n sd_key = df_prices.index[0]\\n sd_index = df_prices_older.index.get_loc(sd_key)\\n\\n num_bins = len(self.bins)\\n max_state_idx = num_bins + num_bins*10 + num_bins*100\\n\\n # Call Q-Learner Constructor\\n self.learner = QLearner( \\n num_states=(max_state_idx + 1), \\n num_actions=3, \\n alpha=0.01, \\n gamma=0.0, \\n rar=0.98, \\n radr=0.9995, \\n dyna=0, \\n verbose=False, \\n )\\n\\n # df_trades = df_prices.copy()\\n df_holdings = df_prices.copy()\\n df_holdings['Holdings'] = np.nan\\n del df_holdings[symbol] # print(df_holdings)\\n\\n # Initlialize Vars\\n cum_ret_prev = 0\\n iters = 0\\n conv_counter = 0\\n Q_prev = np.copy(self.learner.Q)\\n\\n # Get Indicator Values\\n _,_,ind1 = ind.get_BB(df_prices_older, self.lookback)\\n ind2 = ind.get_CCI(df_prices_older, self.lookback)\\n _,_,ind3 = ind.get_SMA_Cross(self.lookback, 100, df_prices_older)\\n ind4 = ind.get_momentum(df_prices_older, self.lookback)\\n _,_,ind5 = ind.get_MACD(df_prices_older)\\n BB = ind1.iloc[sd_index:].values\\n CCI = ind2.iloc[sd_index:].values\\n SMA_Cross = ind3.iloc[sd_index:].values\\n Momentum = ind4.iloc[sd_index:].values\\n MACD = ind5.iloc[sd_index:].values\\n _,self.x0bins = pd.qcut(BB[:,0], num_bins,labels=False,retbins=True)\\n _,self.x1bins = pd.qcut(CCI[:,0],num_bins,labels=False,retbins=True)\\n _,self.x2bins = pd.qcut(SMA_Cross[:,0],num_bins,labels=False,retbins=True)\\n _,self.x3bins = pd.qcut(Momentum[:,0],num_bins,labels=False,retbins=True)\\n _,self.x4bins = pd.qcut(MACD[:,0],num_bins,labels=False,retbins=True)\\n x_0 = np.digitize(BB[:,0], self.x0bins[1:-1])\\n x_1 = np.digitize(CCI[:,0], self.x1bins[1:-1])\\n x_2 = np.digitize(SMA_Cross[:,0], self.x2bins[1:-1])\\n x_3 = np.digitize(Momentum[:,0], self.x3bins[1:-1])\\n x_4 = np.digitize(MACD[:,0], self.x4bins[1:-1])\\n state = x_0 + x_3*10 + x_4*100\\n\\n \\n while not converged:\\n\\n action = self.learner.querysetstate(state[0])\\n daily_return = daily_rets.iloc[0][symbol]\\n cur_price = df_prices.iloc[0][symbol]\\n next_price = df_prices.iloc[1][symbol]\\n df_holdings.iloc[0]['Holdings'], reward = self.take_action(0, action, cur_price, next_price)\\n\\n\\n\\n for day_idx in range(1,daily_rets.shape[0]):\\n\\n\\n daily_return = daily_rets.iloc[day_idx][symbol]\\n cur_price = df_prices.iloc[day_idx-1][symbol]\\n next_price = df_prices.iloc[day_idx][symbol]\\n df_holdings.iloc[day_idx]['Holdings'], reward = self.take_action(df_holdings.iloc[day_idx-1]['Holdings'], action, cur_price, next_price)\\n action = self.learner.query(state[day_idx], reward)\\n\\n df_holdings.iloc[-1]['Holdings'] = 0\\n df_trades = df_holdings.diff()\\n df_trades['Trades'] = df_trades['Holdings']\\n del df_trades['Holdings']\\n df_trades.iloc[0]['Trades'] = 0\\n\\n\\n portvals = msc.compute_portvals( \\n df_trades,\\n symbol, \\n sv, \\n self.commission, \\n self.impact, \\n )\\n\\n cum_ret = (portvals[-1] / portvals[0]) - 1\\n Q_diff = np.abs(self.learner.Q - Q_prev)\\n Q_max_diff = Q_diff.max()\\n\\n if iters > 20:\\n\\n # if abs(cum_ret - cum_ret_prev) < 0.0001:\\n if Q_max_diff < 0.001:\\n conv_counter += 1\\n else:\\n conv_counter = 0\\n\\n if conv_counter > 5 or iters > 20000:\\n converged = True\\n # if iters > 100:\\n # if iters % 100 == 0:\\n # print(\\\"Iteration #\\\", iters)\\n print(\\\"----------------------------------------------\\\")\\n print(\\\"-- --\\\")\\n print(\\\"Iteration #\\\", iters)\\n print(\\\"Error = \\\", abs(cum_ret - cum_ret_prev))\\n print(\\\"Q Diff: \\\", Q_max_diff)\\n print(\\\"Epsilon: \\\", self.learner.rar)\\n\\n cum_ret_prev = cum_ret\\n Q_prev = np.copy(self.learner.Q)\\n iters += 1\\n self.learner.rar *= self.learner.radr\\n # print(\\\"Iters = \\\", iters)\\n print(\\\"Mode Trained in \\\", iters, \\\" iterations!\\\")\\n np.savetxt('Q_Table.csv', self.learner.Q, delimiter=',')\",\n \"def __init__(self, quant_arc_interface):\\n\\n super().__init__()\\n self.args = quant_arc_interface.args \\n self.q_params = nn.Parameter(self.args.q_delta * torch.randn(self.args.q_depth * self.args.n_qubits))\\n self.qai = quant_arc_interface\",\n \"def learn(self, state, action, reward, state_):\\n self.Q.optimizer.zero_grad()\\n states = T.tensor(state, dtype=T.float).to(self.Q.device)\\n action = T.tensor(action).to(self.Q.device)\\n reward = T.tensor(reward).to(self.Q.device)\\n states_ = T.tensor(state_, dtype=T.float).to(self.Q.device)\\n\\n q_pred = self.Q.forward(states)[action]\\n\\n q_next = self.Q.forward(states_).max()\\n\\n q_target = reward + self.gamma*q_next\\n\\n loss = self.Q.loss(q_target, q_pred).to(self.Q.device)\\n loss.backward()\\n self.Q.optimizer.step()\\n self.decrement_epsilon()\",\n \"def learn(self, experience):\\n\\n # Convert experiences to separate list\\n states = np.vstack([e.state for e in experience if e is not None])\\n actions = np.array([e.action for e in experience if e is not None]).astype(np.float32).reshape(-1, self.action_size)\\n rewards = np.array([e.reward for e in experience if e is not None]).astype(np.float32).reshape(-1, 1)\\n dones = np.array([e.done for e in experience if e is not None]).astype(np.uint8).reshape(-1, 1)\\n next_states = np.vstack([e.next_state for e in experience if e is not None])\\n\\n # Get predicted next-state actions and Q values from target models\\n # Q_targets_next = critic_target(next_state, actor_target(next_state))\\n actions_next = self.actor_target.model.predict_on_batch(next_states)\\n Q_targets_next = self.critic_target.model.predict_on_batch([next_states, actions_next])\\n\\n # Compute Q targets for current states and train critic model (local)\\n Q_targets = rewards + self.gamma * Q_targets_next * (1 - dones)\\n self.critic_local.model.train_on_batch(x=[states, actions], y=Q_targets)\\n\\n # Train actor model (local)\\n action_gradients = np.reshape(self.critic_local.get_action_gradients([states, actions, 0]), (-1, self.action_size))\\n self.actor_local.train_fn([states, action_gradients, 1])\\n\\n # soft-update target models\\n self.soft_update(self.critic_local.model, self.critic_target.model)\\n self.soft_update(self.actor_local.model, self.actor_target.model)\",\n \"def __init__(self, **args):\\n self.featExtractor = util.lookup(\\\"SimpleExtractor\\\", globals())()\\n PacmanQAgent.__init__(self, **args)\\n self.sess = tf.Session()\\n self.allFeats = list(self.featExtractor.getFeatures(None, None))\\n numDims = len(self.allFeats)\\n self.x = tf.placeholder(\\\"float\\\", shape=[None, numDims])\\n self.y_ = tf.placeholder(\\\"float\\\", shape=[None, 1])\\n self.W1 = tf.Variable(tf.truncated_normal([numDims, 5], stddev=0.01))\\n self.b1 = tf.Variable(tf.constant(0.01, shape=[5]))\\n self.W2 = tf.Variable(tf.truncated_normal([5, 1]))\\n self.b2 = tf.Variable(tf.constant(0.01, shape=[1]))\\n self.h = tf.nn.relu(tf.matmul(self.x, self.W1) + self.b1)\\n self.out = tf.nn.relu(tf.matmul(self.h, self.W2) + self.b2)\\n self.l2_loss = tf.reduce_sum(tf.square(self.y_ - self.out))\\n self.train_step = tf.train.AdamOptimizer(1e-4).minimize(self.l2_loss)\\n self.sess.run(tf.initialize_all_variables())\",\n \"def __init__(self, args, quant_arc_interface):\\n\\n super().__init__()\\n self.args = args \\n\\n self.q_params = nn.Parameter(self.args.q_delta * torch.randn(self.args.q_depth * self.args.n_qubits))\\n self.qai = quant_arc_interface\",\n \"def __init__(self,\\n num_actions,\\n\\n tau,\\n alpha=1,\\n clip_value_min=-10,\\n target_opt=0,\\n\\n net_conf = None,\\n env = \\\"CartPole\\\",\\n hidden_layer=2, \\n neurons=512,\\n noisy = False,\\n dueling = False,\\n initzer = 'variance_scaling',\\n\\n observation_shape=dqn_agent.NATURE_DQN_OBSERVATION_SHAPE,\\n observation_dtype=dqn_agent.NATURE_DQN_DTYPE,\\n stack_size=dqn_agent.NATURE_DQN_STACK_SIZE,\\n network=networks.ImplicitQuantileNetwork,\\n kappa=1.0,\\n num_tau_samples=32,\\n num_tau_prime_samples=32,\\n num_quantile_samples=32,\\n quantile_embedding_dim=64,\\n double_dqn=False,\\n gamma=0.99,\\n update_horizon=1,\\n min_replay_history=20000,\\n update_period=4,\\n target_update_period=8000,\\n epsilon_fn=dqn_agent.linearly_decaying_epsilon,\\n epsilon_train=0.01,\\n epsilon_eval=0.001,\\n epsilon_decay_period=250000,\\n replay_scheme='prioritized',\\n optimizer='adam',\\n summary_writer=None,\\n summary_writing_frequency=500,\\n seed=None):\\n \\n seed = int(time.time() * 1e6) if seed is None else seed\\n self._net_conf = net_conf\\n self._env = env\\n self._hidden_layer = hidden_layer\\n self._neurons=neurons \\n self._noisy = noisy\\n self._dueling = dueling\\n self._initzer = initzer\\n\\n self._tau = tau\\n self._alpha = alpha\\n self._clip_value_min = clip_value_min\\n self._target_opt = target_opt\\n self._rng = jax.random.PRNGKey(seed)\\n\\n self.kappa = kappa\\n self._replay_scheme = replay_scheme\\n\\n # num_tau_samples = N below equation (3) in the paper.\\n self.num_tau_samples = num_tau_samples\\n # num_tau_prime_samples = N' below equation (3) in the paper.\\n self.num_tau_prime_samples = num_tau_prime_samples\\n # num_quantile_samples = k below equation (3) in the paper.\\n self.num_quantile_samples = num_quantile_samples\\n # quantile_embedding_dim = n above equation (4) in the paper.\\n self.quantile_embedding_dim = quantile_embedding_dim\\n # option to perform double dqn.\\n self.double_dqn = double_dqn\\n\\n\\n super(JaxImplicitQuantileAgentNew, self).__init__(\\n num_actions=num_actions,\\n observation_shape=observation_shape,\\n observation_dtype=observation_dtype,\\n stack_size=stack_size,\\n network=functools.partial(network,\\n \\t num_actions=num_actions,\\n net_conf=self._net_conf,\\n env=self._env,\\n hidden_layer=self._hidden_layer, \\n neurons=self._neurons,\\n noisy=self._noisy,\\n dueling=self._dueling,\\n initzer=self._initzer,\\n quantile_embedding_dim=quantile_embedding_dim),\\n gamma=gamma,\\n update_horizon=update_horizon,\\n min_replay_history=min_replay_history,\\n update_period=update_period,\\n target_update_period=target_update_period,\\n epsilon_fn=epsilon_fn,\\n epsilon_train=epsilon_train,\\n epsilon_eval=epsilon_eval,\\n epsilon_decay_period=epsilon_decay_period,\\n optimizer=optimizer,\\n summary_writer=summary_writer,\\n summary_writing_frequency=summary_writing_frequency)\\n\\n self._num_actions=num_actions\\n self._replay = self._build_replay_buffer()\",\n \"def OSK_Q_MultiProcess_Ave(ave_times=20,\\n learning_rate=0.1,\\n eligibility_factor=0.9,\\n observation_dim=4,\\n mu_1=0.04,\\n mu_2=0.08):\\n # Learning Parameter\\n discount_factor = 0.9\\n discount_of_learning_rate = 0.999\\n epsilon = 0.1\\n\\n # Parameter OSK-Q\\n sigma = 1\\n\\n # Macro\\n NUM_EPISODE = 600\\n AVE_TIMES = ave_times\\n REWARD_THREASHOLD = 40\\n # Definition of dependencies\\n env = gym.make('CartPole-v0')\\n\\n # Run algorithm\\n for ave_times in range(AVE_TIMES):\\n learning_agent_OSKQ = OSKQ(\\n mu_1,\\n mu_2,\\n learning_rate,\\n discount_factor,\\n eligibility_factor,\\n [0, 1],\\n observation_dim,\\n sigma\\n )\\n learning_agent = learning_agent_OSKQ\\n\\n Qfunc_error_history_3 = []\\n total_reward_episode_3 = []\\n time_history_3 = []\\n max_reward = -float(\\\"inf\\\")\\n for i_episode in range(NUM_EPISODE):\\n time_start = time.clock()\\n observation = env.reset()\\n action = learning_agent._m_GreedyPolicy(observation, epsilon)\\n\\n total_reward = 0\\n done = False\\n step = 0\\n while not done:\\n step += 1\\n observation_bar, step_reward, done, info = env.step(action)\\n\\n action_bar = learning_agent._m_GreedyPolicy(\\n observation_bar,\\n epsilon\\n )\\n\\n learning_agent._m_Learn(\\n observation,\\n action,\\n observation_bar,\\n action_bar,\\n step_reward\\n )\\n\\n observation = observation_bar\\n action = action_bar\\n total_reward += step_reward\\n print \\\"Episode finished after {} timesteps in OSK-Q(lambda)\\\".format(step), \\\"in \\\", ave_times + 1, \\\"times\\\"\\n time_end = time.clock()\\n time_consumed = time_end - time_start\\n time_history_3.append(time_consumed)\\n\\n if total_reward > max_reward:\\n if total_reward > REWARD_THREASHOLD:\\n epsilon *= 0.999\\n max_reward = total_reward\\n\\n total_reward_episode_3.append(total_reward) # Add total reward to reward history\\n\\n if i_episode % 10 == 0:\\n print i_episode, \\\"th episode completed\\\"\\n print \\\"Maximal reward is\\\", max_reward, \\\"\\\\n\\\"\\n\\n total_reward_episode_3 = np.array(total_reward_episode_3)\\n if 'total_reward_episode_ave_3' not in locals():\\n total_reward_episode_ave_3 = total_reward_episode_3\\n else:\\n total_reward_episode_ave_3 = total_reward_episode_ave_3 + (total_reward_episode_3 - total_reward_episode_ave_3) / (ave_times * 1.0)\\n\\n time_history_3 = np.array(time_history_3)\\n if 'time_history_ave_3' not in locals():\\n time_history_ave_3 = time_history_3\\n else:\\n time_history_ave_3 = time_history_ave_3 + (time_history_3 - time_history_ave_3) / (ave_times * 1.0)\\n\\n total_reward_episode_3 = total_reward_episode_ave_3\\n time_history_3 = time_history_ave_3\\n\\n with open(\\n path + \\\"total_reward_OSKQ-\\\" + str(learning_rate) + \\\"-\\\" +\\n str(eligibility_factor) + \\\"-\\\" + str(mu_1) + \\\"-\\\" + str(mu_2), 'wb') as f:\\n pickle.dump(total_reward_episode_3, f)\\n with open(\\n path + \\\"time_history_OSKQ-\\\" + str(learning_rate) + \\\"-\\\" +\\n str(eligibility_factor) + \\\"-\\\" + str(mu_1) + \\\"-\\\" + str(mu_2), 'wb') as f:\\n pickle.dump(time_history_3, f)\",\n \"def policies(self, QTable, epsilon, state, next_states, action_to_do): # Inspiration from https://www.geeksforgeeks.org/q-learning-in-python/?fbclid=IwAR1UXR88IuJBhhTakjxNq_gcf3nCmJB0puuoA46J8mZnEan_qx9hhoFzhK8\\r\\n num_actions = 5 # 5 actions-value, [moved_out, into_goal, send_opp_home, send_self_home, move_token] \\r\\n def epsilonGreedyPolicy(): \\r\\n tmp_state = str(state.state[0])\\r\\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\\r\\n valid_act_len = len(np.where(valid_actions==True)[0])\\r\\n\\r\\n Action_probabilities = np.ones(num_actions, dtype = float) * epsilon / valid_act_len # divides probability based on number of valid actions and epsilon (each 0.025 if 4 actions) \\r\\n Action_probabilities = np.multiply(Action_probabilities, valid_actions)\\r\\n\\r\\n # If same values in QTable choose random valid action \\r\\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\\r\\n # Check if valid action else find new best action\\r\\n if not valid_actions[best_action]:\\r\\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\\r\\n for i in range(len(valid_actions)):\\r\\n if valid_actions[actions[i]]:\\r\\n best_action = actions[i]\\r\\n break\\r\\n\\r\\n Action_probabilities[best_action] += (1.0 - epsilon) # Assigns rest probability to best action so probability sums to 1\\r\\n\\r\\n return Action_probabilities \\r\\n\\r\\n def greedyPolicy():\\r\\n tmp_state = str(state.state[0])\\r\\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\\r\\n\\r\\n Action_probabilities = np.zeros(num_actions, dtype = float)\\r\\n\\r\\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\\r\\n # Check if valid action else find new best action\\r\\n if not valid_actions[best_action]:\\r\\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\\r\\n for i in range(len(valid_actions)):\\r\\n if valid_actions[actions[i]]:\\r\\n best_action = actions[i]\\r\\n break\\r\\n\\r\\n\\r\\n Action_probabilities[best_action] += 1.0\\r\\n return Action_probabilities\\r\\n\\r\\n\\r\\n if(self.__chosenPolicy == \\\"epsilon greedy\\\"):\\r\\n return epsilonGreedyPolicy \\r\\n if(self.__chosenPolicy == \\\"greedy\\\"):\\r\\n return greedyPolicy\",\n \"def agent_init(self, agent_config):\\n if agent_config.get('name') is None or not (agent_config.get('name').lower() == 'q-learning' or agent_config.get('name').lower() == 'expected_sarsa'):\\n raise AssertionError(\\\"Invalid agent name. Accepted agents: 'q-learning', 'expected_sarsa'\\\")\\n self.name = agent_config['name']\\n self.device = agent_config['device']\\n self.replay_buffer = ReplayBuffer(agent_config['replay_buffer_size'],\\n agent_config['minibatch_size'],\\n agent_config.get('seed'))\\n self.network = DQN(agent_config['network_config']).to(self.device) # The latest state of the network that is getting replay updates\\n self.network_target = DQN(agent_config['network_config']).to(self.device)\\n\\n optim_config = agent_config['optimizer_config']\\n self.optimizer = optim.Adam(self.network.parameters(), lr=optim_config['step_size'], betas=optim_config['betas'])\\n self.num_actions = agent_config['network_config']['action_dim']\\n self.num_replay = agent_config['num_replay_updates_per_step']\\n self.discount = agent_config['gamma']\\n self.tau = agent_config['tau']\\n\\n self.rand_generator = np.random.RandomState(agent_config.get('seed'))\\n\\n self.last_state = None\\n self.last_action = None\\n\\n self.sum_rewards = 0\\n self.epsiode_steps = 0\\n\\n checkpoint_dir = agent_config.get('checkpoint_dir')\\n if checkpoint_dir is None:\\n self.checkpoint_dir = 'model_weights'\\n else:\\n self.checkpoint_dir = checkpoint_dir\\n \\n if not os.path.isdir(self.checkpoint_dir):\\n os.makedirs(self.checkpoint_dir)\",\n \"def update1(self, state, action, nextState, reward):\\n #print \\\"update1 in ApproximateQAgent\\\"\\n \\\"*** YOUR CODE HERE ***\\\"\\n ##################################################################################################################################Eric Did Stuff\\n actionList = nextState.getLegalActions(self.index)\\n\\n\\n #print \\\"Action List\\\", actionList\\n\\n\\n\\n\\n weights = self.getWeights()\\n\\n features = self.featExtractor.getFeatures(state, action, self)\\n #self.myFeats = features\\n if self.index == 0:\\n print \\\"FEATURES: \\\",features\\n value = self.computeValueFromQValues(nextState)\\n qValue = self.getQValue(state,action)\\n #print \\\"value\\\", value, \\\"qValue\\\", qValue\\n for feature in features:\\n if len(actionList) != 0:\\n weights[feature] = weights[feature] + self.alpha * (reward + self.discount * value - qValue) * features[feature]\\n else:\\n weights[feature] = weights[feature] + self.alpha * (reward - qValue) * features[feature]\\n #print \\\"feature\\\", feature, \\\"weights\\\", weights[feature]\\n #print \\\"weights\\\", weights\\n\\n #util.raiseNotDefined()\",\n \"def getQValue(self, state, action):\\n \\\"\\\"\\\"Description:\\n [Enter a description of what you did here.]\\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\\n \\n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\\n it did not change even a ghost is closing.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n # if weight is empty, then weight will need to initial to 1 for all features\\n # According to which Extractor user choose, weight counter will have equal number of keys.\\n if len(self.weight) == 0:\\n feat = self.featExtractor.getFeatures(state, action)\\n self.weight.incrementAll(feat.keys(), 1)\\n \\n qValue = self.weight * self.featExtractor.getFeatures(state,action)\\n return qValue\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def main():\\n\\n # The X's represent the boundaries of the maze.\\n # Reaching state G results in a reward of +1.\\n # Reaching state E results in a reward of -1.\\n grid = [ # 4 x 3 maze.\\n \\\"XXXXXX\\\",\\n \\\"X GX\\\",\\n \\\"X X EX\\\",\\n \\\"X X\\\",\\n \\\"XXXXXX\\\"\\n ]\\n\\n grid2 = [ # 10 x 8 maze.\\n \\\"XXXXXXXXXXXX\\\",\\n \\\"X X X\\\",\\n \\\"X X XXXXXX X\\\",\\n \\\"X EX\\\",\\n \\\"XX XXXXXX X\\\",\\n \\\"X X X X\\\",\\n \\\"X XX XGXX X\\\",\\n \\\"X XX X X\\\",\\n \\\"XXXX XX\\\",\\n \\\"XXXXXXXXXXXX\\\"\\n ]\\n\\n maze = Maze(grid, (2, 1))\\n maze.display()\\n\\n agent = QAgent(maze)\\n agent.qlearn(250)\\n path = agent.solve_maze()\\n\\n while path:\\n move = path.pop(0)\\n maze = maze.neighbor(move)\\n time.sleep(0.50)\\n maze.display()\\n\\n print(\\\"path: \\\" + str(path))\\n print(\\\"Q table:\\\")\\n print(agent.get_qtable_str())\",\n \"def step(self, state, action, next_state, reward, is_done):\\n state = state.astype('float32')\\n next_state = next_state.astype('float32')\\n self.memory.push(state, action, next_state, reward, is_done*1.)\\n\\n if len(self.memory) > self.batch_size:\\n experience = self.memory.sample(self.batch_size)\\n batch = Transition(*zip(*experience))\\n\\n if self.is_conv_agent:\\n state = torch.tensor(batch.state).permute(0, 3, 1, 2).to(self.device)\\n next_state = torch.tensor(batch.next_state).permute(0, 3, 1, 2).to(self.device)\\n else:\\n state = torch.tensor(batch.state).to(self.device)\\n next_state = torch.tensor(batch.next_state).to(self.device)\\n action = torch.tensor(batch.action).to(self.device)\\n reward = torch.tensor(batch.reward).to(self.device)\\n is_done = torch.tensor(batch.done).to(self.device)\\n\\n q_targets_next = self.q_target_net(next_state).max(1)[0].detach() # Q(s', a)\\n q_targets = reward + (self.gamma * q_targets_next * (1 - is_done)) # R + gamma*Q(s',a)\\n\\n q_expected = self.q_policy_net(state).gather(1, action.unsqueeze(1)) # Q(s,a)\\n\\n # optimize: l = R + gamma*Q(s', a) - Q(s, a)\\n #loss = F.smooth_l1_loss(q_expected, q_targets.unsqueeze(1)) # batch x 1\\n loss = self.loss_fn(q_expected, q_targets.unsqueeze(1)) # batch x 1\\n\\n self.optimizer.zero_grad()\\n loss.backward()\\n # Gradient clip\\n for params in self.q_policy_net.parameters():\\n params.grad.data.clamp_(-3, 3)\\n self.optimizer.step()\\n\\n self.t_step = (self.t_step + 1) % self.update_every\\n if self.t_step == 0:\\n self._soft_update(target_model=self.q_target_net,\\n local_model=self.q_policy_net,\\n tau=self.soft_update_ratio)\",\n \"def learn(self, s, a, reward, sprime, done):\\n pass\",\n \"def learn(self, s, a, reward, sprime, done):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7534157","0.72916085","0.7178249","0.70445454","0.7","0.6985736","0.6985736","0.6985736","0.689876","0.68947405","0.6880697","0.68613094","0.6834198","0.6831387","0.6820141","0.6799026","0.6772288","0.6765899","0.67192644","0.6704822","0.66806555","0.6673666","0.66470337","0.66327417","0.6616404","0.6608786","0.65844434","0.65522295","0.6522697","0.6521317","0.6503922","0.6495148","0.6466031","0.6451691","0.64488703","0.6420621","0.6396896","0.63833356","0.63824105","0.6379866","0.63735497","0.6369855","0.63670886","0.6353687","0.6346749","0.6327368","0.63212055","0.63065904","0.6302015","0.6301055","0.6289593","0.627534","0.6255845","0.62337345","0.6225278","0.6194034","0.6191471","0.61839163","0.6182982","0.6181747","0.6171328","0.6165309","0.61524266","0.61524266","0.61459816","0.6141659","0.6114605","0.610712","0.6105497","0.6105258","0.60965216","0.60938084","0.6086914","0.60781866","0.60720754","0.6071274","0.6061204","0.60611665","0.605321","0.604412","0.6037897","0.6037172","0.602445","0.6022533","0.60036427","0.59987605","0.5990206","0.59884137","0.59734917","0.59717065","0.5966431","0.5964244","0.5962467","0.5962374","0.5951172","0.59506375","0.5947143","0.5938774","0.592747","0.59118116","0.59118116"],"string":"[\n \"0.7534157\",\n \"0.72916085\",\n \"0.7178249\",\n \"0.70445454\",\n \"0.7\",\n \"0.6985736\",\n \"0.6985736\",\n \"0.6985736\",\n \"0.689876\",\n \"0.68947405\",\n \"0.6880697\",\n \"0.68613094\",\n \"0.6834198\",\n \"0.6831387\",\n \"0.6820141\",\n \"0.6799026\",\n \"0.6772288\",\n \"0.6765899\",\n \"0.67192644\",\n \"0.6704822\",\n \"0.66806555\",\n \"0.6673666\",\n \"0.66470337\",\n \"0.66327417\",\n \"0.6616404\",\n \"0.6608786\",\n \"0.65844434\",\n \"0.65522295\",\n \"0.6522697\",\n \"0.6521317\",\n \"0.6503922\",\n \"0.6495148\",\n \"0.6466031\",\n \"0.6451691\",\n \"0.64488703\",\n \"0.6420621\",\n \"0.6396896\",\n \"0.63833356\",\n \"0.63824105\",\n \"0.6379866\",\n \"0.63735497\",\n \"0.6369855\",\n \"0.63670886\",\n \"0.6353687\",\n \"0.6346749\",\n \"0.6327368\",\n \"0.63212055\",\n \"0.63065904\",\n \"0.6302015\",\n \"0.6301055\",\n \"0.6289593\",\n \"0.627534\",\n \"0.6255845\",\n \"0.62337345\",\n \"0.6225278\",\n \"0.6194034\",\n \"0.6191471\",\n \"0.61839163\",\n \"0.6182982\",\n \"0.6181747\",\n \"0.6171328\",\n \"0.6165309\",\n \"0.61524266\",\n \"0.61524266\",\n \"0.61459816\",\n \"0.6141659\",\n \"0.6114605\",\n \"0.610712\",\n \"0.6105497\",\n \"0.6105258\",\n \"0.60965216\",\n \"0.60938084\",\n \"0.6086914\",\n \"0.60781866\",\n \"0.60720754\",\n \"0.6071274\",\n \"0.6061204\",\n \"0.60611665\",\n \"0.605321\",\n \"0.604412\",\n \"0.6037897\",\n \"0.6037172\",\n \"0.602445\",\n \"0.6022533\",\n \"0.60036427\",\n \"0.59987605\",\n \"0.5990206\",\n \"0.59884137\",\n \"0.59734917\",\n \"0.59717065\",\n \"0.5966431\",\n \"0.5964244\",\n \"0.5962467\",\n \"0.5962374\",\n \"0.5951172\",\n \"0.59506375\",\n \"0.5947143\",\n \"0.5938774\",\n \"0.592747\",\n \"0.59118116\",\n \"0.59118116\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88367,"cells":{"query":{"kind":"string","value":"triggered by get play turn method of super class. This is the method were the magic should happen that chooses the right action"},"document":{"kind":"string","value":"def decision(self, state_space: np.ndarray, action_space: ActionSpace):\n # preprocess state space\n # normalizing state space between zero and one ( 2 is max value of stone and -2 is min value of stone\n state_space = min_max_scaling(state_space)\n state_space = state_space.reshape(1, multiply(*state_space.shape))\n qvalues = self._get_qvalues([state_space])\n decision = self._sample_actions(qvalues, action_space)\n return decision"},"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 turn(self):\n pass","def play(self, player, game): \n super().play(player, game)\n game.set_action(\"SLEEP_CODER\")","def game_play(self):","def play(self, player, game):\n super().play(player, game)\n game.set_action(\"STEAL_CODER\")","def begin_turn(self):\n pass","def think_about_action(self, action, turn):\n current_player = action.executor\n enabler_card = action.enabler_card\n if not action.enabler_card:\n enabler_card = Card(0)\n if current_player is not self:\n if action.inspected and not action.canceled:\n self.other_players[current_player][enabler_card] = 1\n self.card_discovered(enabler_card)\n if not (action.canceled or action.stopped): # if the action was succsessfully done\n self.other_players[current_player][enabler_card] *= self.sure_const\n if action.canceled:\n self.other_players[current_player][enabler_card] = 0\n self.card_discovered()\n if self.game.inspecting_player is not self:\n self.other_players[self.game.inspecting_player][enabler_card] *= self.sure_const\n if action.stopped:\n self.think_about_action(turn.stopping_action, turn)","def play_turn(self, cur_board):\n pass","def play(self):\n self.strategy(self)","def process_turn(self):\n data = self.bot.on_turn({'map': self.encode_map(), 'player_num': PLAYER_ID})\n for action in data.get('ACTIONS', []):\n f = getattr(self, action['action_type'].lower(), lambda **k: None)\n f(**action)","def act(self):\n pass","def act(self, action):\n assert action in self.options()\n if self._state == GameState.PLAY_OR_DRAW:\n if isinstance(action, NopAction):\n self._advance_turn()\n elif isinstance(action, DrawAction):\n self._state = GameState.PLAY_DRAWN\n self._current_hand().append(self._draw())\n else:\n self._play_card(action)\n elif self._state == GameState.PLAY:\n if isinstance(action, NopAction):\n self._state = GameState.PLAY_OR_DRAW\n self._advance_turn()\n else:\n self._play_card(action)\n elif self._state == GameState.PLAY_DRAWN:\n if isinstance(action, NopAction):\n self._state = GameState.PLAY_OR_DRAW\n self._advance_turn()\n else:\n self._play_card(action)\n elif self._state == GameState.PICK_COLOR or self._state == GameState.PICK_COLOR_INIT:\n disc = self._discard[-1]\n disc.color = action.color\n if self._state == GameState.PICK_COLOR:\n last_disc = self._discard[-2]\n if disc.card_type == CardType.WILD:\n self._state = GameState.PLAY_OR_DRAW\n elif any(x.color == last_disc.color for x in self._current_hand()):\n self._state = GameState.CHALLENGE_INVALID\n else:\n self._state = GameState.CHALLENGE_VALID\n self._advance_turn()\n else:\n self._state = GameState.PLAY\n elif self._state == GameState.CHALLENGE_VALID or self._state == GameState.CHALLENGE_INVALID:\n if isinstance(action, NopAction):\n for _ in range(4):\n self._current_hand().append(self._draw())\n self._advance_turn()\n elif self._state == GameState.CHALLENGE_INVALID:\n self._advance_turn(by=-1)\n for _ in range(4):\n self._current_hand().append(self._draw())\n self._advance_turn(by=2)\n else:\n for _ in range(6):\n self._current_hand().append(self._draw())\n self._advance_turn()\n self._state = GameState.PLAY_OR_DRAW","def play(self):\r\n self.perform_strategy()","def after_turn(self):\n pass","def play(self, player, game):\n super().play(player, game)\n game.set_action(\"PICKUP_CODER\")","def doTurn(self, gamestate):\n raise NotImplementedError(\"Please Implement this method\")","def update_turn(self):\n pass","def _do_action(self):\n pass","def _do_action(self):\n pass","def play(self):\n\n #Call the superclass play\n return super().play()","def init_turn(self):\n self.before_turn_switches()\n if self.battlefield.win is not None:\n return\n self.before_turn()","def choose_action(self):\r\n pass","def take_action(self, action):\n\t\traise NotImplementedError","def act(self) -> None:\n pass","async def get_action(self, game_ref): # Add other args accordingly.\r\n if(self.type==\"Leader\"):\r\n self.player.gain_summon_points()\r\n\r\n if(self.type==\"Creature\"):\r\n await self.do_auto_skills(game_ref)\r\n self.player.gain_fp()\r\n self.current_actions = self.generate_commands(game= game_ref)\r\n #self.current_actions=await self.check_effects('before', 'command_setting', self.current_actions, None) #Check effects on self.\r\n my_turn = True\r\n await game_ref.send_announcement(\"{}'s turn\".format(self.get_name()))\r\n await self.check_effects('before', 'turn', {'this_piece':self}, game_ref)\r\n while my_turn:\r\n choices = []\r\n for key, item in self.current_actions.items():\r\n print(key)\r\n if item > 0:\r\n choices.append(key)\r\n await self.player.send_embed_to_user()\r\n await game_ref.update_all()\r\n action = await self.player.select_command(choices)\r\n my_turn, completed = await self.process_option(game_ref, action)\r\n if (completed):\r\n if action in self.current_actions:\r\n self.current_actions[action] = self.current_actions[action] - 1\r\n await game_ref.update_all()\r\n\r\n #await asyncio.sleep(0.1)\r\n await game_ref.send_announcement(\"Turn end.\")\r\n await self.check_effects('after', 'turn', {'this_piece':self}, game_ref)\r\n print(\"End OF TURN.\")\r\n return None\r\n # universal options.\r","def perform_actual_action(self, action):\n self.game.perform_action(action)","def take_action(self, *args, **kwargs):\r\n pass","def _action(self):\n pass","def take_action(self, state):","def talk(self):\r\n super().talk()\r\n print(\"meow\")","def play_game(self):\n # need everyone to pass to move to next phase?\n self.deal_cards()\n self.plant_food()","def taketurn(self):\n # get my options from the game\n opts = self.game.options()\n rec_opt = self._primestrat.recommend(opts, self.board)\n if rec_opt is not None:\n self.implementstrategy(rec_opt)\n else:\n super().taketurn()","def play(self, tictactoe):\n raise Exception(\"You implement this method to use it.\")","def robot_takes_turn(self):\n activePlayer = self.get_active_player()\n if activePlayer.humanControlled:\n return\n activeRobot = self.robots[activePlayer]\n if self.turnType == self.REMOVE_TILE:\n remove_tile_fxn = super(RobotGame, self).player_removes_tile\n activeRobot.take_remove_tile_turn(remove_tile_fxn)\n elif self.turnType == self.MOVE_PLAYER:\n move_player_fxn = super(RobotGame, self).player_moves_player\n activeRobot.take_move_player_turn(move_player_fxn)\n elif self.turnType == self.GAME_OVER:\n pass # game over, we do nothing\n else:\n raise # problem with our logic","def play(self, game):\r\n\r\n raise NotImplementedError(\"Subclass must implement\")","def action_run(self):\n pass","def _switch_turn(self, cur_player):\n if cur_player == \"W\":\n self._turn = \"B\"\n else:\n self._turn = \"W\"","def chooseAction(self):\n print \"nothing\"\n pass","def talk(self):\r\n super().talk()\r\n print(\"woof woof\")","def act(self):\n raise NotImplementedError","def actions(self, state, player):\r\n raise NotImplementedError","def talk(self):\r\n super().talk()\r\n print(\"Raaaawr\")","def play_game():\n pass","def action(self):\n pass","def action(self):\n pass","def choose_action(self, board):\n raise NotImplementedError","def call_action(self, action):\n pass","def step(self, action):","def talk(self):\r\n super().talk()\r\n print(\"tsssss\")","def action(self, observation = None):\r\n if observation == None:\r\n observation = self.observer.observe()\r\n \r\n action = self.brain.action(observation)\r\n replay.record(self.number, self.team.name, action)\r\n \r\n if 'speed' in action:\r\n speed = action['speed']\r\n #ensure bounds\r\n speed = max(speed, MIN_SPEED)\r\n speed = min(speed, MAX_SPEED)\r\n self.speed = speed\r\n \r\n if 'turn' in action:\r\n turn = action['turn']\r\n turn = min(turn, MAX_TURN)\r\n turn = max(turn, -MAX_TURN)\r\n self.direction += turn\r\n if self.direction <= -math.pi:\r\n self.direction += math.pi*2\r\n elif self.direction > math.pi:\r\n self.direction -= math.pi*2\r\n \r\n if 'shoot' in action:\r\n self.shoot = bool(action['shoot'])\r\n \r\n if self.shoot and self.ammo > 0:\r\n self.ammo -= 1\r\n shot = ShootSprite(self.world, self)\r\n self.world.shots.add(shot)\r\n if settings.SOUND : \r\n laser.play() \r\n killed_agents = shot.killed_agents()\r\n if len(killed_agents) > 1 and settings.SOUND:\r\n doublekill.play() \r\n for killed_agent in killed_agents:\r\n self.kills += 1\r\n if self.kills == 6 and settings.SOUND:\r\n print str(self),' got a monsterkill!!!'\r\n monsterkill.play() \r\n elif self.kills == 10 and settings.SOUND:\r\n print str(self),' is godlike!!!'\r\n godlike.play() \r\n if PRINT_DEBUG:\r\n print str(killed_agent), \"got killed by\", str(self) \r\n killed_agent.alive = False\r\n self.team.stats[\"kills\"] += 1 \r\n \r\n if 'label' in action:\r\n self.label = action['label']","def onActionChosen(self, agent, action):\n\n pass","def play_single_turn(self, action=None):\n self.turn_count += 1\n if self.save_images_suffix:\n self.game_board.graphical_output(save=True, display=False,\n image_suffix=f'{self.save_images_suffix}_{self.turn_count}')\n if self.game_type == self.game_types['human']:\n self.game_board.graphical_output()\n\n self.player_1.play_turn(action if action else self.get_color_options())\n self.player_2.play_turn(self.get_color_options())\n\n if self.game_type == self.game_types['vs_ai']:\n self.game_board.graphical_output(save=True, image_suffix=self.turn_count)\n\n if self.game_type != self.game_types['r_l']:\n print(f\"player 1 played {self.player_1.color}: {self.player_1.score}\")\n print(f\"player 2 played {self.player_2.color}: {self.player_2.score}\")\n print()","def play(self):\n pass","def getAction(self, gameState):","def talk(self):\r\n super().talk()\r\n print(\"Good day, darling\")","def performCommand(self, game, command):\r\n game.currentTurn.perform(command)","def _turn(self, *args):\n self.send_line('STATUS TURN %s' % self.game.turn)","def _play(self, player):\n\n # Request the current player's desired action\n action = player.request_action()\n\n # Player chose to roll\n if action == \"r\":\n # Roll the die and add to roll total for the turn\n roll = self._die.roll()\n player.update_total_rolls()\n player.update_last_roll(roll)\n # If the player rolls 1, reset the current\n # score and commit the current rolls count\n # to the player's Player object, and exit\n # the loop.\n if roll == 1:\n player.reset_turn_stats()\n player.commit_score()\n print(\"Ouch {}, you rolled a {} and lost all points you accumulated during this turn. Your score for this turn is {}. Your total score is {}.\".format(\n player.get_name(), roll, player.get_current_score(), player.get_total_score()))\n self._active_turn = False\n # If the player rolled other than a 1, update the\n # current score to the value of the roll, check\n # to see if the player's total is >= 100 and end\n # the game, otherwise ask the player for their\n # next action\n else:\n player.update_turn_score(roll)\n if (player.get_current_score() + player.get_total_score()) >= 100:\n player.commit_score()\n player.reset_turn_stats()\n self._end_game, self._active_turn = True, False\n else:\n print(\"Nice {}! You rolled a {}. Your current score for this turn is {}. Your total score is {}\".format(\n player.get_name(),\n roll,\n player.get_current_score(),\n player.get_current_score() + player.get_total_score()\n )\n )\n # Player chose to hold, commit their current score and\n # roll count to their Player object and exit the loop\n elif action == \"h\":\n player.commit_score()\n print(\"{}, you held. Your score for this turn is {}. Your total score is {}.\".format(\n player.get_name(), player.get_current_score(), player.get_total_score()))\n player.reset_turn_stats()\n self._active_turn = False\n # The player entered an invalid action\n else:\n print(\"You entered an invalid action.\")","def changeTurn(self):\r\n # Undoes clicked pieces and removes potential moves from the bar area\r\n for point in self.points:\r\n if point.isClicked():\r\n point.undoClick()\r\n if not self.bar[self.currentPlayer].isEmpty():\r\n self.undoPossibleBarMoves()\r\n \r\n # Changes by turn changing the currentPlayer index and updating all the \r\n # necessary board objects\r\n self.currentPlayer = (self.currentPlayer + 1) % 2\r\n self.dice.makeActive()\r\n for point in self.points:\r\n point.setActiveTurn()\r\n for bar in self.bar:\r\n bar.update()\r\n bar.setActiveTurn()\r\n self.message.resetText('It\\'s ' + self.getCurrentString() + '\\'s turn!', self.surface)\r\n self.turnchanger.setFillColor(self.getTurn())\r\n self.turnchanger.draw(self.surface)\r\n pygame.display.flip()","def __advance(self):\n # If the game is being prepared.\n if self.__current_phase == self.PHASE_PREPARE:\n # If both players are ready.\n if self.__get_current_player().pre_game_prepare() and self.__get_other_player().pre_game_prepare():\n # Start the turn.\n self.__current_phase = self.PHASE_START_TURN\n\n # Begin the game for each player.\n self.__get_current_player().start_game()\n self.__get_other_player().start_game()\n\n # If the game is being set up.\n elif self.__current_phase == self.PHASE_START_TURN:\n # Advance onto the request fire phase.\n self.__current_phase = self.PHASE_REQUEST_SHOT\n\n # Call the start turn method for both players.\n self.__get_current_player().start_turn()\n self.__get_other_player().start_turn()\n\n # If the game requires the user to shoot.\n elif self.__current_phase == self.PHASE_REQUEST_SHOT:\n # Advance onto the fire phase.\n self.__current_phase = self.PHASE_FIRE\n\n # Call the shoot method of the user.\n self.__get_current_player().request_shot()\n\n # If the game requires the other user to be hit.\n elif self.__current_phase == self.PHASE_REQUEST_HIT:\n # Advance onto the hit phase.\n self.__current_phase = self.PHASE_HIT\n\n # Call the other player's request hit method.\n self.__get_other_player().request_hit(self.__current_fire_location)\n\n # If the game shows the hit result.\n elif self.__current_phase == self.PHASE_SHOW_HIT:\n # Advance onto the await phase.\n self.__current_phase = self.PHASE_AWAIT_OPPONENT_SHOT\n\n # Call the player's show hit method.\n self.__get_current_player().show_hit(self.__current_fire_location, self.__current_fire_effect)\n\n # If the game awaits the next shot.\n elif self.__current_phase == self.PHASE_AWAIT_OPPONENT_SHOT:\n # If the opponent has lost.\n if self.__current_fire_effect == Player.SHOT_HIT_TYPE_GAME_OVER:\n # Store the winner's index.\n engine.Engine.game_manager.winner = self.current_player_index\n # Move to the game over phase.\n engine.Engine.load_level(\"GameOver\")\n else:\n # Call the player's await hit method.\n self.__get_current_player().await_opponent_shot()\n\n # If the turn is over.\n if self.current_player_index == 1:\n # Advance to the next turn.\n self.__current_phase = self.PHASE_END_TURN\n else:\n # Advance onto the next fire phase.\n self.__current_phase = self.PHASE_REQUEST_SHOT\n # Increment the user counter.\n self.current_player_index = 1\n\n elif self.__current_phase == self.PHASE_END_TURN:\n # Start a new turn.\n self.__current_phase = self.PHASE_START_TURN\n # Decrement the user counter.\n self.current_player_index = 0\n\n # Call the end turn methods.\n self.__get_current_player().end_turn()\n self.__get_other_player().end_turn()","def turn():\n \n robottype = get_type()\n if robottype == RobotType.PAWN:\n pawn_turn()\n else:\n overlord_turn()\n bytecode = get_bytecode()","def turn():\n \n robottype = get_type()\n if robottype == RobotType.PAWN:\n pawn_turn()\n else:\n overlord_turn()\n bytecode = get_bytecode()","def on_turn(self, turn_state):\n game_state = gamelib.GameState(self.config, turn_state)\n #gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\n #game_state.suppress_warnings(True) #Uncomment this line to suppress warnings.\n\n self.starter_strategy(game_state)\n\n game_state.submit_turn()","def take_turn(self):\r\n self._choose_best_option()\r\n self._do_draw()","def changeTurn(self):\n\t\tif self.turn == 1:\n\t\t\tself.turn = 2\n\t\telse:\n\t\t\tself.turn = 1","def set_turn(self):\n if self.status == self.PLAYER_TURN:\n return\n self.status = self.PLAYER_TURN\n self.client.send_player_turn(10)","def perform_step(self, action):\n pass","def on_turn(self, turn_state):\n game_state = gamelib.GameState(self.config, turn_state)\n gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\n #game_state.suppress_warnings(True) #Uncomment this line to suppress warnings.\n\n self.starter_strategy(game_state)\n\n game_state.submit_turn()","def play(self, tround, context):","def play_step(self, action):\n self.players[0].moving_left = False\n self.players[0].moving_right = False\n if action == MOVE_LEFT:\n self.players[0].moving_left = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_left = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == MOVE_RIGHT:\n self.players[0].moving_right = True\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n self.players[0].moving_right = False\n if self.dead_player or not self.players[0].is_alive:\n return\n elif action == SHOOT:\n if self.dead_player or not self.players[0].is_alive:\n self.update(is_a_star=True)\n return\n if not self.players[0].weapon.is_active:\n self.players[0].shoot()\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\n self.update(is_a_star=True)\n if self.dead_player or not self.players[0].is_alive:\n break\n if self.dead_player or not self.players[0].is_alive:\n return","def act(self, x):\n return self.action","def act(self, state):\n return","def play_move(self,state):\n raise AIError(\"Must be implemented for child class!\")","def _get_turn(self):\n raise NotImplementedError","def _act(self, action):\n self._set_action(action)","def choose_action(self, board, possible_actions):\r\n pass","def play(self):\n print('Playing game...')","def move(self):\r\n return 'rock'","def play(self):\n self._play(self._move_person)","def __init__(self):\r\n self.turn = 0","def do_turn(self, price: int) -> SalesmanAction:","def take_turn(self, turn, actions, world, truck, time):\n self.turn += 1\n\n chosen_upgrade = self.select_upgrade(actions, truck)\n # If there is not an active contract get one\n if(truck.active_contract is None):\n #print(\"Select\")\n chosen_contract = self.select_new_contract(actions, truck)\n actions.set_action(ActionType.select_contract, chosen_contract)\n # Buy gas if below 20% and there is enough money to fill tank to full at max gas price\n elif (truck.speed != 100):\n actions.set_action(ActionType.set_speed, 100)\n print('speed')\n elif(truck.body.current_gas < 1 and truck.money > 100*truck.active_contract.game_map.current_node.gas_price):\n print(\"Gas\")\n actions.set_action(ActionType.buy_gas)\n # If health is below max and have enough money to fully repair do so\n elif truck.health < 100 and truck.money > 1000:\n #print(\"Heal\")\n actions.set_action(ActionType.repair)\n elif chosen_upgrade is not None:\n #print(\"Upgrade\")\n actions.set_action(ActionType.upgrade, chosen_upgrade)\n elif(truck.active_contract.game_map.current_node.next_node is not None):\n # Move to next node\n # Road can be selected by passing the index or road object\n #print(\"Move\")\n road = self.select_new_route(actions, truck)\n actions.set_action(ActionType.select_route, road)\n\n if self.turn == 69 or self.turn == 420:\n print(\"Funny Number! \" + truck.__str__())\n \n pass","def step(self, action):\n assert action in self.infoset.legal_actions\n self.players[self._acting_player_position].set_action(action)\n self._env.step()\n self.infoset = self._game_infoset\n done = False\n reward = 0.0\n if self._game_over:\n done = True\n reward = {\n \"play\": {\n \"landlord\": self._get_reward(\"landlord\"),\n \"landlord_up\": self._get_reward(\"landlord_up\"),\n \"landlord_down\": self._get_reward(\"landlord_down\")\n },\n \"bid\": {\n \"landlord\": self._get_reward_bidding(\"landlord\")*2,\n \"landlord_up\": self._get_reward_bidding(\"landlord_up\"),\n \"landlord_down\": self._get_reward_bidding(\"landlord_down\")\n }\n }\n obs = None\n else:\n obs = get_obs(self.infoset)\n return obs, reward, done, {}","def step(self, action):\n raise NotImplementedError()","def wrapped(widget):\n if r:\n obj.player_choice = random.choice(list(evilrps.Throws))\n else:\n # print(widget, 'throw', throw)\n obj.player_choice = throw\n obj.advance()","def action(self, action):\n if self.is_valid_action(action):\n # Modify the board\n self.board[action[0]][action[1]] = self.player\n\n # Switch player\n self.player = X if self.player == O else O\n else:\n raise Exception('Invalid action')","def turn(self, **kwargs: Any) -> None:\n pass","def step(self, action):\n raise NotImplementedError","def on_turn(self, turn_state):\n game_state = gamelib.GameState(self.config, turn_state)\n gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\n game_state.suppress_warnings(True) #Comment this line to show warnings.\n\n self.emp_line_strategy(game_state)\n\n game_state.submit_turn()","def select_action(self, game_state):\n super().select_action(game_state)\n dim = (game_state.board.num_rows, game_state.board.num_cols)\n if dim != self.dim:\n self._update_cache(dim)\n\n idx = np.arange(len(self.point_cache))\n np.random.shuffle(idx)\n for i in idx:\n p = self.point_cache[i]\n if game_state.is_valid_action(Action.play(p)):\n return Action.play(p)\n return Action.pass_turn()","def getAction(self, gameState):\r\n \"*** YOUR CODE HERE ***\"\r\n util.raiseNotDefined()","def getAction(self, gameState):\r\n \"*** YOUR CODE HERE ***\"\r\n util.raiseNotDefined()","def play_game():\n pass","def play(self):\n if not self.active:\n return\n game_info = {\n 'partisans': self.partisans,\n 'swing': self.swing,\n 'media': self.media,\n 'news': self.news,\n 'mojo': self.mojo,\n 'hype': self.hype,\n 'money': self.money,\n 'cash': self.cash,\n 'cards': self.hand.cards,\n\n 'opp_partisans': self.opponent.partisans,\n 'opp_swing': self.opponent.swing,\n 'opp_media': self.opponent.media,\n 'opp_news': self.opponent.news,\n 'opp_mojo': self.opponent.mojo,\n 'opp_hype': self.opponent.hype,\n 'opp_money': self.opponent.money,\n 'opp_cash': self.opponent.cash,\n 'opp_cards': self.opponent.hand.cards\n }\n\n # print('################')\n # print('opp cards:')\n # for card in game_info['opp_cards']:\n # print(card)\n # print('----------------')\n # print('bots cards:')\n # for card in game_info['cards']:\n # print(card)\n # print('################')\n card, action = self.analysis(game_info)\n\n if action == TO_PRESS:\n card.use()\n elif action == TO_DROP:\n card.drop()","def change_player_turn(self):\r\n self._player_turn *= -1","def transition(self, action):\n raise NotImplementedError","def plant_food(self):\n self.phase.set(0)\n #self.broadcast_phase()\n self.players[self.first_player].take_turn()","def switch_turn(self):\n if self.completed is not None:\n self.current_turn = self.creator if self.current_turn != self.creator else self.opponent\n self.save()","def on_turn(self, turn_state):\n game_state = gamelib.GameState(self.config, turn_state)\n gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\n #game_state.suppress_warnings(True) #Uncomment this line to suppress warnings.\n\n self.fortress(game_state)\n\n game_state.submit_turn()","def update(self):\r\n if not self.tr.game_over and self.tr.turn_tracker:\r\n self.computer_play()","def step(self, action):\n pass","def step(self, action):\n pass"],"string":"[\n \"def turn(self):\\n pass\",\n \"def play(self, player, game): \\n super().play(player, game)\\n game.set_action(\\\"SLEEP_CODER\\\")\",\n \"def game_play(self):\",\n \"def play(self, player, game):\\n super().play(player, game)\\n game.set_action(\\\"STEAL_CODER\\\")\",\n \"def begin_turn(self):\\n pass\",\n \"def think_about_action(self, action, turn):\\n current_player = action.executor\\n enabler_card = action.enabler_card\\n if not action.enabler_card:\\n enabler_card = Card(0)\\n if current_player is not self:\\n if action.inspected and not action.canceled:\\n self.other_players[current_player][enabler_card] = 1\\n self.card_discovered(enabler_card)\\n if not (action.canceled or action.stopped): # if the action was succsessfully done\\n self.other_players[current_player][enabler_card] *= self.sure_const\\n if action.canceled:\\n self.other_players[current_player][enabler_card] = 0\\n self.card_discovered()\\n if self.game.inspecting_player is not self:\\n self.other_players[self.game.inspecting_player][enabler_card] *= self.sure_const\\n if action.stopped:\\n self.think_about_action(turn.stopping_action, turn)\",\n \"def play_turn(self, cur_board):\\n pass\",\n \"def play(self):\\n self.strategy(self)\",\n \"def process_turn(self):\\n data = self.bot.on_turn({'map': self.encode_map(), 'player_num': PLAYER_ID})\\n for action in data.get('ACTIONS', []):\\n f = getattr(self, action['action_type'].lower(), lambda **k: None)\\n f(**action)\",\n \"def act(self):\\n pass\",\n \"def act(self, action):\\n assert action in self.options()\\n if self._state == GameState.PLAY_OR_DRAW:\\n if isinstance(action, NopAction):\\n self._advance_turn()\\n elif isinstance(action, DrawAction):\\n self._state = GameState.PLAY_DRAWN\\n self._current_hand().append(self._draw())\\n else:\\n self._play_card(action)\\n elif self._state == GameState.PLAY:\\n if isinstance(action, NopAction):\\n self._state = GameState.PLAY_OR_DRAW\\n self._advance_turn()\\n else:\\n self._play_card(action)\\n elif self._state == GameState.PLAY_DRAWN:\\n if isinstance(action, NopAction):\\n self._state = GameState.PLAY_OR_DRAW\\n self._advance_turn()\\n else:\\n self._play_card(action)\\n elif self._state == GameState.PICK_COLOR or self._state == GameState.PICK_COLOR_INIT:\\n disc = self._discard[-1]\\n disc.color = action.color\\n if self._state == GameState.PICK_COLOR:\\n last_disc = self._discard[-2]\\n if disc.card_type == CardType.WILD:\\n self._state = GameState.PLAY_OR_DRAW\\n elif any(x.color == last_disc.color for x in self._current_hand()):\\n self._state = GameState.CHALLENGE_INVALID\\n else:\\n self._state = GameState.CHALLENGE_VALID\\n self._advance_turn()\\n else:\\n self._state = GameState.PLAY\\n elif self._state == GameState.CHALLENGE_VALID or self._state == GameState.CHALLENGE_INVALID:\\n if isinstance(action, NopAction):\\n for _ in range(4):\\n self._current_hand().append(self._draw())\\n self._advance_turn()\\n elif self._state == GameState.CHALLENGE_INVALID:\\n self._advance_turn(by=-1)\\n for _ in range(4):\\n self._current_hand().append(self._draw())\\n self._advance_turn(by=2)\\n else:\\n for _ in range(6):\\n self._current_hand().append(self._draw())\\n self._advance_turn()\\n self._state = GameState.PLAY_OR_DRAW\",\n \"def play(self):\\r\\n self.perform_strategy()\",\n \"def after_turn(self):\\n pass\",\n \"def play(self, player, game):\\n super().play(player, game)\\n game.set_action(\\\"PICKUP_CODER\\\")\",\n \"def doTurn(self, gamestate):\\n raise NotImplementedError(\\\"Please Implement this method\\\")\",\n \"def update_turn(self):\\n pass\",\n \"def _do_action(self):\\n pass\",\n \"def _do_action(self):\\n pass\",\n \"def play(self):\\n\\n #Call the superclass play\\n return super().play()\",\n \"def init_turn(self):\\n self.before_turn_switches()\\n if self.battlefield.win is not None:\\n return\\n self.before_turn()\",\n \"def choose_action(self):\\r\\n pass\",\n \"def take_action(self, action):\\n\\t\\traise NotImplementedError\",\n \"def act(self) -> None:\\n pass\",\n \"async def get_action(self, game_ref): # Add other args accordingly.\\r\\n if(self.type==\\\"Leader\\\"):\\r\\n self.player.gain_summon_points()\\r\\n\\r\\n if(self.type==\\\"Creature\\\"):\\r\\n await self.do_auto_skills(game_ref)\\r\\n self.player.gain_fp()\\r\\n self.current_actions = self.generate_commands(game= game_ref)\\r\\n #self.current_actions=await self.check_effects('before', 'command_setting', self.current_actions, None) #Check effects on self.\\r\\n my_turn = True\\r\\n await game_ref.send_announcement(\\\"{}'s turn\\\".format(self.get_name()))\\r\\n await self.check_effects('before', 'turn', {'this_piece':self}, game_ref)\\r\\n while my_turn:\\r\\n choices = []\\r\\n for key, item in self.current_actions.items():\\r\\n print(key)\\r\\n if item > 0:\\r\\n choices.append(key)\\r\\n await self.player.send_embed_to_user()\\r\\n await game_ref.update_all()\\r\\n action = await self.player.select_command(choices)\\r\\n my_turn, completed = await self.process_option(game_ref, action)\\r\\n if (completed):\\r\\n if action in self.current_actions:\\r\\n self.current_actions[action] = self.current_actions[action] - 1\\r\\n await game_ref.update_all()\\r\\n\\r\\n #await asyncio.sleep(0.1)\\r\\n await game_ref.send_announcement(\\\"Turn end.\\\")\\r\\n await self.check_effects('after', 'turn', {'this_piece':self}, game_ref)\\r\\n print(\\\"End OF TURN.\\\")\\r\\n return None\\r\\n # universal options.\\r\",\n \"def perform_actual_action(self, action):\\n self.game.perform_action(action)\",\n \"def take_action(self, *args, **kwargs):\\r\\n pass\",\n \"def _action(self):\\n pass\",\n \"def take_action(self, state):\",\n \"def talk(self):\\r\\n super().talk()\\r\\n print(\\\"meow\\\")\",\n \"def play_game(self):\\n # need everyone to pass to move to next phase?\\n self.deal_cards()\\n self.plant_food()\",\n \"def taketurn(self):\\n # get my options from the game\\n opts = self.game.options()\\n rec_opt = self._primestrat.recommend(opts, self.board)\\n if rec_opt is not None:\\n self.implementstrategy(rec_opt)\\n else:\\n super().taketurn()\",\n \"def play(self, tictactoe):\\n raise Exception(\\\"You implement this method to use it.\\\")\",\n \"def robot_takes_turn(self):\\n activePlayer = self.get_active_player()\\n if activePlayer.humanControlled:\\n return\\n activeRobot = self.robots[activePlayer]\\n if self.turnType == self.REMOVE_TILE:\\n remove_tile_fxn = super(RobotGame, self).player_removes_tile\\n activeRobot.take_remove_tile_turn(remove_tile_fxn)\\n elif self.turnType == self.MOVE_PLAYER:\\n move_player_fxn = super(RobotGame, self).player_moves_player\\n activeRobot.take_move_player_turn(move_player_fxn)\\n elif self.turnType == self.GAME_OVER:\\n pass # game over, we do nothing\\n else:\\n raise # problem with our logic\",\n \"def play(self, game):\\r\\n\\r\\n raise NotImplementedError(\\\"Subclass must implement\\\")\",\n \"def action_run(self):\\n pass\",\n \"def _switch_turn(self, cur_player):\\n if cur_player == \\\"W\\\":\\n self._turn = \\\"B\\\"\\n else:\\n self._turn = \\\"W\\\"\",\n \"def chooseAction(self):\\n print \\\"nothing\\\"\\n pass\",\n \"def talk(self):\\r\\n super().talk()\\r\\n print(\\\"woof woof\\\")\",\n \"def act(self):\\n raise NotImplementedError\",\n \"def actions(self, state, player):\\r\\n raise NotImplementedError\",\n \"def talk(self):\\r\\n super().talk()\\r\\n print(\\\"Raaaawr\\\")\",\n \"def play_game():\\n pass\",\n \"def action(self):\\n pass\",\n \"def action(self):\\n pass\",\n \"def choose_action(self, board):\\n raise NotImplementedError\",\n \"def call_action(self, action):\\n pass\",\n \"def step(self, action):\",\n \"def talk(self):\\r\\n super().talk()\\r\\n print(\\\"tsssss\\\")\",\n \"def action(self, observation = None):\\r\\n if observation == None:\\r\\n observation = self.observer.observe()\\r\\n \\r\\n action = self.brain.action(observation)\\r\\n replay.record(self.number, self.team.name, action)\\r\\n \\r\\n if 'speed' in action:\\r\\n speed = action['speed']\\r\\n #ensure bounds\\r\\n speed = max(speed, MIN_SPEED)\\r\\n speed = min(speed, MAX_SPEED)\\r\\n self.speed = speed\\r\\n \\r\\n if 'turn' in action:\\r\\n turn = action['turn']\\r\\n turn = min(turn, MAX_TURN)\\r\\n turn = max(turn, -MAX_TURN)\\r\\n self.direction += turn\\r\\n if self.direction <= -math.pi:\\r\\n self.direction += math.pi*2\\r\\n elif self.direction > math.pi:\\r\\n self.direction -= math.pi*2\\r\\n \\r\\n if 'shoot' in action:\\r\\n self.shoot = bool(action['shoot'])\\r\\n \\r\\n if self.shoot and self.ammo > 0:\\r\\n self.ammo -= 1\\r\\n shot = ShootSprite(self.world, self)\\r\\n self.world.shots.add(shot)\\r\\n if settings.SOUND : \\r\\n laser.play() \\r\\n killed_agents = shot.killed_agents()\\r\\n if len(killed_agents) > 1 and settings.SOUND:\\r\\n doublekill.play() \\r\\n for killed_agent in killed_agents:\\r\\n self.kills += 1\\r\\n if self.kills == 6 and settings.SOUND:\\r\\n print str(self),' got a monsterkill!!!'\\r\\n monsterkill.play() \\r\\n elif self.kills == 10 and settings.SOUND:\\r\\n print str(self),' is godlike!!!'\\r\\n godlike.play() \\r\\n if PRINT_DEBUG:\\r\\n print str(killed_agent), \\\"got killed by\\\", str(self) \\r\\n killed_agent.alive = False\\r\\n self.team.stats[\\\"kills\\\"] += 1 \\r\\n \\r\\n if 'label' in action:\\r\\n self.label = action['label']\",\n \"def onActionChosen(self, agent, action):\\n\\n pass\",\n \"def play_single_turn(self, action=None):\\n self.turn_count += 1\\n if self.save_images_suffix:\\n self.game_board.graphical_output(save=True, display=False,\\n image_suffix=f'{self.save_images_suffix}_{self.turn_count}')\\n if self.game_type == self.game_types['human']:\\n self.game_board.graphical_output()\\n\\n self.player_1.play_turn(action if action else self.get_color_options())\\n self.player_2.play_turn(self.get_color_options())\\n\\n if self.game_type == self.game_types['vs_ai']:\\n self.game_board.graphical_output(save=True, image_suffix=self.turn_count)\\n\\n if self.game_type != self.game_types['r_l']:\\n print(f\\\"player 1 played {self.player_1.color}: {self.player_1.score}\\\")\\n print(f\\\"player 2 played {self.player_2.color}: {self.player_2.score}\\\")\\n print()\",\n \"def play(self):\\n pass\",\n \"def getAction(self, gameState):\",\n \"def talk(self):\\r\\n super().talk()\\r\\n print(\\\"Good day, darling\\\")\",\n \"def performCommand(self, game, command):\\r\\n game.currentTurn.perform(command)\",\n \"def _turn(self, *args):\\n self.send_line('STATUS TURN %s' % self.game.turn)\",\n \"def _play(self, player):\\n\\n # Request the current player's desired action\\n action = player.request_action()\\n\\n # Player chose to roll\\n if action == \\\"r\\\":\\n # Roll the die and add to roll total for the turn\\n roll = self._die.roll()\\n player.update_total_rolls()\\n player.update_last_roll(roll)\\n # If the player rolls 1, reset the current\\n # score and commit the current rolls count\\n # to the player's Player object, and exit\\n # the loop.\\n if roll == 1:\\n player.reset_turn_stats()\\n player.commit_score()\\n print(\\\"Ouch {}, you rolled a {} and lost all points you accumulated during this turn. Your score for this turn is {}. Your total score is {}.\\\".format(\\n player.get_name(), roll, player.get_current_score(), player.get_total_score()))\\n self._active_turn = False\\n # If the player rolled other than a 1, update the\\n # current score to the value of the roll, check\\n # to see if the player's total is >= 100 and end\\n # the game, otherwise ask the player for their\\n # next action\\n else:\\n player.update_turn_score(roll)\\n if (player.get_current_score() + player.get_total_score()) >= 100:\\n player.commit_score()\\n player.reset_turn_stats()\\n self._end_game, self._active_turn = True, False\\n else:\\n print(\\\"Nice {}! You rolled a {}. Your current score for this turn is {}. Your total score is {}\\\".format(\\n player.get_name(),\\n roll,\\n player.get_current_score(),\\n player.get_current_score() + player.get_total_score()\\n )\\n )\\n # Player chose to hold, commit their current score and\\n # roll count to their Player object and exit the loop\\n elif action == \\\"h\\\":\\n player.commit_score()\\n print(\\\"{}, you held. Your score for this turn is {}. Your total score is {}.\\\".format(\\n player.get_name(), player.get_current_score(), player.get_total_score()))\\n player.reset_turn_stats()\\n self._active_turn = False\\n # The player entered an invalid action\\n else:\\n print(\\\"You entered an invalid action.\\\")\",\n \"def changeTurn(self):\\r\\n # Undoes clicked pieces and removes potential moves from the bar area\\r\\n for point in self.points:\\r\\n if point.isClicked():\\r\\n point.undoClick()\\r\\n if not self.bar[self.currentPlayer].isEmpty():\\r\\n self.undoPossibleBarMoves()\\r\\n \\r\\n # Changes by turn changing the currentPlayer index and updating all the \\r\\n # necessary board objects\\r\\n self.currentPlayer = (self.currentPlayer + 1) % 2\\r\\n self.dice.makeActive()\\r\\n for point in self.points:\\r\\n point.setActiveTurn()\\r\\n for bar in self.bar:\\r\\n bar.update()\\r\\n bar.setActiveTurn()\\r\\n self.message.resetText('It\\\\'s ' + self.getCurrentString() + '\\\\'s turn!', self.surface)\\r\\n self.turnchanger.setFillColor(self.getTurn())\\r\\n self.turnchanger.draw(self.surface)\\r\\n pygame.display.flip()\",\n \"def __advance(self):\\n # If the game is being prepared.\\n if self.__current_phase == self.PHASE_PREPARE:\\n # If both players are ready.\\n if self.__get_current_player().pre_game_prepare() and self.__get_other_player().pre_game_prepare():\\n # Start the turn.\\n self.__current_phase = self.PHASE_START_TURN\\n\\n # Begin the game for each player.\\n self.__get_current_player().start_game()\\n self.__get_other_player().start_game()\\n\\n # If the game is being set up.\\n elif self.__current_phase == self.PHASE_START_TURN:\\n # Advance onto the request fire phase.\\n self.__current_phase = self.PHASE_REQUEST_SHOT\\n\\n # Call the start turn method for both players.\\n self.__get_current_player().start_turn()\\n self.__get_other_player().start_turn()\\n\\n # If the game requires the user to shoot.\\n elif self.__current_phase == self.PHASE_REQUEST_SHOT:\\n # Advance onto the fire phase.\\n self.__current_phase = self.PHASE_FIRE\\n\\n # Call the shoot method of the user.\\n self.__get_current_player().request_shot()\\n\\n # If the game requires the other user to be hit.\\n elif self.__current_phase == self.PHASE_REQUEST_HIT:\\n # Advance onto the hit phase.\\n self.__current_phase = self.PHASE_HIT\\n\\n # Call the other player's request hit method.\\n self.__get_other_player().request_hit(self.__current_fire_location)\\n\\n # If the game shows the hit result.\\n elif self.__current_phase == self.PHASE_SHOW_HIT:\\n # Advance onto the await phase.\\n self.__current_phase = self.PHASE_AWAIT_OPPONENT_SHOT\\n\\n # Call the player's show hit method.\\n self.__get_current_player().show_hit(self.__current_fire_location, self.__current_fire_effect)\\n\\n # If the game awaits the next shot.\\n elif self.__current_phase == self.PHASE_AWAIT_OPPONENT_SHOT:\\n # If the opponent has lost.\\n if self.__current_fire_effect == Player.SHOT_HIT_TYPE_GAME_OVER:\\n # Store the winner's index.\\n engine.Engine.game_manager.winner = self.current_player_index\\n # Move to the game over phase.\\n engine.Engine.load_level(\\\"GameOver\\\")\\n else:\\n # Call the player's await hit method.\\n self.__get_current_player().await_opponent_shot()\\n\\n # If the turn is over.\\n if self.current_player_index == 1:\\n # Advance to the next turn.\\n self.__current_phase = self.PHASE_END_TURN\\n else:\\n # Advance onto the next fire phase.\\n self.__current_phase = self.PHASE_REQUEST_SHOT\\n # Increment the user counter.\\n self.current_player_index = 1\\n\\n elif self.__current_phase == self.PHASE_END_TURN:\\n # Start a new turn.\\n self.__current_phase = self.PHASE_START_TURN\\n # Decrement the user counter.\\n self.current_player_index = 0\\n\\n # Call the end turn methods.\\n self.__get_current_player().end_turn()\\n self.__get_other_player().end_turn()\",\n \"def turn():\\n \\n robottype = get_type()\\n if robottype == RobotType.PAWN:\\n pawn_turn()\\n else:\\n overlord_turn()\\n bytecode = get_bytecode()\",\n \"def turn():\\n \\n robottype = get_type()\\n if robottype == RobotType.PAWN:\\n pawn_turn()\\n else:\\n overlord_turn()\\n bytecode = get_bytecode()\",\n \"def on_turn(self, turn_state):\\n game_state = gamelib.GameState(self.config, turn_state)\\n #gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\\n #game_state.suppress_warnings(True) #Uncomment this line to suppress warnings.\\n\\n self.starter_strategy(game_state)\\n\\n game_state.submit_turn()\",\n \"def take_turn(self):\\r\\n self._choose_best_option()\\r\\n self._do_draw()\",\n \"def changeTurn(self):\\n\\t\\tif self.turn == 1:\\n\\t\\t\\tself.turn = 2\\n\\t\\telse:\\n\\t\\t\\tself.turn = 1\",\n \"def set_turn(self):\\n if self.status == self.PLAYER_TURN:\\n return\\n self.status = self.PLAYER_TURN\\n self.client.send_player_turn(10)\",\n \"def perform_step(self, action):\\n pass\",\n \"def on_turn(self, turn_state):\\n game_state = gamelib.GameState(self.config, turn_state)\\n gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\\n #game_state.suppress_warnings(True) #Uncomment this line to suppress warnings.\\n\\n self.starter_strategy(game_state)\\n\\n game_state.submit_turn()\",\n \"def play(self, tround, context):\",\n \"def play_step(self, action):\\n self.players[0].moving_left = False\\n self.players[0].moving_right = False\\n if action == MOVE_LEFT:\\n self.players[0].moving_left = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_left = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == MOVE_RIGHT:\\n self.players[0].moving_right = True\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n self.players[0].moving_right = False\\n if self.dead_player or not self.players[0].is_alive:\\n return\\n elif action == SHOOT:\\n if self.dead_player or not self.players[0].is_alive:\\n self.update(is_a_star=True)\\n return\\n if not self.players[0].weapon.is_active:\\n self.players[0].shoot()\\n for i in range(LOOP_AT_EACH_MOVE_UPDATE):\\n self.update(is_a_star=True)\\n if self.dead_player or not self.players[0].is_alive:\\n break\\n if self.dead_player or not self.players[0].is_alive:\\n return\",\n \"def act(self, x):\\n return self.action\",\n \"def act(self, state):\\n return\",\n \"def play_move(self,state):\\n raise AIError(\\\"Must be implemented for child class!\\\")\",\n \"def _get_turn(self):\\n raise NotImplementedError\",\n \"def _act(self, action):\\n self._set_action(action)\",\n \"def choose_action(self, board, possible_actions):\\r\\n pass\",\n \"def play(self):\\n print('Playing game...')\",\n \"def move(self):\\r\\n return 'rock'\",\n \"def play(self):\\n self._play(self._move_person)\",\n \"def __init__(self):\\r\\n self.turn = 0\",\n \"def do_turn(self, price: int) -> SalesmanAction:\",\n \"def take_turn(self, turn, actions, world, truck, time):\\n self.turn += 1\\n\\n chosen_upgrade = self.select_upgrade(actions, truck)\\n # If there is not an active contract get one\\n if(truck.active_contract is None):\\n #print(\\\"Select\\\")\\n chosen_contract = self.select_new_contract(actions, truck)\\n actions.set_action(ActionType.select_contract, chosen_contract)\\n # Buy gas if below 20% and there is enough money to fill tank to full at max gas price\\n elif (truck.speed != 100):\\n actions.set_action(ActionType.set_speed, 100)\\n print('speed')\\n elif(truck.body.current_gas < 1 and truck.money > 100*truck.active_contract.game_map.current_node.gas_price):\\n print(\\\"Gas\\\")\\n actions.set_action(ActionType.buy_gas)\\n # If health is below max and have enough money to fully repair do so\\n elif truck.health < 100 and truck.money > 1000:\\n #print(\\\"Heal\\\")\\n actions.set_action(ActionType.repair)\\n elif chosen_upgrade is not None:\\n #print(\\\"Upgrade\\\")\\n actions.set_action(ActionType.upgrade, chosen_upgrade)\\n elif(truck.active_contract.game_map.current_node.next_node is not None):\\n # Move to next node\\n # Road can be selected by passing the index or road object\\n #print(\\\"Move\\\")\\n road = self.select_new_route(actions, truck)\\n actions.set_action(ActionType.select_route, road)\\n\\n if self.turn == 69 or self.turn == 420:\\n print(\\\"Funny Number! \\\" + truck.__str__())\\n \\n pass\",\n \"def step(self, action):\\n assert action in self.infoset.legal_actions\\n self.players[self._acting_player_position].set_action(action)\\n self._env.step()\\n self.infoset = self._game_infoset\\n done = False\\n reward = 0.0\\n if self._game_over:\\n done = True\\n reward = {\\n \\\"play\\\": {\\n \\\"landlord\\\": self._get_reward(\\\"landlord\\\"),\\n \\\"landlord_up\\\": self._get_reward(\\\"landlord_up\\\"),\\n \\\"landlord_down\\\": self._get_reward(\\\"landlord_down\\\")\\n },\\n \\\"bid\\\": {\\n \\\"landlord\\\": self._get_reward_bidding(\\\"landlord\\\")*2,\\n \\\"landlord_up\\\": self._get_reward_bidding(\\\"landlord_up\\\"),\\n \\\"landlord_down\\\": self._get_reward_bidding(\\\"landlord_down\\\")\\n }\\n }\\n obs = None\\n else:\\n obs = get_obs(self.infoset)\\n return obs, reward, done, {}\",\n \"def step(self, action):\\n raise NotImplementedError()\",\n \"def wrapped(widget):\\n if r:\\n obj.player_choice = random.choice(list(evilrps.Throws))\\n else:\\n # print(widget, 'throw', throw)\\n obj.player_choice = throw\\n obj.advance()\",\n \"def action(self, action):\\n if self.is_valid_action(action):\\n # Modify the board\\n self.board[action[0]][action[1]] = self.player\\n\\n # Switch player\\n self.player = X if self.player == O else O\\n else:\\n raise Exception('Invalid action')\",\n \"def turn(self, **kwargs: Any) -> None:\\n pass\",\n \"def step(self, action):\\n raise NotImplementedError\",\n \"def on_turn(self, turn_state):\\n game_state = gamelib.GameState(self.config, turn_state)\\n gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\\n game_state.suppress_warnings(True) #Comment this line to show warnings.\\n\\n self.emp_line_strategy(game_state)\\n\\n game_state.submit_turn()\",\n \"def select_action(self, game_state):\\n super().select_action(game_state)\\n dim = (game_state.board.num_rows, game_state.board.num_cols)\\n if dim != self.dim:\\n self._update_cache(dim)\\n\\n idx = np.arange(len(self.point_cache))\\n np.random.shuffle(idx)\\n for i in idx:\\n p = self.point_cache[i]\\n if game_state.is_valid_action(Action.play(p)):\\n return Action.play(p)\\n return Action.pass_turn()\",\n \"def getAction(self, gameState):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n util.raiseNotDefined()\",\n \"def getAction(self, gameState):\\r\\n \\\"*** YOUR CODE HERE ***\\\"\\r\\n util.raiseNotDefined()\",\n \"def play_game():\\n pass\",\n \"def play(self):\\n if not self.active:\\n return\\n game_info = {\\n 'partisans': self.partisans,\\n 'swing': self.swing,\\n 'media': self.media,\\n 'news': self.news,\\n 'mojo': self.mojo,\\n 'hype': self.hype,\\n 'money': self.money,\\n 'cash': self.cash,\\n 'cards': self.hand.cards,\\n\\n 'opp_partisans': self.opponent.partisans,\\n 'opp_swing': self.opponent.swing,\\n 'opp_media': self.opponent.media,\\n 'opp_news': self.opponent.news,\\n 'opp_mojo': self.opponent.mojo,\\n 'opp_hype': self.opponent.hype,\\n 'opp_money': self.opponent.money,\\n 'opp_cash': self.opponent.cash,\\n 'opp_cards': self.opponent.hand.cards\\n }\\n\\n # print('################')\\n # print('opp cards:')\\n # for card in game_info['opp_cards']:\\n # print(card)\\n # print('----------------')\\n # print('bots cards:')\\n # for card in game_info['cards']:\\n # print(card)\\n # print('################')\\n card, action = self.analysis(game_info)\\n\\n if action == TO_PRESS:\\n card.use()\\n elif action == TO_DROP:\\n card.drop()\",\n \"def change_player_turn(self):\\r\\n self._player_turn *= -1\",\n \"def transition(self, action):\\n raise NotImplementedError\",\n \"def plant_food(self):\\n self.phase.set(0)\\n #self.broadcast_phase()\\n self.players[self.first_player].take_turn()\",\n \"def switch_turn(self):\\n if self.completed is not None:\\n self.current_turn = self.creator if self.current_turn != self.creator else self.opponent\\n self.save()\",\n \"def on_turn(self, turn_state):\\n game_state = gamelib.GameState(self.config, turn_state)\\n gamelib.debug_write('Performing turn {} of your custom algo strategy'.format(game_state.turn_number))\\n #game_state.suppress_warnings(True) #Uncomment this line to suppress warnings.\\n\\n self.fortress(game_state)\\n\\n game_state.submit_turn()\",\n \"def update(self):\\r\\n if not self.tr.game_over and self.tr.turn_tracker:\\r\\n self.computer_play()\",\n \"def step(self, action):\\n pass\",\n \"def step(self, action):\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7292713","0.7109823","0.7075418","0.7049332","0.695085","0.68663824","0.6862658","0.67548853","0.67518234","0.67462504","0.67203665","0.6714001","0.66854596","0.66723174","0.6632199","0.65679246","0.6557006","0.6557006","0.65565354","0.6540824","0.6538428","0.6499839","0.6463982","0.6417004","0.64064103","0.63967764","0.63659954","0.63462913","0.6330342","0.632895","0.6318478","0.63140094","0.6311843","0.6293649","0.6282675","0.6282551","0.6273886","0.6248713","0.62356454","0.6234658","0.6220765","0.6216735","0.6199585","0.6199585","0.61743957","0.6165856","0.61647016","0.6146046","0.6139416","0.61346704","0.61343974","0.612541","0.61108774","0.61065626","0.61032313","0.6093848","0.6093475","0.6076581","0.60745925","0.606414","0.606414","0.6062812","0.6061703","0.605526","0.60549146","0.6052657","0.6031387","0.60095185","0.60079724","0.60017353","0.6000485","0.5994694","0.59849656","0.5962374","0.5952563","0.59495056","0.5947365","0.58927506","0.58924454","0.58905435","0.58902496","0.5888707","0.5888675","0.5880755","0.5880224","0.5870195","0.58657706","0.5854272","0.58340293","0.5831481","0.5831481","0.58206195","0.58082634","0.5804009","0.58028156","0.57948554","0.57934934","0.5789174","0.57803917","0.5766434","0.5766434"],"string":"[\n \"0.7292713\",\n \"0.7109823\",\n \"0.7075418\",\n \"0.7049332\",\n \"0.695085\",\n \"0.68663824\",\n \"0.6862658\",\n \"0.67548853\",\n \"0.67518234\",\n \"0.67462504\",\n \"0.67203665\",\n \"0.6714001\",\n \"0.66854596\",\n \"0.66723174\",\n \"0.6632199\",\n \"0.65679246\",\n \"0.6557006\",\n \"0.6557006\",\n \"0.65565354\",\n \"0.6540824\",\n \"0.6538428\",\n \"0.6499839\",\n \"0.6463982\",\n \"0.6417004\",\n \"0.64064103\",\n \"0.63967764\",\n \"0.63659954\",\n \"0.63462913\",\n \"0.6330342\",\n \"0.632895\",\n \"0.6318478\",\n \"0.63140094\",\n \"0.6311843\",\n \"0.6293649\",\n \"0.6282675\",\n \"0.6282551\",\n \"0.6273886\",\n \"0.6248713\",\n \"0.62356454\",\n \"0.6234658\",\n \"0.6220765\",\n \"0.6216735\",\n \"0.6199585\",\n \"0.6199585\",\n \"0.61743957\",\n \"0.6165856\",\n \"0.61647016\",\n \"0.6146046\",\n \"0.6139416\",\n \"0.61346704\",\n \"0.61343974\",\n \"0.612541\",\n \"0.61108774\",\n \"0.61065626\",\n \"0.61032313\",\n \"0.6093848\",\n \"0.6093475\",\n \"0.6076581\",\n \"0.60745925\",\n \"0.606414\",\n \"0.606414\",\n \"0.6062812\",\n \"0.6061703\",\n \"0.605526\",\n \"0.60549146\",\n \"0.6052657\",\n \"0.6031387\",\n \"0.60095185\",\n \"0.60079724\",\n \"0.60017353\",\n \"0.6000485\",\n \"0.5994694\",\n \"0.59849656\",\n \"0.5962374\",\n \"0.5952563\",\n \"0.59495056\",\n \"0.5947365\",\n \"0.58927506\",\n \"0.58924454\",\n \"0.58905435\",\n \"0.58902496\",\n \"0.5888707\",\n \"0.5888675\",\n \"0.5880755\",\n \"0.5880224\",\n \"0.5870195\",\n \"0.58657706\",\n \"0.5854272\",\n \"0.58340293\",\n \"0.5831481\",\n \"0.5831481\",\n \"0.58206195\",\n \"0.58082634\",\n \"0.5804009\",\n \"0.58028156\",\n \"0.57948554\",\n \"0.57934934\",\n \"0.5789174\",\n \"0.57803917\",\n \"0.5766434\",\n \"0.5766434\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88368,"cells":{"query":{"kind":"string","value":"pick actions given qvalues. Uses epsilongreedy exploration strategy."},"document":{"kind":"string","value":"def _sample_actions(self, qvalues: np.ndarray, action_space: ActionSpace):\n epsilon = self.epsilon\n batch_size, x = qvalues.shape\n dim = int(x ** 0.25)\n qvalues_reshaped = np.reshape(qvalues, (dim, dim, dim, dim))\n if random.random() < epsilon:\n keys = [key for key in action_space.keys()]\n ix = random.sample(range(len(keys)), 1)[0]\n stone_id = keys[ix]\n move_id = random.sample(range(len(action_space[stone_id])), 1)[0]\n move = action_space[stone_id][move_id]\n decision = np.concatenate([move[\"old_coord\"], move[\"new_coord\"]])\n else:\n possible_actions = qvalues_reshaped * action_space.space_array\n flattened_index = np.nanargmax(possible_actions)\n decision = np.array(np.unravel_index(flattened_index, self.action_shape))\n\n return decision"},"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 select_action(self, q_values):\n assert q_values.ndim == 1\n q_values = q_values.astype('float64')\n nb_actions = q_values.shape[0]\n\n exp_values = np.exp(np.clip(q_values / self.tau, self.clip[0], self.clip[1]))\n probs = exp_values / np.sum(exp_values)\n action = np.random.choice(range(nb_actions), p=probs)\n log.info(f\"Chosen action by keras-rl {action} - probabilities: {probs}\")\n return action","def select_action(self, q_values, **kwargs):\n _rand = np.random.rand(1, 1)\n rand_action = np.random.randint(self.num_actions, size=(5, 5))\n q_values = np.reshape(q_values, [10, 5, 5])\n max_action = np.argmax(q_values, axis=0)\n # max_action = np.reshape(max_action, (-1,1))\n action_map = np.reshape(max_action, (5, 5))\n # print(action_map)\n _mask = _rand < self.epsilon\n res = _mask * rand_action + (1 - _mask) * max_action\n return res","def select_action(self, q_values):\n \n action = Sc2Action()\n\n # Epsilon-Greedy\n # pdb.set_trace()\n egran=np.random.uniform()\n if egran < self.eps and not self.testing:\n action.action = np.random.random_integers(0, self.nb_actions-1)\n action.coords = (np.random.random_integers(0, self.nb_pixels-1), np.random.random_integers(0, self.nb_pixels-1))\n if self.eps <0.05:\n print('eps:',self.eps)\n\n else:\n # greedy.\n action.action = np.argmax(q_values[0]) \n #pdb.set_trace()\n action.coords = np.unravel_index(q_values[1].argmax(), q_values[1].shape)[1:3]\n \n # action.coords = np.unravel_index(np.reshape(q_values[1][0][:][:], (16, 16)).argmax(), np.reshape(\n\n assert len(action.coords) == 2\n\n return action","def sample_actions(self, qvalues):\r\n epsilon = self.epsilon\r\n batch_size, n_actions = qvalues.shape\r\n\r\n random_actions = np.random.choice(n_actions, size=batch_size)\r\n best_actions = qvalues.argmax(axis=-1)\r\n\r\n should_explore = np.random.choice(\r\n [0, 1], batch_size, p=[1-epsilon, epsilon])\r\n return np.where(should_explore, random_actions, best_actions)","def select_action(self, q_values):\n assert q_values.ndim == 1\n nb_actions = q_values.shape[0]\n if np.random.uniform() < self.eps:\n copy_q_values = np.copy(q_values)\n idx = np.argmax(q_values)\n copy_q_values[idx] = 0\n for i in range(0, nb_actions):\n val = copy_q_values[i]\n copy_q_values[i] = -1e8 if val == 0 else val * np.random.uniform()\n action = np.argmax(copy_q_values)\n else:\n action = np.argmax(q_values)\n return action","def sample_actions(self, qvalues):\n epsilon = self.epsilon\n batch_size, n_actions = qvalues.shape\n\n random_actions = np.random.choice(n_actions, size=batch_size)\n best_actions = qvalues.argmax(axis=-1)\n\n should_explore = np.random.choice(\n [0, 1], batch_size, p=[1-epsilon, epsilon])\n return np.where(should_explore, random_actions, best_actions)","def sample_actions(self, qvalues):\n epsilon = self.epsilon\n batch_size, n_actions = qvalues.shape\n\n random_actions = np.random.choice(n_actions, size=batch_size)\n best_actions = qvalues.argmax(axis=-1)\n\n should_explore = np.random.choice(\n [0, 1], batch_size, p=[1-epsilon, epsilon])\n return np.where(should_explore, random_actions, best_actions)","def sample_actions(self, qvalues):\n epsilon = self.epsilon\n batch_size, n_actions = qvalues.shape\n\n random_actions = np.random.choice(n_actions, size=batch_size)\n best_actions = qvalues.argmax(axis=-1)\n\n should_explore = np.random.choice(\n [0, 1], batch_size, p=[1-epsilon, epsilon])\n return np.where(should_explore, random_actions, best_actions)","def __call__(self, state, q_values):\n\n if self.policy_type == \"greedy\":\n is_greedy = True\n else:\n is_greedy = random.uniform(0, 1) > self.epsilon\n\n if is_greedy :\n # choose greedy action\n index_action = np.argmax(q_values[state])\n else:\n # get a random action\n index_action = random.randint(0,3)\n\n return actions_dict[index_action]","def act(self, q_values, *args, **kwargs):\n if np.random.binomial(1, p=self.epsilon_updater.cur_value):\n action = np.array([np.random.choice(range(len(q_values)))])\n else:\n action = np.array([np.argmax(q_values)])\n self.epsilon_updater.update()\n return action","def choose_action( self):\n \"\"\"greedy, random, e-greedy, boltzmann, bayesian\"\"\"\n\tif self.exploration == \"greedy\":\n #Choose an action with the maximum expected value.\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\n a = a[0]\n return a\n if self.exploration == \"random\":\n #Choose an action randomly.\n a = env.action_space.sample()\n if self.exploration == \"e-greedy\":\n #Choose an action by greedily (with e chance of random action) from the Q-network\n if np.random.rand(1) < e or total_steps < pre_train_steps:\n a = env.action_space.sample()\n else:\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\n a = a[0]\n return a\n if self.exploration == \"boltzmann\":\n #Choose an action probabilistically, with weights relative to the Q-values.\n Q_d,allQ = sess.run([q_net.Q_dist,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.Temp:e,q_net.keep_per:1.0})\n a = np.random.choice(Q_d[0],p=Q_d[0])\n a = np.argmax(Q_d[0] == a)\n return a\n if self.exploration == \"bayesian\":\n #Choose an action using a sample from a dropout approximation of a bayesian q-network.\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:(1-e)+0.1})\n a = a[0]\n return a","def pick_action(self, available_actions, epsilon=.05):\n if np.random.uniform(0, 1) < epsilon:\n action = available_actions[np.random.randint(\n 0, len(available_actions))]\n else:\n q_values_of_state = self.q_table[self.environment.current_location]\n maxValue = max(q_values_of_state.values())\n action = np.random.choice(\n [k for k, v in q_values_of_state.items() if v == maxValue]\n )\n\n return action","def eps_greedy(Q, epsilon, num_actions):\n if np.random.uniform(0,1,1) > epsilon:\n action = np.argmax(Q)\n else:\n action = np.random.randint(low=0, high=num_actions)\n \n Q_value = Q[action]\n return action, Q_value","def sample_actions(self, qvalues):\n batch_size, n_actions = qvalues.shape\n best_actions = qvalues.argmax(axis=-1)\n\n return qvalues.argmax(axis=-1)","def get_action_Qvalues(Qvalues,actions):\n\n batch_i = T.arange(Qvalues.shape[0])[:,None]\n time_i = T.arange(Qvalues.shape[1])[None,:]\n action_Qvalues_predicted= Qvalues[batch_i,time_i, actions]\n return action_Qvalues_predicted","def pick_action(self):\n if self.exploration_mode == 'time':\n self.acq_func.exploration_rate = self.exploration_rate(self.duration + 1)\n elif self.exploration_mode == 'samples':\n self.acq_func.exploration_rate = self.exploration_rate(len(self.rounds) + 1)\n\n fid, x = optim.pick_acquisition_mf(acq_func=self.acq_func,\n optimizer=self.aux_optimizer,\n gammas=self.gammas,\n x_init=self.aux_x_init)\n rmean, rsd = self.acq_func.predict_mf(fid=fid, x=x)\n\n # Undo negation of objective function so as to not confuse user\n if self.mode == 'min':\n rmean = -rmean\n\n rospy.loginfo('Next sample (%d, %s) with beta %f and predicted reward %f +- %f',\n fid,\n str(x), self.acq_func.exploration_rate,\n rmean,\n rsd)\n return fid, x","def select_q_values_by_action(q_values, actions):\n return tf.reduce_sum(\n q_values * tf.one_hot(actions, q_values.get_shape()[1]),\n axis=1\n )","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n legal_actions = self.getLegalActions(state)\n if len(legal_actions) == 0: return None\n values = [self.getQValue(state, action) for action in legal_actions]\n max_value = max(values)\n best_indices = [index for index in range(len(values)) if values[index] == max_value]\n return legal_actions[random.choice(best_indices)]","def computeActionFromQValues(self, state):\n actions = self.getLegalActions(state)\n if len(actions) == 0:\n return None\n qVals = [self.getQValue(state, a) for a in actions]\n bestActions = []\n bestVal = max(qVals)\n for i in range(len(actions)):\n if qVals[i] == bestVal:\n bestActions.append(actions[i])\n return random.choice(bestActions) #Break ties randomly","def computeActionFromValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n\n\n #check if teminal\n if self.mdp.isTerminal(state):\n return None\n else:\n # get all actions for state\n actionArr = self.mdp.getPossibleActions(state)\n\n #Q val and action at index 0 of action Array\n currentQ = self.computeQValueFromValues(state, actionArr[0])\n currentAction = actionArr[0]\n\n #loop through action Array\n for action in actionArr:\n #compute q at each index\n possibleQ = self.computeQValueFromValues(state, action)\n\n if (possibleQ == currentQ):\n currentAction = random.choice([currentAction, action])\n\n\n elif (possibleQ > currentQ):\n # want to return action for greatest Q value\n currentAction = action\n # update Q to keep track of corresponding value\n currentQ = possibleQ\n\n\n\n\n return currentAction","def select_action(state, policy, model, num_actions,\n EPS_START, EPS_END, EPS_DECAY, steps_done, alpha, beta):\n # sample = random.random()\n # eps_threshold = EPS_END + (EPS_START - EPS_END) * \\\n # math.exp(-1. * steps_done / EPS_DECAY)\n # .data.max(1)[1].view(1, 1)\n # if sample <= eps_threshold:\n # return LongTensor([[random.randrange(num_actions)]])\n\n\n \n Q = model(Variable(state, volatile=True).type(FloatTensor))\n pi0 = policy(Variable(state, volatile=True).type(FloatTensor))\n # print(pi0.data.numpy())\n V = torch.log((torch.pow(pi0, alpha) * torch.exp(beta * Q)).sum(1) ) / beta\n \n #### FOUND ERROR: ( Q ) returns a tensor of nan at some point\n if np.isnan( Q.sum(1).data[0]) :\n print(\"Q = \", Q)\n print(\"state = \", state)\n\n pi_i = torch.pow(pi0, alpha) * torch.exp(beta * (Q - V))\n m = Categorical(pi_i)\n action = m.sample().data.view(1, 1)\n return action\n # numpy.random.choice(numpy.arange(0, num_actions), p=probabilities)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n position = state.getPacmanPosition()\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return None\n\n max_value = self.computeValueFromQValues(state)\n\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\n\n return random.choice(actions)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n position = state.getPacmanPosition()\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return None\n\n max_value = self.computeValueFromQValues(state)\n\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\n\n return random.choice(actions)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n position = state.getPacmanPosition()\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return None\n\n max_value = self.computeValueFromQValues(state)\n\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\n\n return random.choice(actions)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n position = state.getPacmanPosition()\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return None\n\n max_value = self.computeValueFromQValues(state)\n\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\n\n return random.choice(actions)","def selectAction(self, state, require_q=False):\n e = self.exploration.value(self.steps_done)\n self.steps_done += 1\n q_values = self.forwardPolicyNet(state)\n if random.random() > e:\n action = q_values.max(1)[1].view(1, 1)\n else:\n if hasattr(self.env, 'nA'):\n action_space = self.env.nA\n else:\n action_space = self.env.action_space.n\n action = torch.tensor([[random.randrange(action_space)]], device=self.device, dtype=torch.long)\n q_value = q_values.gather(1, action).item()\n if require_q:\n return action, q_value\n return action","def act(self, q_values, *args, **kwargs):\n pass","def computeActionFromValues(self, state):\n\n ##util.raiseNotDefined()\n #\"*** YOUR CODE STARTS HERE ***\"\n \n # Code to remove --- from here\n resultingAction = None\n if self.mdp.isTerminal(state):\n return resultingAction\n else:\n bestq = float(\"-inf\")\n actions = self.mdp.getPossibleActions(state)\n for action in actions:\n qvalue = self.computeQValueFromValues(state, action)\n if qvalue > bestq:\n bestq = qvalue\n resultingAction = action\n return resultingAction\n\n # Code to remove --- to here\n #\"*** YOUR CODE FINISHES HERE ***\"","def act(self, state):\r\n self.state_info, actions= self.env.generatePossibleAction(state)\r\n # import pdb; pdb.set_trace()\r\n # print(actions)\r\n if self.eps > 0. and np.random.rand() < self.eps:\r\n # select the action randomly\r\n return random.choice(actions)\r\n # import pdb; pdb.set_trace()\r\n qvals = {action: self.Q_value[self.state_info, action] for action in actions}\r\n max_q = max(qvals.values())\r\n\r\n # in case of multiple actions having the same Q values\r\n actions_with_max_q = [a for a,q in qvals.items() if q == max_q]\r\n return random.choice(actions_with_max_q)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n self.Temporary_QValue = util.Counter() #initializing a temporary QValue counter\n\n temporary_QValue = self.Temporary_QValue\n\n legal_Actions = self.getLegalActions(state) #get all the legal actions like north,south,east,west,exit\n\n length_legalActions = len(legal_Actions) #find length of legal actions just to find later if we have legal actions or not\n\n if length_legalActions == 0: #to check if we have any legal action or not\n return 0.0 #Returns value 0 as we do not have any legal actions, we cannot pass 'None' as autograder in q8 expects a float value and not string value\n\n for a in legal_Actions: #loop to check for each legal action\n\n temporary_QValue[a] = self.getQValue(state,a) #Find the Qvalue of each action\n\n best_action = temporary_QValue.argMax() #find the best action to take in a state\n return best_action\n #util.raiseNotDefined()","def _select_action(self):\n if self.eval_mode:\n self._log_values()\n epsilon = self.epsilon_eval\n else:\n epsilon = self.epsilon_fn(\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_train)\n if random.random() <= epsilon:\n # Choose a random action with probability epsilon.\n return random.randint(0, self.num_actions - 1)\n else:\n # Choose the action with highest Q-value at the current state according\n # to the current head.\n return self._compute_q_argmax()","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n legal_actions = self.getLegalActions(state)\n\n if len(legal_actions) == 0:\n return None\n\n max_value = self.computeValueFromQValues(state)\n\n actions = [action for action in legal_actions if self.values[(str(state), action)] == max_value]\n\n return random.choice(actions)","def select_action(self, state, **kwargs):\n preprocessed_state = self.preprocessor.process_state_for_network(state)\n q_values = self.calc_q_values(preprocessed_state)\n #print (np.argmax(q_values), q_values)\n return self.policy[self.mode].select_action(q_values), preprocessed_state","def policies(self, QTable, epsilon, state, next_states, action_to_do): # Inspiration from https://www.geeksforgeeks.org/q-learning-in-python/?fbclid=IwAR1UXR88IuJBhhTakjxNq_gcf3nCmJB0puuoA46J8mZnEan_qx9hhoFzhK8\r\n num_actions = 5 # 5 actions-value, [moved_out, into_goal, send_opp_home, send_self_home, move_token] \r\n def epsilonGreedyPolicy(): \r\n tmp_state = str(state.state[0])\r\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\r\n valid_act_len = len(np.where(valid_actions==True)[0])\r\n\r\n Action_probabilities = np.ones(num_actions, dtype = float) * epsilon / valid_act_len # divides probability based on number of valid actions and epsilon (each 0.025 if 4 actions) \r\n Action_probabilities = np.multiply(Action_probabilities, valid_actions)\r\n\r\n # If same values in QTable choose random valid action \r\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\r\n # Check if valid action else find new best action\r\n if not valid_actions[best_action]:\r\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\r\n for i in range(len(valid_actions)):\r\n if valid_actions[actions[i]]:\r\n best_action = actions[i]\r\n break\r\n\r\n Action_probabilities[best_action] += (1.0 - epsilon) # Assigns rest probability to best action so probability sums to 1\r\n\r\n return Action_probabilities \r\n\r\n def greedyPolicy():\r\n tmp_state = str(state.state[0])\r\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\r\n\r\n Action_probabilities = np.zeros(num_actions, dtype = float)\r\n\r\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\r\n # Check if valid action else find new best action\r\n if not valid_actions[best_action]:\r\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\r\n for i in range(len(valid_actions)):\r\n if valid_actions[actions[i]]:\r\n best_action = actions[i]\r\n break\r\n\r\n\r\n Action_probabilities[best_action] += 1.0\r\n return Action_probabilities\r\n\r\n\r\n if(self.__chosenPolicy == \"epsilon greedy\"):\r\n return epsilonGreedyPolicy \r\n if(self.__chosenPolicy == \"greedy\"):\r\n return greedyPolicy","def select_action(self, state):\n \n ##create lists and string to save relative action information\n actions = []\n action = ''\n all_actions = []\n \n ##get the action with the maximum value\n temp = {}\n for (s, a), value in self.Q.iteritems():\n if s == state:\n temp[(s, a)] = value\n all_actions.append(a) \n max_value = max(temp.values())\n for (s, a) , value in temp.iteritems():\n if value == max_value:\n actions.append(a)\n\n ##if we have more than one action with max_values, random return one\n if len(actions) > 1:\n index = random.randint(0,len(actions) - 1)\n action = str(actions[index])\n else:\n for item in actions:\n action = item\n \n ##when the random number less than epsilon, then return one action randomly \n if random.random() < self.epsilon:\n index = random.randint(0, len(all_actions) - 1)\n action = str(all_actions[index])\n \n ##if the random number not less than epsilon, then return the action with max value\n return action","def choose_action(self, state):\n if random.random() < self.epsilon:\n self.epsilon -= self.epsilon_annealing_rate\n return random.choice(self.valid_actions)\n \n #initialize search variables\n opt_action = self.valid_actions[0]\n opt_value = 0\n\n #performs a search across all valid actions for highest q-value.\n for action in self.valid_actions:\n cur_value = self.q_value(state, action)\n if cur_value > opt_value:\n opt_action = action\n opt_value = cur_value\n elif cur_value == opt_value:\n opt_action = random.choice([opt_action, action])\n return opt_action","def select_action(self, state):\n \n ##create lists and string to save relative action information\n actions = []\n action = ''\n all_actions = []\n \n ##get the action with the maximum value\n temp = {}\n for (s, a), value in self.Q.iteritems():\n if s == state:\n temp[(s, a)] = value\n all_actions.append(a)\n \n max_value = max(temp.values())\n for (s, a) , value in temp.iteritems():\n if value == max_value:\n actions.append(a)\n\n ##if we have more than one action with max_values, random return one\n if len(actions) > 1:\n index = random.randint(0,len(actions) - 1)\n action = str(actions[index])\n else:\n for item in actions:\n action = item\n \n ##when the random number less than epsilon, then return one action randomly \n if random.random() < self.epsilon:\n index = random.randint(0, len(all_actions) - 1)\n action = str(all_actions[index])\n \n ##if the random number not less than epsilon, then return the action with max value\n return action","def decide_actions(self, eval_states, *args):\n\n return self.nn.predict_exploration(eval_states, self.ed.epsilon)","def select_action(self):\n estimated_q_a = self._action_value_estimator.get_estimated_q_a()\n\n if np.random.rand() < self._epsilon:\n chosen_action = random.choice(list(estimated_q_a.keys()))\n else:\n chosen_action = max(estimated_q_a, key=estimated_q_a.get)\n\n return chosen_action","def eps_greedy_action(self, phi, tabu):\n\n # increase counter of actions taken\n self.a_count += 1\n\n # if within the initial buffer before learning starts, random action\n aval_actions = None\n if self.a_count < self.warmup:\n\n if len(tabu) > 0:\n # Remove tabu actions from list of available actions\n aval_actions = [a for a in self.actions if a not in tabu]\n\n action = self.random_action(aval_actions)\n return action, None\n\n elif (self.a_count == self.warmup) and self.verbose:\n print('learning starts')\n\n # evaluate Q(phi, a) for each action\n qvalues = self.Qmodel.predict(phi, batch_size=1)[0]\n\n # generate random value\n randn = np.random.uniform()\n\n # eliminate tabu values from possible actions to pick\n aval_actions = None\n if len(tabu) > 0:\n if randn < self.epsilon:\n aval_actions = [a for a in self.actions if a not in tabu]\n else:\n # Update Qs to low values to ensure they are not picked\n tabu_idx = [i for i in range(self.num_actions) if self.actions[i] in tabu]\n qvalues[tabu_idx] = -9999\n\n # eps-greedy, select random action\n if randn < self.epsilon:\n action = self.random_action(aval_actions)\n a_i = self.action_str2idx(action)\n else:\n # select best action\n a_i = np.argmax(qvalues)\n action = self.actions[a_i]\n\n # update greedy parameter and action count\n self.epsilon *= self.discount_epsilon\n self.a_count += 1\n\n return action, qvalues[a_i]","def choose_action(self, board):\n options = board.empty_cells\n # to allow exploration, have a small probability of a random move\n p_random = random.random()\n # if the state is not in the table add it\n if (self.sign, board.state) not in self.Q_table.keys() or p_random < self.epsilon:\n values = {}\n for option in options:\n values[option] = random.random()\n self.Q_table[(self.sign, board.state)] = values\n self.action = random.choice(options)\n else:\n values = self.Q_table[(self.sign, board.state)]\n action = max(values, key=values.get)\n self.action = action\n\n # decrease exploration after each action\n if self.epsilon > 0:\n self.epsilon -= 0.0001\n\n return self.action","def computeActionFromValues(self, state):\n \"*** YOUR CODE HERE ***\"\n actions = self.mdp.getPossibleActions(state)\n # Initialize max_value as - infinity\n # Initialize best action as None, choose max_value action\n max_value = float(\"-inf\")\n computed_action = None\n\n for action in actions:\n # Find q value of specified action\n q_value = self.computeQValueFromValues(state, action)\n # Update action if it's the best so far\n if q_value > max_value:\n max_value = q_value\n computed_action = action\n return computed_action","def computeActionFromValues(self, state):\n \"*** YOUR CODE HERE ***\"\n actions = self.mdp.getPossibleActions(state)\n optimalAction = None\n maxValue = float('-inf')\n for a in actions:\n qValue = self.computeQValueFromValues(state, a)\n if qValue > maxValue:\n maxValue = qValue\n optimalAction = a\n return optimalAction","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n max_qvalue = None\n for action in self.legalActions:\n qvalue = self.getQValue(state, action)\n if max_qvalue is None or max_qvalue < qvalue:\n max_qvalue = qvalue\n\n if max_qvalue is None:\n return None\n\n actions = []\n for action in self.legalActions:\n qvalue = self.getQValue(state, action)\n if qvalue == max_qvalue:\n actions.append(action)\n\n if max_qvalue is not None and len(actions) == 0:\n return self.legalActions[0]\n if len(actions) > 1:\n return Const.DO_NOTHING\n return random.choice(actions)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n\n max_qvalue = None\n for action in self.legalActions:\n qvalue = self.getQValue(state, action)\n if max_qvalue is None or max_qvalue < qvalue:\n max_qvalue = qvalue\n\n if max_qvalue is None:\n return None\n\n actions = []\n for action in self.legalActions:\n qvalue = self.getQValue(state, action)\n if qvalue == max_qvalue:\n actions.append(action)\n\n if max_qvalue is not None and len(actions) == 0:\n return self.legalActions[0]\n if len(actions) > 1:\n return Const.DO_NOTHING\n return random.choice(actions)","def _select_action(self):\n if self.eval_mode:\n epsilon = self.epsilon_eval\n else:\n epsilon = self.epsilon_fn(\n self.epsilon_decay_period,\n self.training_steps,\n self.min_replay_history,\n self.epsilon_train)\n if random.random() <= epsilon:\n # Choose a random action with probability epsilon.\n return random.randint(0, self.num_actions - 1)\n else:\n # Choose the action with highest Q-value at the current state.\n if self._interact == 'stochastic':\n selected_action = self._stochastic_action\n elif self._interact == 'greedy':\n selected_action = self._q_argmax\n else:\n raise ValueError('Undefined interaction')\n return self._sess.run(selected_action,\n {self.state_ph: self.state})","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n if not self.getLegalActions(state): return None\n\n best_action = None;\n best_value = float('-inf')\n for action in self.getLegalActions(state):\n if self.getQValue(state, action) > best_value:\n best_value = self.getQValue(state, action)\n best_action = action\n return best_action","def bestAction(self):\n get_q = self.getQFunction()\n maxq = -5000\n best_actions = []\n for (state, action), q in get_q.items():\n if q > maxq:\n maxq = q\n best_actions = [action]\n elif q == maxq:\n best_actions.append(action)\n return self.tuple_to_dictionary(random.choice(best_actions))","def choose_action(self, state):\n prob = [] # Probability distribution\n for i in range(len(ACTIONS)):\n prob.append(self.epsilon/4)\n Q_func = self.policy.predict(process_state(state))\n Q_vals = Q_func[0]\n max_index = []\n Qmax = np.amax(Q_vals)\n for i in range(len(prob)):\n if Q_vals[i] == Qmax:\n # max_index.append(i)\n prob[i] = 1 - self.epsilon + self.epsilon/4\n break\n # ind = np.random.choice(max_index)\n # prob[ind] = 1 - self.epsilon + self.epsilon/4\n action = np.random.choice(ACTIONS, p = prob)\n return action","def chooseAction(self,state):\r\n #generate float btwn 0-1\r\n choice = random.random()\r\n \r\n #choose according to that number\r\n if choice > self.epsilon:\r\n return(self.maxQ(state)[1])\r\n else:\r\n #choose randomly\r\n return(self.actions[random.randrange(0,len(self.actions))])","def chooseAction(self,state):\r\n #generate float btwn 0-1\r\n choice = random.random()\r\n \r\n #choose according to that number\r\n if choice > self.epsilon:\r\n return(self.maxQ(state)[1])\r\n else:\r\n #choose randomly\r\n return(self.actions[random.randrange(0,len(self.actions))])","def actionSelector(self): \n if self.Temp!=0:\n if len(self.lessons) > 60 and self.var_T: \n # if the agent haven't already gotten food since a certain time \n # we increase the temperature by 0.001 \n if self.count_without_food>12:\n self.Temp += 0.01 \n if self.Temp>=(self.var_T[0]): \n self.Temp = self.var_T[0] \n # otherwise we decrease the temperatur by 0.001 \n else: \n self.Temp -= 0.001\n if self.Temp <= (self.var_T[-1]):\n self.Temp = self.var_T[-1]\n \n s = np.sum([np.exp(float(k)/self.Temp) for k in self.U_list])\n\n self.action_proba =[np.exp(float(m)/self.Temp)/s for m in self.U_list]\n action = np.random.choice(np.arange(4),p=self.action_proba) # choice a random choice relating to the probability distribution given by the softmax algorith \n else:\n action = np.argmax(self.U_list)\n return action","def epsilonGreedyChooser(normalAction, state, stepsDone):\n epsThreshold = EPS_END + (EPS_START - EPS_END) * math.exp(-1. * stepsDone / EPS_DECAY)\n randomSample = random.random()\n if randomSample > epsThreshold:\n action = normalAction(state).max(1)[1].view(1, 1)[0].item()\n #print(action)\n return action\n else:\n return ENVIRONMENT.action_space.sample()","def takeAction(self, state):\n # go greedy or not?\n if random.uniform(0, 1) < self.epsilon:\n # greedy selection\n # find best action\n allActions = torch.stack(\n tuple(torch.cat((state.strengths, state.focus, changes)) for changes in self.actionSet))\n evaluation = self.q.evaluateBunch(allActions)\n action = Action(state, self.actionSet[evaluation.argmax()])\n return action\n else:\n # random selection\n return Action(state, random.choice(self.actionSet))","def select_action(self, state):\n # print(\"agent.select_action() - state: {}\".format(state))\n\n self.step_counter += 1\n # self.epsilon = max(0.1, 1.0-self.step_counter/self.epsilon_decay_steps)\n epsilon_min = .01\n epsilon_max = .8\n epsilon_step = epsilon_max - (epsilon_max - epsilon_min) * self.step_counter / self.epsilon_decay_steps\n self.epsilon = max(epsilon_min, epsilon_step)\n # self.epsilon = max(0.1, 1.0/self.step_counter)\n\n rand = random.uniform(0, 1)\n if rand < self.epsilon:\n # choose random action\n return np.random.choice(self.nA)\n else:\n # choose greedy action\n return np.argmax(self.Q[state])","def eps_greedy_policy(q_values, eps, forbidden_actions):\r\n\r\n q_values[forbidden_actions] = np.NINF\r\n indices = torch.nonzero(q_values == q_values.max())\r\n random_index = random.randint(0, indices.shape[1]-1)\r\n best_action_index = indices[random_index]\r\n l = len(q_values)\r\n n_forbidden_actions = np.count_nonzero(forbidden_actions)\r\n p = eps / (l-n_forbidden_actions)\r\n\r\n policy = np.full([l], p)\r\n policy[forbidden_actions] = 0\r\n policy[best_action_index] += 1 - eps\r\n\r\n return policy","def greedy_policy(self, q, s):\n\t\tresult = []\n\t\tif q is None:\n\t\t\treturn result\n\t\tmax_val = q[0]\n\t\tfor action in self.feasible_actions_in_state(s):\n\t\t\tq_value = q[action]\n\t\t\tif q_value == max_val:\n\t\t\t\tresult.append(action)\n\t\t\telif q_value > max_val:\n\t\t\t\tresult = [action]\n\t\t\t\tmax_val = q_value\n\t\treturn result","def select_action(self, state, evaluate):\n random_number = np.random.uniform()\n if random_number < self.epsilon and evaluate==False:\n # Random action\n return torch.tensor(random.randint(0,self.env.nA-1))\n\n else:\n # Greedy action\n state = [state]\n state = torch.stack(state)\n state = state.to(self.device, dtype=torch.float)\n q_values = self.main_dqn(state)\n argmax = torch.argmax(q_values).item()\n\n if evaluate:\n if self.env.freely_moving:\n self.list_evaluation_values.append(q_values.reshape(self.env.number_of_rows, self.env.number_of_columns))\n else:\n self.list_evaluation_values.append(q_values.reshape(1, self.env.nA))\n\n return torch.tensor(argmax)","def choose_action(self, state):\n pure_action = self.actor_local.model.predict(state)[0]\n # add gaussian noise for exploration\n # noise = np.random.normal(self.noise_mean, self.noise_stddev, self.action_size)\n \n # add OU noise for exploration\n noise = self.noise.sample()\n\n # action = np.clip(pure_action + noise, self.action_low, self.action_high)\n # print(\"pure\", pure_action)\n # print(\"noise\", noise)\n # action = self.action_high * (pure_action + noise)\n # action = pure_action + noise\n action = np.clip(pure_action + noise, self.action_low, self.action_high)\n # print(\"action\", action)\n return action.tolist()","def choose_action(self, state, epsilon_greedy=False):\n chosen_action = None\n if epsilon_greedy:\n if np.random.rand() <= self.epsilon:\n print('random actions')\n\n # choose random action\n chosen_action = random.choice(self.actions)\n\n else:\n print('argmax')\n\n # find the action with greatest Q value\n maxQ = -float(\"inf\")\n for action in self.actions:\n input_data = np.asarray(state + action).reshape(self.OUTPUT_DIM, self.INPUT_DIM)\n Q = self.model.predict(input_data)\n if Q > maxQ:\n maxQ = Q\n chosen_action = action\n\n else:\n\n # policy rollout\n maxQ = -float(\"inf\")\n for action in self.actions:\n input_data = np.asarray(state + action).reshape(self.OUTPUT_DIM, self.INPUT_DIM)\n Q = self.model.predict(input_data)\n if Q > maxQ:\n maxQ = Q\n chosen_action = action\n\n return chosen_action","def act(self, s, exploration, game, return_pred_opp=False):\n opponent_p = self.compute_opponent_model(s)\n # print(opponent_p)\n opponent_action = np.random.choice(\n opponent_p.size, size=1, p=opponent_p)[0]\n # agent_p = np.exp(self.Q[s][:, opponent_action])\n agent_p = self.compute_marginal_pi(s)\n if exploration and random.random() < self.episilon:\n agent_action = random.randint(0, self.action_num - 1)\n else:\n if self.verbose:\n for s in self.Q.keys():\n print('{}--------------'.format(self.id_))\n print('Q of agent {}: state {}: {}'.format(self.id_, s, str(self.Q[s])))\n # print('QAof agent {}: state {}: {}'.format(self.id_, s, str(self.Q_A[s])))\n # self.Q_A\n print('pi of agent {}: state {}: {}'.format(self.id_, s, self.pi[s]))\n # print('pi of opponent agent {}: state{}: {}'.format(self.id_, s, self.opponent_best_pi[s]))\n print('{}--------------'.format(self.id_))\n agent_action = StationaryAgent.sample(agent_p)\n if return_pred_opp:\n return agent_action, opponent_action\n else:\n return agent_action","def EpsGreedy(self, actions, game_state):\n if random.random() < self.epsilon:\n return random.choice(actions)\n else:\n return self.best_action(actions, game_state)","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n actions = self.getLegalActions(state)\n if len(actions) == 0:\n return None\n values = [self.getQValue(state, action) for action in actions]\n LoT = zip(values, actions)\n (bestValue, bestAction) = max(LoT)\n return bestAction","def chooseAction(self,state):\r\n #generate float btwn 0-1\r\n choice = random.random()\r\n feat = self.feat_funct(state)\r\n #choose according to that number\r\n if choice > self.epsilon:\r\n return(self.maxQ(feat)[1])\r\n else:\r\n #choose randomly\r\n return(self.actions[random.randrange(0,len(self.actions))])","def execute_best_actions(self):\n while True:\n print(\"In execute_best_actions\")\n s = self.get_state_num()\n qvals = self.Q[s]\n # Get action with largest qval\n best_action = np.argmax(qvals)\n # We don't actually update with rewards,\n # but use them to know when to perform next action\n # We want to travel 0.5 m in action's direction.\n self.apply_action(best_action)\n while self.reward == None:\n rospy.sleep(0.5)\n print(\"Reward =\", self.reward)\n self.reward = None","def take_action(self, state):\n if self.epsilon_decay is not None:\n self.epsilon *= self.epsilon_decay\n if random.random() < self.epsilon:\n action = super(BaseQAgent, self).random_next_action(state)\n self.log('exploration move: {0}'.format(str(action)))\n else:\n action = self.greedy_next_action(state)\n self.log('exploitation move: {0}'.format(str(action)))\n return action","def computeActionFromValues(self, state):\n \"*** YOUR CODE HERE ***\"\n if self.mdp.isTerminal(state):\n return None\n \n actions = self.mdp.getPossibleActions(state)\n \n if len(actions) == 0:\n return None\n \n # compteur des q_values\n values = util.Counter()\n \n for action in actions:\n values[action] = self.computeQValueFromValues(state, action)\n \n return values.argMax()\n util.raiseNotDefined()","def choose_action(state, qmatrix, numb_actions):\n\n qmatrix = check_state_exist(state, qmatrix, numb_actions)\n if np.random.uniform() < epsilon:\n # choose best action from qmatrix\n state_action = qmatrix.loc[state, :]\n state_action = state_action.reindex(np.random.permutation(state_action.index)) # some actions have same value\n action = state_action.idxmax()\n else:\n # choose random action from qmatrix\n action = np.random.choice(list(range(numb_actions))) \n return action","def obtain_action(self, timestep):\r\n\t\t# Finds all actions which have not been selected before.\r\n\t\tzero_action = np.argwhere(self.player_selected_actions == 0).flatten()\r\n\r\n\t\t# Checks if there are any actions which have not been selected before.\r\n\t\tif zero_action.size:\r\n\t\t\t# Returns a random action index that has not been selected before.\r\n\t\t\treturn np.random.choice(zero_action).item()\r\n\r\n\t\telse:\r\n\t\t\t# Calculates the sum of the Q value estimate and the upper\r\n\t\t\t# confidence bound term\r\n\t\t\tvalue_list = self.player_Q + self.confidence_level * (np.log(timestep+1) / self.player_selected_actions) ** 0.5\r\n\r\n\t\t\t# Returns a random action index selected among the action indexes\r\n\t\t\t# with the maximum sum.\r\n\t\t\treturn np.random.choice(np.argwhere(value_list == value_list.max()).flatten()).item()","def select_action(engine, observation):\n with torch.no_grad():\n dqn.eval()\n if torch.rand(1).item() < epsilon:\n return random_action(observation)\n else:\n return dqn(observation).greedy()","def select_action_q_and_u(self, env, is_root_node) -> chess.Move:\n\n # this method is called with state locked\n state = board_state_key(env)\n\n my_visitstats = self.tree[state]\n\n if my_visitstats.p is not None: #push p to edges\n tot_p = 1e-8\n for mov in env.legal_moves():\n mov_p = my_visitstats.p[self.move_lookup[mov]]\n my_visitstats.a[mov].p = mov_p\n tot_p += mov_p\n for a_s in my_visitstats.a.values():\n a_s.p /= tot_p\n my_visitstats.p = None\n\n xx_ = np.sqrt(my_visitstats.sum_n + 1) # sqrt of sum(N(s, b); for all b)\n\n e = self.play_conf.noise_eps\n c_puct = self.play_conf.c_puct\n dir_alpha = self.play_conf.dirichlet_alpha\n\n best_s = -999\n best_a = None\n if is_root_node:\n noise = np.random.dirichlet([dir_alpha] * len(my_visitstats.a))\n\n i = 0\n for action, a_s in my_visitstats.a.items():\n p_ = a_s.p\n if is_root_node:\n p_ = (1-e) * p_ + e * noise[i]\n i += 1\n b = a_s.q + c_puct * p_ * xx_ / (1 + a_s.n)\n if b > best_s:\n best_s = b\n best_a = action\n\n return best_a","def select_action(self, state, explore=False):\n if (np.random.rand() < self.EPSILON) and explore:\n actionIdx = np.random.randint(0, self.numJoinAction)\n actionIdxTuple = actionIndexInt2Tuple(actionIdx, self.numActionList)\n else:\n self.Q_network.eval()\n state = torch.from_numpy(state).float().to(self.device)\n state_action_values = self.Q_network(state)\n Q_mtx = (\n state_action_values.detach().cpu().reshape(\n self.numActionList[0], self.numActionList[1]\n )\n )\n pursuerValues, colIndices = Q_mtx.max(dim=1)\n _, rowIdx = pursuerValues.min(dim=0)\n colIdx = colIndices[rowIdx]\n actionIdxTuple = (np.array(rowIdx), np.array(colIdx))\n actionIdx = actionIndexTuple2Int(actionIdxTuple, self.numActionList)\n return actionIdx, actionIdxTuple","def getPolicy(self, state):\n \"\"\"Description:\n Find all of q-values of current state, and choose the action \n with the hight q-value as optimal policy\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n legalActions = self.getLegalActions(state)\n action = None\n policy = util.Counter() # use counter to store action and its q-value\n \n if len(legalActions) == 0:\n return action\n \n for a in legalActions:\n policy[a] = self.getQValue(state, a)\n action = policy.argMax()\n return action\n\n \"\"\" END CODE \"\"\"","def get_action(self, state, available_actions, play_mode=False):\n epsilon = self.current_epsilon()\n will_explore = np.random.random_sample() < epsilon\n\n if not play_mode and will_explore:\n return np.random.choice(available_actions)\n else:\n query_state = np.reshape(state, tuple([1,1] + self.state_shape)).astype(np.float32)\n query_actions_filter = np.zeros((1, self.actions_count), dtype=np.float32)\n query_actions_filter[0][available_actions] = 1.0\n\n chosen_action = self.session.run(self.query_action, {\n self.states: query_state,\n self.query_actions_filter: query_actions_filter\n })\n\n return chosen_action[0]","def select_action(self, q_values, is_training):\n # if is_training then do epsilon decay,\n # otherwise use constant epsilon = 0.05\n if is_training:\n if self.epsilon > self.end:\n self.epsilon -= self.decay_stepsize\n else:\n self.epsilon = 0\n return super(LinearDecayGreedyEpsilonPolicy, self).select_action(q_values)","def computeActionFromValues(self, state):\n \"*** YOUR CODE HERE ***\"\n maxvalue = -100000000\n bestaction = None\n for action in self.mdp.getPossibleActions(state):\n valueforthisaction = self.getQValue(state, action) # is this right? \n if valueforthisaction > maxvalue:\n bestaction = action\n maxvalue = valueforthisaction\n return bestaction","def sample_action(q_pi, policies, num_controls, action_selection=\"deterministic\", alpha = 16.0):\n\n num_factors = len(num_controls)\n\n action_marginals = utils.obj_array_zeros(num_controls)\n \n # weight each action according to its integrated posterior probability over policies and timesteps\n for pol_idx, policy in enumerate(policies):\n for t in range(policy.shape[0]):\n for factor_i, action_i in enumerate(policy[t, :]):\n action_marginals[factor_i][action_i] += q_pi[pol_idx]\n \n selected_policy = np.zeros(num_factors)\n for factor_i in range(num_factors):\n\n # Either you do this:\n if action_selection == 'deterministic':\n selected_policy[factor_i] = np.argmax(action_marginals[factor_i])\n elif action_selection == 'stochastic':\n p_actions = softmax(action_marginals[factor_i] * alpha)\n selected_policy[factor_i] = utils.sample(p_actions)\n\n return selected_policy","def chooseAction(self, gameState):\n actions = gameState.getLegalActions(self.index)\n\n # You can profile your evaluation time by uncommenting these lines\n # start = time.time()\n opIndices = self.getOpponents(gameState)\n opStates = [gameState.getAgentState(i) for i in opIndices]\n opCarry = [x.numCarrying for x in opStates]\n \n if max(opCarry) >= 5:\n self.isOffensive = False\n else:\n self.isOffensive = True\n\n values = [self.evaluate(gameState, a) for a in actions]\n # print 'eval time for agent %d: %.4f' % (self.index, time.time() - start)\n\n maxValue = max(values)\n bestActions = [a for a, v in zip(actions, values) if v == maxValue]\n\n\n\n # print if get eaten\n myPos = gameState.getAgentPosition(self.index)\n prevGameState = self.getPreviousObservation()\n if prevGameState is not None:\n\n previousPos = prevGameState.getAgentPosition(self.index)\n if self.getMazeDistance(myPos, previousPos) > 1:\n print(\"prePostion\",previousPos)\n print()\n previousLegalAction = prevGameState.getLegalActions(self.index)\n print([(self.evaluate(prevGameState, a), a) for a in previousLegalAction])\n print()\n print(self.getNonScaredGhostPos(prevGameState))\n print()\n print()\n\n\n return random.choice(bestActions)","def _get_action(self, state, episode):\n if (episode < self.num_explore_episodes):\n action = [random.choice(list(range(self.num_actions)))\n for _ in range(len(state))]\n return action\n\n action = []\n self.model.q_1.eval()\n with torch.no_grad():\n state = torch.tensor(state, device=self.device).float()\n action = torch.argmin(self.model.q_1(state), dim=-1).tolist()\n self.model.q_1.train()\n return action","def step(self):\n # No need for epsilon as exploration is controlled by c\n\n\n # Step in time (choose an action) \n n = np.sum(self.action_count)\n if n > 0: # Condition to evaluate on first iteration, because np.log(0) = -inf\n mask = self.action_count > 0 # Mask to avoid division by 0 on the formula for upper confidence uncertainties\n uncertainties = np.zeros(self.action_count.shape)\n uncertainties[mask] = self.c*np.sqrt(np.log(n)/self.action_count[mask])\n uncertainties[~mask] = float('inf') # We increment uncertainty of actions we've never chosen\n else:\n uncertainties = np.array(np.repeat(float('inf'), len(self.action_count))) \n optimals = self.Q + uncertainties # Uncertainty rises the value of less chosen actions, hence promoting exploration\n \n max_actions = np.argwhere(optimals == np.amax(optimals)).flatten() # greedy actions (max value)\n if len(max_actions) == 1:\n self.last_action = max_actions\n else:\n self.last_action = np.random.choice(max_actions)\n\n return self.last_action","def getAction(self, state):\n # Pick Action\n legalActions = self.getLegalActions(state)\n action = None\n\n \"\"\"Description:\n Use util.flipCoin, if return true then randomly choice from legalAction\n if flase, then sue getPolicy to get best policy action\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n if len(legalActions) == 0:\n return action # None\n \n if util.flipCoin(self.epsilon):\n ''' exploration function (not work well)''' \n# posPol = util.Counter()\n# for a in legalActions:\n# if self.getQValue(state,a) >= 0:\n# posPol[a] = -1*self.getQValue(state, a) + (1000/(self.vitCount[(state,a)]+0.0001))\n# #print \"posPol[\", a, \"]= \",posPol[a]\n# #posPol[a] = (self.getQValue(state, a) * self.epsilon** self.vitCount[(state,a)]) + ( self.epsilon/(self.vitCount[(state,a)]+0.1) )\n# if len(posPol) == 0:\n# action = random.choice(legalActions)\n# else:\n# action = posPol.argMax() # random.choice(posPol.keys())\n ''' Random exploration '''\n action = random.choice(legalActions)\n else:\n action = self.getPolicy(state)\n \n \"\"\" END CODE \"\"\"\n\n return action","def select_action(self, state):\r\n policy_s = self.epsilon_greedy_probs(self.nA, self.Q[state], self.count, self.epsilon)\r\n return np.random.choice(np.arange(self.nA), p=policy_s)","def select_action(self, state):\n if state in self.Q:\n action = np.random.choice(np.arange(self.nA), p=self.get_probs(self.Q[state], self.epsilon, self.nA))\n else :\n action = np.random.choice(self.nA)\n\n return action","def calcQ(self,thisObs,next_action,reward):\n \n thisObs_tup=(thisObs['volume'],thisObs['time'])\n lastAction_tup=(self.lastAction['vol'],self.lastAction['price'])\n lastObs_tup=(self.lastObs['volume'],self.lastObs['time'])\n lastQvalue=0\n maxQvalue=0\n temp_action=()\n \n if (len(self.Qvalue)>0): \n \"\"\"Searches the Q-value dictionary\"\"\"\n for key,value in self.Qvalue.iteritems():\n \n if (key[0][0]== thisObs_tup[0] and key[0][1]==thisObs_tup[1]):\n if (value > maxQvalue):\n maxQvalue=value\n temp_action = key[1]\n \n if (key[0][0]== lastObs_tup[0] and key[0][1]==lastObs_tup[1] and \n key[1][0]== lastAction_tup[0] and key[1][1]==lastAction_tup[1]):\n \n lastQvalue=self.Qvalue[key]\n #print(\"This state was already encoutered and updated\")\n \n self.Qvalue[(lastObs_tup,lastAction_tup)]=lastQvalue+alpha*(reward+(gamma*maxQvalue)-lastQvalue) \n #print 'The Qtable is',self.Qvalue\n if (len(temp_action)!=0):\n #print \"I found a greedy action\" \n next_action['vol'] = temp_action[0]\n next_action['price']=temp_action[1]\n else: \n next_action=self.return_random_action(thisObs)\n \n return next_action","def act(self, s, exploration, game):\n agent_p = self.compute_marginal_pi(s, one_hot=False)\n if self.exploration and random.random() < self.episilon:\n agent_action = random.randint(0, self.action_num - 1)\n else:\n if self.verbose:\n for s in self.Q.keys():\n print('{}--------------'.format(self.id_))\n print('Q of agent {}: state {}: {}'.format(self.id_, s, str(self.Q[s])))\n # print('QAof agent {}: state {}: {}'.format(self.id_, s, str(self.Q_A[s])))\n # self.Q_A\n print('pi of agent {}: state {}: {}'.format(self.id_, s, self.pi[s]))\n # print('pi of opponent agent {}: state{}: {}'.format(self.id_, s, self.opponent_best_pi[s]))\n print('{}--------------'.format(self.id_))\n agent_action = np.argmax(agent_p)\n return agent_action","def computeQValueFromValues(self, state, action):\n\n ##util.raiseNotDefined()\n #\"*** YOUR CODE STARTS HERE ***\"\n # Code to remove --- from here\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\n qvalue = 0\n for (nextState, probability) in transitions:\n reward = self.mdp.getReward(state, action, nextState)\n qvalue += probability *(reward + self.discount*self.values[nextState])\n # Code to remove --- to here\n #\"*** YOUR CODE FINISHES HERE ***\"\n \n return qvalue","def select_action(self, env, state, **kwargs):\n\n self.epsilon = 1 - (len(self.memory.memory)*1.0)/self.memory.max_size + 0.05\n if np.random.uniform() <= self.epsilon:\n index = env.action_space.sample()\n else:\n index = np.argmax(self.Q.predict(state))\n\n return index","def select_action(self, state: np.ndarray) -> np.ndarray:\n # epsilon greedy policy\n # pylint: disable=comparison-with-callable\n if self.epsilon > np.random.random():\n selected_action = np.array(self.env.action_space.sample())\n else:\n with torch.no_grad():\n state = self._preprocess_state(state, self.device)\n selected_action = self.dqn(state).argmax()\n selected_action = selected_action.cpu().numpy()\n\n # Decay epsilon\n self.epsilon = max(\n self.epsilon\n - (self.max_epsilon - self.min_epsilon) * self.hyper_params.epsilon_decay,\n self.min_epsilon,\n )\n\n return selected_action","def choose_action(self, observation):\r\n observation = T.unsqueeze(T.FloatTensor(observation), 0)\r\n # Epsilon-greedy policy\r\n if np.random.uniform() < self.epsilon: \r\n # Get all of the Q values for the current state (forward prop)\r\n actions_value = self.Q_eval.forward(observation)\r\n\r\n # Take the optimal action \r\n action = T.max(actions_value, 1)[1].data.numpy()\r\n action = action[0] if self.action_space == 0 else action.reshape(self.action_space) # return the argmax index\r\n else: \r\n # Choose a random action in the action space list\r\n action = np.random.randint(0, self.num_actions)\r\n action = action if self.action_space == 0 else action.reshape(self.action_space)\r\n\r\n return action","def select_action(images, n_actions, device, eps_threshold=-1):\n actions = []\n\n for i in images:\n if eps_threshold == -1:\n actions.append(torch.tensor([[random.randrange(n_actions)]], device=device, dtype=torch.long))\n else:\n sample = random.random()\n if sample > eps_threshold:\n with torch.no_grad():\n # t.min(1) will return smallest column value of each row.\n # second column on min result is index of where min element was\n # found, so we pick action with the lower expected reward.\n actions.append(policy_net(i.unsqueeze(0)).min(1)[1].view(1, 1))\n else:\n actions.append(torch.tensor([[random.randrange(n_actions)]], device=device, dtype=torch.long))\n\n return torch.tensor(actions, device=device)","def get_action_choice(self, state: str, epsilon: float):\n\n # e-greedy\n if random.random() < epsilon:\n return {0: random.choice(Actions.actions), 1: random.choice(Actions.actions)}\n else:\n # Get the Q-values for the actions in this state\n Qs_t = self.Q_t[state]\n\n max_Qs_t = max(Qs_t.values())\n\n # find index of the max Q-values\n max_index = [a for a, q in Qs_t.items()\n if q == max_Qs_t]\n\n # choose one of the max-index with uniform distribution\n selected = random.choice(max_index)\n return {0: selected[0], 1: selected[1]}","def choose_action(self):\n\n def is_random_exploration():\n\n # 5. Return whether do random choice\n # hint: generate a random number, and compare\n # it with epsilon\n if random.random() < self.epsilon:\n return True\n else:\n return False\n\n final_action = ''\n if self.learning:\n if is_random_exploration():\n # 6. Return random choose aciton\n final_action = self.valid_actions[random.randint(0, 3)]\n else:\n # 7. Return action with highest q value\n final_action = max(\n self.Qtable[self.state].items(),\n key=operator.itemgetter(1))[0]\n elif self.testing:\n # 7. choose action with highest q value\n final_action = max(\n self.Qtable[self.state].items(),\n key=operator.itemgetter(1))[0]\n else:\n # 6. Return random choose aciton\n final_action = self.valid_actions[random.randint(0, 3)]\n\n return final_action","def _transition_q_learning(self):\n if self.state.as_tuple() not in self.qstore.q:\n self.enum.enumerate_state(self.state, self.qstore.q)\n\n action_values = self.qstore.q[self.state.as_tuple()]\n # epsilon greedy choice\n if np.random.random() < self.epsilon:\n action = State(*action_values['actions'][np.random.randint(len(action_values['actions']))])\n else:\n max_q_value = max(action_values['utilities'])\n max_q_indexes = [i for i in range(len(action_values['actions'])) if\n action_values['utilities'][i] == max_q_value]\n max_actions = [action_values['actions'][i] for i in max_q_indexes]\n action = State(*max_actions[np.random.randint(len(max_actions))])\n\n self.state = action.copy()\n\n self._post_transition_updates()","def computeActionFromQValues(self, state):\n \"*** YOUR CODE HERE ***\"\n ############################################################################################################ Eric Changed state to self.index\n \n legalActions = state.getLegalActions(self.index)\n #print \"COMPUTEACTIONFROMQVALUES in QLEARNINGAGENT, LEGALACTIONS: \", legalActions\n if len(legalActions) == 0:\n return None\n maxValue = self.getQValue(state, legalActions[0])\n maxAction = legalActions[0]\n\n for a in legalActions:\n myQValue = self.getQValue(state, a)\n #print \"COMPUTEACTIONFROMQVALUES in QLEARNINGAGENT, MYQVALUE: \", myQValue, \" MAXVALUE: \", maxValue\n if myQValue > maxValue:\n maxValue = self.getQValue(state, a)\n maxAction = a\n if myQValue == maxValue:\n if util.flipCoin(0.5):\n maxValue = self.getQValue(state, a)\n maxAction = a\n #print \"COMPUTEACTIONFROMQVALUES in QLEARNINGAGENT, MAXACTION: \", maxAction\n return maxAction\n util.raiseNotDefined()","def get_action(self,state):\n \n q_values = self.__network.predict(state[None])[0]\n \n ###YOUR CODE\n if np.random.rand()<self.epsilon:\n return np.random.choice(self.n_actions)\n return np.argmax(q_values)","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qValue = 0\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\n #print('Transitions: ' + str(transitions))\n for t in transitions:\n nextState, prob = t\n reward = self.mdp.getReward(state, action, nextState)\n #print('Reward: ' + str(reward))\n oneTransition = prob * (reward + self.discount * self.values[nextState])\n qValue = qValue + oneTransition\n return qValue","def choose_action(env, Q, observation, epsilon):\n if np.random.uniform(0, 1) < epsilon:\n action = env.action_space.sample()\n else:\n action = np.argmax(Q[observation, :])\n return action","def getQValue(self, state, action):\n \"\"\"Description:\n [Enter a description of what you did here.]\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\n \n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\n it did not change even a ghost is closing.\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n # if weight is empty, then weight will need to initial to 1 for all features\n # According to which Extractor user choose, weight counter will have equal number of keys.\n if len(self.weight) == 0:\n feat = self.featExtractor.getFeatures(state, action)\n self.weight.incrementAll(feat.keys(), 1)\n \n qValue = self.weight * self.featExtractor.getFeatures(state,action)\n return qValue\n \"\"\" END CODE \"\"\"","def choose_action(self, previous_action, episode, state):\n explore_threshold = 0.1\n # Year1: BO\n if state == 1:\n samples = self.BO.suggest()\n #print('predict: ', self.BO.predict())\n\n # Year2-4: TS\n elif episode < 10 or random.random() <= 1 - explore_threshold:\n #print('=== Exploration: Thompson Sampling ===')\n samples = {}\n for key in self.ActionValue:\n samples[key] = np.random.beta(self.ActionValue[key][0], self.ActionValue[key][1])\n # Year2-4: GP\n else: # episode >= 10 and random.random() > explore_threshold\n #print('=== Exploration: Gaussian Process ===')\n # Fitting GP: NOTE: method 化しろ\n # Make training data for GPR: x = (act_{t-1}, act_t), y = (reward_t)\n a = self.action_reward_history\n x = []\n y = []\n # TODO: refactor\n is_current_terminal = False\n for ep in range(len(a[1])): # = range(20)\n for year in self.years:\n if year == 1:\n continue\n x_ = a[year-1][ep][0] + a[year][ep][0]\n y_ = a[year][ep][1]\n x.append(x_)\n y.append(y_)\n if ep + 1 == episode and year == state:\n is_current_terminal = True\n break\n if is_current_terminal:\n break\n\n #print('=== GP I/O ===')\n #print(list(zip(x, y)))\n # Fitting GP regression\n kernel = Matern(length_scale=np.max(y)*2, length_scale_bounds=\"fixed\", nu=1.5) # Optimization Success\n gpr = GaussianProcessRegressor(kernel=kernel, normalize_y=True, n_restarts_optimizer=10).fit(x, y)\n\n # NOTE: Action space to search.\n xy = self.actions\n\n # Map input to gp prediction\n input_list = [previous_action + j for j in xy]\n gp_pred = gpr.predict(input_list) # mu: mean\n samples = {tuple(action_reward[0]): action_reward[1] for action_reward in zip(xy, gp_pred)}\n\n # NOTE: shuffle top actions\n top_samples_gp = 10\n sorted_samples = sorted(samples.items(), key=lambda x: x[1], reverse=True)\n top_samples = dict(sorted_samples[:top_samples_gp])\n top_samples_values = list(top_samples.values())\n top_samples_shuffle = dict(zip(top_samples, random.sample(top_samples_values, len(top_samples_values))))\n remain_samples = dict(sorted_samples[top_samples_gp:])\n samples = dict(ChainMap(top_samples_shuffle, remain_samples))\n\n max_value_actions = sorted(samples.items(), key=lambda x: x[1], reverse=True)\n max_value_action = max_value_actions[0][0]\n\n if state != 1: # previous_action is not None:\n # Statistics of past actions\n past_histry = [k for i in self.action_sequence.values() for j in i.values() for k in j]\n if past_histry:\n past_mean = np.mean(past_histry)\n past_max = np.max(past_histry)\n past_min = np.min(past_histry)\n else:\n past_mean = 0\n past_max = 10000\n past_min = -10000\n\n # It is not used in the case of the sampling whose **consecutive sequence** was a negative reward in the past\n for a, r in max_value_actions:\n # For GP samples\n if previous_action not in self.action_sequence: # For next action\n self.action_sequence[previous_action] = {action_next: [] for action_next in self.actions}\n if a not in self.action_sequence[previous_action]: # For current action\n self.action_sequence[previous_action][a] = []\n\n action_sequence_ = self.action_sequence[previous_action][a]\n # If the action was not sampled in the past, use it.\n if not action_sequence_:\n max_value_action = a\n #print('NEW', max_value_action)\n break\n cond_less_0 = min(action_sequence_) <= 0\n if len(action_sequence_) >= 1: # NOTE: 2 is more robust?\n cond_less_mean = np.mean(action_sequence_) <= past_mean\n else:\n cond_less_mean = False\n\n if cond_less_0 or cond_less_mean:\n #print(f\"\"\"\n # CONDITION\n # action_sequence_: {action_sequence_}\n # cond_less_0: {cond_less_0}\n # cond_less_mean: {cond_less_mean} {np.mean(action_sequence_)}({past_mean})\n # max_value_action: {max_value_action}\n # a: {a}\n # r: {r}\n #\"\"\")\n continue\n\n # If there is a sequence in the past and its reward is higher than the past average, the minimum value is not less than 0\n\n max_value_action = a\n #print('GOOD', max_value_action)\n break\n\n return max_value_action","def get_action(self, state):\n depth_limit = 20\n\n if state.ply_count < 4 and self.data is not None:\n if state in self.data:\n self.queue.put(self.data[state])\n else:\n self.queue.put(random.choice(state.actions()))\n else:\n for depth in range(1, depth_limit+1):\n best_move = self.alpha_beta_search(state, depth)\n if best_move is not None:\n self.queue.put(best_move)"],"string":"[\n \"def select_action(self, q_values):\\n assert q_values.ndim == 1\\n q_values = q_values.astype('float64')\\n nb_actions = q_values.shape[0]\\n\\n exp_values = np.exp(np.clip(q_values / self.tau, self.clip[0], self.clip[1]))\\n probs = exp_values / np.sum(exp_values)\\n action = np.random.choice(range(nb_actions), p=probs)\\n log.info(f\\\"Chosen action by keras-rl {action} - probabilities: {probs}\\\")\\n return action\",\n \"def select_action(self, q_values, **kwargs):\\n _rand = np.random.rand(1, 1)\\n rand_action = np.random.randint(self.num_actions, size=(5, 5))\\n q_values = np.reshape(q_values, [10, 5, 5])\\n max_action = np.argmax(q_values, axis=0)\\n # max_action = np.reshape(max_action, (-1,1))\\n action_map = np.reshape(max_action, (5, 5))\\n # print(action_map)\\n _mask = _rand < self.epsilon\\n res = _mask * rand_action + (1 - _mask) * max_action\\n return res\",\n \"def select_action(self, q_values):\\n \\n action = Sc2Action()\\n\\n # Epsilon-Greedy\\n # pdb.set_trace()\\n egran=np.random.uniform()\\n if egran < self.eps and not self.testing:\\n action.action = np.random.random_integers(0, self.nb_actions-1)\\n action.coords = (np.random.random_integers(0, self.nb_pixels-1), np.random.random_integers(0, self.nb_pixels-1))\\n if self.eps <0.05:\\n print('eps:',self.eps)\\n\\n else:\\n # greedy.\\n action.action = np.argmax(q_values[0]) \\n #pdb.set_trace()\\n action.coords = np.unravel_index(q_values[1].argmax(), q_values[1].shape)[1:3]\\n \\n # action.coords = np.unravel_index(np.reshape(q_values[1][0][:][:], (16, 16)).argmax(), np.reshape(\\n\\n assert len(action.coords) == 2\\n\\n return action\",\n \"def sample_actions(self, qvalues):\\r\\n epsilon = self.epsilon\\r\\n batch_size, n_actions = qvalues.shape\\r\\n\\r\\n random_actions = np.random.choice(n_actions, size=batch_size)\\r\\n best_actions = qvalues.argmax(axis=-1)\\r\\n\\r\\n should_explore = np.random.choice(\\r\\n [0, 1], batch_size, p=[1-epsilon, epsilon])\\r\\n return np.where(should_explore, random_actions, best_actions)\",\n \"def select_action(self, q_values):\\n assert q_values.ndim == 1\\n nb_actions = q_values.shape[0]\\n if np.random.uniform() < self.eps:\\n copy_q_values = np.copy(q_values)\\n idx = np.argmax(q_values)\\n copy_q_values[idx] = 0\\n for i in range(0, nb_actions):\\n val = copy_q_values[i]\\n copy_q_values[i] = -1e8 if val == 0 else val * np.random.uniform()\\n action = np.argmax(copy_q_values)\\n else:\\n action = np.argmax(q_values)\\n return action\",\n \"def sample_actions(self, qvalues):\\n epsilon = self.epsilon\\n batch_size, n_actions = qvalues.shape\\n\\n random_actions = np.random.choice(n_actions, size=batch_size)\\n best_actions = qvalues.argmax(axis=-1)\\n\\n should_explore = np.random.choice(\\n [0, 1], batch_size, p=[1-epsilon, epsilon])\\n return np.where(should_explore, random_actions, best_actions)\",\n \"def sample_actions(self, qvalues):\\n epsilon = self.epsilon\\n batch_size, n_actions = qvalues.shape\\n\\n random_actions = np.random.choice(n_actions, size=batch_size)\\n best_actions = qvalues.argmax(axis=-1)\\n\\n should_explore = np.random.choice(\\n [0, 1], batch_size, p=[1-epsilon, epsilon])\\n return np.where(should_explore, random_actions, best_actions)\",\n \"def sample_actions(self, qvalues):\\n epsilon = self.epsilon\\n batch_size, n_actions = qvalues.shape\\n\\n random_actions = np.random.choice(n_actions, size=batch_size)\\n best_actions = qvalues.argmax(axis=-1)\\n\\n should_explore = np.random.choice(\\n [0, 1], batch_size, p=[1-epsilon, epsilon])\\n return np.where(should_explore, random_actions, best_actions)\",\n \"def __call__(self, state, q_values):\\n\\n if self.policy_type == \\\"greedy\\\":\\n is_greedy = True\\n else:\\n is_greedy = random.uniform(0, 1) > self.epsilon\\n\\n if is_greedy :\\n # choose greedy action\\n index_action = np.argmax(q_values[state])\\n else:\\n # get a random action\\n index_action = random.randint(0,3)\\n\\n return actions_dict[index_action]\",\n \"def act(self, q_values, *args, **kwargs):\\n if np.random.binomial(1, p=self.epsilon_updater.cur_value):\\n action = np.array([np.random.choice(range(len(q_values)))])\\n else:\\n action = np.array([np.argmax(q_values)])\\n self.epsilon_updater.update()\\n return action\",\n \"def choose_action( self):\\n \\\"\\\"\\\"greedy, random, e-greedy, boltzmann, bayesian\\\"\\\"\\\"\\n\\tif self.exploration == \\\"greedy\\\":\\n #Choose an action with the maximum expected value.\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\\n a = a[0]\\n return a\\n if self.exploration == \\\"random\\\":\\n #Choose an action randomly.\\n a = env.action_space.sample()\\n if self.exploration == \\\"e-greedy\\\":\\n #Choose an action by greedily (with e chance of random action) from the Q-network\\n if np.random.rand(1) < e or total_steps < pre_train_steps:\\n a = env.action_space.sample()\\n else:\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:1.0})\\n a = a[0]\\n return a\\n if self.exploration == \\\"boltzmann\\\":\\n #Choose an action probabilistically, with weights relative to the Q-values.\\n Q_d,allQ = sess.run([q_net.Q_dist,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.Temp:e,q_net.keep_per:1.0})\\n a = np.random.choice(Q_d[0],p=Q_d[0])\\n a = np.argmax(Q_d[0] == a)\\n return a\\n if self.exploration == \\\"bayesian\\\":\\n #Choose an action using a sample from a dropout approximation of a bayesian q-network.\\n a,allQ = sess.run([q_net.predict,q_net.Q_out],feed_dict={q_net.inputs:[s],q_net.keep_per:(1-e)+0.1})\\n a = a[0]\\n return a\",\n \"def pick_action(self, available_actions, epsilon=.05):\\n if np.random.uniform(0, 1) < epsilon:\\n action = available_actions[np.random.randint(\\n 0, len(available_actions))]\\n else:\\n q_values_of_state = self.q_table[self.environment.current_location]\\n maxValue = max(q_values_of_state.values())\\n action = np.random.choice(\\n [k for k, v in q_values_of_state.items() if v == maxValue]\\n )\\n\\n return action\",\n \"def eps_greedy(Q, epsilon, num_actions):\\n if np.random.uniform(0,1,1) > epsilon:\\n action = np.argmax(Q)\\n else:\\n action = np.random.randint(low=0, high=num_actions)\\n \\n Q_value = Q[action]\\n return action, Q_value\",\n \"def sample_actions(self, qvalues):\\n batch_size, n_actions = qvalues.shape\\n best_actions = qvalues.argmax(axis=-1)\\n\\n return qvalues.argmax(axis=-1)\",\n \"def get_action_Qvalues(Qvalues,actions):\\n\\n batch_i = T.arange(Qvalues.shape[0])[:,None]\\n time_i = T.arange(Qvalues.shape[1])[None,:]\\n action_Qvalues_predicted= Qvalues[batch_i,time_i, actions]\\n return action_Qvalues_predicted\",\n \"def pick_action(self):\\n if self.exploration_mode == 'time':\\n self.acq_func.exploration_rate = self.exploration_rate(self.duration + 1)\\n elif self.exploration_mode == 'samples':\\n self.acq_func.exploration_rate = self.exploration_rate(len(self.rounds) + 1)\\n\\n fid, x = optim.pick_acquisition_mf(acq_func=self.acq_func,\\n optimizer=self.aux_optimizer,\\n gammas=self.gammas,\\n x_init=self.aux_x_init)\\n rmean, rsd = self.acq_func.predict_mf(fid=fid, x=x)\\n\\n # Undo negation of objective function so as to not confuse user\\n if self.mode == 'min':\\n rmean = -rmean\\n\\n rospy.loginfo('Next sample (%d, %s) with beta %f and predicted reward %f +- %f',\\n fid,\\n str(x), self.acq_func.exploration_rate,\\n rmean,\\n rsd)\\n return fid, x\",\n \"def select_q_values_by_action(q_values, actions):\\n return tf.reduce_sum(\\n q_values * tf.one_hot(actions, q_values.get_shape()[1]),\\n axis=1\\n )\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n legal_actions = self.getLegalActions(state)\\n if len(legal_actions) == 0: return None\\n values = [self.getQValue(state, action) for action in legal_actions]\\n max_value = max(values)\\n best_indices = [index for index in range(len(values)) if values[index] == max_value]\\n return legal_actions[random.choice(best_indices)]\",\n \"def computeActionFromQValues(self, state):\\n actions = self.getLegalActions(state)\\n if len(actions) == 0:\\n return None\\n qVals = [self.getQValue(state, a) for a in actions]\\n bestActions = []\\n bestVal = max(qVals)\\n for i in range(len(actions)):\\n if qVals[i] == bestVal:\\n bestActions.append(actions[i])\\n return random.choice(bestActions) #Break ties randomly\",\n \"def computeActionFromValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n\\n\\n #check if teminal\\n if self.mdp.isTerminal(state):\\n return None\\n else:\\n # get all actions for state\\n actionArr = self.mdp.getPossibleActions(state)\\n\\n #Q val and action at index 0 of action Array\\n currentQ = self.computeQValueFromValues(state, actionArr[0])\\n currentAction = actionArr[0]\\n\\n #loop through action Array\\n for action in actionArr:\\n #compute q at each index\\n possibleQ = self.computeQValueFromValues(state, action)\\n\\n if (possibleQ == currentQ):\\n currentAction = random.choice([currentAction, action])\\n\\n\\n elif (possibleQ > currentQ):\\n # want to return action for greatest Q value\\n currentAction = action\\n # update Q to keep track of corresponding value\\n currentQ = possibleQ\\n\\n\\n\\n\\n return currentAction\",\n \"def select_action(state, policy, model, num_actions,\\n EPS_START, EPS_END, EPS_DECAY, steps_done, alpha, beta):\\n # sample = random.random()\\n # eps_threshold = EPS_END + (EPS_START - EPS_END) * \\\\\\n # math.exp(-1. * steps_done / EPS_DECAY)\\n # .data.max(1)[1].view(1, 1)\\n # if sample <= eps_threshold:\\n # return LongTensor([[random.randrange(num_actions)]])\\n\\n\\n \\n Q = model(Variable(state, volatile=True).type(FloatTensor))\\n pi0 = policy(Variable(state, volatile=True).type(FloatTensor))\\n # print(pi0.data.numpy())\\n V = torch.log((torch.pow(pi0, alpha) * torch.exp(beta * Q)).sum(1) ) / beta\\n \\n #### FOUND ERROR: ( Q ) returns a tensor of nan at some point\\n if np.isnan( Q.sum(1).data[0]) :\\n print(\\\"Q = \\\", Q)\\n print(\\\"state = \\\", state)\\n\\n pi_i = torch.pow(pi0, alpha) * torch.exp(beta * (Q - V))\\n m = Categorical(pi_i)\\n action = m.sample().data.view(1, 1)\\n return action\\n # numpy.random.choice(numpy.arange(0, num_actions), p=probabilities)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n position = state.getPacmanPosition()\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return None\\n\\n max_value = self.computeValueFromQValues(state)\\n\\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\\n\\n return random.choice(actions)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n position = state.getPacmanPosition()\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return None\\n\\n max_value = self.computeValueFromQValues(state)\\n\\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\\n\\n return random.choice(actions)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n position = state.getPacmanPosition()\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return None\\n\\n max_value = self.computeValueFromQValues(state)\\n\\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\\n\\n return random.choice(actions)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n position = state.getPacmanPosition()\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return None\\n\\n max_value = self.computeValueFromQValues(state)\\n\\n actions = [action for action in legal_actions if self.values[(str(position), action)] == max_value]\\n\\n return random.choice(actions)\",\n \"def selectAction(self, state, require_q=False):\\n e = self.exploration.value(self.steps_done)\\n self.steps_done += 1\\n q_values = self.forwardPolicyNet(state)\\n if random.random() > e:\\n action = q_values.max(1)[1].view(1, 1)\\n else:\\n if hasattr(self.env, 'nA'):\\n action_space = self.env.nA\\n else:\\n action_space = self.env.action_space.n\\n action = torch.tensor([[random.randrange(action_space)]], device=self.device, dtype=torch.long)\\n q_value = q_values.gather(1, action).item()\\n if require_q:\\n return action, q_value\\n return action\",\n \"def act(self, q_values, *args, **kwargs):\\n pass\",\n \"def computeActionFromValues(self, state):\\n\\n ##util.raiseNotDefined()\\n #\\\"*** YOUR CODE STARTS HERE ***\\\"\\n \\n # Code to remove --- from here\\n resultingAction = None\\n if self.mdp.isTerminal(state):\\n return resultingAction\\n else:\\n bestq = float(\\\"-inf\\\")\\n actions = self.mdp.getPossibleActions(state)\\n for action in actions:\\n qvalue = self.computeQValueFromValues(state, action)\\n if qvalue > bestq:\\n bestq = qvalue\\n resultingAction = action\\n return resultingAction\\n\\n # Code to remove --- to here\\n #\\\"*** YOUR CODE FINISHES HERE ***\\\"\",\n \"def act(self, state):\\r\\n self.state_info, actions= self.env.generatePossibleAction(state)\\r\\n # import pdb; pdb.set_trace()\\r\\n # print(actions)\\r\\n if self.eps > 0. and np.random.rand() < self.eps:\\r\\n # select the action randomly\\r\\n return random.choice(actions)\\r\\n # import pdb; pdb.set_trace()\\r\\n qvals = {action: self.Q_value[self.state_info, action] for action in actions}\\r\\n max_q = max(qvals.values())\\r\\n\\r\\n # in case of multiple actions having the same Q values\\r\\n actions_with_max_q = [a for a,q in qvals.items() if q == max_q]\\r\\n return random.choice(actions_with_max_q)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n self.Temporary_QValue = util.Counter() #initializing a temporary QValue counter\\n\\n temporary_QValue = self.Temporary_QValue\\n\\n legal_Actions = self.getLegalActions(state) #get all the legal actions like north,south,east,west,exit\\n\\n length_legalActions = len(legal_Actions) #find length of legal actions just to find later if we have legal actions or not\\n\\n if length_legalActions == 0: #to check if we have any legal action or not\\n return 0.0 #Returns value 0 as we do not have any legal actions, we cannot pass 'None' as autograder in q8 expects a float value and not string value\\n\\n for a in legal_Actions: #loop to check for each legal action\\n\\n temporary_QValue[a] = self.getQValue(state,a) #Find the Qvalue of each action\\n\\n best_action = temporary_QValue.argMax() #find the best action to take in a state\\n return best_action\\n #util.raiseNotDefined()\",\n \"def _select_action(self):\\n if self.eval_mode:\\n self._log_values()\\n epsilon = self.epsilon_eval\\n else:\\n epsilon = self.epsilon_fn(\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_train)\\n if random.random() <= epsilon:\\n # Choose a random action with probability epsilon.\\n return random.randint(0, self.num_actions - 1)\\n else:\\n # Choose the action with highest Q-value at the current state according\\n # to the current head.\\n return self._compute_q_argmax()\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n legal_actions = self.getLegalActions(state)\\n\\n if len(legal_actions) == 0:\\n return None\\n\\n max_value = self.computeValueFromQValues(state)\\n\\n actions = [action for action in legal_actions if self.values[(str(state), action)] == max_value]\\n\\n return random.choice(actions)\",\n \"def select_action(self, state, **kwargs):\\n preprocessed_state = self.preprocessor.process_state_for_network(state)\\n q_values = self.calc_q_values(preprocessed_state)\\n #print (np.argmax(q_values), q_values)\\n return self.policy[self.mode].select_action(q_values), preprocessed_state\",\n \"def policies(self, QTable, epsilon, state, next_states, action_to_do): # Inspiration from https://www.geeksforgeeks.org/q-learning-in-python/?fbclid=IwAR1UXR88IuJBhhTakjxNq_gcf3nCmJB0puuoA46J8mZnEan_qx9hhoFzhK8\\r\\n num_actions = 5 # 5 actions-value, [moved_out, into_goal, send_opp_home, send_self_home, move_token] \\r\\n def epsilonGreedyPolicy(): \\r\\n tmp_state = str(state.state[0])\\r\\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\\r\\n valid_act_len = len(np.where(valid_actions==True)[0])\\r\\n\\r\\n Action_probabilities = np.ones(num_actions, dtype = float) * epsilon / valid_act_len # divides probability based on number of valid actions and epsilon (each 0.025 if 4 actions) \\r\\n Action_probabilities = np.multiply(Action_probabilities, valid_actions)\\r\\n\\r\\n # If same values in QTable choose random valid action \\r\\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\\r\\n # Check if valid action else find new best action\\r\\n if not valid_actions[best_action]:\\r\\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\\r\\n for i in range(len(valid_actions)):\\r\\n if valid_actions[actions[i]]:\\r\\n best_action = actions[i]\\r\\n break\\r\\n\\r\\n Action_probabilities[best_action] += (1.0 - epsilon) # Assigns rest probability to best action so probability sums to 1\\r\\n\\r\\n return Action_probabilities \\r\\n\\r\\n def greedyPolicy():\\r\\n tmp_state = str(state.state[0])\\r\\n valid_actions = np.append(action_to_do, True) # the True appended is move_token\\r\\n\\r\\n Action_probabilities = np.zeros(num_actions, dtype = float)\\r\\n\\r\\n best_action = np.argmax(QTable[tmp_state]) # Find index of action which gives highest QValue\\r\\n # Check if valid action else find new best action\\r\\n if not valid_actions[best_action]:\\r\\n actions = np.argsort(-QTable[tmp_state]) # descending order of action values\\r\\n for i in range(len(valid_actions)):\\r\\n if valid_actions[actions[i]]:\\r\\n best_action = actions[i]\\r\\n break\\r\\n\\r\\n\\r\\n Action_probabilities[best_action] += 1.0\\r\\n return Action_probabilities\\r\\n\\r\\n\\r\\n if(self.__chosenPolicy == \\\"epsilon greedy\\\"):\\r\\n return epsilonGreedyPolicy \\r\\n if(self.__chosenPolicy == \\\"greedy\\\"):\\r\\n return greedyPolicy\",\n \"def select_action(self, state):\\n \\n ##create lists and string to save relative action information\\n actions = []\\n action = ''\\n all_actions = []\\n \\n ##get the action with the maximum value\\n temp = {}\\n for (s, a), value in self.Q.iteritems():\\n if s == state:\\n temp[(s, a)] = value\\n all_actions.append(a) \\n max_value = max(temp.values())\\n for (s, a) , value in temp.iteritems():\\n if value == max_value:\\n actions.append(a)\\n\\n ##if we have more than one action with max_values, random return one\\n if len(actions) > 1:\\n index = random.randint(0,len(actions) - 1)\\n action = str(actions[index])\\n else:\\n for item in actions:\\n action = item\\n \\n ##when the random number less than epsilon, then return one action randomly \\n if random.random() < self.epsilon:\\n index = random.randint(0, len(all_actions) - 1)\\n action = str(all_actions[index])\\n \\n ##if the random number not less than epsilon, then return the action with max value\\n return action\",\n \"def choose_action(self, state):\\n if random.random() < self.epsilon:\\n self.epsilon -= self.epsilon_annealing_rate\\n return random.choice(self.valid_actions)\\n \\n #initialize search variables\\n opt_action = self.valid_actions[0]\\n opt_value = 0\\n\\n #performs a search across all valid actions for highest q-value.\\n for action in self.valid_actions:\\n cur_value = self.q_value(state, action)\\n if cur_value > opt_value:\\n opt_action = action\\n opt_value = cur_value\\n elif cur_value == opt_value:\\n opt_action = random.choice([opt_action, action])\\n return opt_action\",\n \"def select_action(self, state):\\n \\n ##create lists and string to save relative action information\\n actions = []\\n action = ''\\n all_actions = []\\n \\n ##get the action with the maximum value\\n temp = {}\\n for (s, a), value in self.Q.iteritems():\\n if s == state:\\n temp[(s, a)] = value\\n all_actions.append(a)\\n \\n max_value = max(temp.values())\\n for (s, a) , value in temp.iteritems():\\n if value == max_value:\\n actions.append(a)\\n\\n ##if we have more than one action with max_values, random return one\\n if len(actions) > 1:\\n index = random.randint(0,len(actions) - 1)\\n action = str(actions[index])\\n else:\\n for item in actions:\\n action = item\\n \\n ##when the random number less than epsilon, then return one action randomly \\n if random.random() < self.epsilon:\\n index = random.randint(0, len(all_actions) - 1)\\n action = str(all_actions[index])\\n \\n ##if the random number not less than epsilon, then return the action with max value\\n return action\",\n \"def decide_actions(self, eval_states, *args):\\n\\n return self.nn.predict_exploration(eval_states, self.ed.epsilon)\",\n \"def select_action(self):\\n estimated_q_a = self._action_value_estimator.get_estimated_q_a()\\n\\n if np.random.rand() < self._epsilon:\\n chosen_action = random.choice(list(estimated_q_a.keys()))\\n else:\\n chosen_action = max(estimated_q_a, key=estimated_q_a.get)\\n\\n return chosen_action\",\n \"def eps_greedy_action(self, phi, tabu):\\n\\n # increase counter of actions taken\\n self.a_count += 1\\n\\n # if within the initial buffer before learning starts, random action\\n aval_actions = None\\n if self.a_count < self.warmup:\\n\\n if len(tabu) > 0:\\n # Remove tabu actions from list of available actions\\n aval_actions = [a for a in self.actions if a not in tabu]\\n\\n action = self.random_action(aval_actions)\\n return action, None\\n\\n elif (self.a_count == self.warmup) and self.verbose:\\n print('learning starts')\\n\\n # evaluate Q(phi, a) for each action\\n qvalues = self.Qmodel.predict(phi, batch_size=1)[0]\\n\\n # generate random value\\n randn = np.random.uniform()\\n\\n # eliminate tabu values from possible actions to pick\\n aval_actions = None\\n if len(tabu) > 0:\\n if randn < self.epsilon:\\n aval_actions = [a for a in self.actions if a not in tabu]\\n else:\\n # Update Qs to low values to ensure they are not picked\\n tabu_idx = [i for i in range(self.num_actions) if self.actions[i] in tabu]\\n qvalues[tabu_idx] = -9999\\n\\n # eps-greedy, select random action\\n if randn < self.epsilon:\\n action = self.random_action(aval_actions)\\n a_i = self.action_str2idx(action)\\n else:\\n # select best action\\n a_i = np.argmax(qvalues)\\n action = self.actions[a_i]\\n\\n # update greedy parameter and action count\\n self.epsilon *= self.discount_epsilon\\n self.a_count += 1\\n\\n return action, qvalues[a_i]\",\n \"def choose_action(self, board):\\n options = board.empty_cells\\n # to allow exploration, have a small probability of a random move\\n p_random = random.random()\\n # if the state is not in the table add it\\n if (self.sign, board.state) not in self.Q_table.keys() or p_random < self.epsilon:\\n values = {}\\n for option in options:\\n values[option] = random.random()\\n self.Q_table[(self.sign, board.state)] = values\\n self.action = random.choice(options)\\n else:\\n values = self.Q_table[(self.sign, board.state)]\\n action = max(values, key=values.get)\\n self.action = action\\n\\n # decrease exploration after each action\\n if self.epsilon > 0:\\n self.epsilon -= 0.0001\\n\\n return self.action\",\n \"def computeActionFromValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n actions = self.mdp.getPossibleActions(state)\\n # Initialize max_value as - infinity\\n # Initialize best action as None, choose max_value action\\n max_value = float(\\\"-inf\\\")\\n computed_action = None\\n\\n for action in actions:\\n # Find q value of specified action\\n q_value = self.computeQValueFromValues(state, action)\\n # Update action if it's the best so far\\n if q_value > max_value:\\n max_value = q_value\\n computed_action = action\\n return computed_action\",\n \"def computeActionFromValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n actions = self.mdp.getPossibleActions(state)\\n optimalAction = None\\n maxValue = float('-inf')\\n for a in actions:\\n qValue = self.computeQValueFromValues(state, a)\\n if qValue > maxValue:\\n maxValue = qValue\\n optimalAction = a\\n return optimalAction\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n max_qvalue = None\\n for action in self.legalActions:\\n qvalue = self.getQValue(state, action)\\n if max_qvalue is None or max_qvalue < qvalue:\\n max_qvalue = qvalue\\n\\n if max_qvalue is None:\\n return None\\n\\n actions = []\\n for action in self.legalActions:\\n qvalue = self.getQValue(state, action)\\n if qvalue == max_qvalue:\\n actions.append(action)\\n\\n if max_qvalue is not None and len(actions) == 0:\\n return self.legalActions[0]\\n if len(actions) > 1:\\n return Const.DO_NOTHING\\n return random.choice(actions)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n\\n max_qvalue = None\\n for action in self.legalActions:\\n qvalue = self.getQValue(state, action)\\n if max_qvalue is None or max_qvalue < qvalue:\\n max_qvalue = qvalue\\n\\n if max_qvalue is None:\\n return None\\n\\n actions = []\\n for action in self.legalActions:\\n qvalue = self.getQValue(state, action)\\n if qvalue == max_qvalue:\\n actions.append(action)\\n\\n if max_qvalue is not None and len(actions) == 0:\\n return self.legalActions[0]\\n if len(actions) > 1:\\n return Const.DO_NOTHING\\n return random.choice(actions)\",\n \"def _select_action(self):\\n if self.eval_mode:\\n epsilon = self.epsilon_eval\\n else:\\n epsilon = self.epsilon_fn(\\n self.epsilon_decay_period,\\n self.training_steps,\\n self.min_replay_history,\\n self.epsilon_train)\\n if random.random() <= epsilon:\\n # Choose a random action with probability epsilon.\\n return random.randint(0, self.num_actions - 1)\\n else:\\n # Choose the action with highest Q-value at the current state.\\n if self._interact == 'stochastic':\\n selected_action = self._stochastic_action\\n elif self._interact == 'greedy':\\n selected_action = self._q_argmax\\n else:\\n raise ValueError('Undefined interaction')\\n return self._sess.run(selected_action,\\n {self.state_ph: self.state})\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if not self.getLegalActions(state): return None\\n\\n best_action = None;\\n best_value = float('-inf')\\n for action in self.getLegalActions(state):\\n if self.getQValue(state, action) > best_value:\\n best_value = self.getQValue(state, action)\\n best_action = action\\n return best_action\",\n \"def bestAction(self):\\n get_q = self.getQFunction()\\n maxq = -5000\\n best_actions = []\\n for (state, action), q in get_q.items():\\n if q > maxq:\\n maxq = q\\n best_actions = [action]\\n elif q == maxq:\\n best_actions.append(action)\\n return self.tuple_to_dictionary(random.choice(best_actions))\",\n \"def choose_action(self, state):\\n prob = [] # Probability distribution\\n for i in range(len(ACTIONS)):\\n prob.append(self.epsilon/4)\\n Q_func = self.policy.predict(process_state(state))\\n Q_vals = Q_func[0]\\n max_index = []\\n Qmax = np.amax(Q_vals)\\n for i in range(len(prob)):\\n if Q_vals[i] == Qmax:\\n # max_index.append(i)\\n prob[i] = 1 - self.epsilon + self.epsilon/4\\n break\\n # ind = np.random.choice(max_index)\\n # prob[ind] = 1 - self.epsilon + self.epsilon/4\\n action = np.random.choice(ACTIONS, p = prob)\\n return action\",\n \"def chooseAction(self,state):\\r\\n #generate float btwn 0-1\\r\\n choice = random.random()\\r\\n \\r\\n #choose according to that number\\r\\n if choice > self.epsilon:\\r\\n return(self.maxQ(state)[1])\\r\\n else:\\r\\n #choose randomly\\r\\n return(self.actions[random.randrange(0,len(self.actions))])\",\n \"def chooseAction(self,state):\\r\\n #generate float btwn 0-1\\r\\n choice = random.random()\\r\\n \\r\\n #choose according to that number\\r\\n if choice > self.epsilon:\\r\\n return(self.maxQ(state)[1])\\r\\n else:\\r\\n #choose randomly\\r\\n return(self.actions[random.randrange(0,len(self.actions))])\",\n \"def actionSelector(self): \\n if self.Temp!=0:\\n if len(self.lessons) > 60 and self.var_T: \\n # if the agent haven't already gotten food since a certain time \\n # we increase the temperature by 0.001 \\n if self.count_without_food>12:\\n self.Temp += 0.01 \\n if self.Temp>=(self.var_T[0]): \\n self.Temp = self.var_T[0] \\n # otherwise we decrease the temperatur by 0.001 \\n else: \\n self.Temp -= 0.001\\n if self.Temp <= (self.var_T[-1]):\\n self.Temp = self.var_T[-1]\\n \\n s = np.sum([np.exp(float(k)/self.Temp) for k in self.U_list])\\n\\n self.action_proba =[np.exp(float(m)/self.Temp)/s for m in self.U_list]\\n action = np.random.choice(np.arange(4),p=self.action_proba) # choice a random choice relating to the probability distribution given by the softmax algorith \\n else:\\n action = np.argmax(self.U_list)\\n return action\",\n \"def epsilonGreedyChooser(normalAction, state, stepsDone):\\n epsThreshold = EPS_END + (EPS_START - EPS_END) * math.exp(-1. * stepsDone / EPS_DECAY)\\n randomSample = random.random()\\n if randomSample > epsThreshold:\\n action = normalAction(state).max(1)[1].view(1, 1)[0].item()\\n #print(action)\\n return action\\n else:\\n return ENVIRONMENT.action_space.sample()\",\n \"def takeAction(self, state):\\n # go greedy or not?\\n if random.uniform(0, 1) < self.epsilon:\\n # greedy selection\\n # find best action\\n allActions = torch.stack(\\n tuple(torch.cat((state.strengths, state.focus, changes)) for changes in self.actionSet))\\n evaluation = self.q.evaluateBunch(allActions)\\n action = Action(state, self.actionSet[evaluation.argmax()])\\n return action\\n else:\\n # random selection\\n return Action(state, random.choice(self.actionSet))\",\n \"def select_action(self, state):\\n # print(\\\"agent.select_action() - state: {}\\\".format(state))\\n\\n self.step_counter += 1\\n # self.epsilon = max(0.1, 1.0-self.step_counter/self.epsilon_decay_steps)\\n epsilon_min = .01\\n epsilon_max = .8\\n epsilon_step = epsilon_max - (epsilon_max - epsilon_min) * self.step_counter / self.epsilon_decay_steps\\n self.epsilon = max(epsilon_min, epsilon_step)\\n # self.epsilon = max(0.1, 1.0/self.step_counter)\\n\\n rand = random.uniform(0, 1)\\n if rand < self.epsilon:\\n # choose random action\\n return np.random.choice(self.nA)\\n else:\\n # choose greedy action\\n return np.argmax(self.Q[state])\",\n \"def eps_greedy_policy(q_values, eps, forbidden_actions):\\r\\n\\r\\n q_values[forbidden_actions] = np.NINF\\r\\n indices = torch.nonzero(q_values == q_values.max())\\r\\n random_index = random.randint(0, indices.shape[1]-1)\\r\\n best_action_index = indices[random_index]\\r\\n l = len(q_values)\\r\\n n_forbidden_actions = np.count_nonzero(forbidden_actions)\\r\\n p = eps / (l-n_forbidden_actions)\\r\\n\\r\\n policy = np.full([l], p)\\r\\n policy[forbidden_actions] = 0\\r\\n policy[best_action_index] += 1 - eps\\r\\n\\r\\n return policy\",\n \"def greedy_policy(self, q, s):\\n\\t\\tresult = []\\n\\t\\tif q is None:\\n\\t\\t\\treturn result\\n\\t\\tmax_val = q[0]\\n\\t\\tfor action in self.feasible_actions_in_state(s):\\n\\t\\t\\tq_value = q[action]\\n\\t\\t\\tif q_value == max_val:\\n\\t\\t\\t\\tresult.append(action)\\n\\t\\t\\telif q_value > max_val:\\n\\t\\t\\t\\tresult = [action]\\n\\t\\t\\t\\tmax_val = q_value\\n\\t\\treturn result\",\n \"def select_action(self, state, evaluate):\\n random_number = np.random.uniform()\\n if random_number < self.epsilon and evaluate==False:\\n # Random action\\n return torch.tensor(random.randint(0,self.env.nA-1))\\n\\n else:\\n # Greedy action\\n state = [state]\\n state = torch.stack(state)\\n state = state.to(self.device, dtype=torch.float)\\n q_values = self.main_dqn(state)\\n argmax = torch.argmax(q_values).item()\\n\\n if evaluate:\\n if self.env.freely_moving:\\n self.list_evaluation_values.append(q_values.reshape(self.env.number_of_rows, self.env.number_of_columns))\\n else:\\n self.list_evaluation_values.append(q_values.reshape(1, self.env.nA))\\n\\n return torch.tensor(argmax)\",\n \"def choose_action(self, state):\\n pure_action = self.actor_local.model.predict(state)[0]\\n # add gaussian noise for exploration\\n # noise = np.random.normal(self.noise_mean, self.noise_stddev, self.action_size)\\n \\n # add OU noise for exploration\\n noise = self.noise.sample()\\n\\n # action = np.clip(pure_action + noise, self.action_low, self.action_high)\\n # print(\\\"pure\\\", pure_action)\\n # print(\\\"noise\\\", noise)\\n # action = self.action_high * (pure_action + noise)\\n # action = pure_action + noise\\n action = np.clip(pure_action + noise, self.action_low, self.action_high)\\n # print(\\\"action\\\", action)\\n return action.tolist()\",\n \"def choose_action(self, state, epsilon_greedy=False):\\n chosen_action = None\\n if epsilon_greedy:\\n if np.random.rand() <= self.epsilon:\\n print('random actions')\\n\\n # choose random action\\n chosen_action = random.choice(self.actions)\\n\\n else:\\n print('argmax')\\n\\n # find the action with greatest Q value\\n maxQ = -float(\\\"inf\\\")\\n for action in self.actions:\\n input_data = np.asarray(state + action).reshape(self.OUTPUT_DIM, self.INPUT_DIM)\\n Q = self.model.predict(input_data)\\n if Q > maxQ:\\n maxQ = Q\\n chosen_action = action\\n\\n else:\\n\\n # policy rollout\\n maxQ = -float(\\\"inf\\\")\\n for action in self.actions:\\n input_data = np.asarray(state + action).reshape(self.OUTPUT_DIM, self.INPUT_DIM)\\n Q = self.model.predict(input_data)\\n if Q > maxQ:\\n maxQ = Q\\n chosen_action = action\\n\\n return chosen_action\",\n \"def act(self, s, exploration, game, return_pred_opp=False):\\n opponent_p = self.compute_opponent_model(s)\\n # print(opponent_p)\\n opponent_action = np.random.choice(\\n opponent_p.size, size=1, p=opponent_p)[0]\\n # agent_p = np.exp(self.Q[s][:, opponent_action])\\n agent_p = self.compute_marginal_pi(s)\\n if exploration and random.random() < self.episilon:\\n agent_action = random.randint(0, self.action_num - 1)\\n else:\\n if self.verbose:\\n for s in self.Q.keys():\\n print('{}--------------'.format(self.id_))\\n print('Q of agent {}: state {}: {}'.format(self.id_, s, str(self.Q[s])))\\n # print('QAof agent {}: state {}: {}'.format(self.id_, s, str(self.Q_A[s])))\\n # self.Q_A\\n print('pi of agent {}: state {}: {}'.format(self.id_, s, self.pi[s]))\\n # print('pi of opponent agent {}: state{}: {}'.format(self.id_, s, self.opponent_best_pi[s]))\\n print('{}--------------'.format(self.id_))\\n agent_action = StationaryAgent.sample(agent_p)\\n if return_pred_opp:\\n return agent_action, opponent_action\\n else:\\n return agent_action\",\n \"def EpsGreedy(self, actions, game_state):\\n if random.random() < self.epsilon:\\n return random.choice(actions)\\n else:\\n return self.best_action(actions, game_state)\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n actions = self.getLegalActions(state)\\n if len(actions) == 0:\\n return None\\n values = [self.getQValue(state, action) for action in actions]\\n LoT = zip(values, actions)\\n (bestValue, bestAction) = max(LoT)\\n return bestAction\",\n \"def chooseAction(self,state):\\r\\n #generate float btwn 0-1\\r\\n choice = random.random()\\r\\n feat = self.feat_funct(state)\\r\\n #choose according to that number\\r\\n if choice > self.epsilon:\\r\\n return(self.maxQ(feat)[1])\\r\\n else:\\r\\n #choose randomly\\r\\n return(self.actions[random.randrange(0,len(self.actions))])\",\n \"def execute_best_actions(self):\\n while True:\\n print(\\\"In execute_best_actions\\\")\\n s = self.get_state_num()\\n qvals = self.Q[s]\\n # Get action with largest qval\\n best_action = np.argmax(qvals)\\n # We don't actually update with rewards,\\n # but use them to know when to perform next action\\n # We want to travel 0.5 m in action's direction.\\n self.apply_action(best_action)\\n while self.reward == None:\\n rospy.sleep(0.5)\\n print(\\\"Reward =\\\", self.reward)\\n self.reward = None\",\n \"def take_action(self, state):\\n if self.epsilon_decay is not None:\\n self.epsilon *= self.epsilon_decay\\n if random.random() < self.epsilon:\\n action = super(BaseQAgent, self).random_next_action(state)\\n self.log('exploration move: {0}'.format(str(action)))\\n else:\\n action = self.greedy_next_action(state)\\n self.log('exploitation move: {0}'.format(str(action)))\\n return action\",\n \"def computeActionFromValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if self.mdp.isTerminal(state):\\n return None\\n \\n actions = self.mdp.getPossibleActions(state)\\n \\n if len(actions) == 0:\\n return None\\n \\n # compteur des q_values\\n values = util.Counter()\\n \\n for action in actions:\\n values[action] = self.computeQValueFromValues(state, action)\\n \\n return values.argMax()\\n util.raiseNotDefined()\",\n \"def choose_action(state, qmatrix, numb_actions):\\n\\n qmatrix = check_state_exist(state, qmatrix, numb_actions)\\n if np.random.uniform() < epsilon:\\n # choose best action from qmatrix\\n state_action = qmatrix.loc[state, :]\\n state_action = state_action.reindex(np.random.permutation(state_action.index)) # some actions have same value\\n action = state_action.idxmax()\\n else:\\n # choose random action from qmatrix\\n action = np.random.choice(list(range(numb_actions))) \\n return action\",\n \"def obtain_action(self, timestep):\\r\\n\\t\\t# Finds all actions which have not been selected before.\\r\\n\\t\\tzero_action = np.argwhere(self.player_selected_actions == 0).flatten()\\r\\n\\r\\n\\t\\t# Checks if there are any actions which have not been selected before.\\r\\n\\t\\tif zero_action.size:\\r\\n\\t\\t\\t# Returns a random action index that has not been selected before.\\r\\n\\t\\t\\treturn np.random.choice(zero_action).item()\\r\\n\\r\\n\\t\\telse:\\r\\n\\t\\t\\t# Calculates the sum of the Q value estimate and the upper\\r\\n\\t\\t\\t# confidence bound term\\r\\n\\t\\t\\tvalue_list = self.player_Q + self.confidence_level * (np.log(timestep+1) / self.player_selected_actions) ** 0.5\\r\\n\\r\\n\\t\\t\\t# Returns a random action index selected among the action indexes\\r\\n\\t\\t\\t# with the maximum sum.\\r\\n\\t\\t\\treturn np.random.choice(np.argwhere(value_list == value_list.max()).flatten()).item()\",\n \"def select_action(engine, observation):\\n with torch.no_grad():\\n dqn.eval()\\n if torch.rand(1).item() < epsilon:\\n return random_action(observation)\\n else:\\n return dqn(observation).greedy()\",\n \"def select_action_q_and_u(self, env, is_root_node) -> chess.Move:\\n\\n # this method is called with state locked\\n state = board_state_key(env)\\n\\n my_visitstats = self.tree[state]\\n\\n if my_visitstats.p is not None: #push p to edges\\n tot_p = 1e-8\\n for mov in env.legal_moves():\\n mov_p = my_visitstats.p[self.move_lookup[mov]]\\n my_visitstats.a[mov].p = mov_p\\n tot_p += mov_p\\n for a_s in my_visitstats.a.values():\\n a_s.p /= tot_p\\n my_visitstats.p = None\\n\\n xx_ = np.sqrt(my_visitstats.sum_n + 1) # sqrt of sum(N(s, b); for all b)\\n\\n e = self.play_conf.noise_eps\\n c_puct = self.play_conf.c_puct\\n dir_alpha = self.play_conf.dirichlet_alpha\\n\\n best_s = -999\\n best_a = None\\n if is_root_node:\\n noise = np.random.dirichlet([dir_alpha] * len(my_visitstats.a))\\n\\n i = 0\\n for action, a_s in my_visitstats.a.items():\\n p_ = a_s.p\\n if is_root_node:\\n p_ = (1-e) * p_ + e * noise[i]\\n i += 1\\n b = a_s.q + c_puct * p_ * xx_ / (1 + a_s.n)\\n if b > best_s:\\n best_s = b\\n best_a = action\\n\\n return best_a\",\n \"def select_action(self, state, explore=False):\\n if (np.random.rand() < self.EPSILON) and explore:\\n actionIdx = np.random.randint(0, self.numJoinAction)\\n actionIdxTuple = actionIndexInt2Tuple(actionIdx, self.numActionList)\\n else:\\n self.Q_network.eval()\\n state = torch.from_numpy(state).float().to(self.device)\\n state_action_values = self.Q_network(state)\\n Q_mtx = (\\n state_action_values.detach().cpu().reshape(\\n self.numActionList[0], self.numActionList[1]\\n )\\n )\\n pursuerValues, colIndices = Q_mtx.max(dim=1)\\n _, rowIdx = pursuerValues.min(dim=0)\\n colIdx = colIndices[rowIdx]\\n actionIdxTuple = (np.array(rowIdx), np.array(colIdx))\\n actionIdx = actionIndexTuple2Int(actionIdxTuple, self.numActionList)\\n return actionIdx, actionIdxTuple\",\n \"def getPolicy(self, state):\\n \\\"\\\"\\\"Description:\\n Find all of q-values of current state, and choose the action \\n with the hight q-value as optimal policy\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n legalActions = self.getLegalActions(state)\\n action = None\\n policy = util.Counter() # use counter to store action and its q-value\\n \\n if len(legalActions) == 0:\\n return action\\n \\n for a in legalActions:\\n policy[a] = self.getQValue(state, a)\\n action = policy.argMax()\\n return action\\n\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def get_action(self, state, available_actions, play_mode=False):\\n epsilon = self.current_epsilon()\\n will_explore = np.random.random_sample() < epsilon\\n\\n if not play_mode and will_explore:\\n return np.random.choice(available_actions)\\n else:\\n query_state = np.reshape(state, tuple([1,1] + self.state_shape)).astype(np.float32)\\n query_actions_filter = np.zeros((1, self.actions_count), dtype=np.float32)\\n query_actions_filter[0][available_actions] = 1.0\\n\\n chosen_action = self.session.run(self.query_action, {\\n self.states: query_state,\\n self.query_actions_filter: query_actions_filter\\n })\\n\\n return chosen_action[0]\",\n \"def select_action(self, q_values, is_training):\\n # if is_training then do epsilon decay,\\n # otherwise use constant epsilon = 0.05\\n if is_training:\\n if self.epsilon > self.end:\\n self.epsilon -= self.decay_stepsize\\n else:\\n self.epsilon = 0\\n return super(LinearDecayGreedyEpsilonPolicy, self).select_action(q_values)\",\n \"def computeActionFromValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n maxvalue = -100000000\\n bestaction = None\\n for action in self.mdp.getPossibleActions(state):\\n valueforthisaction = self.getQValue(state, action) # is this right? \\n if valueforthisaction > maxvalue:\\n bestaction = action\\n maxvalue = valueforthisaction\\n return bestaction\",\n \"def sample_action(q_pi, policies, num_controls, action_selection=\\\"deterministic\\\", alpha = 16.0):\\n\\n num_factors = len(num_controls)\\n\\n action_marginals = utils.obj_array_zeros(num_controls)\\n \\n # weight each action according to its integrated posterior probability over policies and timesteps\\n for pol_idx, policy in enumerate(policies):\\n for t in range(policy.shape[0]):\\n for factor_i, action_i in enumerate(policy[t, :]):\\n action_marginals[factor_i][action_i] += q_pi[pol_idx]\\n \\n selected_policy = np.zeros(num_factors)\\n for factor_i in range(num_factors):\\n\\n # Either you do this:\\n if action_selection == 'deterministic':\\n selected_policy[factor_i] = np.argmax(action_marginals[factor_i])\\n elif action_selection == 'stochastic':\\n p_actions = softmax(action_marginals[factor_i] * alpha)\\n selected_policy[factor_i] = utils.sample(p_actions)\\n\\n return selected_policy\",\n \"def chooseAction(self, gameState):\\n actions = gameState.getLegalActions(self.index)\\n\\n # You can profile your evaluation time by uncommenting these lines\\n # start = time.time()\\n opIndices = self.getOpponents(gameState)\\n opStates = [gameState.getAgentState(i) for i in opIndices]\\n opCarry = [x.numCarrying for x in opStates]\\n \\n if max(opCarry) >= 5:\\n self.isOffensive = False\\n else:\\n self.isOffensive = True\\n\\n values = [self.evaluate(gameState, a) for a in actions]\\n # print 'eval time for agent %d: %.4f' % (self.index, time.time() - start)\\n\\n maxValue = max(values)\\n bestActions = [a for a, v in zip(actions, values) if v == maxValue]\\n\\n\\n\\n # print if get eaten\\n myPos = gameState.getAgentPosition(self.index)\\n prevGameState = self.getPreviousObservation()\\n if prevGameState is not None:\\n\\n previousPos = prevGameState.getAgentPosition(self.index)\\n if self.getMazeDistance(myPos, previousPos) > 1:\\n print(\\\"prePostion\\\",previousPos)\\n print()\\n previousLegalAction = prevGameState.getLegalActions(self.index)\\n print([(self.evaluate(prevGameState, a), a) for a in previousLegalAction])\\n print()\\n print(self.getNonScaredGhostPos(prevGameState))\\n print()\\n print()\\n\\n\\n return random.choice(bestActions)\",\n \"def _get_action(self, state, episode):\\n if (episode < self.num_explore_episodes):\\n action = [random.choice(list(range(self.num_actions)))\\n for _ in range(len(state))]\\n return action\\n\\n action = []\\n self.model.q_1.eval()\\n with torch.no_grad():\\n state = torch.tensor(state, device=self.device).float()\\n action = torch.argmin(self.model.q_1(state), dim=-1).tolist()\\n self.model.q_1.train()\\n return action\",\n \"def step(self):\\n # No need for epsilon as exploration is controlled by c\\n\\n\\n # Step in time (choose an action) \\n n = np.sum(self.action_count)\\n if n > 0: # Condition to evaluate on first iteration, because np.log(0) = -inf\\n mask = self.action_count > 0 # Mask to avoid division by 0 on the formula for upper confidence uncertainties\\n uncertainties = np.zeros(self.action_count.shape)\\n uncertainties[mask] = self.c*np.sqrt(np.log(n)/self.action_count[mask])\\n uncertainties[~mask] = float('inf') # We increment uncertainty of actions we've never chosen\\n else:\\n uncertainties = np.array(np.repeat(float('inf'), len(self.action_count))) \\n optimals = self.Q + uncertainties # Uncertainty rises the value of less chosen actions, hence promoting exploration\\n \\n max_actions = np.argwhere(optimals == np.amax(optimals)).flatten() # greedy actions (max value)\\n if len(max_actions) == 1:\\n self.last_action = max_actions\\n else:\\n self.last_action = np.random.choice(max_actions)\\n\\n return self.last_action\",\n \"def getAction(self, state):\\n # Pick Action\\n legalActions = self.getLegalActions(state)\\n action = None\\n\\n \\\"\\\"\\\"Description:\\n Use util.flipCoin, if return true then randomly choice from legalAction\\n if flase, then sue getPolicy to get best policy action\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n if len(legalActions) == 0:\\n return action # None\\n \\n if util.flipCoin(self.epsilon):\\n ''' exploration function (not work well)''' \\n# posPol = util.Counter()\\n# for a in legalActions:\\n# if self.getQValue(state,a) >= 0:\\n# posPol[a] = -1*self.getQValue(state, a) + (1000/(self.vitCount[(state,a)]+0.0001))\\n# #print \\\"posPol[\\\", a, \\\"]= \\\",posPol[a]\\n# #posPol[a] = (self.getQValue(state, a) * self.epsilon** self.vitCount[(state,a)]) + ( self.epsilon/(self.vitCount[(state,a)]+0.1) )\\n# if len(posPol) == 0:\\n# action = random.choice(legalActions)\\n# else:\\n# action = posPol.argMax() # random.choice(posPol.keys())\\n ''' Random exploration '''\\n action = random.choice(legalActions)\\n else:\\n action = self.getPolicy(state)\\n \\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\\n\\n return action\",\n \"def select_action(self, state):\\r\\n policy_s = self.epsilon_greedy_probs(self.nA, self.Q[state], self.count, self.epsilon)\\r\\n return np.random.choice(np.arange(self.nA), p=policy_s)\",\n \"def select_action(self, state):\\n if state in self.Q:\\n action = np.random.choice(np.arange(self.nA), p=self.get_probs(self.Q[state], self.epsilon, self.nA))\\n else :\\n action = np.random.choice(self.nA)\\n\\n return action\",\n \"def calcQ(self,thisObs,next_action,reward):\\n \\n thisObs_tup=(thisObs['volume'],thisObs['time'])\\n lastAction_tup=(self.lastAction['vol'],self.lastAction['price'])\\n lastObs_tup=(self.lastObs['volume'],self.lastObs['time'])\\n lastQvalue=0\\n maxQvalue=0\\n temp_action=()\\n \\n if (len(self.Qvalue)>0): \\n \\\"\\\"\\\"Searches the Q-value dictionary\\\"\\\"\\\"\\n for key,value in self.Qvalue.iteritems():\\n \\n if (key[0][0]== thisObs_tup[0] and key[0][1]==thisObs_tup[1]):\\n if (value > maxQvalue):\\n maxQvalue=value\\n temp_action = key[1]\\n \\n if (key[0][0]== lastObs_tup[0] and key[0][1]==lastObs_tup[1] and \\n key[1][0]== lastAction_tup[0] and key[1][1]==lastAction_tup[1]):\\n \\n lastQvalue=self.Qvalue[key]\\n #print(\\\"This state was already encoutered and updated\\\")\\n \\n self.Qvalue[(lastObs_tup,lastAction_tup)]=lastQvalue+alpha*(reward+(gamma*maxQvalue)-lastQvalue) \\n #print 'The Qtable is',self.Qvalue\\n if (len(temp_action)!=0):\\n #print \\\"I found a greedy action\\\" \\n next_action['vol'] = temp_action[0]\\n next_action['price']=temp_action[1]\\n else: \\n next_action=self.return_random_action(thisObs)\\n \\n return next_action\",\n \"def act(self, s, exploration, game):\\n agent_p = self.compute_marginal_pi(s, one_hot=False)\\n if self.exploration and random.random() < self.episilon:\\n agent_action = random.randint(0, self.action_num - 1)\\n else:\\n if self.verbose:\\n for s in self.Q.keys():\\n print('{}--------------'.format(self.id_))\\n print('Q of agent {}: state {}: {}'.format(self.id_, s, str(self.Q[s])))\\n # print('QAof agent {}: state {}: {}'.format(self.id_, s, str(self.Q_A[s])))\\n # self.Q_A\\n print('pi of agent {}: state {}: {}'.format(self.id_, s, self.pi[s]))\\n # print('pi of opponent agent {}: state{}: {}'.format(self.id_, s, self.opponent_best_pi[s]))\\n print('{}--------------'.format(self.id_))\\n agent_action = np.argmax(agent_p)\\n return agent_action\",\n \"def computeQValueFromValues(self, state, action):\\n\\n ##util.raiseNotDefined()\\n #\\\"*** YOUR CODE STARTS HERE ***\\\"\\n # Code to remove --- from here\\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\\n qvalue = 0\\n for (nextState, probability) in transitions:\\n reward = self.mdp.getReward(state, action, nextState)\\n qvalue += probability *(reward + self.discount*self.values[nextState])\\n # Code to remove --- to here\\n #\\\"*** YOUR CODE FINISHES HERE ***\\\"\\n \\n return qvalue\",\n \"def select_action(self, env, state, **kwargs):\\n\\n self.epsilon = 1 - (len(self.memory.memory)*1.0)/self.memory.max_size + 0.05\\n if np.random.uniform() <= self.epsilon:\\n index = env.action_space.sample()\\n else:\\n index = np.argmax(self.Q.predict(state))\\n\\n return index\",\n \"def select_action(self, state: np.ndarray) -> np.ndarray:\\n # epsilon greedy policy\\n # pylint: disable=comparison-with-callable\\n if self.epsilon > np.random.random():\\n selected_action = np.array(self.env.action_space.sample())\\n else:\\n with torch.no_grad():\\n state = self._preprocess_state(state, self.device)\\n selected_action = self.dqn(state).argmax()\\n selected_action = selected_action.cpu().numpy()\\n\\n # Decay epsilon\\n self.epsilon = max(\\n self.epsilon\\n - (self.max_epsilon - self.min_epsilon) * self.hyper_params.epsilon_decay,\\n self.min_epsilon,\\n )\\n\\n return selected_action\",\n \"def choose_action(self, observation):\\r\\n observation = T.unsqueeze(T.FloatTensor(observation), 0)\\r\\n # Epsilon-greedy policy\\r\\n if np.random.uniform() < self.epsilon: \\r\\n # Get all of the Q values for the current state (forward prop)\\r\\n actions_value = self.Q_eval.forward(observation)\\r\\n\\r\\n # Take the optimal action \\r\\n action = T.max(actions_value, 1)[1].data.numpy()\\r\\n action = action[0] if self.action_space == 0 else action.reshape(self.action_space) # return the argmax index\\r\\n else: \\r\\n # Choose a random action in the action space list\\r\\n action = np.random.randint(0, self.num_actions)\\r\\n action = action if self.action_space == 0 else action.reshape(self.action_space)\\r\\n\\r\\n return action\",\n \"def select_action(images, n_actions, device, eps_threshold=-1):\\n actions = []\\n\\n for i in images:\\n if eps_threshold == -1:\\n actions.append(torch.tensor([[random.randrange(n_actions)]], device=device, dtype=torch.long))\\n else:\\n sample = random.random()\\n if sample > eps_threshold:\\n with torch.no_grad():\\n # t.min(1) will return smallest column value of each row.\\n # second column on min result is index of where min element was\\n # found, so we pick action with the lower expected reward.\\n actions.append(policy_net(i.unsqueeze(0)).min(1)[1].view(1, 1))\\n else:\\n actions.append(torch.tensor([[random.randrange(n_actions)]], device=device, dtype=torch.long))\\n\\n return torch.tensor(actions, device=device)\",\n \"def get_action_choice(self, state: str, epsilon: float):\\n\\n # e-greedy\\n if random.random() < epsilon:\\n return {0: random.choice(Actions.actions), 1: random.choice(Actions.actions)}\\n else:\\n # Get the Q-values for the actions in this state\\n Qs_t = self.Q_t[state]\\n\\n max_Qs_t = max(Qs_t.values())\\n\\n # find index of the max Q-values\\n max_index = [a for a, q in Qs_t.items()\\n if q == max_Qs_t]\\n\\n # choose one of the max-index with uniform distribution\\n selected = random.choice(max_index)\\n return {0: selected[0], 1: selected[1]}\",\n \"def choose_action(self):\\n\\n def is_random_exploration():\\n\\n # 5. Return whether do random choice\\n # hint: generate a random number, and compare\\n # it with epsilon\\n if random.random() < self.epsilon:\\n return True\\n else:\\n return False\\n\\n final_action = ''\\n if self.learning:\\n if is_random_exploration():\\n # 6. Return random choose aciton\\n final_action = self.valid_actions[random.randint(0, 3)]\\n else:\\n # 7. Return action with highest q value\\n final_action = max(\\n self.Qtable[self.state].items(),\\n key=operator.itemgetter(1))[0]\\n elif self.testing:\\n # 7. choose action with highest q value\\n final_action = max(\\n self.Qtable[self.state].items(),\\n key=operator.itemgetter(1))[0]\\n else:\\n # 6. Return random choose aciton\\n final_action = self.valid_actions[random.randint(0, 3)]\\n\\n return final_action\",\n \"def _transition_q_learning(self):\\n if self.state.as_tuple() not in self.qstore.q:\\n self.enum.enumerate_state(self.state, self.qstore.q)\\n\\n action_values = self.qstore.q[self.state.as_tuple()]\\n # epsilon greedy choice\\n if np.random.random() < self.epsilon:\\n action = State(*action_values['actions'][np.random.randint(len(action_values['actions']))])\\n else:\\n max_q_value = max(action_values['utilities'])\\n max_q_indexes = [i for i in range(len(action_values['actions'])) if\\n action_values['utilities'][i] == max_q_value]\\n max_actions = [action_values['actions'][i] for i in max_q_indexes]\\n action = State(*max_actions[np.random.randint(len(max_actions))])\\n\\n self.state = action.copy()\\n\\n self._post_transition_updates()\",\n \"def computeActionFromQValues(self, state):\\n \\\"*** YOUR CODE HERE ***\\\"\\n ############################################################################################################ Eric Changed state to self.index\\n \\n legalActions = state.getLegalActions(self.index)\\n #print \\\"COMPUTEACTIONFROMQVALUES in QLEARNINGAGENT, LEGALACTIONS: \\\", legalActions\\n if len(legalActions) == 0:\\n return None\\n maxValue = self.getQValue(state, legalActions[0])\\n maxAction = legalActions[0]\\n\\n for a in legalActions:\\n myQValue = self.getQValue(state, a)\\n #print \\\"COMPUTEACTIONFROMQVALUES in QLEARNINGAGENT, MYQVALUE: \\\", myQValue, \\\" MAXVALUE: \\\", maxValue\\n if myQValue > maxValue:\\n maxValue = self.getQValue(state, a)\\n maxAction = a\\n if myQValue == maxValue:\\n if util.flipCoin(0.5):\\n maxValue = self.getQValue(state, a)\\n maxAction = a\\n #print \\\"COMPUTEACTIONFROMQVALUES in QLEARNINGAGENT, MAXACTION: \\\", maxAction\\n return maxAction\\n util.raiseNotDefined()\",\n \"def get_action(self,state):\\n \\n q_values = self.__network.predict(state[None])[0]\\n \\n ###YOUR CODE\\n if np.random.rand()<self.epsilon:\\n return np.random.choice(self.n_actions)\\n return np.argmax(q_values)\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qValue = 0\\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\\n #print('Transitions: ' + str(transitions))\\n for t in transitions:\\n nextState, prob = t\\n reward = self.mdp.getReward(state, action, nextState)\\n #print('Reward: ' + str(reward))\\n oneTransition = prob * (reward + self.discount * self.values[nextState])\\n qValue = qValue + oneTransition\\n return qValue\",\n \"def choose_action(env, Q, observation, epsilon):\\n if np.random.uniform(0, 1) < epsilon:\\n action = env.action_space.sample()\\n else:\\n action = np.argmax(Q[observation, :])\\n return action\",\n \"def getQValue(self, state, action):\\n \\\"\\\"\\\"Description:\\n [Enter a description of what you did here.]\\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\\n \\n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\\n it did not change even a ghost is closing.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n # if weight is empty, then weight will need to initial to 1 for all features\\n # According to which Extractor user choose, weight counter will have equal number of keys.\\n if len(self.weight) == 0:\\n feat = self.featExtractor.getFeatures(state, action)\\n self.weight.incrementAll(feat.keys(), 1)\\n \\n qValue = self.weight * self.featExtractor.getFeatures(state,action)\\n return qValue\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def choose_action(self, previous_action, episode, state):\\n explore_threshold = 0.1\\n # Year1: BO\\n if state == 1:\\n samples = self.BO.suggest()\\n #print('predict: ', self.BO.predict())\\n\\n # Year2-4: TS\\n elif episode < 10 or random.random() <= 1 - explore_threshold:\\n #print('=== Exploration: Thompson Sampling ===')\\n samples = {}\\n for key in self.ActionValue:\\n samples[key] = np.random.beta(self.ActionValue[key][0], self.ActionValue[key][1])\\n # Year2-4: GP\\n else: # episode >= 10 and random.random() > explore_threshold\\n #print('=== Exploration: Gaussian Process ===')\\n # Fitting GP: NOTE: method 化しろ\\n # Make training data for GPR: x = (act_{t-1}, act_t), y = (reward_t)\\n a = self.action_reward_history\\n x = []\\n y = []\\n # TODO: refactor\\n is_current_terminal = False\\n for ep in range(len(a[1])): # = range(20)\\n for year in self.years:\\n if year == 1:\\n continue\\n x_ = a[year-1][ep][0] + a[year][ep][0]\\n y_ = a[year][ep][1]\\n x.append(x_)\\n y.append(y_)\\n if ep + 1 == episode and year == state:\\n is_current_terminal = True\\n break\\n if is_current_terminal:\\n break\\n\\n #print('=== GP I/O ===')\\n #print(list(zip(x, y)))\\n # Fitting GP regression\\n kernel = Matern(length_scale=np.max(y)*2, length_scale_bounds=\\\"fixed\\\", nu=1.5) # Optimization Success\\n gpr = GaussianProcessRegressor(kernel=kernel, normalize_y=True, n_restarts_optimizer=10).fit(x, y)\\n\\n # NOTE: Action space to search.\\n xy = self.actions\\n\\n # Map input to gp prediction\\n input_list = [previous_action + j for j in xy]\\n gp_pred = gpr.predict(input_list) # mu: mean\\n samples = {tuple(action_reward[0]): action_reward[1] for action_reward in zip(xy, gp_pred)}\\n\\n # NOTE: shuffle top actions\\n top_samples_gp = 10\\n sorted_samples = sorted(samples.items(), key=lambda x: x[1], reverse=True)\\n top_samples = dict(sorted_samples[:top_samples_gp])\\n top_samples_values = list(top_samples.values())\\n top_samples_shuffle = dict(zip(top_samples, random.sample(top_samples_values, len(top_samples_values))))\\n remain_samples = dict(sorted_samples[top_samples_gp:])\\n samples = dict(ChainMap(top_samples_shuffle, remain_samples))\\n\\n max_value_actions = sorted(samples.items(), key=lambda x: x[1], reverse=True)\\n max_value_action = max_value_actions[0][0]\\n\\n if state != 1: # previous_action is not None:\\n # Statistics of past actions\\n past_histry = [k for i in self.action_sequence.values() for j in i.values() for k in j]\\n if past_histry:\\n past_mean = np.mean(past_histry)\\n past_max = np.max(past_histry)\\n past_min = np.min(past_histry)\\n else:\\n past_mean = 0\\n past_max = 10000\\n past_min = -10000\\n\\n # It is not used in the case of the sampling whose **consecutive sequence** was a negative reward in the past\\n for a, r in max_value_actions:\\n # For GP samples\\n if previous_action not in self.action_sequence: # For next action\\n self.action_sequence[previous_action] = {action_next: [] for action_next in self.actions}\\n if a not in self.action_sequence[previous_action]: # For current action\\n self.action_sequence[previous_action][a] = []\\n\\n action_sequence_ = self.action_sequence[previous_action][a]\\n # If the action was not sampled in the past, use it.\\n if not action_sequence_:\\n max_value_action = a\\n #print('NEW', max_value_action)\\n break\\n cond_less_0 = min(action_sequence_) <= 0\\n if len(action_sequence_) >= 1: # NOTE: 2 is more robust?\\n cond_less_mean = np.mean(action_sequence_) <= past_mean\\n else:\\n cond_less_mean = False\\n\\n if cond_less_0 or cond_less_mean:\\n #print(f\\\"\\\"\\\"\\n # CONDITION\\n # action_sequence_: {action_sequence_}\\n # cond_less_0: {cond_less_0}\\n # cond_less_mean: {cond_less_mean} {np.mean(action_sequence_)}({past_mean})\\n # max_value_action: {max_value_action}\\n # a: {a}\\n # r: {r}\\n #\\\"\\\"\\\")\\n continue\\n\\n # If there is a sequence in the past and its reward is higher than the past average, the minimum value is not less than 0\\n\\n max_value_action = a\\n #print('GOOD', max_value_action)\\n break\\n\\n return max_value_action\",\n \"def get_action(self, state):\\n depth_limit = 20\\n\\n if state.ply_count < 4 and self.data is not None:\\n if state in self.data:\\n self.queue.put(self.data[state])\\n else:\\n self.queue.put(random.choice(state.actions()))\\n else:\\n for depth in range(1, depth_limit+1):\\n best_move = self.alpha_beta_search(state, depth)\\n if best_move is not None:\\n self.queue.put(best_move)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.760534","0.75458944","0.7489394","0.7308543","0.7302607","0.7277997","0.7277997","0.7277997","0.70307344","0.68159276","0.6684784","0.6582526","0.6519748","0.6445827","0.6419524","0.64174616","0.6408558","0.6391456","0.63895744","0.6350018","0.6345844","0.6332576","0.6332576","0.6332576","0.6332576","0.62450695","0.6205171","0.61900157","0.61757934","0.6148381","0.6126689","0.6115727","0.6087258","0.6072108","0.6067957","0.606677","0.60442525","0.60330397","0.60244334","0.60169405","0.60165894","0.60088897","0.60035336","0.6000524","0.6000524","0.5988457","0.5968986","0.5958798","0.59241897","0.59156054","0.59156054","0.589154","0.58879435","0.5887124","0.5878191","0.5874153","0.5869836","0.5869124","0.5862216","0.58417135","0.58405674","0.5838958","0.5837133","0.5835402","0.5822061","0.5807334","0.58053875","0.5791407","0.57691807","0.5761898","0.5757047","0.5736391","0.5735428","0.57299525","0.57164687","0.5707041","0.5697509","0.56972444","0.5686209","0.5675028","0.5635443","0.56132644","0.56084704","0.5602078","0.5575391","0.55714566","0.55671895","0.5564587","0.556402","0.5559551","0.5557325","0.55547786","0.55533457","0.55382746","0.55230296","0.5515562","0.55147517","0.55139565","0.55117667","0.5505979"],"string":"[\n \"0.760534\",\n \"0.75458944\",\n \"0.7489394\",\n \"0.7308543\",\n \"0.7302607\",\n \"0.7277997\",\n \"0.7277997\",\n \"0.7277997\",\n \"0.70307344\",\n \"0.68159276\",\n \"0.6684784\",\n \"0.6582526\",\n \"0.6519748\",\n \"0.6445827\",\n \"0.6419524\",\n \"0.64174616\",\n \"0.6408558\",\n \"0.6391456\",\n \"0.63895744\",\n \"0.6350018\",\n \"0.6345844\",\n \"0.6332576\",\n \"0.6332576\",\n \"0.6332576\",\n \"0.6332576\",\n \"0.62450695\",\n \"0.6205171\",\n \"0.61900157\",\n \"0.61757934\",\n \"0.6148381\",\n \"0.6126689\",\n \"0.6115727\",\n \"0.6087258\",\n \"0.6072108\",\n \"0.6067957\",\n \"0.606677\",\n \"0.60442525\",\n \"0.60330397\",\n \"0.60244334\",\n \"0.60169405\",\n \"0.60165894\",\n \"0.60088897\",\n \"0.60035336\",\n \"0.6000524\",\n \"0.6000524\",\n \"0.5988457\",\n \"0.5968986\",\n \"0.5958798\",\n \"0.59241897\",\n \"0.59156054\",\n \"0.59156054\",\n \"0.589154\",\n \"0.58879435\",\n \"0.5887124\",\n \"0.5878191\",\n \"0.5874153\",\n \"0.5869836\",\n \"0.5869124\",\n \"0.5862216\",\n \"0.58417135\",\n \"0.58405674\",\n \"0.5838958\",\n \"0.5837133\",\n \"0.5835402\",\n \"0.5822061\",\n \"0.5807334\",\n \"0.58053875\",\n \"0.5791407\",\n \"0.57691807\",\n \"0.5761898\",\n \"0.5757047\",\n \"0.5736391\",\n \"0.5735428\",\n \"0.57299525\",\n \"0.57164687\",\n \"0.5707041\",\n \"0.5697509\",\n \"0.56972444\",\n \"0.5686209\",\n \"0.5675028\",\n \"0.5635443\",\n \"0.56132644\",\n \"0.56084704\",\n \"0.5602078\",\n \"0.5575391\",\n \"0.55714566\",\n \"0.55671895\",\n \"0.5564587\",\n \"0.556402\",\n \"0.5559551\",\n \"0.5557325\",\n \"0.55547786\",\n \"0.55533457\",\n \"0.55382746\",\n \"0.55230296\",\n \"0.5515562\",\n \"0.55147517\",\n \"0.55139565\",\n \"0.55117667\",\n \"0.5505979\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.65002364"},"document_rank":{"kind":"string","value":"13"}}},{"rowIdx":88369,"cells":{"query":{"kind":"string","value":"takes agent's observation, returns qvalues. Both are tf Tensors"},"document":{"kind":"string","value":"def _get_qvalues(self, state_t):\n qvalues = self.network(state_t)\n return qvalues"},"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 get_q_values(self, observations, twin_q=False):\n if twin_q:\n q_model = self.twin_q_model\n else:\n q_model = self.main_q_model\n\n q_vals = q_model([observations[self.vf_obs_key]])\n return tf.reshape(q_vals, [-1, self.num_outputs])","def get_qvalues(self, prev_state, obs_t):\r\n obs_t = torch.tensor(obs_t, device=self.device, dtype=torch.float)\r\n (h, c), qvalues = self.forward(prev_state, obs_t)\r\n return (h.detach(), c.detach()), qvalues.data.cpu().numpy()","def get_qval(self, observation, action):\n obs_variable = Variable(torch.from_numpy(observation),\n volatile=True).type(torch.FloatTensor)\n\n # obs_variable sets volatile to True, thus, we do not set\n # it here\n action_variable = Variable(torch.from_numpy(action)).type(\n torch.FloatTensor)\n\n q_value_variable = self.forward(obs_variable, action_variable)\n return q_value_variable.data.numpy()","def get_qvalues(self, states):\n model_device = next(self.parameters()).device\n states = torch.tensor(states, device=model_device, dtype=torch.float32)\n qvalues = self.forward(states)\n return qvalues.data.cpu().numpy()","def get_qvalues(self, states):\n model_device = next(self.parameters()).device\n states = torch.tensor(states, device=model_device, dtype=torch.float)\n qvalues = self.forward(states)\n return qvalues.data.cpu().numpy()","def get_qvalues(self, states):\n model_device = next(self.parameters()).device\n states = torch.tensor(states, device=model_device, dtype=torch.float)\n qvalues = self.forward(states)\n return qvalues.data.cpu().numpy()","def getQValue(self, state, action):\n features = self.featExtractor.getFeatures(state, action)\n features_as_list = [features[feat] for feat in self.allFeats]\n features_vec = np.array([features_as_list])\n result = self.out.eval(feed_dict = {self.x: features_vec},\n session=self.sess)\n return result[0][0]","def q_values(self, state):\n return self.sess.run(self.graph.target_q_values,\n feed_dict={self.graph.states: [state]}).reshape(-1)","def get_q_values_op(self, state, scope, reuse=False):\r\n # this information might be useful\r\n num_actions = self.env.num_actions\r\n out = state\r\n print out.shape\r\n ##############################################################\r\n\r\n # TODO: Build a more reasonable network!!!\r\n\r\n with tf.variable_scope(scope, reuse=reuse):\r\n # out = tf.contrib.layers.fully_connected(out, 2048, activation_fn=tf.nn.relu)\r\n out = tf.contrib.layers.fully_connected(out, 1024, activation_fn=tf.nn.relu)\r\n out = tf.contrib.layers.flatten(out)\r\n out = tf.contrib.layers.fully_connected(out, 512, activation_fn=tf.nn.relu)\r\n out = tf.contrib.layers.fully_connected(out, num_actions, activation_fn=None)\r\n \r\n return out","def calc_q_values(self, state):\n return self._sess.run(self._q_pred_0,\n feed_dict={self._state_placeholder:state});","def value(self, observation, prev_action, prev_reward):\n agent_inputs = buffer_to((observation, prev_action, prev_reward),\n device=self.device)\n _mu, _log_std, value, _rnn_state = self.model(*agent_inputs, self.prev_rnn_state)\n return value.to(\"cpu\")","def calc_q_values(self, state):\n state = state[None, :, :, :]\n return self.q_network.predict_on_batch(state)","def get_q_values_op(self, state, scope, reuse=False):\r\n # this information might be useful\r\n num_actions = self.env.action_space.n\r\n out = state\r\n \r\n with tf.variable_scope(scope, reuse=reuse):\r\n out = layers.fully_connected(layers.flatten(out), num_actions, activation_fn=None)\r\n\r\n return out","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n Q_Value = 0 #initializing q value\n\n feat_Extractor = self.featExtractor\n\n weight = self.weights #To get the weight to control exploration and exploitation\n\n features = feat_Extractor.getFeatures(state,action) #to get all the features associated with (state,action) pair\n\n for each_feature in features:\n #refer to README_Reinforcement.txt for the formula at line 11\n temp_Qvalue = weight[each_feature] * features[each_feature] #Q(state,action) = w * featureVector where * is the dotProduct operator\n Q_Value = Q_Value + temp_Qvalue\n\n return Q_Value #Returns final qvalue\n #util.raiseNotDefined()","def q_values(self):\n # reshape input to 4d tensor [batch, height, width, channels]\n input = tf.reshape(self.state,\n [-1,\n Parameters.IMAGE_HEIGHT,\n Parameters.IMAGE_WIDTH,\n Parameters.AGENT_HISTORY_LENGTH])\n\n # convolutional layer 1\n \"\"\"\n [Article] The first hidden layer convolves 32 filters of 8 x 8 with stride 4 with the\n input image and applies a rectifier nonlinearity\n \"\"\"\n W_conv1 = self.weight_variable(\n [8, 8, Parameters.AGENT_HISTORY_LENGTH, 32])\n b_conv1 = self.bias_variable([32])\n conv1 = tf.nn.conv2d(\n input,\n W_conv1,\n strides=[1, 4, 4, 1],\n padding='VALID') # would 'SAME' also work ?\n h_conv1 = tf.nn.relu(conv1 + b_conv1)\n\n # output of conv 1 is of shape [-1 x 20 x 20 x 32]\n\n # convolutional layer 2\n \"\"\"\n [Article] The second hidden layer convolves 64 filters of 4 x 4 with stride 2,\n again followed by a rectifier nonlinearity\n \"\"\"\n W_conv2 = self.weight_variable([4, 4, 32, 64])\n b_conv2 = self.bias_variable([64])\n conv2 = tf.nn.conv2d(\n h_conv1, W_conv2, strides=[1, 2, 2, 1], padding='VALID')\n h_conv2 = tf.nn.relu(conv2 + b_conv2)\n\n # output of conv 2 is of shape [-1 x 9 x 9 x 64]\n\n # convolutional layer 3\n \"\"\"\n [Article] This is followed by a third convolutional layer that convolves\n 64 filters of 3 x 3 with stride 1 followed by a rectifier\n \"\"\"\n W_conv3 = self.weight_variable([3, 3, 64, 64])\n b_conv3 = self.bias_variable([64])\n conv3 = tf.nn.conv2d(\n h_conv2, W_conv3, strides=[1, 1, 1, 1], padding='VALID')\n h_conv3 = tf.nn.relu(conv3 + b_conv3)\n\n # output of conv 3 is of shape [-1 x 7 x 7 x 64]\n\n h_conv3_flat = tf.reshape(h_conv3, [-1, 7 * 7 * 64])\n\n # fully connected layer 1\n W_fc1 = self.weight_variable([7 * 7 * 64, 512])\n b_fc1 = self.bias_variable([512])\n fc1 = tf.matmul(h_conv3_flat, W_fc1)\n self.h_fc1 = h_fc1 = tf.nn.relu(fc1 + b_fc1)\n\n # fully connected layer 2 (output layer)\n W_fc2 = self.weight_variable([512, self.action_space])\n b_fc2 = self.bias_variable([self.action_space])\n fc2 = tf.matmul(h_fc1, W_fc2)\n\n # network output is of shape (1, self.action_space)\n \"\"\"\n [Article] We use an architecture in which there is a separate output unit\n for each possible action [ = one-hot encoding ], and only the state representation\n is an input to the neural network. The outputs correspond to the predicted Q-values of\n the individual actions for the input state.\n \"\"\"\n predicted_q_values = fc2 + b_fc2\n\n # saving learning parameters and layers output to access them directly\n # if needed\n\n self.learning_parameters[\"W_conv1\"], self.learning_parameters[\"b_conv1\"] = W_conv1, b_conv1\n self.layers[\"conv1\"], self.layers[\"h_conv1\"] = conv1, h_conv1\n\n self.learning_parameters[\"W_conv2\"], self.learning_parameters[\"b_conv2\"] = W_conv2, b_conv2\n self.layers[\"conv2\"], self.layers[\"h_conv2\"] = conv2, h_conv2\n\n self.learning_parameters[\"W_conv3\"], self.learning_parameters[\"b_conv3\"] = W_conv3, b_conv3\n self.layers[\"conv3\"], self.layers[\"h_conv3\"], self.layers[\"h_conv3_flat\"] = conv3, h_conv3, h_conv3_flat\n\n self.learning_parameters[\"W_fc1\"], self.learning_parameters[\"b_fc1\"] = W_fc1, b_fc1\n self.layers[\"fc1\"], self.layers[\"h_fc1\"] = fc1, h_fc1\n\n self.learning_parameters[\"W_fc2\"], self.learning_parameters[\"b_fc2\"] = W_fc2, b_fc2\n self.layers[\"fc2\"], self.layers[\"h_fc2\"] = fc2, predicted_q_values\n\n return(predicted_q_values)","def calc_q_values(self, state): \n q_vals = self.q_network.predict(np.swapaxes(state,0,3))\n return q_vals","def get_action_Qvalues(Qvalues,actions):\n\n batch_i = T.arange(Qvalues.shape[0])[:,None]\n time_i = T.arange(Qvalues.shape[1])[None,:]\n action_Qvalues_predicted= Qvalues[batch_i,time_i, actions]\n return action_Qvalues_predicted","def getQValue(self, state, action):\n #print \"getQValue in ApproximateQAgent\"\n\n \"*** YOUR CODE HERE ***\"\n weights = self.getWeights()\n features = self.featExtractor.getFeatures(state, action, self)\n\n value = 0\n\n #print \"FEATURES: \", features\n #print \"WEIGHTS: \", weights\n\n for feature in features:\n value += features[feature]*weights[feature]\n return value\n #util.raiseNotDefined()","def get(self, action: Action) -> Qval:\n b_q_values = self.with_batch_dim(self.q_values)\n return b_q_values.gather(1, action.long().view(-1, 1)).squeeze(1)","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qvalue = 0\n features = self.featExtractor.getFeatures(state, action)\n #Each feature is in the form of dictionary {((3, 3), 'east'): 1.0}. Each key is a combination of coordinate and direction. Each value represents the old qvalue.\n for feature in features.keys():\n qvalue += features[feature] * self.weights[feature]\n return qvalue","def compute_q_value(self, state, actions):\n state_values = self.forward(state)\n state_action_value = state_values.gather(1, actions)\n return state_action_value.squeeze()","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qvalue = 0.0\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\n qvalue += value * self.weights[feature_name]\n return qvalue","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qvalue = 0.0\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\n qvalue += value * self.weights[feature_name]\n return qvalue","def compute_qvalues(self, state):\n return self.model.predict([np.expand_dims(item, 0) for item in state])[0]","def getQValue(self, gameState, action):\n features = self.getFeatures(gameState, action)\n return features * self.weights","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n qvalues = <YOUR CODE>\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert (\n len(qvalues.shape) == 2 and \n qvalues.shape[0] == state_t.shape[0] and \n qvalues.shape[1] == n_actions\n )\n\n return qvalues","def get_twin_q_values(self, observations):\n return self.get_q_values(observations, twin_q=True)","def forward(self, obs_variable, actions_variable):\n state_action = torch.cat((obs_variable, actions_variable), 1)\n q_val_variable = self.model(state_action)\n\n return q_val_variable","def _getQvals(self, board):\r\n state = self._getState(board)\r\n # create the input to neural network\r\n toNN = [state[i-1] for i in range(1, self.inputSize)]\r\n toNN.insert(0, 0.0)\r\n # find expected rewards\r\n qVals = []\r\n for i in range(self.rowSize):\r\n toNN[0] = float(i)\r\n qVals.append(self.Q.calculate(toNN))\r\n return qVals","def value(self, observation, prev_action, prev_reward):\n model_inputs = buffer_to((observation, prev_action, prev_reward),\n device=self.device)\n _mu, _log_std, value = self.model(*model_inputs)\n return value.to(\"cpu\")","def calc_q_values_1(self, state):\n return self._sess.run(self._q_pred_1,\n feed_dict={self._state_placeholder:state});","def get_q_values(self, state):\n raise NotImplemented","def get_q_values_op(self, state, scope, reuse=False):\r\n num_actions = self.env.action_space.n\r\n with tf.variable_scope(scope, reuse=reuse):\r\n return layers.fully_connected(layers.flatten(state), num_actions, activation_fn=None)","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n feature_dictionary = self.featExtractor.getFeatures(state, action)\n\n QValue = 0\n for feature in feature_dictionary:\n QValue += self.weights[feature] * feature_dictionary[feature]\n return QValue","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n feature_dictionary = self.featExtractor.getFeatures(state, action)\n\n QValue = 0\n for feature in feature_dictionary:\n QValue += self.weights[feature] * feature_dictionary[feature]\n return QValue","def get_q_values(self, state, scope, reuse=False):\n input_size, hidden_size, output_size, hidden_size_2 = self.input_size, self.hidden_size, self.output_size, self.config.hidden_size_2\n with tf.variable_scope(scope):\n x = state\n w1 = self.init_weight(input_size, hidden_size, \"W1\")\n b1 = tf.Variable(tf.zeros(hidden_size), \"b1\")\n x = tf.add(tf.matmul(x, w1), b1)\n x = tf.nn.relu(x)\n\n w2 = self.init_weight(hidden_size, output_size, \"W2\", scale = 0.1)\n b2 = tf.Variable(tf.zeros(output_size), \"b2\")\n x = tf.add(tf.matmul(x, w2), b2)\n\n # w2 = self.init_weight(hidden_size, hidden_size_2, \"W2\", scale = 0.1)\n # b2 = tf.Variable(tf.zeros(hidden_size_2), \"b2\")\n # x = tf.add(tf.matmul(x, w2), b2)\n # x = tf.nn.relu(x)\n\n # w3 = self.init_weight(hidden_size_2, output_size, \"W3\", scale = 0.1)\n # b3 = tf.Variable(tf.zeros(output_size), \"b3\")\n # x = tf.add(tf.matmul(x, w3), b3)\n return x, w1, w2","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n transition_state_probs = self.mdp.getTransitionStatesAndProbs(state, action)\n # Add each state and probability to q_value\n q_value = 0\n for state_, probability in transition_state_probs:\n state_reward = self.mdp.getReward(state, state_, action)\n q_value += probability * (state_reward + self.discount * self.values[state_])\n return q_value","def compute_observation(self):\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\n robotEuler = p.getEulerFromQuaternion(robotOrn)\n linear, angular = p.getBaseVelocity(self.botId)\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))","def get_qs(self, state):\n state = state.astype(np.float32)\n if len(state.shape) == 3:\n state = state.reshape([1] + list(self.input_shape))\n return self.session.run(self.q_policy,\n feed_dict={self.s_placeholder: state})","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n # OUR CODE HERE\n #get the value of the state\n qVal = self.values[state]\n #iterate through the MDP transition states from the current state\n for transitionState, probability in self.mdp.getTransitionStatesAndProbs(state, action):\n #q value = discount * expected value of reward of state\n qVal += self.discount * probability * self.values[transitionState]\n return qVal\n # END OUR CODE","def getQValue(self, state, action):\n \"\"\"Description:\n [Enter a description of what you did here.]\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\n \n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\n it did not change even a ghost is closing.\n \"\"\"\n \"\"\" YOUR CODE HERE \"\"\"\n # if weight is empty, then weight will need to initial to 1 for all features\n # According to which Extractor user choose, weight counter will have equal number of keys.\n if len(self.weight) == 0:\n feat = self.featExtractor.getFeatures(state, action)\n self.weight.incrementAll(feat.keys(), 1)\n \n qValue = self.weight * self.featExtractor.getFeatures(state,action)\n return qValue\n \"\"\" END CODE \"\"\"","def computeQValueFromValues(self, state, action):\n #get the Transition function and nextStates\n state_prob_pair=self.mdp.getTransitionStatesAndProbs(state,action)\n #initialize the value to zero\n actual_value=0\n #iterate over probabilities (transition functions) and next states\n for pair in state_prob_pair:\n #compute qvalue\n actual_value+=pair[1]*(self.mdp.getReward(state,action,pair[0])+self.discount*self.values[pair[0]])\n #print \"The Q value is \",actual_value\n return actual_value","def getQvalue(self, state, action):\n featureVector = self.getFeatures(state, action)\n qValue = 0\n for k in featureVector.keys():\n qValue = qValue + self.weights[k] * featureVector[k]\n\n return qValue","def computeQValueFromValues(self, state, action):\n \"*** YOUR CODE HERE ***\"\n qValue = 0\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\n #print('Transitions: ' + str(transitions))\n for t in transitions:\n nextState, prob = t\n reward = self.mdp.getReward(state, action, nextState)\n #print('Reward: ' + str(reward))\n oneTransition = prob * (reward + self.discount * self.values[nextState])\n qValue = qValue + oneTransition\n return qValue","def get_q_values(self, state, network):\n out = None\n state = state.permute(0, 3, 1, 2)\n #pdb.set_trace()\n ##############################################################\n ################ YOUR CODE HERE - 4-5 lines lines ################\n if network == 'q_network':\n out = self.q_network(state)\n else:\n out = self.target_network(state)\n ##############################################################\n ######################## END YOUR CODE #######################\n return out","def get_target_q_values(\n self, next_states: torch.Tensor, rewards: torch.Tensor, dones: torch.Tensor\n ) -> torch.Tensor:\n return ddqn_q_target(self, next_states, rewards, dones)","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n # print \"GETQVALUE in QLEARNINGAGENT, QVALUE: \",self.Q[(state, action)]\n\n return self.Q[(state, action)]\n\n\n util.raiseNotDefined()","def computeQValueFromValues(self, state, action):\n\n ##util.raiseNotDefined()\n #\"*** YOUR CODE STARTS HERE ***\"\n # Code to remove --- from here\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\n qvalue = 0\n for (nextState, probability) in transitions:\n reward = self.mdp.getReward(state, action, nextState)\n qvalue += probability *(reward + self.discount*self.values[nextState])\n # Code to remove --- to here\n #\"*** YOUR CODE FINISHES HERE ***\"\n \n return qvalue","def compute_Q_value(self, phi, act) -> float:\n q_vec = phi @ self.Wq\n return q_vec[act]","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n conved_1 = self.conv1(state_t)\n conved_2 = self.conv2(conved_1)\n conved_3 = self.conv3(conved_2)\n qvalues = self.dense(conved_3)\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert len(\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == n_actions\n\n return qvalues","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n qvalues = self.network(state_t)\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert len(\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\n\n return qvalues","def value_iteration(env):\n Qvalues = torch.zeros(NUM_STATES)\n\n max_iterations = 100\n mse = []\n for _ in range(max_iterations):\n Vtemp = torch.zeros(NUM_STATES)\n # for each state we search for best move\n for st in range(NUM_STATES):\n max_value, _ = next_step_evaluation(env, st, Qvalues)\n #Qvalues[st] = max_value.item()\n Vtemp[st] = max_value.item()\n mse.append(((Qvalues-Vtemp)**2).mean())\n Qvalues = Vtemp\n\n return Qvalues, mse","def calc_q_values(self, state):\n return self.q_values_func([state])[0]","def act(self, state, epsilon, env):\n if random.random() > epsilon:\n state = Variable(torch.FloatTensor(state)).unsqueeze(0) # adds extra dim when single input\n state = self.vari_gpu(state)\n _, u_opt = self.forward(state)\n action = (u_opt.cpu().detach().numpy()) # compute the u*[0] \n #print('act:q_value ',q_value)\n #print('act:model action ',action)\n else:\n rand = np.random.rand(int(np.array(env.action_space.shape)))\n high = env.action_space.high\n low = env.action_space.low\n action = low + rand*(high-low)\n #print('act: ',action)\n return action","def getObservation(self):\n res = zeros(4)\n all = self.env.getSensors()\n res[0] = all[3]\n res[1] = all[1]\n res[2] = all[3] and all[1]\n res[3] = not all[3] and not all[1]\n return res","def getObservation(self):\n sensors = self.env.getSensors()\n if self.sensor_limits:\n sensors = self.normalize(sensors)\n return sensors","def get_tf_t_vals(sess):\n return sess.run(\n TfUtils.get_tf_t_vars(sess)\n )","def calc_q_values(self, state, Q, flag):\n\n if flag == 0:\n self.train_data = np.concatenate([st.state for st in state])\n return Q.predict_on_batch(self.train_data)\n elif flag == 1:\n return Q.predict_on_batch(np.concatenate([st.next_state for st in state]))","def get_state_observed_values(self):\n obsState = numpy.zeros(self.get_num_variables())\n i = 0\n for v in self.variables:\n obsState[i] = v.read_value_in_fmu(self.fmu)\n i += 1\n return obsState","def _build_target_q_op(self):\n targets = []\n for gamma, target_q in zip(self.gammas,\n self._replay_next_target_net_outputs.q_values):\n # Get the maximum Q-value across the actions dimension.\n replay_next_qt_max = tf.reduce_max(target_q, 1)\n\n # Calculate the Bellman target value.\n # Q_t = R_t + \\gamma^N * Q'_t+1\n # where,\n # Q'_t+1 = \\argmax_a Q(S_t+1, a)\n # (or) 0 if S_t is a terminal state,\n # and\n # N is the update horizon (by default, N=1).\n cumulative_gamma = math.pow(gamma, self.update_horizon)\n n_step_reward = self._build_discounted_n_step_rewards(gamma)\n targets.append(n_step_reward + cumulative_gamma * replay_next_qt_max *\n (1. - tf.cast(self._replay.terminals, tf.float32)))\n return targets","def forward(self, state_t):\n # Use your network to compute qvalues for given state\n conved_features = self.conv_layers(state_t)\n A = self.head_A(conved_features)\n V = self.head_V(conved_features).repeat(1, self.n_actions)\n mean_A = torch.mean(A, dim=-1, keepdim=True).repeat(1, self.n_actions)\n qvalues = A + V - mean_A\n\n assert qvalues.requires_grad, \"qvalues must be a torch tensor with grad\"\n assert len(\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\n\n return qvalues","def jval(self):\n return self.q * self.model.nobs_moms","def getQValue(self, state, action):\n features = self.featExtractor.getFeatures(state, action)\n total = 0\n for feat in features:\n total += self.getWeights()[feat] * features[feat]\n return total","def q(self):\n return self.model.gmmobjective(self.params, self.weights)","def t(self: Q) -> np.array:\n\n return np.array([self.t])","def computeQValueFromValues(self, state, action):\r\n #\r\n weightedVfvsSum = 0\r\n reward = 0\r\n # to get possible next state(s)\r\n for nextState, prob in self.mdp.getTransitionStatesAndProbs(state, action):\r\n reward += self.mdp.getReward(state, action, nextState) * prob\r\n #print \":computeQValueFromValues: nextState is: \", nextState, \" | self.values[nextState] is: \", self.values[nextState]\r\n weightedVfvsSum += prob * self.getValue(nextState)\r\n #\r\n return ( reward + ( self.discount * weightedVfvsSum) ) # making the actual qvalue\r","def computeQValueFromValues(self, state, action):\n #get all possible actions from current state\n possibleActions = self.mdp.getPossibleActions(state)\n\n #if action is illegal return 0\n if action in possibleActions:\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\n returnVal = 0\n index = 0\n\n #loop through all trainsitions/probabilities\n while index < len(transitions):\n #This returns s' and T(s, a, s')\n (nextState, prob) = transitions[index]\n\n\n #This returns R(s,a,s')\n rewardVal = self.mdp.getReward(state, action, nextState)\n\n #This is gamma * V(s')\n lastPartOfEquation = self.values[nextState] *self.discount\n\n #This is T(s, a, s')[R(s, a, s') + gamma * V(s'). Bellman equation\n returnVal = returnVal + prob * (rewardVal + lastPartOfEquation)\n index = index + 1\n\n return returnVal\n else:\n return 0","def _get_obs(self):\n pos = []\n z = []\n for i in range(params['memory_size']):\n if self._step - i * params['memory_size'] > 1:\n pos.append(self._track_item['joint_pos'][self._step - i * params['memory_size'] - 1].copy())\n z.append(self._track_item['z'][self._step - i * params['memory_size'] - 1].copy())\n else:\n pos.append(self._track_item['joint_pos'][0].copy())\n if len(self._track_item['z']) < 1:\n z.append(self.z.copy())\n else:\n z.append(self._track_item['z'][0].copy())\n out = pos\n if params['observation_version'] == 1:\n out += z\n ob = {\n 'observation' : np.concatenate(out, -1),\n 'desired_goal' : self.desired_goal.copy(),\n 'achieved_goal' : self.achieved_goal.copy(),\n 'z' : self.z.copy()\n }\n return ob","def _model(self, scope):\n\n with tf.variable_scope(scope):\n\n act = tf.nn.elu\n initializer = tfcl.variance_scaling_initializer()\n xs = tf.layers.dense(self.state, 400, act, kernel_initializer=initializer)\n xs = tf.layers.dense(xs, 300, None, kernel_initializer=initializer)\n\n xa = tf.layers.dense(self._action, 400, act, kernel_initializer=initializer)\n xa = tf.layers.dense(xa, 300, None, kernel_initializer=initializer)\n\n x = tf.nn.elu(xa + xs)\n\n q_value = tf.layers.dense(x, 1, None, kernel_initializer=initializer)\n\n return q_value","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n # print \"getQValue\"\n features = self.featExtractor.getFeatures(state, self.index)#.values()\n #weights = self.weights.values()\n #dotProduct = reduce( (lambda x, y: x*y), map( (lambda x, y: x+y), self.weights, features))\n #return dotProduct\n score = 0\n for key in features.keys():\n score += features[key]*self.weights[key]\n return score","def select_q_values_by_action(q_values, actions):\n return tf.reduce_sum(\n q_values * tf.one_hot(actions, q_values.get_shape()[1]),\n axis=1\n )","def computeQValueFromValues(self, state, action):\n # assign q value to 0\n qvalue = 0\n\n # get the possible transition states and actions\n possible_tansition = self.mdp.getTransitionStatesAndProbs(state, action)\n\n # for each transition in list of possible transitions\n # transition[0] has the successor state (s-prime) represented in co-ordinates\n for transition in possible_tansition:\n\n # calculate reward transition\n reward = self.mdp.getReward(state, action, transition[0])\n\n # transition[1] has the probablity of reaching a particular successor state (s-prime) from state, action pair\n probability = transition[1]\n\n # get the utility value from tansition[0] which has successor state represented in coordinates\n utility_value = self.getValue(transition[0])\n\n # compute q value collectively using reward and probability transition\n qvalue = qvalue + (probability * (reward + (self.discount * utility_value)))\n\n # return q value\n return qvalue","def get_all_state_action_values(self, state):\n return torch.tensor([[self.get_state_action_value(state, action) for action in range(self.action_space.n)]]).float()","def call(self, obs):\n\t\tx = tf.convert_to_tensor(obs)\n\t\thidden_logs = self.hidden1(x)\n\t\thidden_vals = self.hidden2(x)\n\t\treturn self.logits(hidden_logs), self.value(hidden_vals)","def forward(self, prev_state, obs_t):\r\n # Use your network to compute qvalues for given state\r\n #print(state_t.shape)\r\n h = self.conv(obs_t)\r\n\r\n h = h.view(h.size(0), -1)\r\n\r\n new_state = h_new, c_new = self.lstm(h, prev_state)\r\n advantage = self.adv(h_new)\r\n value = self.val(h_new)\r\n\r\n\r\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\r\n qvalues = value + advantage - adv_mean\r\n\r\n return new_state, qvalues","def _get_obs(self):\n return self.observation_function[self.cur_state]","def vvalue(self) -> Qval:\n return self.with_batch_dim(self.q_values).max(1).values","def get_observation(self , reward = False):\n\t\t# magnetic_ends ****\n\t\topen_magnetic_ends = rnadc.count_magnetic_ends(graph = self._state._graph)\n\t\t# sequence_length difference factor\n\t\tinstance_counter, seq_length = self._state.get_state_counters()\n\t\tseq_length_difference = abs(seq_length - self._state._seq_length_threshold)\n\t\t# composability factor\n\t\tif reward:\n\t\t\treturn open_magnetic_ends , seq_length_difference\n\t\telse:\n\t\t\treturn [open_magnetic_ends] + [seq_length_difference] + self.get_action_history()","def action_value(self, obs):\n\t\tlogits, value = self.predict_on_batch(obs)\n\t\taction = self.dist.predict_on_batch(logits)\n\t\treturn np.squeeze(action, axis=-1), np.squeeze(value, axis=-1)","def get_action_value(mdp, state_values, state, action, gamma):\n\n Q = 0\n # YOUR CODE HERE\n return Q","def computeQValueFromValues(self, state, action):\n\n # Find expected utility of making this move\n x = 0\n for t in self.mdp.getTransitionStatesAndProbs(state,action):\n x += t[1] * self.getValue(t[0])\n\n\n # Return Reward + discounted expected utility\n return self.mdp.getReward(state,None,None) + self.discount*x","def calculate_q_vals(self, rews_list):\n\n # Case 1: trajectory-based PG \n if not self.reward_to_go:\n\n # TODO: Estimate the Q value Q^{pi}(s_t, a_t) using rewards from that entire trajectory\n # HINT1: value of each point (t) = total discounted reward summed over the entire trajectory (from 0 to T-1)\n # In other words, q(s_t, a_t) = sum_{t'=0}^{T-1} gamma^t' r_{t'}\n # Hint3: see the helper functions at the bottom of this file\n q_values = np.concatenate([self._discounted_return(r) for r in rews_list])\n\n # Case 2: reward-to-go PG \n else:\n\n # TODO: Estimate the Q value Q^{pi}(s_t, a_t) as the reward-to-go\n # HINT1: value of each point (t) = total discounted reward summed over the remainder of that trajectory\n # (from t to T-1)\n # In other words, q(s_t, a_t) = sum_{t'=t}^{T-1} gamma^(t'-t) * r_{t'}\n # Hint3: see the helper functions at the bottom of this file\n q_values = np.concatenate([self._discounted_cumsum(r) for r in rews_list])\n\n return q_values.astype(np.float32)","def computevaluefromqvalues(self, state):\n legalactions = env.getlegalactions(deepcopy(env.state_to_array(state)))\n if len(legalactions) == 0:\n return 0.0\n tmp = Counter()\n for action in legalactions:\n tmp[action] = self.getqvalue(state, action)\n return tmp[tmp.argMax()]","def computeQValueFromValues(self, state, action):\n newState_prob = self.mdp.getTransitionStatesAndProbs(state, action)\n sum = 0\n for i in newState_prob:\n sum += i[1]*(self.mdp.getReward(state, action, i[0])+(self.discount*self.getValue(i[0])))\n return sum \n \n util.raiseNotDefined()","def getqvalue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n if (state, action) not in self.qvals:\n self.qvals[(state, action)] = 0.0\n return self.qvals[(state, action)]","def mc_policy_evaluation(env, policy, Q_value, n_visits, gamma=0.9):\n nS = env.nS # number of states\n nA = env.nA # number of actions\n episode = generate_episode(env, policy)\n # print(episode)\n returns = generate_returns(episode, gamma=gamma)\n # print(returns)\n visit_flag = np.zeros((nS, nA))\n ############################\n # YOUR IMPLEMENTATION HERE #\n \n for i in range(0, len(episode)): #for each state,action,reward in the episode\n # print(\"sub episode: i = \" + str(i))\n s_t, a_t, r_t = episode[i] \n \n if visit_flag[s_t, a_t] == 0: # if the current state, action has not been visited previously in this episode\n # print(\"state: \" + str(s_t) + \", action: \" + str(a_t))\n # print(\"Q = \" + str(Q_value))\n # print(\"returns = \" + str(returns))\n \n visit_flag[s_t, a_t] = 1 # set flag to 1 (so we don't revisit the state again in this episode)\n n_visits[s_t, a_t] += 1 # increase the total number of visits to the state in ALL episodes\n Q_value[s_t,a_t] = Q_value[s_t,a_t] + 1/n_visits[s_t, a_t] * (returns[i] - Q_value[s_t,a_t]) # update Q value\n\n ############################\n return Q_value, n_visits","def computeQValueFromValues(self, state, action):\n \n \n next_states_probs = self.mdp.getTransitionStatesAndProbs(state, action)\n # liste des recompenses R(s,a,s')\n rewards = []\n # liste des probas de transitions P(s'|a,s)\n probs = []\n # liste des Vk(s')\n previous_values = []\n # occurence[0] = les next_state\n # occurence[1] = les proba de transi\n for occurence in next_states_probs:\n rewards.append(self.mdp.getReward(state, action, occurence[0]))\n probs.append(occurence[1])\n previous_values.append(self.getValue(occurence[0]))\n Q_value = 0\n # boucle qui calcule somme des ( P(s'|a,s) * [R(s,a,s') + gamma * Vk(s')] ) sur les s'\n for i in range(len(probs)):\n Q_value += probs[i] * (rewards[i] + self.discount * previous_values[i])\n \n return Q_value\n util.raiseNotDefined()","def all_q_variables(self):\n\n return self.main_q_variables() + (self.twin_q_variables() if self.twin_q_net else [])","def Values(self) -> _n_1_t_4:","def get_action(self, obs):\n q = self.sess.run(self._qvals, feed_dict={self._observation: obs})\n max_a = np.argmax(q, axis=1)\n\n # Epsilon greedy method.\n global_step = self.sess.run(tf.train.get_global_step())\n batch_size = obs.shape[0]\n actions = np.random.randint(self._dim_act, size=batch_size)\n idx = np.random.uniform(size=batch_size) > self._epsilon_schedule(global_step)\n actions[idx] = max_a[idx]\n return actions","def getQValue(self, state, action):\n \"*** YOUR CODE HERE ***\"\n Q_Value = self.Q\n\n if (state,action) not in Q_Value: #Checks if state is present in dictionary or not, basically if we have ever seen a state or not\n\n Q_Value[(state,action)]= 0.0 #Put value as zero because we have not seen the state as if now\n\n\n return Q_Value[(state,action)] #Returns Q node value\n #util.raiseNotDefined()","def batch_q_learning(self):\n\n if(self.memory.get_usage() > Parameters.AGENT_HISTORY_LENGTH):\n\n state_t, action, reward, state_t_plus_1, terminal, i_s_weights, memory_indices = self.memory.bring_back_memories()\n\n q_t_plus_1 = self.tf_session.run(\n self.target_dqn.q_values, {\n self.target_dqn_input: state_t_plus_1})\n max_q_t_plus_1 = np.max(q_t_plus_1, axis=1)\n\n target_q_t = (1. - terminal) * \\\n Parameters.DISCOUNT_FACTOR * max_q_t_plus_1 + reward\n\n _, q_t, losses = self.tf_session.run([self.dqn.optimize, self.dqn.q_values, self.dqn.errors],\n {\n self.dqn.target_q: target_q_t,\n self.dqn.action: action,\n self.dqn_input: state_t,\n self.dqn.i_s_weights: i_s_weights\n })\n\n self.memory.update(\n memory_indices,\n np.squeeze(q_t),\n losses,\n self.get_learning_completion())\n input_shape = (1, Parameters.IMAGE_HEIGHT, Parameters.IMAGE_WIDTH, Parameters.AGENT_HISTORY_LENGTH)\n dqn_input = self.environment.get_input().reshape(input_shape)\n q_values = self.tf_session.run(\n self.dqn.q_values, {\n self.dqn_input: dqn_input})\n Plotter.add_q_values_at_t(q_values)\n else:\n print('[WARNING] Not enough memory for a batch')","def getQValue(self, state, action):\n position = self.computePosition(state)\n action_column = self.columAction[action]\n\n return self.q_table[position][action_column]","def observation_value(self):\n pass","def avf_values(env, num_optimization_steps=1000, num_tasks=50,\n tf_device='/cpu:*'):\n num_states = env.num_states\n num_actions = env.num_actions\n # Construct compatible P matrix, with action at the end, and assuming\n # deterministic transitions.\n p = np.transpose(env.transition_probs, [0, 2, 1])\n r = env.rewards\n sess = tf.Session()\n # deltas: probe vector, num_tasks x num_states-dimensional.\n deltas = np.random.random((num_tasks, num_states)) * 2.0 - 1.0\n with tf.device(tf_device):\n dummy = tf.constant(np.array([[1.0]]), dtype=tf.float32)\n model = tf.keras.Sequential()\n model.add(tf.keras.layers.Dense(num_tasks * num_states * num_actions))\n logits = model(dummy)\n logits = tf.reshape(logits, [num_tasks, num_states, num_actions])\n policy = tf.nn.softmax(logits)\n expanded_policy = tf.expand_dims(policy, axis=-1)\n tiled_p = np.tile(p, [num_tasks, 1, 1, 1])\n tiled_p *= np.float64(env.gamma) # Precompute P as much as possible.\n expanded_policy = tf.cast(expanded_policy, tf.float64)\n ppi = tf.matmul(tiled_p, expanded_policy)\n ppi = tf.reshape(ppi, (num_tasks, num_states, num_states))\n tiled_eye = np.tile(np.eye(num_states), [num_tasks, 1, 1])\n # tiled_eye - Ppi is k x n x n, the last two dimensions are inverted.\n # Note discount factor has been incorporated above.\n resolvent = tf.linalg.inv(tiled_eye - ppi)\n r = np.expand_dims(r, axis=1) # Make rewards row vectors.\n r = np.tile(r, [num_tasks, 1, 1, 1])\n rpi = tf.matmul(r, expanded_policy) # Expected reward.\n rpi = tf.reshape(rpi, (num_tasks, num_states, 1)) # Drop last dimension.\n value_func = tf.matmul(resolvent, rpi)\n # Deltas should be k x n, make k x 1 x n (row vectors).\n deltas = np.expand_dims(deltas, axis=1)\n deltas = tf.constant(deltas, dtype=tf.float64)\n loss = -tf.matmul(deltas, value_func)\n optimizer = tf.train.AdamOptimizer(\n learning_rate=0.1, epsilon=0.0003125)\n loss = tf.reduce_sum(loss)\n train_op = optimizer.minimize(loss)\n sess.run(tf.initializers.global_variables())\n for _ in range(num_optimization_steps):\n sess.run([loss, train_op])\n vf_output = sess.run(value_func)\n return vf_output","def get(self):\n if now()-self.last_query < 1./self.query_rate:\n return None,None\n self.last_query = now()\n\n # query from saver (an old strategy that may be desired at points): \n #self.saver.query_flag.value = True\n #fr = mp2np(self.saver.query_queue)\n #frts = self.saver.query_queue_ts.value\n \n # query from _PSEye (a newer strategy that is preferable for most uses):\n self.pseye.query_flag.value = True\n while self.pseye.query_flag.value == True:\n pass\n fr = self.pseye.query_queue[0]\n frts = self.pseye.query_queue_ts.value\n\n x,y = self.resolution[self.query_idx]\n return frts,fr.reshape([y,x])","def computeQValueFromValues(self, state, action):\n totalsum = 0\n reward = 0\n for nextstate, transition in self.mdp.getTransitionStatesAndProbs(state, action):\n reward = self.mdp.getReward(state, action, nextstate)\n totalsum += transition * (reward + self.discount * self.getValue(nextstate)) # right way to access previous value?\n return totalsum","def __call__(self, state, observation, agent_info=None, history=None):\n B = observation.n_elems()\n\n _mean, _var = self.model(observation[\"frame\"])\n _id = torch.eye(self.action_dim).unsqueeze(0).repeat(B, 1, 1)\n\n distribution = torch.distributions.Normal(_mean, _var)\n action_sampled = distribution.sample()\n action_max = _mean\n smask = (\n agent_info[\"stochastic\"].float().unsqueeze(-1).repeat(1, self.action_dim)\n )\n action = action_sampled * smask + (1.0 - smask) * action_max\n\n agent_do = DictTensor({\"action\": action, \"mean\": _mean, \"std\": _var})\n state = DictTensor({})\n return agent_do, state","def predict_Q(self, state, action):\r\n state = np.reshape(state, (-1, self.feature_number))\r\n action = np.reshape(action, (-1, self.action_space))\r\n Q_value = self.critic.predict([state, action])\r\n return Q_value","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"],"string":"[\n \"def get_q_values(self, observations, twin_q=False):\\n if twin_q:\\n q_model = self.twin_q_model\\n else:\\n q_model = self.main_q_model\\n\\n q_vals = q_model([observations[self.vf_obs_key]])\\n return tf.reshape(q_vals, [-1, self.num_outputs])\",\n \"def get_qvalues(self, prev_state, obs_t):\\r\\n obs_t = torch.tensor(obs_t, device=self.device, dtype=torch.float)\\r\\n (h, c), qvalues = self.forward(prev_state, obs_t)\\r\\n return (h.detach(), c.detach()), qvalues.data.cpu().numpy()\",\n \"def get_qval(self, observation, action):\\n obs_variable = Variable(torch.from_numpy(observation),\\n volatile=True).type(torch.FloatTensor)\\n\\n # obs_variable sets volatile to True, thus, we do not set\\n # it here\\n action_variable = Variable(torch.from_numpy(action)).type(\\n torch.FloatTensor)\\n\\n q_value_variable = self.forward(obs_variable, action_variable)\\n return q_value_variable.data.numpy()\",\n \"def get_qvalues(self, states):\\n model_device = next(self.parameters()).device\\n states = torch.tensor(states, device=model_device, dtype=torch.float32)\\n qvalues = self.forward(states)\\n return qvalues.data.cpu().numpy()\",\n \"def get_qvalues(self, states):\\n model_device = next(self.parameters()).device\\n states = torch.tensor(states, device=model_device, dtype=torch.float)\\n qvalues = self.forward(states)\\n return qvalues.data.cpu().numpy()\",\n \"def get_qvalues(self, states):\\n model_device = next(self.parameters()).device\\n states = torch.tensor(states, device=model_device, dtype=torch.float)\\n qvalues = self.forward(states)\\n return qvalues.data.cpu().numpy()\",\n \"def getQValue(self, state, action):\\n features = self.featExtractor.getFeatures(state, action)\\n features_as_list = [features[feat] for feat in self.allFeats]\\n features_vec = np.array([features_as_list])\\n result = self.out.eval(feed_dict = {self.x: features_vec},\\n session=self.sess)\\n return result[0][0]\",\n \"def q_values(self, state):\\n return self.sess.run(self.graph.target_q_values,\\n feed_dict={self.graph.states: [state]}).reshape(-1)\",\n \"def get_q_values_op(self, state, scope, reuse=False):\\r\\n # this information might be useful\\r\\n num_actions = self.env.num_actions\\r\\n out = state\\r\\n print out.shape\\r\\n ##############################################################\\r\\n\\r\\n # TODO: Build a more reasonable network!!!\\r\\n\\r\\n with tf.variable_scope(scope, reuse=reuse):\\r\\n # out = tf.contrib.layers.fully_connected(out, 2048, activation_fn=tf.nn.relu)\\r\\n out = tf.contrib.layers.fully_connected(out, 1024, activation_fn=tf.nn.relu)\\r\\n out = tf.contrib.layers.flatten(out)\\r\\n out = tf.contrib.layers.fully_connected(out, 512, activation_fn=tf.nn.relu)\\r\\n out = tf.contrib.layers.fully_connected(out, num_actions, activation_fn=None)\\r\\n \\r\\n return out\",\n \"def calc_q_values(self, state):\\n return self._sess.run(self._q_pred_0,\\n feed_dict={self._state_placeholder:state});\",\n \"def value(self, observation, prev_action, prev_reward):\\n agent_inputs = buffer_to((observation, prev_action, prev_reward),\\n device=self.device)\\n _mu, _log_std, value, _rnn_state = self.model(*agent_inputs, self.prev_rnn_state)\\n return value.to(\\\"cpu\\\")\",\n \"def calc_q_values(self, state):\\n state = state[None, :, :, :]\\n return self.q_network.predict_on_batch(state)\",\n \"def get_q_values_op(self, state, scope, reuse=False):\\r\\n # this information might be useful\\r\\n num_actions = self.env.action_space.n\\r\\n out = state\\r\\n \\r\\n with tf.variable_scope(scope, reuse=reuse):\\r\\n out = layers.fully_connected(layers.flatten(out), num_actions, activation_fn=None)\\r\\n\\r\\n return out\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n Q_Value = 0 #initializing q value\\n\\n feat_Extractor = self.featExtractor\\n\\n weight = self.weights #To get the weight to control exploration and exploitation\\n\\n features = feat_Extractor.getFeatures(state,action) #to get all the features associated with (state,action) pair\\n\\n for each_feature in features:\\n #refer to README_Reinforcement.txt for the formula at line 11\\n temp_Qvalue = weight[each_feature] * features[each_feature] #Q(state,action) = w * featureVector where * is the dotProduct operator\\n Q_Value = Q_Value + temp_Qvalue\\n\\n return Q_Value #Returns final qvalue\\n #util.raiseNotDefined()\",\n \"def q_values(self):\\n # reshape input to 4d tensor [batch, height, width, channels]\\n input = tf.reshape(self.state,\\n [-1,\\n Parameters.IMAGE_HEIGHT,\\n Parameters.IMAGE_WIDTH,\\n Parameters.AGENT_HISTORY_LENGTH])\\n\\n # convolutional layer 1\\n \\\"\\\"\\\"\\n [Article] The first hidden layer convolves 32 filters of 8 x 8 with stride 4 with the\\n input image and applies a rectifier nonlinearity\\n \\\"\\\"\\\"\\n W_conv1 = self.weight_variable(\\n [8, 8, Parameters.AGENT_HISTORY_LENGTH, 32])\\n b_conv1 = self.bias_variable([32])\\n conv1 = tf.nn.conv2d(\\n input,\\n W_conv1,\\n strides=[1, 4, 4, 1],\\n padding='VALID') # would 'SAME' also work ?\\n h_conv1 = tf.nn.relu(conv1 + b_conv1)\\n\\n # output of conv 1 is of shape [-1 x 20 x 20 x 32]\\n\\n # convolutional layer 2\\n \\\"\\\"\\\"\\n [Article] The second hidden layer convolves 64 filters of 4 x 4 with stride 2,\\n again followed by a rectifier nonlinearity\\n \\\"\\\"\\\"\\n W_conv2 = self.weight_variable([4, 4, 32, 64])\\n b_conv2 = self.bias_variable([64])\\n conv2 = tf.nn.conv2d(\\n h_conv1, W_conv2, strides=[1, 2, 2, 1], padding='VALID')\\n h_conv2 = tf.nn.relu(conv2 + b_conv2)\\n\\n # output of conv 2 is of shape [-1 x 9 x 9 x 64]\\n\\n # convolutional layer 3\\n \\\"\\\"\\\"\\n [Article] This is followed by a third convolutional layer that convolves\\n 64 filters of 3 x 3 with stride 1 followed by a rectifier\\n \\\"\\\"\\\"\\n W_conv3 = self.weight_variable([3, 3, 64, 64])\\n b_conv3 = self.bias_variable([64])\\n conv3 = tf.nn.conv2d(\\n h_conv2, W_conv3, strides=[1, 1, 1, 1], padding='VALID')\\n h_conv3 = tf.nn.relu(conv3 + b_conv3)\\n\\n # output of conv 3 is of shape [-1 x 7 x 7 x 64]\\n\\n h_conv3_flat = tf.reshape(h_conv3, [-1, 7 * 7 * 64])\\n\\n # fully connected layer 1\\n W_fc1 = self.weight_variable([7 * 7 * 64, 512])\\n b_fc1 = self.bias_variable([512])\\n fc1 = tf.matmul(h_conv3_flat, W_fc1)\\n self.h_fc1 = h_fc1 = tf.nn.relu(fc1 + b_fc1)\\n\\n # fully connected layer 2 (output layer)\\n W_fc2 = self.weight_variable([512, self.action_space])\\n b_fc2 = self.bias_variable([self.action_space])\\n fc2 = tf.matmul(h_fc1, W_fc2)\\n\\n # network output is of shape (1, self.action_space)\\n \\\"\\\"\\\"\\n [Article] We use an architecture in which there is a separate output unit\\n for each possible action [ = one-hot encoding ], and only the state representation\\n is an input to the neural network. The outputs correspond to the predicted Q-values of\\n the individual actions for the input state.\\n \\\"\\\"\\\"\\n predicted_q_values = fc2 + b_fc2\\n\\n # saving learning parameters and layers output to access them directly\\n # if needed\\n\\n self.learning_parameters[\\\"W_conv1\\\"], self.learning_parameters[\\\"b_conv1\\\"] = W_conv1, b_conv1\\n self.layers[\\\"conv1\\\"], self.layers[\\\"h_conv1\\\"] = conv1, h_conv1\\n\\n self.learning_parameters[\\\"W_conv2\\\"], self.learning_parameters[\\\"b_conv2\\\"] = W_conv2, b_conv2\\n self.layers[\\\"conv2\\\"], self.layers[\\\"h_conv2\\\"] = conv2, h_conv2\\n\\n self.learning_parameters[\\\"W_conv3\\\"], self.learning_parameters[\\\"b_conv3\\\"] = W_conv3, b_conv3\\n self.layers[\\\"conv3\\\"], self.layers[\\\"h_conv3\\\"], self.layers[\\\"h_conv3_flat\\\"] = conv3, h_conv3, h_conv3_flat\\n\\n self.learning_parameters[\\\"W_fc1\\\"], self.learning_parameters[\\\"b_fc1\\\"] = W_fc1, b_fc1\\n self.layers[\\\"fc1\\\"], self.layers[\\\"h_fc1\\\"] = fc1, h_fc1\\n\\n self.learning_parameters[\\\"W_fc2\\\"], self.learning_parameters[\\\"b_fc2\\\"] = W_fc2, b_fc2\\n self.layers[\\\"fc2\\\"], self.layers[\\\"h_fc2\\\"] = fc2, predicted_q_values\\n\\n return(predicted_q_values)\",\n \"def calc_q_values(self, state): \\n q_vals = self.q_network.predict(np.swapaxes(state,0,3))\\n return q_vals\",\n \"def get_action_Qvalues(Qvalues,actions):\\n\\n batch_i = T.arange(Qvalues.shape[0])[:,None]\\n time_i = T.arange(Qvalues.shape[1])[None,:]\\n action_Qvalues_predicted= Qvalues[batch_i,time_i, actions]\\n return action_Qvalues_predicted\",\n \"def getQValue(self, state, action):\\n #print \\\"getQValue in ApproximateQAgent\\\"\\n\\n \\\"*** YOUR CODE HERE ***\\\"\\n weights = self.getWeights()\\n features = self.featExtractor.getFeatures(state, action, self)\\n\\n value = 0\\n\\n #print \\\"FEATURES: \\\", features\\n #print \\\"WEIGHTS: \\\", weights\\n\\n for feature in features:\\n value += features[feature]*weights[feature]\\n return value\\n #util.raiseNotDefined()\",\n \"def get(self, action: Action) -> Qval:\\n b_q_values = self.with_batch_dim(self.q_values)\\n return b_q_values.gather(1, action.long().view(-1, 1)).squeeze(1)\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qvalue = 0\\n features = self.featExtractor.getFeatures(state, action)\\n #Each feature is in the form of dictionary {((3, 3), 'east'): 1.0}. Each key is a combination of coordinate and direction. Each value represents the old qvalue.\\n for feature in features.keys():\\n qvalue += features[feature] * self.weights[feature]\\n return qvalue\",\n \"def compute_q_value(self, state, actions):\\n state_values = self.forward(state)\\n state_action_value = state_values.gather(1, actions)\\n return state_action_value.squeeze()\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qvalue = 0.0\\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\\n qvalue += value * self.weights[feature_name]\\n return qvalue\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qvalue = 0.0\\n for feature_name, value in self.featExtractor.getFeatures(state, action).iteritems():\\n qvalue += value * self.weights[feature_name]\\n return qvalue\",\n \"def compute_qvalues(self, state):\\n return self.model.predict([np.expand_dims(item, 0) for item in state])[0]\",\n \"def getQValue(self, gameState, action):\\n features = self.getFeatures(gameState, action)\\n return features * self.weights\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n qvalues = <YOUR CODE>\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert (\\n len(qvalues.shape) == 2 and \\n qvalues.shape[0] == state_t.shape[0] and \\n qvalues.shape[1] == n_actions\\n )\\n\\n return qvalues\",\n \"def get_twin_q_values(self, observations):\\n return self.get_q_values(observations, twin_q=True)\",\n \"def forward(self, obs_variable, actions_variable):\\n state_action = torch.cat((obs_variable, actions_variable), 1)\\n q_val_variable = self.model(state_action)\\n\\n return q_val_variable\",\n \"def _getQvals(self, board):\\r\\n state = self._getState(board)\\r\\n # create the input to neural network\\r\\n toNN = [state[i-1] for i in range(1, self.inputSize)]\\r\\n toNN.insert(0, 0.0)\\r\\n # find expected rewards\\r\\n qVals = []\\r\\n for i in range(self.rowSize):\\r\\n toNN[0] = float(i)\\r\\n qVals.append(self.Q.calculate(toNN))\\r\\n return qVals\",\n \"def value(self, observation, prev_action, prev_reward):\\n model_inputs = buffer_to((observation, prev_action, prev_reward),\\n device=self.device)\\n _mu, _log_std, value = self.model(*model_inputs)\\n return value.to(\\\"cpu\\\")\",\n \"def calc_q_values_1(self, state):\\n return self._sess.run(self._q_pred_1,\\n feed_dict={self._state_placeholder:state});\",\n \"def get_q_values(self, state):\\n raise NotImplemented\",\n \"def get_q_values_op(self, state, scope, reuse=False):\\r\\n num_actions = self.env.action_space.n\\r\\n with tf.variable_scope(scope, reuse=reuse):\\r\\n return layers.fully_connected(layers.flatten(state), num_actions, activation_fn=None)\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n feature_dictionary = self.featExtractor.getFeatures(state, action)\\n\\n QValue = 0\\n for feature in feature_dictionary:\\n QValue += self.weights[feature] * feature_dictionary[feature]\\n return QValue\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n feature_dictionary = self.featExtractor.getFeatures(state, action)\\n\\n QValue = 0\\n for feature in feature_dictionary:\\n QValue += self.weights[feature] * feature_dictionary[feature]\\n return QValue\",\n \"def get_q_values(self, state, scope, reuse=False):\\n input_size, hidden_size, output_size, hidden_size_2 = self.input_size, self.hidden_size, self.output_size, self.config.hidden_size_2\\n with tf.variable_scope(scope):\\n x = state\\n w1 = self.init_weight(input_size, hidden_size, \\\"W1\\\")\\n b1 = tf.Variable(tf.zeros(hidden_size), \\\"b1\\\")\\n x = tf.add(tf.matmul(x, w1), b1)\\n x = tf.nn.relu(x)\\n\\n w2 = self.init_weight(hidden_size, output_size, \\\"W2\\\", scale = 0.1)\\n b2 = tf.Variable(tf.zeros(output_size), \\\"b2\\\")\\n x = tf.add(tf.matmul(x, w2), b2)\\n\\n # w2 = self.init_weight(hidden_size, hidden_size_2, \\\"W2\\\", scale = 0.1)\\n # b2 = tf.Variable(tf.zeros(hidden_size_2), \\\"b2\\\")\\n # x = tf.add(tf.matmul(x, w2), b2)\\n # x = tf.nn.relu(x)\\n\\n # w3 = self.init_weight(hidden_size_2, output_size, \\\"W3\\\", scale = 0.1)\\n # b3 = tf.Variable(tf.zeros(output_size), \\\"b3\\\")\\n # x = tf.add(tf.matmul(x, w3), b3)\\n return x, w1, w2\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n transition_state_probs = self.mdp.getTransitionStatesAndProbs(state, action)\\n # Add each state and probability to q_value\\n q_value = 0\\n for state_, probability in transition_state_probs:\\n state_reward = self.mdp.getReward(state, state_, action)\\n q_value += probability * (state_reward + self.discount * self.values[state_])\\n return q_value\",\n \"def compute_observation(self):\\n robotPos, robotOrn = p.getBasePositionAndOrientation(self.botId)\\n robotEuler = p.getEulerFromQuaternion(robotOrn)\\n linear, angular = p.getBaseVelocity(self.botId)\\n return (np.array([robotEuler[0],angular[0],self.vt], dtype='float32'))\",\n \"def get_qs(self, state):\\n state = state.astype(np.float32)\\n if len(state.shape) == 3:\\n state = state.reshape([1] + list(self.input_shape))\\n return self.session.run(self.q_policy,\\n feed_dict={self.s_placeholder: state})\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # OUR CODE HERE\\n #get the value of the state\\n qVal = self.values[state]\\n #iterate through the MDP transition states from the current state\\n for transitionState, probability in self.mdp.getTransitionStatesAndProbs(state, action):\\n #q value = discount * expected value of reward of state\\n qVal += self.discount * probability * self.values[transitionState]\\n return qVal\\n # END OUR CODE\",\n \"def getQValue(self, state, action):\\n \\\"\\\"\\\"Description:\\n [Enter a description of what you did here.]\\n Use first equation in slide 71 of MDP to compute q-value depond on weights and current features.\\n \\n !! But I think what I did is not work for IdentityExtractor. Because feature of IdentityExtrator always return 1,\\n it did not change even a ghost is closing.\\n \\\"\\\"\\\"\\n \\\"\\\"\\\" YOUR CODE HERE \\\"\\\"\\\"\\n # if weight is empty, then weight will need to initial to 1 for all features\\n # According to which Extractor user choose, weight counter will have equal number of keys.\\n if len(self.weight) == 0:\\n feat = self.featExtractor.getFeatures(state, action)\\n self.weight.incrementAll(feat.keys(), 1)\\n \\n qValue = self.weight * self.featExtractor.getFeatures(state,action)\\n return qValue\\n \\\"\\\"\\\" END CODE \\\"\\\"\\\"\",\n \"def computeQValueFromValues(self, state, action):\\n #get the Transition function and nextStates\\n state_prob_pair=self.mdp.getTransitionStatesAndProbs(state,action)\\n #initialize the value to zero\\n actual_value=0\\n #iterate over probabilities (transition functions) and next states\\n for pair in state_prob_pair:\\n #compute qvalue\\n actual_value+=pair[1]*(self.mdp.getReward(state,action,pair[0])+self.discount*self.values[pair[0]])\\n #print \\\"The Q value is \\\",actual_value\\n return actual_value\",\n \"def getQvalue(self, state, action):\\n featureVector = self.getFeatures(state, action)\\n qValue = 0\\n for k in featureVector.keys():\\n qValue = qValue + self.weights[k] * featureVector[k]\\n\\n return qValue\",\n \"def computeQValueFromValues(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n qValue = 0\\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\\n #print('Transitions: ' + str(transitions))\\n for t in transitions:\\n nextState, prob = t\\n reward = self.mdp.getReward(state, action, nextState)\\n #print('Reward: ' + str(reward))\\n oneTransition = prob * (reward + self.discount * self.values[nextState])\\n qValue = qValue + oneTransition\\n return qValue\",\n \"def get_q_values(self, state, network):\\n out = None\\n state = state.permute(0, 3, 1, 2)\\n #pdb.set_trace()\\n ##############################################################\\n ################ YOUR CODE HERE - 4-5 lines lines ################\\n if network == 'q_network':\\n out = self.q_network(state)\\n else:\\n out = self.target_network(state)\\n ##############################################################\\n ######################## END YOUR CODE #######################\\n return out\",\n \"def get_target_q_values(\\n self, next_states: torch.Tensor, rewards: torch.Tensor, dones: torch.Tensor\\n ) -> torch.Tensor:\\n return ddqn_q_target(self, next_states, rewards, dones)\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # print \\\"GETQVALUE in QLEARNINGAGENT, QVALUE: \\\",self.Q[(state, action)]\\n\\n return self.Q[(state, action)]\\n\\n\\n util.raiseNotDefined()\",\n \"def computeQValueFromValues(self, state, action):\\n\\n ##util.raiseNotDefined()\\n #\\\"*** YOUR CODE STARTS HERE ***\\\"\\n # Code to remove --- from here\\n transitions = self.mdp.getTransitionStatesAndProbabilities(state, action)\\n qvalue = 0\\n for (nextState, probability) in transitions:\\n reward = self.mdp.getReward(state, action, nextState)\\n qvalue += probability *(reward + self.discount*self.values[nextState])\\n # Code to remove --- to here\\n #\\\"*** YOUR CODE FINISHES HERE ***\\\"\\n \\n return qvalue\",\n \"def compute_Q_value(self, phi, act) -> float:\\n q_vec = phi @ self.Wq\\n return q_vec[act]\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n conved_1 = self.conv1(state_t)\\n conved_2 = self.conv2(conved_1)\\n conved_3 = self.conv3(conved_2)\\n qvalues = self.dense(conved_3)\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert len(\\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == n_actions\\n\\n return qvalues\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n qvalues = self.network(state_t)\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert len(\\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\\n\\n return qvalues\",\n \"def value_iteration(env):\\n Qvalues = torch.zeros(NUM_STATES)\\n\\n max_iterations = 100\\n mse = []\\n for _ in range(max_iterations):\\n Vtemp = torch.zeros(NUM_STATES)\\n # for each state we search for best move\\n for st in range(NUM_STATES):\\n max_value, _ = next_step_evaluation(env, st, Qvalues)\\n #Qvalues[st] = max_value.item()\\n Vtemp[st] = max_value.item()\\n mse.append(((Qvalues-Vtemp)**2).mean())\\n Qvalues = Vtemp\\n\\n return Qvalues, mse\",\n \"def calc_q_values(self, state):\\n return self.q_values_func([state])[0]\",\n \"def act(self, state, epsilon, env):\\n if random.random() > epsilon:\\n state = Variable(torch.FloatTensor(state)).unsqueeze(0) # adds extra dim when single input\\n state = self.vari_gpu(state)\\n _, u_opt = self.forward(state)\\n action = (u_opt.cpu().detach().numpy()) # compute the u*[0] \\n #print('act:q_value ',q_value)\\n #print('act:model action ',action)\\n else:\\n rand = np.random.rand(int(np.array(env.action_space.shape)))\\n high = env.action_space.high\\n low = env.action_space.low\\n action = low + rand*(high-low)\\n #print('act: ',action)\\n return action\",\n \"def getObservation(self):\\n res = zeros(4)\\n all = self.env.getSensors()\\n res[0] = all[3]\\n res[1] = all[1]\\n res[2] = all[3] and all[1]\\n res[3] = not all[3] and not all[1]\\n return res\",\n \"def getObservation(self):\\n sensors = self.env.getSensors()\\n if self.sensor_limits:\\n sensors = self.normalize(sensors)\\n return sensors\",\n \"def get_tf_t_vals(sess):\\n return sess.run(\\n TfUtils.get_tf_t_vars(sess)\\n )\",\n \"def calc_q_values(self, state, Q, flag):\\n\\n if flag == 0:\\n self.train_data = np.concatenate([st.state for st in state])\\n return Q.predict_on_batch(self.train_data)\\n elif flag == 1:\\n return Q.predict_on_batch(np.concatenate([st.next_state for st in state]))\",\n \"def get_state_observed_values(self):\\n obsState = numpy.zeros(self.get_num_variables())\\n i = 0\\n for v in self.variables:\\n obsState[i] = v.read_value_in_fmu(self.fmu)\\n i += 1\\n return obsState\",\n \"def _build_target_q_op(self):\\n targets = []\\n for gamma, target_q in zip(self.gammas,\\n self._replay_next_target_net_outputs.q_values):\\n # Get the maximum Q-value across the actions dimension.\\n replay_next_qt_max = tf.reduce_max(target_q, 1)\\n\\n # Calculate the Bellman target value.\\n # Q_t = R_t + \\\\gamma^N * Q'_t+1\\n # where,\\n # Q'_t+1 = \\\\argmax_a Q(S_t+1, a)\\n # (or) 0 if S_t is a terminal state,\\n # and\\n # N is the update horizon (by default, N=1).\\n cumulative_gamma = math.pow(gamma, self.update_horizon)\\n n_step_reward = self._build_discounted_n_step_rewards(gamma)\\n targets.append(n_step_reward + cumulative_gamma * replay_next_qt_max *\\n (1. - tf.cast(self._replay.terminals, tf.float32)))\\n return targets\",\n \"def forward(self, state_t):\\n # Use your network to compute qvalues for given state\\n conved_features = self.conv_layers(state_t)\\n A = self.head_A(conved_features)\\n V = self.head_V(conved_features).repeat(1, self.n_actions)\\n mean_A = torch.mean(A, dim=-1, keepdim=True).repeat(1, self.n_actions)\\n qvalues = A + V - mean_A\\n\\n assert qvalues.requires_grad, \\\"qvalues must be a torch tensor with grad\\\"\\n assert len(\\n qvalues.shape) == 2 and qvalues.shape[0] == state_t.shape[0] and qvalues.shape[1] == self.n_actions\\n\\n return qvalues\",\n \"def jval(self):\\n return self.q * self.model.nobs_moms\",\n \"def getQValue(self, state, action):\\n features = self.featExtractor.getFeatures(state, action)\\n total = 0\\n for feat in features:\\n total += self.getWeights()[feat] * features[feat]\\n return total\",\n \"def q(self):\\n return self.model.gmmobjective(self.params, self.weights)\",\n \"def t(self: Q) -> np.array:\\n\\n return np.array([self.t])\",\n \"def computeQValueFromValues(self, state, action):\\r\\n #\\r\\n weightedVfvsSum = 0\\r\\n reward = 0\\r\\n # to get possible next state(s)\\r\\n for nextState, prob in self.mdp.getTransitionStatesAndProbs(state, action):\\r\\n reward += self.mdp.getReward(state, action, nextState) * prob\\r\\n #print \\\":computeQValueFromValues: nextState is: \\\", nextState, \\\" | self.values[nextState] is: \\\", self.values[nextState]\\r\\n weightedVfvsSum += prob * self.getValue(nextState)\\r\\n #\\r\\n return ( reward + ( self.discount * weightedVfvsSum) ) # making the actual qvalue\\r\",\n \"def computeQValueFromValues(self, state, action):\\n #get all possible actions from current state\\n possibleActions = self.mdp.getPossibleActions(state)\\n\\n #if action is illegal return 0\\n if action in possibleActions:\\n transitions = self.mdp.getTransitionStatesAndProbs(state, action)\\n returnVal = 0\\n index = 0\\n\\n #loop through all trainsitions/probabilities\\n while index < len(transitions):\\n #This returns s' and T(s, a, s')\\n (nextState, prob) = transitions[index]\\n\\n\\n #This returns R(s,a,s')\\n rewardVal = self.mdp.getReward(state, action, nextState)\\n\\n #This is gamma * V(s')\\n lastPartOfEquation = self.values[nextState] *self.discount\\n\\n #This is T(s, a, s')[R(s, a, s') + gamma * V(s'). Bellman equation\\n returnVal = returnVal + prob * (rewardVal + lastPartOfEquation)\\n index = index + 1\\n\\n return returnVal\\n else:\\n return 0\",\n \"def _get_obs(self):\\n pos = []\\n z = []\\n for i in range(params['memory_size']):\\n if self._step - i * params['memory_size'] > 1:\\n pos.append(self._track_item['joint_pos'][self._step - i * params['memory_size'] - 1].copy())\\n z.append(self._track_item['z'][self._step - i * params['memory_size'] - 1].copy())\\n else:\\n pos.append(self._track_item['joint_pos'][0].copy())\\n if len(self._track_item['z']) < 1:\\n z.append(self.z.copy())\\n else:\\n z.append(self._track_item['z'][0].copy())\\n out = pos\\n if params['observation_version'] == 1:\\n out += z\\n ob = {\\n 'observation' : np.concatenate(out, -1),\\n 'desired_goal' : self.desired_goal.copy(),\\n 'achieved_goal' : self.achieved_goal.copy(),\\n 'z' : self.z.copy()\\n }\\n return ob\",\n \"def _model(self, scope):\\n\\n with tf.variable_scope(scope):\\n\\n act = tf.nn.elu\\n initializer = tfcl.variance_scaling_initializer()\\n xs = tf.layers.dense(self.state, 400, act, kernel_initializer=initializer)\\n xs = tf.layers.dense(xs, 300, None, kernel_initializer=initializer)\\n\\n xa = tf.layers.dense(self._action, 400, act, kernel_initializer=initializer)\\n xa = tf.layers.dense(xa, 300, None, kernel_initializer=initializer)\\n\\n x = tf.nn.elu(xa + xs)\\n\\n q_value = tf.layers.dense(x, 1, None, kernel_initializer=initializer)\\n\\n return q_value\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n # print \\\"getQValue\\\"\\n features = self.featExtractor.getFeatures(state, self.index)#.values()\\n #weights = self.weights.values()\\n #dotProduct = reduce( (lambda x, y: x*y), map( (lambda x, y: x+y), self.weights, features))\\n #return dotProduct\\n score = 0\\n for key in features.keys():\\n score += features[key]*self.weights[key]\\n return score\",\n \"def select_q_values_by_action(q_values, actions):\\n return tf.reduce_sum(\\n q_values * tf.one_hot(actions, q_values.get_shape()[1]),\\n axis=1\\n )\",\n \"def computeQValueFromValues(self, state, action):\\n # assign q value to 0\\n qvalue = 0\\n\\n # get the possible transition states and actions\\n possible_tansition = self.mdp.getTransitionStatesAndProbs(state, action)\\n\\n # for each transition in list of possible transitions\\n # transition[0] has the successor state (s-prime) represented in co-ordinates\\n for transition in possible_tansition:\\n\\n # calculate reward transition\\n reward = self.mdp.getReward(state, action, transition[0])\\n\\n # transition[1] has the probablity of reaching a particular successor state (s-prime) from state, action pair\\n probability = transition[1]\\n\\n # get the utility value from tansition[0] which has successor state represented in coordinates\\n utility_value = self.getValue(transition[0])\\n\\n # compute q value collectively using reward and probability transition\\n qvalue = qvalue + (probability * (reward + (self.discount * utility_value)))\\n\\n # return q value\\n return qvalue\",\n \"def get_all_state_action_values(self, state):\\n return torch.tensor([[self.get_state_action_value(state, action) for action in range(self.action_space.n)]]).float()\",\n \"def call(self, obs):\\n\\t\\tx = tf.convert_to_tensor(obs)\\n\\t\\thidden_logs = self.hidden1(x)\\n\\t\\thidden_vals = self.hidden2(x)\\n\\t\\treturn self.logits(hidden_logs), self.value(hidden_vals)\",\n \"def forward(self, prev_state, obs_t):\\r\\n # Use your network to compute qvalues for given state\\r\\n #print(state_t.shape)\\r\\n h = self.conv(obs_t)\\r\\n\\r\\n h = h.view(h.size(0), -1)\\r\\n\\r\\n new_state = h_new, c_new = self.lstm(h, prev_state)\\r\\n advantage = self.adv(h_new)\\r\\n value = self.val(h_new)\\r\\n\\r\\n\\r\\n adv_mean = torch.mean(advantage, dim=1, keepdim=True)\\r\\n qvalues = value + advantage - adv_mean\\r\\n\\r\\n return new_state, qvalues\",\n \"def _get_obs(self):\\n return self.observation_function[self.cur_state]\",\n \"def vvalue(self) -> Qval:\\n return self.with_batch_dim(self.q_values).max(1).values\",\n \"def get_observation(self , reward = False):\\n\\t\\t# magnetic_ends ****\\n\\t\\topen_magnetic_ends = rnadc.count_magnetic_ends(graph = self._state._graph)\\n\\t\\t# sequence_length difference factor\\n\\t\\tinstance_counter, seq_length = self._state.get_state_counters()\\n\\t\\tseq_length_difference = abs(seq_length - self._state._seq_length_threshold)\\n\\t\\t# composability factor\\n\\t\\tif reward:\\n\\t\\t\\treturn open_magnetic_ends , seq_length_difference\\n\\t\\telse:\\n\\t\\t\\treturn [open_magnetic_ends] + [seq_length_difference] + self.get_action_history()\",\n \"def action_value(self, obs):\\n\\t\\tlogits, value = self.predict_on_batch(obs)\\n\\t\\taction = self.dist.predict_on_batch(logits)\\n\\t\\treturn np.squeeze(action, axis=-1), np.squeeze(value, axis=-1)\",\n \"def get_action_value(mdp, state_values, state, action, gamma):\\n\\n Q = 0\\n # YOUR CODE HERE\\n return Q\",\n \"def computeQValueFromValues(self, state, action):\\n\\n # Find expected utility of making this move\\n x = 0\\n for t in self.mdp.getTransitionStatesAndProbs(state,action):\\n x += t[1] * self.getValue(t[0])\\n\\n\\n # Return Reward + discounted expected utility\\n return self.mdp.getReward(state,None,None) + self.discount*x\",\n \"def calculate_q_vals(self, rews_list):\\n\\n # Case 1: trajectory-based PG \\n if not self.reward_to_go:\\n\\n # TODO: Estimate the Q value Q^{pi}(s_t, a_t) using rewards from that entire trajectory\\n # HINT1: value of each point (t) = total discounted reward summed over the entire trajectory (from 0 to T-1)\\n # In other words, q(s_t, a_t) = sum_{t'=0}^{T-1} gamma^t' r_{t'}\\n # Hint3: see the helper functions at the bottom of this file\\n q_values = np.concatenate([self._discounted_return(r) for r in rews_list])\\n\\n # Case 2: reward-to-go PG \\n else:\\n\\n # TODO: Estimate the Q value Q^{pi}(s_t, a_t) as the reward-to-go\\n # HINT1: value of each point (t) = total discounted reward summed over the remainder of that trajectory\\n # (from t to T-1)\\n # In other words, q(s_t, a_t) = sum_{t'=t}^{T-1} gamma^(t'-t) * r_{t'}\\n # Hint3: see the helper functions at the bottom of this file\\n q_values = np.concatenate([self._discounted_cumsum(r) for r in rews_list])\\n\\n return q_values.astype(np.float32)\",\n \"def computevaluefromqvalues(self, state):\\n legalactions = env.getlegalactions(deepcopy(env.state_to_array(state)))\\n if len(legalactions) == 0:\\n return 0.0\\n tmp = Counter()\\n for action in legalactions:\\n tmp[action] = self.getqvalue(state, action)\\n return tmp[tmp.argMax()]\",\n \"def computeQValueFromValues(self, state, action):\\n newState_prob = self.mdp.getTransitionStatesAndProbs(state, action)\\n sum = 0\\n for i in newState_prob:\\n sum += i[1]*(self.mdp.getReward(state, action, i[0])+(self.discount*self.getValue(i[0])))\\n return sum \\n \\n util.raiseNotDefined()\",\n \"def getqvalue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n if (state, action) not in self.qvals:\\n self.qvals[(state, action)] = 0.0\\n return self.qvals[(state, action)]\",\n \"def mc_policy_evaluation(env, policy, Q_value, n_visits, gamma=0.9):\\n nS = env.nS # number of states\\n nA = env.nA # number of actions\\n episode = generate_episode(env, policy)\\n # print(episode)\\n returns = generate_returns(episode, gamma=gamma)\\n # print(returns)\\n visit_flag = np.zeros((nS, nA))\\n ############################\\n # YOUR IMPLEMENTATION HERE #\\n \\n for i in range(0, len(episode)): #for each state,action,reward in the episode\\n # print(\\\"sub episode: i = \\\" + str(i))\\n s_t, a_t, r_t = episode[i] \\n \\n if visit_flag[s_t, a_t] == 0: # if the current state, action has not been visited previously in this episode\\n # print(\\\"state: \\\" + str(s_t) + \\\", action: \\\" + str(a_t))\\n # print(\\\"Q = \\\" + str(Q_value))\\n # print(\\\"returns = \\\" + str(returns))\\n \\n visit_flag[s_t, a_t] = 1 # set flag to 1 (so we don't revisit the state again in this episode)\\n n_visits[s_t, a_t] += 1 # increase the total number of visits to the state in ALL episodes\\n Q_value[s_t,a_t] = Q_value[s_t,a_t] + 1/n_visits[s_t, a_t] * (returns[i] - Q_value[s_t,a_t]) # update Q value\\n\\n ############################\\n return Q_value, n_visits\",\n \"def computeQValueFromValues(self, state, action):\\n \\n \\n next_states_probs = self.mdp.getTransitionStatesAndProbs(state, action)\\n # liste des recompenses R(s,a,s')\\n rewards = []\\n # liste des probas de transitions P(s'|a,s)\\n probs = []\\n # liste des Vk(s')\\n previous_values = []\\n # occurence[0] = les next_state\\n # occurence[1] = les proba de transi\\n for occurence in next_states_probs:\\n rewards.append(self.mdp.getReward(state, action, occurence[0]))\\n probs.append(occurence[1])\\n previous_values.append(self.getValue(occurence[0]))\\n Q_value = 0\\n # boucle qui calcule somme des ( P(s'|a,s) * [R(s,a,s') + gamma * Vk(s')] ) sur les s'\\n for i in range(len(probs)):\\n Q_value += probs[i] * (rewards[i] + self.discount * previous_values[i])\\n \\n return Q_value\\n util.raiseNotDefined()\",\n \"def all_q_variables(self):\\n\\n return self.main_q_variables() + (self.twin_q_variables() if self.twin_q_net else [])\",\n \"def Values(self) -> _n_1_t_4:\",\n \"def get_action(self, obs):\\n q = self.sess.run(self._qvals, feed_dict={self._observation: obs})\\n max_a = np.argmax(q, axis=1)\\n\\n # Epsilon greedy method.\\n global_step = self.sess.run(tf.train.get_global_step())\\n batch_size = obs.shape[0]\\n actions = np.random.randint(self._dim_act, size=batch_size)\\n idx = np.random.uniform(size=batch_size) > self._epsilon_schedule(global_step)\\n actions[idx] = max_a[idx]\\n return actions\",\n \"def getQValue(self, state, action):\\n \\\"*** YOUR CODE HERE ***\\\"\\n Q_Value = self.Q\\n\\n if (state,action) not in Q_Value: #Checks if state is present in dictionary or not, basically if we have ever seen a state or not\\n\\n Q_Value[(state,action)]= 0.0 #Put value as zero because we have not seen the state as if now\\n\\n\\n return Q_Value[(state,action)] #Returns Q node value\\n #util.raiseNotDefined()\",\n \"def batch_q_learning(self):\\n\\n if(self.memory.get_usage() > Parameters.AGENT_HISTORY_LENGTH):\\n\\n state_t, action, reward, state_t_plus_1, terminal, i_s_weights, memory_indices = self.memory.bring_back_memories()\\n\\n q_t_plus_1 = self.tf_session.run(\\n self.target_dqn.q_values, {\\n self.target_dqn_input: state_t_plus_1})\\n max_q_t_plus_1 = np.max(q_t_plus_1, axis=1)\\n\\n target_q_t = (1. - terminal) * \\\\\\n Parameters.DISCOUNT_FACTOR * max_q_t_plus_1 + reward\\n\\n _, q_t, losses = self.tf_session.run([self.dqn.optimize, self.dqn.q_values, self.dqn.errors],\\n {\\n self.dqn.target_q: target_q_t,\\n self.dqn.action: action,\\n self.dqn_input: state_t,\\n self.dqn.i_s_weights: i_s_weights\\n })\\n\\n self.memory.update(\\n memory_indices,\\n np.squeeze(q_t),\\n losses,\\n self.get_learning_completion())\\n input_shape = (1, Parameters.IMAGE_HEIGHT, Parameters.IMAGE_WIDTH, Parameters.AGENT_HISTORY_LENGTH)\\n dqn_input = self.environment.get_input().reshape(input_shape)\\n q_values = self.tf_session.run(\\n self.dqn.q_values, {\\n self.dqn_input: dqn_input})\\n Plotter.add_q_values_at_t(q_values)\\n else:\\n print('[WARNING] Not enough memory for a batch')\",\n \"def getQValue(self, state, action):\\n position = self.computePosition(state)\\n action_column = self.columAction[action]\\n\\n return self.q_table[position][action_column]\",\n \"def observation_value(self):\\n pass\",\n \"def avf_values(env, num_optimization_steps=1000, num_tasks=50,\\n tf_device='/cpu:*'):\\n num_states = env.num_states\\n num_actions = env.num_actions\\n # Construct compatible P matrix, with action at the end, and assuming\\n # deterministic transitions.\\n p = np.transpose(env.transition_probs, [0, 2, 1])\\n r = env.rewards\\n sess = tf.Session()\\n # deltas: probe vector, num_tasks x num_states-dimensional.\\n deltas = np.random.random((num_tasks, num_states)) * 2.0 - 1.0\\n with tf.device(tf_device):\\n dummy = tf.constant(np.array([[1.0]]), dtype=tf.float32)\\n model = tf.keras.Sequential()\\n model.add(tf.keras.layers.Dense(num_tasks * num_states * num_actions))\\n logits = model(dummy)\\n logits = tf.reshape(logits, [num_tasks, num_states, num_actions])\\n policy = tf.nn.softmax(logits)\\n expanded_policy = tf.expand_dims(policy, axis=-1)\\n tiled_p = np.tile(p, [num_tasks, 1, 1, 1])\\n tiled_p *= np.float64(env.gamma) # Precompute P as much as possible.\\n expanded_policy = tf.cast(expanded_policy, tf.float64)\\n ppi = tf.matmul(tiled_p, expanded_policy)\\n ppi = tf.reshape(ppi, (num_tasks, num_states, num_states))\\n tiled_eye = np.tile(np.eye(num_states), [num_tasks, 1, 1])\\n # tiled_eye - Ppi is k x n x n, the last two dimensions are inverted.\\n # Note discount factor has been incorporated above.\\n resolvent = tf.linalg.inv(tiled_eye - ppi)\\n r = np.expand_dims(r, axis=1) # Make rewards row vectors.\\n r = np.tile(r, [num_tasks, 1, 1, 1])\\n rpi = tf.matmul(r, expanded_policy) # Expected reward.\\n rpi = tf.reshape(rpi, (num_tasks, num_states, 1)) # Drop last dimension.\\n value_func = tf.matmul(resolvent, rpi)\\n # Deltas should be k x n, make k x 1 x n (row vectors).\\n deltas = np.expand_dims(deltas, axis=1)\\n deltas = tf.constant(deltas, dtype=tf.float64)\\n loss = -tf.matmul(deltas, value_func)\\n optimizer = tf.train.AdamOptimizer(\\n learning_rate=0.1, epsilon=0.0003125)\\n loss = tf.reduce_sum(loss)\\n train_op = optimizer.minimize(loss)\\n sess.run(tf.initializers.global_variables())\\n for _ in range(num_optimization_steps):\\n sess.run([loss, train_op])\\n vf_output = sess.run(value_func)\\n return vf_output\",\n \"def get(self):\\n if now()-self.last_query < 1./self.query_rate:\\n return None,None\\n self.last_query = now()\\n\\n # query from saver (an old strategy that may be desired at points): \\n #self.saver.query_flag.value = True\\n #fr = mp2np(self.saver.query_queue)\\n #frts = self.saver.query_queue_ts.value\\n \\n # query from _PSEye (a newer strategy that is preferable for most uses):\\n self.pseye.query_flag.value = True\\n while self.pseye.query_flag.value == True:\\n pass\\n fr = self.pseye.query_queue[0]\\n frts = self.pseye.query_queue_ts.value\\n\\n x,y = self.resolution[self.query_idx]\\n return frts,fr.reshape([y,x])\",\n \"def computeQValueFromValues(self, state, action):\\n totalsum = 0\\n reward = 0\\n for nextstate, transition in self.mdp.getTransitionStatesAndProbs(state, action):\\n reward = self.mdp.getReward(state, action, nextstate)\\n totalsum += transition * (reward + self.discount * self.getValue(nextstate)) # right way to access previous value?\\n return totalsum\",\n \"def __call__(self, state, observation, agent_info=None, history=None):\\n B = observation.n_elems()\\n\\n _mean, _var = self.model(observation[\\\"frame\\\"])\\n _id = torch.eye(self.action_dim).unsqueeze(0).repeat(B, 1, 1)\\n\\n distribution = torch.distributions.Normal(_mean, _var)\\n action_sampled = distribution.sample()\\n action_max = _mean\\n smask = (\\n agent_info[\\\"stochastic\\\"].float().unsqueeze(-1).repeat(1, self.action_dim)\\n )\\n action = action_sampled * smask + (1.0 - smask) * action_max\\n\\n agent_do = DictTensor({\\\"action\\\": action, \\\"mean\\\": _mean, \\\"std\\\": _var})\\n state = DictTensor({})\\n return agent_do, state\",\n \"def predict_Q(self, state, action):\\r\\n state = np.reshape(state, (-1, self.feature_number))\\r\\n action = np.reshape(action, (-1, self.action_space))\\r\\n Q_value = self.critic.predict([state, action])\\r\\n return Q_value\",\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]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75412387","0.7281996","0.71252626","0.69886816","0.6963875","0.6963875","0.69577503","0.68997633","0.65830016","0.6473342","0.6445998","0.64198893","0.63429874","0.6339201","0.63150895","0.63051134","0.63030916","0.6275476","0.62655336","0.6251307","0.62018985","0.61683613","0.61683613","0.61276484","0.6111008","0.6110557","0.6078945","0.6063605","0.60610545","0.6057232","0.60488385","0.6004835","0.5993625","0.599069","0.599069","0.5990534","0.5973102","0.59294224","0.59053737","0.5895711","0.58752537","0.58678097","0.5865514","0.5836993","0.5832465","0.5830414","0.58133626","0.5808276","0.5752613","0.5748112","0.57467425","0.5731074","0.5714219","0.5687453","0.5686056","0.56841","0.5678986","0.56698287","0.564575","0.5639617","0.56382537","0.56061715","0.5584896","0.55760825","0.55670273","0.55616283","0.5539609","0.55261576","0.55204564","0.5508533","0.5502895","0.5489875","0.5485293","0.5482832","0.54783416","0.54750866","0.54746056","0.5470787","0.54626566","0.5460694","0.5450394","0.5443357","0.54296595","0.5422255","0.5421802","0.5413352","0.5412613","0.5412066","0.5398521","0.53937054","0.5393451","0.5374001","0.53593373","0.53577167","0.5357712","0.5352777","0.53491","0.53473157","0.534609","0.5345996"],"string":"[\n \"0.75412387\",\n \"0.7281996\",\n \"0.71252626\",\n \"0.69886816\",\n \"0.6963875\",\n \"0.6963875\",\n \"0.69577503\",\n \"0.68997633\",\n \"0.65830016\",\n \"0.6473342\",\n \"0.6445998\",\n \"0.64198893\",\n \"0.63429874\",\n \"0.6339201\",\n \"0.63150895\",\n \"0.63051134\",\n \"0.63030916\",\n \"0.6275476\",\n \"0.62655336\",\n \"0.6251307\",\n \"0.62018985\",\n \"0.61683613\",\n \"0.61683613\",\n \"0.61276484\",\n \"0.6111008\",\n \"0.6110557\",\n \"0.6078945\",\n \"0.6063605\",\n \"0.60610545\",\n \"0.6057232\",\n \"0.60488385\",\n \"0.6004835\",\n \"0.5993625\",\n \"0.599069\",\n \"0.599069\",\n \"0.5990534\",\n \"0.5973102\",\n \"0.59294224\",\n \"0.59053737\",\n \"0.5895711\",\n \"0.58752537\",\n \"0.58678097\",\n \"0.5865514\",\n \"0.5836993\",\n \"0.5832465\",\n \"0.5830414\",\n \"0.58133626\",\n \"0.5808276\",\n \"0.5752613\",\n \"0.5748112\",\n \"0.57467425\",\n \"0.5731074\",\n \"0.5714219\",\n \"0.5687453\",\n \"0.5686056\",\n \"0.56841\",\n \"0.5678986\",\n \"0.56698287\",\n \"0.564575\",\n \"0.5639617\",\n \"0.56382537\",\n \"0.56061715\",\n \"0.5584896\",\n \"0.55760825\",\n \"0.55670273\",\n \"0.55616283\",\n \"0.5539609\",\n \"0.55261576\",\n \"0.55204564\",\n \"0.5508533\",\n \"0.5502895\",\n \"0.5489875\",\n \"0.5485293\",\n \"0.5482832\",\n \"0.54783416\",\n \"0.54750866\",\n \"0.54746056\",\n \"0.5470787\",\n \"0.54626566\",\n \"0.5460694\",\n \"0.5450394\",\n \"0.5443357\",\n \"0.54296595\",\n \"0.5422255\",\n \"0.5421802\",\n \"0.5413352\",\n \"0.5412613\",\n \"0.5412066\",\n \"0.5398521\",\n \"0.53937054\",\n \"0.5393451\",\n \"0.5374001\",\n \"0.53593373\",\n \"0.53577167\",\n \"0.5357712\",\n \"0.5352777\",\n \"0.53491\",\n \"0.53473157\",\n \"0.534609\",\n \"0.5345996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.64679205"},"document_rank":{"kind":"string","value":"10"}}},{"rowIdx":88370,"cells":{"query":{"kind":"string","value":"assign target_network.weights variables to their respective agent.weights values."},"document":{"kind":"string","value":"def load_weigths_into_target_network(self):\n logging.debug(\"Transfer Weight!\")\n self.network.save_weights(self._save_path)\n self.target_network.load_weights(self._save_path)"},"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 update_target_network(self):\n self.target.set_weights(self.policy.get_weights()) # Update weights of target network with weights of policy network","def transfer_weights(self):\n W, target_W = self.model.get_weights(), self.target_model.get_weights()\n for i in range(len(W)):\n target_W[i] = self.tau * W[i] + (1 - self.tau)* target_W[i]\n self.target_model.set_weights(target_W)","def _update_target_model(self):\n self.target_network.model.set_weights(self.policy_network.model.get_weights())","def _set_weights(self, weights):\r\n self.weights = weights.reshape(self.output_size, self.input_size+1)","def update_target_network(self):\n self.target_dqn.set_weights.remote(self.dqn.get_weights.remote())","def _weights_for_target(self, target):\n\n self._update_global_transform(target)\n projected_target = self.global_transform.pseudoinverse().apply(target)\n # now we have the target in model space, project it to recover the\n # weights\n new_weights = self.model.project(projected_target)\n # TODO investigate the impact of this, could be problematic\n # the model can't perfectly reproduce the target we asked for -\n # reset the global_transform.target to what it CAN produce\n #refined_target = self._target_for_weights(new_weights)\n #self.global_transform.target = refined_target\n return new_weights","def adjust_weights(weights, target, learn_rate):\r\n\r\n for w in range(0, len(target)):\r\n weights[w] += learn_rate * (target[w] - weights[w])","def set_weights(self, weights):\r\n self.weights = weights","def reassignWeights(self,weights):\n\t\n\t\tbranches = self.collectAllBranches()\n\n\t\tfor i in range(self.nBranches):\n\n\t\t\tbranches[i].weight = weights[i]","def setweights(self, weights):\n # I call it weights because it is the relative weights of the atoms, not\n # because I'm confusing weight and mass\n self.weights = weights\n self.totalweight = numpy.sum(weights)","def set_weights(self, weights):\n self._weights = weights\n self.normalize_weights() ########################added\n #self.get_weights()","def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())","def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())","def update_target_model(self):\n self.target_model.set_weights(self.model.get_weights())","def update_weights(self):\n self._weights = self._weights + self.update_weights_value","def update_weights(self):\r\n\r\n inedges=self.in_edges\r\n for edge in inedges:\r\n weight=edge.weight+self.learning_rate*self.delta*(edge.source.activation)\r\n edge.change_weight(weight)","def _set_weights(self):\n self.Wc = torch.mm(self.TP.T, self.W).mm(self.TP)","def soft_update_target_network(self):\n \n pars_behavior = self.model.get_weights() # these have form [W1, b1, W2, b2, ..], Wi = weights of layer i\n pars_target = self.target_model.get_weights() # bi = biases in layer i\n \n ctr = 0\n for par_behavior,par_target in zip(pars_behavior,pars_target):\n par_target = par_target*(1-self.tau) + par_behavior*self.tau\n pars_target[ctr] = par_target\n ctr += 1\n\n self.target_model.set_weights(pars_target)","def update_weights(self):\n\t\tpass","def soft_update_target_network(self):\n \n pars_behavior = self.model.get_weights() # these have form [W1, b1, W2, b2, ..], Wi = weights of layer i\n pars_target = self.target_model.get_weights() # bi = biases in layer i\n \n for par_behavior,par_target in zip(pars_behavior,pars_target):\n par_target = par_target*(1-self.tau) + par_behavior*self.tau\n pars_target[ctr] = par_target\n\n self.target_model.set_weights(pars_target)","def get_weights(self, nn_weights, rov_id): # Get weights from CCEA population\n\n for w in range(self.n_weights):\n self.weights[rov_id, w] = nn_weights[w]","def targets_weights_fn(self):\n return common_layers.weights_all","def hard_copy_weights(self, target, source):\n for target_param, param in zip(target.parameters(), source.parameters()):\n target_param.data.copy_(param.data)","def set_weights(self, weights: Dict[PolicyID, dict]):\n self.workers.local_worker().set_weights(weights)","def pull_weights(self, learning_rate):\n for w in self.weights:\n w.value += learning_rate * w.gradient\n # Reset all the weights' gradient to 0\n # We will not reset all other units' gradient, because all other units should be initialized in next training\n # round, and the init value of gradient is 0\n for w in self.weights:\n w.gradient = 0","def transfer_weights(\n self, new_model, new_optimizer=None, optimizer=None, ignore_weights=None\n ):\n if type(self) is not type(new_model):\n raise ValueError(\n \"Transferring weights to another model type is not supported\"\n )\n if ignore_weights is None:\n ignore_weights = set()\n ignore_weights_ref = set(weight.ref() for weight in ignore_weights)\n weights = self.weights\n new_weights = new_model.weights\n for weight, new_weight in zip(weights, new_weights):\n if new_weight.ref() not in ignore_weights_ref:\n new_weight.assign(weight)\n if new_optimizer is not None and optimizer is not None:\n for slot_name in new_optimizer.get_slot_names():\n if slot_name not in optimizer.get_slot_names():\n continue\n new_slot = new_optimizer.get_slot(new_weight, slot_name)\n slot = optimizer.get_slot(weight, slot_name)\n new_slot.assign(slot)","def update_weights(self):\n\n self.weights -= self.loss_grads\n self.loss_grads = np.zeros(self.weights.shape)","def weights(self, weights):\n\n self._weights = weights","def update_weights(self):\n self._weights = self._weights + self.update_weights_value\n self.weights_clipping()","def set_weights(self, weights):\n self.forcing_term.weights_[:, :] = weights.reshape(*self.forcing_term.shape)","def setWeights(self, w):\n raise NotImplementedError","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def set_weights(self, weights):\n tuples = []\n for layer in self.layers:\n num_param = len(layer.weights)\n layer_weights = weights[:num_param]\n for sw, w in zip(layer.weights, layer_weights):\n tuples.append((sw, w))\n weights = weights[num_param:]\n K.batch_set_value(tuples)","def init_weights(self) -> None:\n nn.init.kaiming_normal_(self._U)\n nn.init.kaiming_normal_(self._W)\n nn.init.kaiming_normal_(self._V)\n\n nn.init.normal_(self._b)","def set_weights(self, weights):\n self.model.set_weights(weights)","def _set_weights(self, weights):\n i = iter(weights)\n\n for param in self.params:\n param.set_value(i.next())","def _set_weights(self, weights):\n i = iter(weights)\n\n for param in self.params:\n param.set_value(i.next())","def _update_weights(self, xi, target):\n output = self.net_input(xi)\n error = (target - output)\n self.w_[1:] += self.eta * xi.dot(error)\n self.w_[0] += self.eta * error\n cost = 0.5 * error**2\n return cost","def _update_weights(self, xi, target):\n output = self.net_input(xi)\n error = (target - output)\n self.w_[1:] += self.eta * xi.dot(error)\n self.w_[0] += self.eta * error\n cost = 0.5 * error**2\n return cost","def init_weights(self):\n self._q_neuron.h(self._weights) \n self._q_neuron.x(self._weights)","def _update_weights(self, xi, target):\n output = self.net_input(xi)\n error= (target - output)\n self.w_[1:] += self.eta * xi.dot(error)\n self.w_[0] += self.eta * error\n cost =0.5* error**2\n return cost","def set_weights(self, w):\n self.nn.set_param_values(w)","def load_weights(self, weights):\n\n i = 0\n for l in range(1, self.num_layers()):\n for n in range(self.get_layer(l).num_nodes):\n for w in range(len(self.get_node_with_layer(l, n).weights)):\n self.get_node_with_layer(l, n).weights[w] = weights[i]\n i += 1","def copy_para(from_model, to_model):\n for i, j in zip(from_model.trainable_weights, to_model.trainable_weights):\n j.assign(i)","def _soft_update_target_network(self):\n\n # Update the target network\n for target_param, param in zip(self.actor_target_network.parameters(), self.actor_network.parameters()):\n target_param.data.copy_((1-self.args.tau) * target_param.data + self.args.tau * param.data)\n\n # Update the critic network\n for target_param, param in zip(self.critic_target_network.parameters(), self.critic_network.parameters()):\n target_param.data.copy_((1-self.args.tau) * target_param.data + self.args.tau * param.data)","def setWeightInitializer(self,weights):\n self.init_w = weights","def init_weights(self, load_weights=None):\n if load_weights:\n # TODO\n pass\n else:\n # x: lower layer nodes n\n # y: current layer nodes n\n x = self.weights_shape[1]\n y = self.weights_shape[0]\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member","def set_output_weights(self, weight_matrix):\n pass","def sync(net, net_tar):\n for var, var_tar in zip(net.trainable_weights,\n net_tar.trainable_weights):\n var_tar.assign(var)","def update_target_network(self):\n variables = self.online_network.trainable_variables\n variables_copy = [tf.Variable(v) for v in variables]\n self.target_network.trainable_variables = variables_copy","def initialize_weights(self):\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\n self._batch)","def get_hard_target_model_updates(target, source):\n target.set_weights(source.get_weights())\n\n return target","def initialize_weights(self):\n # compute lmda.\n self.lmda = float(self.c)/float(self.N)\n # bias term. This should not get a regularization penalty.\n self.bias = {}\n # weight vector\n self.w = {}\n # lastW[j] = k, indicates that feature j was last updated at time k.\n self.lastW = {}\n for lbl in self.labels:\n self.bias[lbl] = 0\n self.w[lbl] = {}\n self.lastW[lbl] = {}\n pass","def my_assign_weights(context, data):\n pass","def update_weights(self):\n activation, activation_p = self.feedforward()\n # initialize delta_weights\n delta_w = np.zeros(2)\n # simultaneous calculate delta_weights\n for i, element in enumerate(self.y):\n delta_w += (activation[i]-element)*(activation_p[i])*self.X[i]\n # update weight\n self.weights -= self.alfa*delta_w","def update_weights(self, X, Y, learning_rate):\n grads = self.calculate_gradients(X, Y)\n #update weights and biases\n self.weights[0] = self.weights[0] - learning_rate * grads[\"dW1\"]\n self.weights[1] = self.weights[1] - learning_rate * grads[\"dW2\"]\n self.biases[0] = self.biases[0] - learning_rate * grads[\"db1\"]\n self.biases[1] = self.biases[1] - learning_rate * grads[\"db2\"]","def init_weights(self):\n\n params = torch.load(self.resnet_weight)\n\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\n\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\n self.fc4.out_features)\n self.fc4.weight.data.uniform_(-r, r)\n self.fc4.bias.data.fill_(0)","def test_net_weight_update(self):\n nn = NeuralNet(0, 0, '', '', blank=True)\n nn.create_net(2, 1, 2, 2)\n nn.eta = 0.1\n\n # Override weights to static value for reproducibility\n for node in nn.layers[2].nodes:\n node.weights = [0.6, 0.6]\n\n for node in nn.layers[3].nodes:\n node.weights = [1.0, 1.0]\n\n nn.update_weights([2, 3], [0], test=True)\n\n test_weight = nn.layers[-1].nodes[0].weights[0]\n self.assertEqual(round(test_weight, 4), 0.9901)","def soft_update_actor(self):\n local_weights = np.array(self.actor_local.model.get_weights())\n target_weights = np.array(self.actor_target.model.get_weights())\n\n assert len(local_weights) == len(\n target_weights), ('Local and target model parameters must have '\n 'the same size')\n\n new_weights = self.tau * local_weights + (1 - self.tau) * target_weights\n self.actor_target.model.set_weights(new_weights)","def init_weights(model):\n ...","def _initialize_weights(self):\n pass","def updateWeights(inputs, outputs, learning_rate, y, weights):\n for i in range(len(weights)):\n weights[i] = weights[i] + learning_rate * (outputs - y) * inputs[i]\n return weights","def sync_target_network(self):\n for t, e in zip(\n self.target_network.trainable_variables, self.online_network.trainable_variables\n ):\n t.assign(e)","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def adjust_params(self, inputs, target_costs, original_costs):\n costs = self.measure_costs(inputs)\n weights = [(target_costs[i] - costs[i]) / (target_costs[i] - original_costs[i]) for i in range(target_costs)]\n totalweights = sum(weights)\n for i in range(weights):\n self.morphnet_target_cost_thresholds[i] = weights[i] / totalweights","def get_weights(self):\n # First part is iterating over hidden weights. Then append the output weight.\n return [self.hidden_layers[i].get_weight().cpu().detach().numpy() for i in range(self.depth)] + \\\n [self.output_weight.cpu().detach().numpy()]","def get_weights(self):\n # First part is iterating over hidden weights. Then append the output weight.\n return [self.hidden_layers[i].get_weight() for i in range(self.depth)] + \\\n [self.output_weight.cpu().detach().numpy()]","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)\n # Tie weights if needed\n self.tie_weights()","def set_weights(self, weights):\n\n self._cnn_model.set_weights(weights)","def update_target_network(self, tau):\n for t, e in zip(\n self.target_network.trainable_variables, self.online_network.trainable_variables\n ):\n t.assign(t * (1-tau) + e * tau)","def initialize_weights(self):\n for layer in self._cnn_layers:\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)","def init_weights(self):\n self.transformer.init_weights()\n if self.loss_cls.use_sigmoid:\n bias_init = bias_init_with_prob(0.01)\n for m in self.cls_branches:\n nn.init.constant_(m[-1].bias, bias_init)","def copy_weights(self):\n return copy.deepcopy(self.weights_ih), copy.deepcopy(self.weights_ho)","def update(self, weights, grads):\n learn_rate_t = self.learn_rate\n\n new_weights = []\n for w, g in zip(weights, grads):\n\n # Apply weight decay\n if w.shape[1] > 1:\n # Weight matrix\n g_t = learn_rate_t * (g + self.weight_decay * w)\n else:\n # Bias matrix\n g_t = learn_rate_t * g\n w_t = w - g_t\n new_weights.append(w_t)\n return new_weights","def initialize_weights(self):\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\n return w1, w2","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)","def set_weights(self, W):\r\n if self.weights.shape!=W.shape:\r\n return -1\r\n self.weights = W","def update_weights(self, weight_delta):\n\n self._weights = math_util.vector_sum(self._weights, weight_delta)","def setWeights(self, weights):\n self._call_java('setWeights', weights)","def set_weights(self, weights):\n params = self.weights\n if len(params) != len(weights):\n raise ValueError('You called `set_weights(weights)` on layer \"' +\n self.name + '\" with a weight list of length ' +\n str(len(weights)) + ', but the layer was expecting ' +\n str(len(params)) + ' weights. Provided weights: ' +\n str(weights)[:50] + '...')\n if not params:\n return\n weight_value_tuples = []\n param_values = K.batch_get_value(params)\n for pv, p, w in zip(param_values, params, weights):\n if pv.shape != w.shape:\n raise ValueError('Layer weight shape ' + str(pv.shape) +\n ' not compatible with '\n 'provided weight shape ' + str(w.shape))\n weight_value_tuples.append((p, w))\n K.batch_set_value(weight_value_tuples)","def reset_weights(self):\n self.policy_backbone.reset_weights()\n self.value_backbone.reset_weights()\n self.action_head.reset_weights()\n self.critic_head.reset_weights()","def normalizeWeights(self):\n for wt in self.weights:\n wt[wt>1] = 1\n wt[wt<-1] = -1\n for bs in self.bias:\n bs[bs>1] = 1\n bs[bs<-1] = -1","def init_variables():\n weights = np.random.normal(size=2)\n bias = 0\n return weights, bias","def _mutate_weights(self, weights):\n return weights + normal(loc=0, scale=self.standard_deviation, size=weights.shape[0])","def change_weight(self, new_weight_arr):\n self.weights = new_weight_arr","def update_weights(x_train, y_train, weights, learning_rate):\r\n predictions = compute_prediction(x_train, weights)\r\n weights_delta = np.dot(x_train.T, y_train - predictions)\r\n m = y_train.shape[0]\r\n weights += learning_rate / float(m) * weights_delta\r\n return weights","def reset_weights(self):\r\n self._weights = deepcopy(self._tmp_weights)\r\n self._tmp_weights = None","def init_weights(self):\n with torch.no_grad():\n self._init_weights()","def _create_weights(self):\n gate_size = self._hidden_size * self._num_gates\n # Compute the shape of weight and bias.\n matrix_shapes, bias_shapes = [], []\n for layer in range(self._num_layers):\n for direction in range(self._num_directions):\n layer_input_size = self._input_size if layer == 0 \\\n else self._hidden_size * self._num_directions\n w_ih_shape = [gate_size, layer_input_size]\n w_hh_shape = [gate_size, self._hidden_size]\n b_ih_shape, b_hh_shape = [gate_size], [gate_size]\n matrix_shapes.extend([w_ih_shape, w_hh_shape])\n bias_shapes.extend([b_ih_shape, b_hh_shape])\n # Create single float32 weights.\n weights_count = 0\n self._weights_shapes = matrix_shapes + bias_shapes\n for shape in self._weights_shapes:\n weights_count += math_util.prod(shape)\n self._weights = Tensor([weights_count])\n self._weights.requires_grad = True","def gen_weights(self, f_target):\n\n # calculate x and psi\n x_track = self.cs.rollout()\n psi_track = self.gen_psi(x_track)\n\n # efficiently calculate BF weights using weighted linear regression\n self.w = jnp.zeros((self.n_dmps, self.n_bfs))\n for d in range(self.n_dmps):\n # spatial scaling term\n k = self.goal[d] - self.y0[d]\n for b in range(self.n_bfs):\n numer = jnp.sum(x_track * psi_track[:, b] * f_target[:, d])\n denom = jnp.sum(x_track ** 2 * psi_track[:, b])\n self.w[d, b] = numer / denom\n if abs(k) > 1e-5:\n self.w[d, b] /= k\n\n self.w = jnp.nan_to_num(self.w)","def _setWeights(self):\r\n for layer in self.layer_names:\r\n raw_w = getattr(self, f'{layer}_raw')\r\n self.module._parameters[layer] = F.dropout(raw_w, p=self.weight_pro, training=self.training)","def _weight_edges(self):\n weights = {}\n for edge in self.network.edges():\n weights[edge] = self.distance_matrix[edge]\n nx.set_edge_attributes(self.network, 'weight', weights)","def set_weights(self, W):\n if(self.weights.shape != W.shape):\n return -1\n self.weights = W","def init_weights_(self):\n raise NotImplementedError","def weight_observer(self, episode):\r\n weights_all = self.actor.get_weights()\r\n self.observed_weights[episode, 0] = weights_all[4][3, 0] # 4th weight of output neuron actor\r\n self.observed_weights[episode, 1] = weights_all[4][4, 0] # 5th weight of output neuron actor\r\n self.observed_weights[episode, 2] = weights_all[4][5, 0] # 6th weight of output neuron actor\r\n self.observed_weights[episode, 3] = weights_all[5][0] # bias of output neuron actor\r","def get_weights(self):\n return [self.w, self.b]","def _compute_weights(self):\n with variable_scope.variable_scope('compute_weights'):\n self.layer.W = nn_impl.l2_normalize(\n self.layer.v, axis=self.norm_axes) * self.layer.g","def _compute_weights(self):\n with variable_scope.variable_scope('compute_weights'):\n self.layer.W = nn_impl.l2_normalize(\n self.layer.v, axis=self.norm_axes) * self.layer.g","def initialize_weights(self, seed=None):\r\n if seed!=None:\r\n np.random.seed(seed)\r\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)"],"string":"[\n \"def update_target_network(self):\\n self.target.set_weights(self.policy.get_weights()) # Update weights of target network with weights of policy network\",\n \"def transfer_weights(self):\\n W, target_W = self.model.get_weights(), self.target_model.get_weights()\\n for i in range(len(W)):\\n target_W[i] = self.tau * W[i] + (1 - self.tau)* target_W[i]\\n self.target_model.set_weights(target_W)\",\n \"def _update_target_model(self):\\n self.target_network.model.set_weights(self.policy_network.model.get_weights())\",\n \"def _set_weights(self, weights):\\r\\n self.weights = weights.reshape(self.output_size, self.input_size+1)\",\n \"def update_target_network(self):\\n self.target_dqn.set_weights.remote(self.dqn.get_weights.remote())\",\n \"def _weights_for_target(self, target):\\n\\n self._update_global_transform(target)\\n projected_target = self.global_transform.pseudoinverse().apply(target)\\n # now we have the target in model space, project it to recover the\\n # weights\\n new_weights = self.model.project(projected_target)\\n # TODO investigate the impact of this, could be problematic\\n # the model can't perfectly reproduce the target we asked for -\\n # reset the global_transform.target to what it CAN produce\\n #refined_target = self._target_for_weights(new_weights)\\n #self.global_transform.target = refined_target\\n return new_weights\",\n \"def adjust_weights(weights, target, learn_rate):\\r\\n\\r\\n for w in range(0, len(target)):\\r\\n weights[w] += learn_rate * (target[w] - weights[w])\",\n \"def set_weights(self, weights):\\r\\n self.weights = weights\",\n \"def reassignWeights(self,weights):\\n\\t\\n\\t\\tbranches = self.collectAllBranches()\\n\\n\\t\\tfor i in range(self.nBranches):\\n\\n\\t\\t\\tbranches[i].weight = weights[i]\",\n \"def setweights(self, weights):\\n # I call it weights because it is the relative weights of the atoms, not\\n # because I'm confusing weight and mass\\n self.weights = weights\\n self.totalweight = numpy.sum(weights)\",\n \"def set_weights(self, weights):\\n self._weights = weights\\n self.normalize_weights() ########################added\\n #self.get_weights()\",\n \"def update_target_model(self):\\n self.target_model.set_weights(self.model.get_weights())\",\n \"def update_target_model(self):\\n self.target_model.set_weights(self.model.get_weights())\",\n \"def update_target_model(self):\\n self.target_model.set_weights(self.model.get_weights())\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\",\n \"def update_weights(self):\\r\\n\\r\\n inedges=self.in_edges\\r\\n for edge in inedges:\\r\\n weight=edge.weight+self.learning_rate*self.delta*(edge.source.activation)\\r\\n edge.change_weight(weight)\",\n \"def _set_weights(self):\\n self.Wc = torch.mm(self.TP.T, self.W).mm(self.TP)\",\n \"def soft_update_target_network(self):\\n \\n pars_behavior = self.model.get_weights() # these have form [W1, b1, W2, b2, ..], Wi = weights of layer i\\n pars_target = self.target_model.get_weights() # bi = biases in layer i\\n \\n ctr = 0\\n for par_behavior,par_target in zip(pars_behavior,pars_target):\\n par_target = par_target*(1-self.tau) + par_behavior*self.tau\\n pars_target[ctr] = par_target\\n ctr += 1\\n\\n self.target_model.set_weights(pars_target)\",\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def soft_update_target_network(self):\\n \\n pars_behavior = self.model.get_weights() # these have form [W1, b1, W2, b2, ..], Wi = weights of layer i\\n pars_target = self.target_model.get_weights() # bi = biases in layer i\\n \\n for par_behavior,par_target in zip(pars_behavior,pars_target):\\n par_target = par_target*(1-self.tau) + par_behavior*self.tau\\n pars_target[ctr] = par_target\\n\\n self.target_model.set_weights(pars_target)\",\n \"def get_weights(self, nn_weights, rov_id): # Get weights from CCEA population\\n\\n for w in range(self.n_weights):\\n self.weights[rov_id, w] = nn_weights[w]\",\n \"def targets_weights_fn(self):\\n return common_layers.weights_all\",\n \"def hard_copy_weights(self, target, source):\\n for target_param, param in zip(target.parameters(), source.parameters()):\\n target_param.data.copy_(param.data)\",\n \"def set_weights(self, weights: Dict[PolicyID, dict]):\\n self.workers.local_worker().set_weights(weights)\",\n \"def pull_weights(self, learning_rate):\\n for w in self.weights:\\n w.value += learning_rate * w.gradient\\n # Reset all the weights' gradient to 0\\n # We will not reset all other units' gradient, because all other units should be initialized in next training\\n # round, and the init value of gradient is 0\\n for w in self.weights:\\n w.gradient = 0\",\n \"def transfer_weights(\\n self, new_model, new_optimizer=None, optimizer=None, ignore_weights=None\\n ):\\n if type(self) is not type(new_model):\\n raise ValueError(\\n \\\"Transferring weights to another model type is not supported\\\"\\n )\\n if ignore_weights is None:\\n ignore_weights = set()\\n ignore_weights_ref = set(weight.ref() for weight in ignore_weights)\\n weights = self.weights\\n new_weights = new_model.weights\\n for weight, new_weight in zip(weights, new_weights):\\n if new_weight.ref() not in ignore_weights_ref:\\n new_weight.assign(weight)\\n if new_optimizer is not None and optimizer is not None:\\n for slot_name in new_optimizer.get_slot_names():\\n if slot_name not in optimizer.get_slot_names():\\n continue\\n new_slot = new_optimizer.get_slot(new_weight, slot_name)\\n slot = optimizer.get_slot(weight, slot_name)\\n new_slot.assign(slot)\",\n \"def update_weights(self):\\n\\n self.weights -= self.loss_grads\\n self.loss_grads = np.zeros(self.weights.shape)\",\n \"def weights(self, weights):\\n\\n self._weights = weights\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\\n self.weights_clipping()\",\n \"def set_weights(self, weights):\\n self.forcing_term.weights_[:, :] = weights.reshape(*self.forcing_term.shape)\",\n \"def setWeights(self, w):\\n raise NotImplementedError\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def set_weights(self, weights):\\n tuples = []\\n for layer in self.layers:\\n num_param = len(layer.weights)\\n layer_weights = weights[:num_param]\\n for sw, w in zip(layer.weights, layer_weights):\\n tuples.append((sw, w))\\n weights = weights[num_param:]\\n K.batch_set_value(tuples)\",\n \"def init_weights(self) -> None:\\n nn.init.kaiming_normal_(self._U)\\n nn.init.kaiming_normal_(self._W)\\n nn.init.kaiming_normal_(self._V)\\n\\n nn.init.normal_(self._b)\",\n \"def set_weights(self, weights):\\n self.model.set_weights(weights)\",\n \"def _set_weights(self, weights):\\n i = iter(weights)\\n\\n for param in self.params:\\n param.set_value(i.next())\",\n \"def _set_weights(self, weights):\\n i = iter(weights)\\n\\n for param in self.params:\\n param.set_value(i.next())\",\n \"def _update_weights(self, xi, target):\\n output = self.net_input(xi)\\n error = (target - output)\\n self.w_[1:] += self.eta * xi.dot(error)\\n self.w_[0] += self.eta * error\\n cost = 0.5 * error**2\\n return cost\",\n \"def _update_weights(self, xi, target):\\n output = self.net_input(xi)\\n error = (target - output)\\n self.w_[1:] += self.eta * xi.dot(error)\\n self.w_[0] += self.eta * error\\n cost = 0.5 * error**2\\n return cost\",\n \"def init_weights(self):\\n self._q_neuron.h(self._weights) \\n self._q_neuron.x(self._weights)\",\n \"def _update_weights(self, xi, target):\\n output = self.net_input(xi)\\n error= (target - output)\\n self.w_[1:] += self.eta * xi.dot(error)\\n self.w_[0] += self.eta * error\\n cost =0.5* error**2\\n return cost\",\n \"def set_weights(self, w):\\n self.nn.set_param_values(w)\",\n \"def load_weights(self, weights):\\n\\n i = 0\\n for l in range(1, self.num_layers()):\\n for n in range(self.get_layer(l).num_nodes):\\n for w in range(len(self.get_node_with_layer(l, n).weights)):\\n self.get_node_with_layer(l, n).weights[w] = weights[i]\\n i += 1\",\n \"def copy_para(from_model, to_model):\\n for i, j in zip(from_model.trainable_weights, to_model.trainable_weights):\\n j.assign(i)\",\n \"def _soft_update_target_network(self):\\n\\n # Update the target network\\n for target_param, param in zip(self.actor_target_network.parameters(), self.actor_network.parameters()):\\n target_param.data.copy_((1-self.args.tau) * target_param.data + self.args.tau * param.data)\\n\\n # Update the critic network\\n for target_param, param in zip(self.critic_target_network.parameters(), self.critic_network.parameters()):\\n target_param.data.copy_((1-self.args.tau) * target_param.data + self.args.tau * param.data)\",\n \"def setWeightInitializer(self,weights):\\n self.init_w = weights\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def set_output_weights(self, weight_matrix):\\n pass\",\n \"def sync(net, net_tar):\\n for var, var_tar in zip(net.trainable_weights,\\n net_tar.trainable_weights):\\n var_tar.assign(var)\",\n \"def update_target_network(self):\\n variables = self.online_network.trainable_variables\\n variables_copy = [tf.Variable(v) for v in variables]\\n self.target_network.trainable_variables = variables_copy\",\n \"def initialize_weights(self):\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(\\n self._batch)\",\n \"def get_hard_target_model_updates(target, source):\\n target.set_weights(source.get_weights())\\n\\n return target\",\n \"def initialize_weights(self):\\n # compute lmda.\\n self.lmda = float(self.c)/float(self.N)\\n # bias term. This should not get a regularization penalty.\\n self.bias = {}\\n # weight vector\\n self.w = {}\\n # lastW[j] = k, indicates that feature j was last updated at time k.\\n self.lastW = {}\\n for lbl in self.labels:\\n self.bias[lbl] = 0\\n self.w[lbl] = {}\\n self.lastW[lbl] = {}\\n pass\",\n \"def my_assign_weights(context, data):\\n pass\",\n \"def update_weights(self):\\n activation, activation_p = self.feedforward()\\n # initialize delta_weights\\n delta_w = np.zeros(2)\\n # simultaneous calculate delta_weights\\n for i, element in enumerate(self.y):\\n delta_w += (activation[i]-element)*(activation_p[i])*self.X[i]\\n # update weight\\n self.weights -= self.alfa*delta_w\",\n \"def update_weights(self, X, Y, learning_rate):\\n grads = self.calculate_gradients(X, Y)\\n #update weights and biases\\n self.weights[0] = self.weights[0] - learning_rate * grads[\\\"dW1\\\"]\\n self.weights[1] = self.weights[1] - learning_rate * grads[\\\"dW2\\\"]\\n self.biases[0] = self.biases[0] - learning_rate * grads[\\\"db1\\\"]\\n self.biases[1] = self.biases[1] - learning_rate * grads[\\\"db2\\\"]\",\n \"def init_weights(self):\\n\\n params = torch.load(self.resnet_weight)\\n\\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\\n\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\\n self.fc4.out_features)\\n self.fc4.weight.data.uniform_(-r, r)\\n self.fc4.bias.data.fill_(0)\",\n \"def test_net_weight_update(self):\\n nn = NeuralNet(0, 0, '', '', blank=True)\\n nn.create_net(2, 1, 2, 2)\\n nn.eta = 0.1\\n\\n # Override weights to static value for reproducibility\\n for node in nn.layers[2].nodes:\\n node.weights = [0.6, 0.6]\\n\\n for node in nn.layers[3].nodes:\\n node.weights = [1.0, 1.0]\\n\\n nn.update_weights([2, 3], [0], test=True)\\n\\n test_weight = nn.layers[-1].nodes[0].weights[0]\\n self.assertEqual(round(test_weight, 4), 0.9901)\",\n \"def soft_update_actor(self):\\n local_weights = np.array(self.actor_local.model.get_weights())\\n target_weights = np.array(self.actor_target.model.get_weights())\\n\\n assert len(local_weights) == len(\\n target_weights), ('Local and target model parameters must have '\\n 'the same size')\\n\\n new_weights = self.tau * local_weights + (1 - self.tau) * target_weights\\n self.actor_target.model.set_weights(new_weights)\",\n \"def init_weights(model):\\n ...\",\n \"def _initialize_weights(self):\\n pass\",\n \"def updateWeights(inputs, outputs, learning_rate, y, weights):\\n for i in range(len(weights)):\\n weights[i] = weights[i] + learning_rate * (outputs - y) * inputs[i]\\n return weights\",\n \"def sync_target_network(self):\\n for t, e in zip(\\n self.target_network.trainable_variables, self.online_network.trainable_variables\\n ):\\n t.assign(e)\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def adjust_params(self, inputs, target_costs, original_costs):\\n costs = self.measure_costs(inputs)\\n weights = [(target_costs[i] - costs[i]) / (target_costs[i] - original_costs[i]) for i in range(target_costs)]\\n totalweights = sum(weights)\\n for i in range(weights):\\n self.morphnet_target_cost_thresholds[i] = weights[i] / totalweights\",\n \"def get_weights(self):\\n # First part is iterating over hidden weights. Then append the output weight.\\n return [self.hidden_layers[i].get_weight().cpu().detach().numpy() for i in range(self.depth)] + \\\\\\n [self.output_weight.cpu().detach().numpy()]\",\n \"def get_weights(self):\\n # First part is iterating over hidden weights. Then append the output weight.\\n return [self.hidden_layers[i].get_weight() for i in range(self.depth)] + \\\\\\n [self.output_weight.cpu().detach().numpy()]\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\\n # Tie weights if needed\\n self.tie_weights()\",\n \"def set_weights(self, weights):\\n\\n self._cnn_model.set_weights(weights)\",\n \"def update_target_network(self, tau):\\n for t, e in zip(\\n self.target_network.trainable_variables, self.online_network.trainable_variables\\n ):\\n t.assign(t * (1-tau) + e * tau)\",\n \"def initialize_weights(self):\\n for layer in self._cnn_layers:\\n weights_initializer.WeightsInitializer.initialize_layer_or_model(layer)\",\n \"def init_weights(self):\\n self.transformer.init_weights()\\n if self.loss_cls.use_sigmoid:\\n bias_init = bias_init_with_prob(0.01)\\n for m in self.cls_branches:\\n nn.init.constant_(m[-1].bias, bias_init)\",\n \"def copy_weights(self):\\n return copy.deepcopy(self.weights_ih), copy.deepcopy(self.weights_ho)\",\n \"def update(self, weights, grads):\\n learn_rate_t = self.learn_rate\\n\\n new_weights = []\\n for w, g in zip(weights, grads):\\n\\n # Apply weight decay\\n if w.shape[1] > 1:\\n # Weight matrix\\n g_t = learn_rate_t * (g + self.weight_decay * w)\\n else:\\n # Bias matrix\\n g_t = learn_rate_t * g\\n w_t = w - g_t\\n new_weights.append(w_t)\\n return new_weights\",\n \"def initialize_weights(self):\\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\\n return w1, w2\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def set_weights(self, W):\\r\\n if self.weights.shape!=W.shape:\\r\\n return -1\\r\\n self.weights = W\",\n \"def update_weights(self, weight_delta):\\n\\n self._weights = math_util.vector_sum(self._weights, weight_delta)\",\n \"def setWeights(self, weights):\\n self._call_java('setWeights', weights)\",\n \"def set_weights(self, weights):\\n params = self.weights\\n if len(params) != len(weights):\\n raise ValueError('You called `set_weights(weights)` on layer \\\"' +\\n self.name + '\\\" with a weight list of length ' +\\n str(len(weights)) + ', but the layer was expecting ' +\\n str(len(params)) + ' weights. Provided weights: ' +\\n str(weights)[:50] + '...')\\n if not params:\\n return\\n weight_value_tuples = []\\n param_values = K.batch_get_value(params)\\n for pv, p, w in zip(param_values, params, weights):\\n if pv.shape != w.shape:\\n raise ValueError('Layer weight shape ' + str(pv.shape) +\\n ' not compatible with '\\n 'provided weight shape ' + str(w.shape))\\n weight_value_tuples.append((p, w))\\n K.batch_set_value(weight_value_tuples)\",\n \"def reset_weights(self):\\n self.policy_backbone.reset_weights()\\n self.value_backbone.reset_weights()\\n self.action_head.reset_weights()\\n self.critic_head.reset_weights()\",\n \"def normalizeWeights(self):\\n for wt in self.weights:\\n wt[wt>1] = 1\\n wt[wt<-1] = -1\\n for bs in self.bias:\\n bs[bs>1] = 1\\n bs[bs<-1] = -1\",\n \"def init_variables():\\n weights = np.random.normal(size=2)\\n bias = 0\\n return weights, bias\",\n \"def _mutate_weights(self, weights):\\n return weights + normal(loc=0, scale=self.standard_deviation, size=weights.shape[0])\",\n \"def change_weight(self, new_weight_arr):\\n self.weights = new_weight_arr\",\n \"def update_weights(x_train, y_train, weights, learning_rate):\\r\\n predictions = compute_prediction(x_train, weights)\\r\\n weights_delta = np.dot(x_train.T, y_train - predictions)\\r\\n m = y_train.shape[0]\\r\\n weights += learning_rate / float(m) * weights_delta\\r\\n return weights\",\n \"def reset_weights(self):\\r\\n self._weights = deepcopy(self._tmp_weights)\\r\\n self._tmp_weights = None\",\n \"def init_weights(self):\\n with torch.no_grad():\\n self._init_weights()\",\n \"def _create_weights(self):\\n gate_size = self._hidden_size * self._num_gates\\n # Compute the shape of weight and bias.\\n matrix_shapes, bias_shapes = [], []\\n for layer in range(self._num_layers):\\n for direction in range(self._num_directions):\\n layer_input_size = self._input_size if layer == 0 \\\\\\n else self._hidden_size * self._num_directions\\n w_ih_shape = [gate_size, layer_input_size]\\n w_hh_shape = [gate_size, self._hidden_size]\\n b_ih_shape, b_hh_shape = [gate_size], [gate_size]\\n matrix_shapes.extend([w_ih_shape, w_hh_shape])\\n bias_shapes.extend([b_ih_shape, b_hh_shape])\\n # Create single float32 weights.\\n weights_count = 0\\n self._weights_shapes = matrix_shapes + bias_shapes\\n for shape in self._weights_shapes:\\n weights_count += math_util.prod(shape)\\n self._weights = Tensor([weights_count])\\n self._weights.requires_grad = True\",\n \"def gen_weights(self, f_target):\\n\\n # calculate x and psi\\n x_track = self.cs.rollout()\\n psi_track = self.gen_psi(x_track)\\n\\n # efficiently calculate BF weights using weighted linear regression\\n self.w = jnp.zeros((self.n_dmps, self.n_bfs))\\n for d in range(self.n_dmps):\\n # spatial scaling term\\n k = self.goal[d] - self.y0[d]\\n for b in range(self.n_bfs):\\n numer = jnp.sum(x_track * psi_track[:, b] * f_target[:, d])\\n denom = jnp.sum(x_track ** 2 * psi_track[:, b])\\n self.w[d, b] = numer / denom\\n if abs(k) > 1e-5:\\n self.w[d, b] /= k\\n\\n self.w = jnp.nan_to_num(self.w)\",\n \"def _setWeights(self):\\r\\n for layer in self.layer_names:\\r\\n raw_w = getattr(self, f'{layer}_raw')\\r\\n self.module._parameters[layer] = F.dropout(raw_w, p=self.weight_pro, training=self.training)\",\n \"def _weight_edges(self):\\n weights = {}\\n for edge in self.network.edges():\\n weights[edge] = self.distance_matrix[edge]\\n nx.set_edge_attributes(self.network, 'weight', weights)\",\n \"def set_weights(self, W):\\n if(self.weights.shape != W.shape):\\n return -1\\n self.weights = W\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def weight_observer(self, episode):\\r\\n weights_all = self.actor.get_weights()\\r\\n self.observed_weights[episode, 0] = weights_all[4][3, 0] # 4th weight of output neuron actor\\r\\n self.observed_weights[episode, 1] = weights_all[4][4, 0] # 5th weight of output neuron actor\\r\\n self.observed_weights[episode, 2] = weights_all[4][5, 0] # 6th weight of output neuron actor\\r\\n self.observed_weights[episode, 3] = weights_all[5][0] # bias of output neuron actor\\r\",\n \"def get_weights(self):\\n return [self.w, self.b]\",\n \"def _compute_weights(self):\\n with variable_scope.variable_scope('compute_weights'):\\n self.layer.W = nn_impl.l2_normalize(\\n self.layer.v, axis=self.norm_axes) * self.layer.g\",\n \"def _compute_weights(self):\\n with variable_scope.variable_scope('compute_weights'):\\n self.layer.W = nn_impl.l2_normalize(\\n self.layer.v, axis=self.norm_axes) * self.layer.g\",\n \"def initialize_weights(self, seed=None):\\r\\n if seed!=None:\\r\\n np.random.seed(seed)\\r\\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.74298966","0.7240756","0.7069389","0.70639586","0.6890794","0.6858491","0.68172055","0.67953044","0.66856223","0.6684053","0.6666912","0.66301864","0.66301864","0.66301864","0.6627997","0.6626138","0.66244763","0.6613709","0.6606935","0.65739423","0.65707046","0.65415126","0.65166694","0.6503992","0.64976764","0.6482621","0.64774495","0.64719504","0.6471572","0.64573246","0.64483076","0.6423183","0.6401689","0.638735","0.6387112","0.6379597","0.6379597","0.6370631","0.6370631","0.63529134","0.6351137","0.63476086","0.6320003","0.6316425","0.630478","0.62836087","0.6273256","0.62687486","0.6267846","0.6259722","0.6253709","0.62376153","0.62337935","0.62180454","0.62128794","0.62123924","0.6195679","0.6194602","0.6182178","0.6160176","0.6160137","0.61572874","0.6154193","0.61507004","0.61500317","0.6141869","0.61379534","0.6135759","0.6121444","0.6114666","0.6103566","0.6100453","0.6085352","0.6085206","0.6081689","0.6067582","0.6065555","0.6064914","0.6046024","0.6043962","0.6034176","0.6032971","0.60263413","0.60196686","0.6019546","0.6019153","0.6018166","0.6007549","0.60019934","0.59990984","0.5995382","0.59931505","0.5987742","0.5984368","0.59832335","0.59799266","0.59717065","0.5971256","0.5971256","0.59603524"],"string":"[\n \"0.74298966\",\n \"0.7240756\",\n \"0.7069389\",\n \"0.70639586\",\n \"0.6890794\",\n \"0.6858491\",\n \"0.68172055\",\n \"0.67953044\",\n \"0.66856223\",\n \"0.6684053\",\n \"0.6666912\",\n \"0.66301864\",\n \"0.66301864\",\n \"0.66301864\",\n \"0.6627997\",\n \"0.6626138\",\n \"0.66244763\",\n \"0.6613709\",\n \"0.6606935\",\n \"0.65739423\",\n \"0.65707046\",\n \"0.65415126\",\n \"0.65166694\",\n \"0.6503992\",\n \"0.64976764\",\n \"0.6482621\",\n \"0.64774495\",\n \"0.64719504\",\n \"0.6471572\",\n \"0.64573246\",\n \"0.64483076\",\n \"0.6423183\",\n \"0.6401689\",\n \"0.638735\",\n \"0.6387112\",\n \"0.6379597\",\n \"0.6379597\",\n \"0.6370631\",\n \"0.6370631\",\n \"0.63529134\",\n \"0.6351137\",\n \"0.63476086\",\n \"0.6320003\",\n \"0.6316425\",\n \"0.630478\",\n \"0.62836087\",\n \"0.6273256\",\n \"0.62687486\",\n \"0.6267846\",\n \"0.6259722\",\n \"0.6253709\",\n \"0.62376153\",\n \"0.62337935\",\n \"0.62180454\",\n \"0.62128794\",\n \"0.62123924\",\n \"0.6195679\",\n \"0.6194602\",\n \"0.6182178\",\n \"0.6160176\",\n \"0.6160137\",\n \"0.61572874\",\n \"0.6154193\",\n \"0.61507004\",\n \"0.61500317\",\n \"0.6141869\",\n \"0.61379534\",\n \"0.6135759\",\n \"0.6121444\",\n \"0.6114666\",\n \"0.6103566\",\n \"0.6100453\",\n \"0.6085352\",\n \"0.6085206\",\n \"0.6081689\",\n \"0.6067582\",\n \"0.6065555\",\n \"0.6064914\",\n \"0.6046024\",\n \"0.6043962\",\n \"0.6034176\",\n \"0.6032971\",\n \"0.60263413\",\n \"0.60196686\",\n \"0.6019546\",\n \"0.6019153\",\n \"0.6018166\",\n \"0.6007549\",\n \"0.60019934\",\n \"0.59990984\",\n \"0.5995382\",\n \"0.59931505\",\n \"0.5987742\",\n \"0.5984368\",\n \"0.59832335\",\n \"0.59799266\",\n \"0.59717065\",\n \"0.5971256\",\n \"0.5971256\",\n \"0.59603524\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7086991"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":88371,"cells":{"query":{"kind":"string","value":"relative if true, the exclusion of the ratios (relative to the inputs given) are plotted. If False, these ratios are multiplied by the SM cross sections and branching ratios into gamma gamma inputIsAbs is a list (set) of file names which should be treated as if they had ABSOLUTE limits on cross sections rather than relative limits. minMass and masMass can be used to restrict the plotting range"},"document":{"kind":"string","value":"def makePlot(csvFnames, relative, includeExpected = True, fermiophobic = None, ymax = None, inputIsAbs = None, drawXsectBR = False,\n minMass = None,\n maxMass = None,\n plotLog = False\n ):\n\n #--------------------\n # read the files \n #--------------------\n data = []\n color = 0\n\n for fname in csvFnames:\n\n while True:\n color += 1\n if color not in colorsToAvoid:\n break\n\n # define a name: if there is a comma in the file name assume that the\n # part before the comma is the actual file name and the part after it\n # is the label we should use\n #\n # if there is no comma, just use the basename (without .csv) as label\n pos = fname.find(',')\n if pos == -1:\n # not found\n name = os.path.basename(fname)\n if name.lower().endswith(\".csv\"):\n name = name[:-4]\n else:\n name = fname[pos+1:]\n fname = fname[:pos]\n\n masses, observedValues, expectedValues, \\\n expected_minus_2_sigma_values, \\\n expected_minus_1_sigma_values, \\\n expected_plus_1_sigma_values, \\\n expected_plus_2_sigma_values = PlotUtils.readCSV(open(fname), includeExpected)\n\n #--------------------\n # filter on masses\n #--------------------\n indices = range(len(masses))\n\n if minMass != None:\n indices = [ i for i in indices if masses[i] >= minMass ]\n\n if maxMass != None:\n indices = [ i for i in indices if masses[i] <= maxMass ]\n\n masses = [ masses[i] for i in indices ]\n observedValues = [ observedValues[i] for i in indices ]\n expectedValues = [ expectedValues[i] for i in indices ]\n\n #--------------------\n \n tmp = { \"masses\": masses,\n \"observedValues\": observedValues,\n \"expectedValues\": expectedValues,\n\n # for labels\n \"name\": name,\n\n # assign the color here\n \"color\": color,\n }\n\n\n \n data.append(tmp) \n\n\n #--------------------\n \n # just to make sure we're not picking up something in the code afterwards\n del masses\n del observedValues\n del expectedValues\n #--------------------\n \n if not relative:\n\n # if we're plotting the absolute cross sections, we\n # need to know whether this is Standard Model or Fermiophobic\n assert(fermiophobic != None)\n\n if fermiophobic:\n typeName = \"FP\"\n else:\n typeName = \"SM\"\n\n # convert to absolute cross sections\n for line, fname in zip(data, csvFnames):\n if fname in inputIsAbs:\n # already absolute\n continue\n\n line['observedValues'] = PlotUtils.multiplyArrayByXsectAndBR(line['masses'], line['observedValues'], fermiophobic)\n line['expectedValues'] = PlotUtils.multiplyArrayByXsectAndBR(line['masses'], line['expectedValues'], fermiophobic)\n\n else:\n # we're asked to plot relative results, convert to relative for those\n # inputs which are absolute\n\n for line, fname in zip(data, csvFnames):\n if not fname in inputIsAbs:\n # relative input, no need to convert\n continue\n\n line['observedValues'] = PlotUtils.divideArrayByXsectAndBR(line['masses'], line['observedValues'], fermiophobic)\n line['expectedValues'] = PlotUtils.divideArrayByXsectAndBR(line['masses'], line['expectedValues'], fermiophobic)\n\n #----------------------------------------\n # legend\n #----------------------------------------\n legend = ROOT.TLegend(options.legendXleft, options.legendYbottom,\n options.legendXright,options.legendYtop); gcSaver.append(legend)\n \n legend.SetShadowColor(0);\n legend.SetFillColor(0);\n legend.SetBorderSize(0);\n\n #----------------------------------------\n # produce the 'observed' graphs\n #----------------------------------------\n\n allGraphs = []\n\n for line in data:\n gr = PlotUtils.makeGraphFromArrays(line['masses'], line['observedValues'])\n line['grObserved'] = gr\n gcSaver.append(gr)\n\n if options.observedLineWidth > 0:\n gr.SetLineWidth(options.observedLineWidth)\n else:\n # set default width for legend\n gr.SetLineWidth(4)\n\n gr.SetLineColor(line['color'])\n\n legend.AddEntry(gr,line['name'],\"L\")\n\n if options.observedLineWidth > 0:\n allGraphs.append(gr)\n\n #----------------------------------------\n # produce the 'expected' graphs\n #----------------------------------------\n\n if includeExpected:\n\n for line in data:\n \n grExpected = PlotUtils.makeGraphFromArrays(line['masses'], line['expectedValues'])\n gcSaver.append(grExpected)\n\n line['grExpected'] = grExpected\n\n grExpected.SetLineStyle(ROOT.kDashed)\n grExpected.SetLineWidth(4)\n grExpected.SetLineColor(line['color'])\n\n allGraphs.append(grExpected)\n\n # label = makeGraphLabelOnRight(grExpected, minMass, maxMass, \"BG exp.\")\n # label.SetTextSize(label.GetTextSize() * 0.7) \n # label.Draw()\n # gcSaver.append(label)\n\n #myCanvas = ROOT.TCanvas(\"myCanvas\",\"Title Goes Here\")\n #myCanvas.SetLogy(plotLog)\n\n #----------------------------------------\n # produce the graph for the theoretical cross section\n #----------------------------------------\n if drawXsectBR:\n # add a graph for the theoretical cross section\n\n # take the 'or' of all masses given\n import operator\n allMasses = sorted(reduce(operator.add, [ line['masses'] for line in data ] ))\n\n # for the moment, limit this to integer masses (in GeV)\n # (the cross section interpolation seems not yet to be functional)\n allMasses = sorted(list(set([ int(round(x)) for x in allMasses ])))\n\n # print \"allMasses=\",allMasses\n\n theoXsectBr = [ PlotUtils.getXsectTimesBR(mass, fermiophobic) for mass in allMasses ]\n gr = PlotUtils.makeGraphFromArrays(allMasses, theoXsectBr)\n\n gr.SetLineWidth(4)\n gr.SetLineStyle(ROOT.kDotted)\n\n legend.AddEntry(gr,\"theo. #sigma * BR\",\"L\")\n\n gcSaver.append(gr)\n allGraphs.append(gr)\n\n #----------------------------------------\n # determine the y scale\n #----------------------------------------\n\n if ymax == None:\n\n # determine this from the values, not from the graphs\n # (is there a way to do this from the graphs ?)\n ymax = max([value for line in data for value in line['observedValues'] ]) \n\n if includeExpected:\n ymax = max(ymax, max([value for line in data for value in line['expectedValues'] ]))\n\n ymax *= 1.1\n\n # TODO: remove this if statement ?!\n if not relative:\n if fermiophobic:\n # fix the y scale by hand in order not to\n # stretch it too much because of large\n # scaling factors for the theoretical expectation\n ymax = 0.5\n\n #----------------------------------------\n # determine x scale (mass range)\n #----------------------------------------\n allMasses = [value for line in data for value in line['masses'] ]\n actualMinMass = min(allMasses)\n actualMaxMass = max(allMasses)\n\n del allMasses\n\n #----------------------------------------\n\n # create a dummy histogram to set the x range\n hdummy = ROOT.TH1F(\"hdummy\",\"\",1,actualMinMass,actualMaxMass)\n gcSaver.append(hdummy)\n\n hdummy.SetMaximum(ymax)\n hdummy.Draw()\n\n ROOT.gStyle.SetOptTitle(0)\n\n #----------------------------------------\n # draw the graphs\n #----------------------------------------\n\n for gr in allGraphs:\n gr.Draw(\"C,same\")\n #gr.Draw(\"L,same\")\n\n \n #----------------------------------------\n\n ROOT.gStyle.SetOptStat(0)\n hdummy.SetXTitle(\"m_{H} [GeV/c^{2}]\")\n hdummy.GetYaxis().SetTitleOffset(1.2 * hdummy.GetYaxis().GetTitleOffset())\n\n if relative:\n hdummy.SetYTitle(\"#sigma/#sigma(theo)\")\n else:\n hdummy.SetYTitle(\"#sigma(%s) * BR(#gamma#gamma) [pb]\" % typeName)\n \n ROOT.gPad.SetGrid()\n\n if options.showTitle:\n label = ROOT.TLatex(0.5,0.85,\"Excluded at 95% CL.\")\n gcSaver.append(label)\n label.SetNDC(1)\n\n label.SetTextAlign(21)\n label.Draw()\n\n\n legend.Draw()\n\n ROOT.gPad.Modified()\n\n ROOT.gPad.Modified()"},"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 plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\n\n# alt keyword check\n for k in ['file','filename']: \n if kwargs.get(k,'') != '': output = kwargs[k]\n for k in ['legends','labels']: \n if kwargs.get(k,'') != '': legend = kwargs[k]\n\n# force input into a list\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\n else: inputlist = [inp]\n\n# if input is a string of filenames, read in each file to a spectrum object\n if isinstance(inputlist[0],str):\n# try a glob search string \n files = glob.glob(os.path.normpath(inputlist[0]))\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\n inputlist = files\n# try reading in files into Spectrum object\n try:\n splist = [splat.Spectrum(file = f) for f in inputlist]\n except:\n raise ValueError('\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\n\n# if filenames, read in each file to a spectrum object\n elif isinstance(inputlist[0],splat.Spectrum):\n splist = copy.deepcopy(inputlist)\n else:\n raise ValueError('\\nInput should be list of splat.Spectrum objects or filenames')\n\n# normalize if desired\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in splist]\n\n# comparison files are present\n complist = []\n if comparisons != None:\n comp = copy.deepcopy(comparisons)\n if not isinstance(comp,list): comp = [comp]\n if isinstance(comp[0],str):\n try:\n complist = [splat.Spectrum(file = f) for f in comp]\n except:\n print('\\nCould not read in comparison files: ignoring comparisons')\n if isinstance(comp[0],splat.Spectrum):\n complist = comp\n if len(complist) < len(splist):\n while len(complist) < len(splist):\n complist.append(complist[-1])\n# normalize\n if normalize==True:\n tmp = [sp.normalize(normrange) for sp in complist]\n\n# set comparison files to be standards for spectral classification\n# overrules input comparison sample\n if classify == True:\n complist = []\n base_kwargs={\n 'return_standard': True,\n 'method': 'kirkpatrick',\n }\n base_kwargs.update(classify_kwargs)\n for sp in splist:\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\n\n# prep for plotting\n plotlist = []\n clist = []\n for i,sp in enumerate(splist):\n if len(complist) == len(splist):\n plotlist.append([sp,complist[i]])\n clist.extend(basecolors)\n else:\n plotlist.append([sp])\n clist.extend(basecolors[0])\n\n# manage legends\n if len(legend) != 0:\n if not isinstance(legend,list): legend = [legend]\n if len(legend) < (len(splist)+len(complist)):\n# guess: just left out the comparison legends \n if len(complist) > 0 and len(legend) == len(splist):\n legtmp = []\n for i,l in enumerate(legend):\n legtmp.extend([l,'{}'.format(complist[i].name)])\n legend = legtmp\n else:\n# otherwise: pad the remaining legends with the last legend (pairs) \n while len(legend) < (len(splist)+len(complist)):\n if len(complist)>0:\n legend.extend([legend[-2],legend[-1]])\n else:\n legend.extend([legend[-1]])\n if len(legend) > (len(splist)+len(complist)):\n legend = legend[0:(len(splist)+len(complist))]\n else:\n legend = []\n for i,sp in enumerate(splist):\n l = []\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\n else: l.append(os.path.basename(sp.filename))\n if len(complist)>0:\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\n else: l.append(os.path.basename(complist[i].filename))\n legend.extend(l)\n\n# generate plot\n base_kwargs={\n 'multiplot': True,\n 'multipage': True,\n 'legends': legend,\n 'colors': clist,\n 'layout': layout,\n 'fontscale': fontscale,\n 'output': output,\n }\n base_kwargs.update(plot_kwargs)\n fig = plotSpectrum(plotlist,**base_kwargs)\n\n return fig","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 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_checks(inputfile, outputfile, absetamin, absetamax, max_pt, pu_min, pu_max):\n\n print \"Doing eta bin: %g - %g, max L1 jet pt: %g\" % (absetamin, absetamax, max_pt)\n\n # Input tree\n tree_raw = inputfile.Get(\"valid\")\n\n # Output folders\n output_f = outputfile.mkdir('eta_%g_%g' % (absetamin, absetamax))\n output_f_hists = output_f.mkdir(\"Histograms\")\n\n # Eta cut string\n eta_cutStr = \" TMath::Abs(eta)<%g && TMath::Abs(eta) > %g \" % (absetamax, absetamin)\n # Pt cut string\n pt_cutStr = \"pt < %g\" % max_pt\n # PU cut string\n pu_cutStr = \"numPUVertices <= %f && numPUVertices >= %f\" % (pu_max, pu_min)\n # Avoid L1 saturated jets cut (from 2017 any l1 jet with a saturated tower is auto given pt=1024GeV)\n avoidSaturation_cut = \"pt < 1023.1\"\n cutStr = \" && \".join([eta_cutStr, pt_cutStr, pu_cutStr, avoidSaturation_cut])\n\n # Draw response (pT^L1/pT^Gen) for all pt bins\n tree_raw.Draw(\"rsp>>hrsp_eta_%g_%g(100,0,5)\" % (absetamin, absetamax), cutStr)\n hrsp_eta = ROOT.gROOT.FindObject(\"hrsp_eta_%g_%g\" % (absetamin, absetamax))\n hrsp_eta.SetTitle(\";response (p_{T}^{L1}/p_{T}^{Ref});\")\n if absetamin < 2.9:\n fit_result = hrsp_eta.Fit(\"gaus\", \"QER\", \"\",\n hrsp_eta.GetMean() - hrsp_eta.GetRMS(),\n hrsp_eta.GetMean() + hrsp_eta.GetRMS())\n else:\n peak = hrsp_eta.GetBinCenter(hrsp_eta.GetMaximumBin())\n fit_result = hrsp_eta.Fit(\"gaus\", \"QER\", \"\",\n peak - (0.5 * hrsp_eta.GetRMS()),\n peak + (0.5 * hrsp_eta.GetRMS()))\n\n # mean = hrsp_eta.GetFunction(\"gaus\").GetParameter(1)\n # err = hrsp_eta.GetFunction(\"gaus\").GetParError(1)\n output_f_hists.WriteTObject(hrsp_eta)\n\n # nb_pt, pt_min, pt_max = 63, 0, 252 # for GCT/Stage 1\n nb_pt, pt_min, pt_max = 512, 0, 1024 # for Stage 2\n nb_rsp, rsp_min, rsp_max = 100, 0, 5\n\n # Draw rsp (pT^L1/pT^Gen) Vs GenJet pT\n tree_raw.Draw(\"rsp:ptRef>>h2d_rsp_gen(%d,%g,%g,%d,%g,%g)\" % (nb_pt, pt_min, pt_max, nb_rsp, rsp_min, rsp_max), cutStr)\n h2d_rsp_gen = ROOT.gROOT.FindObject(\"h2d_rsp_gen\")\n h2d_rsp_gen.SetTitle(\";p_{T}^{Ref} [GeV];response (p_{T}^{L1}/p_{T}^{Ref})\")\n output_f_hists.WriteTObject(h2d_rsp_gen)\n\n h2d_rsp_gen_norm = cu.norm_vertical_bins(h2d_rsp_gen)\n output_f_hists.WriteTObject(h2d_rsp_gen_norm)\n\n # Draw rsp (pT^L1/pT^Gen) Vs L1 pT\n tree_raw.Draw(\"rsp:pt>>h2d_rsp_l1(%d,%g,%g,%d,%g,%g)\" % (nb_pt, pt_min, pt_max, nb_rsp, rsp_min, rsp_max), cutStr)\n h2d_rsp_l1 = ROOT.gROOT.FindObject(\"h2d_rsp_l1\")\n h2d_rsp_l1.SetTitle(\";p_{T}^{L1} [GeV];response (p_{T}^{L1}/p_{T}^{Ref})\")\n output_f_hists.WriteTObject(h2d_rsp_l1)\n\n h2d_rsp_l1_norm = cu.norm_vertical_bins(h2d_rsp_l1)\n output_f_hists.WriteTObject(h2d_rsp_l1_norm)\n\n # Draw pT^Gen Vs pT^L1\n tree_raw.Draw(\"pt:ptRef>>h2d_gen_l1(%d,%g,%g,%d,%g,%g)\" % (nb_pt, pt_min, pt_max, nb_pt, pt_min, pt_max), cutStr)\n h2d_gen_l1 = ROOT.gROOT.FindObject(\"h2d_gen_l1\")\n h2d_gen_l1.SetTitle(\";p_{T}^{Ref} [GeV];p_{T}^{L1} [GeV]\")\n output_f_hists.WriteTObject(h2d_gen_l1)","def compute_and_plot_mass_hist(raw_images, gen_sample_raw, display=True, ax=None, log=True, lim=lim_hist, confidence=None, ylim=None, fractional_difference=False, algo='relative', loc=1, **kwargs):\n# raw_max = 250884 \n# lim = [np.log10(1), np.log10(raw_max/3)]\n y_real, y_fake, x = stats.mass_hist_real_fake(raw_images, gen_sample_raw, log=log, lim=lim, mean=False)\n# l2, logel2, l1, logel1 = stats.diff_vec(np.mean(y_real, axis=0), np.mean(y_fake, axis=0))\n# rel_diff = None\n# if confidence is not None:\n# rel_diff = stats.relative_diff(y_real, y_fake).mean()\n# if display:\n# print('Log l2 Mass histogram loss: {}\\n'\n# 'L2 Peak Mass histogram: {}\\n'\n# 'Log l1 Mass histogram loss: {}\\n'\n# 'L1 Mass histogram loss: {}'.format(logel2, l2, logel1, l1))\n npix = np.prod(raw_images.shape[1:])\n d = safe_fd(y_real,y_fake, npix)\n score = fd2score(d)\n if display:\n print('Mass Frechet Distance: {}\\n'\n 'Mass Score : {}\\n'.format(d, score))\n \n plot_cmp(x, y_fake, y_real, title='Mass histogram', xlabel='Number of particles', ylabel='Pixel count', ax=ax, xscale='log' if log else 'linear', shade=True, confidence=confidence, ylim=ylim, fractional_difference=fractional_difference, algorithm=algo, loc=loc)\n return score","def testIsAbs(self, mock_abs):\n mock_abs.return_value = True\n\n self.assertTrue(\n self.mr.is_abs\n )\n\n mock_abs.assert_called_once_with(\n os.path.join(self.directory, self.filename)\n )\n\n mock_abs.return_value = False\n\n self.assertFalse(\n self.mr.is_abs\n )","def _init_mass(self, mmin, mmax, nmbin):\n self.lgmass, self.dlgmass = np.linspace(log10(mmin), log10(mmax), \n num=nmbin, retstep=True)\n self.mass = np.power(10.0, self.lgmass) \n self.scale = np.power(self.r3conv*self.mass, 1.0/3.0) \n self.lgmmax = self.lgmass[-1]\n self.lgmmin = self.lgmass[0]","def abs_units(wb_run,sample_run,mono_van,wb_mono,samp_rmm,samp_mass,ei_guess,rebin,map_file,monovan_mapfile,**kwargs): \n #available keywords\n #abs_units_van_range\n global reducer, rm_zero,inst_name,van_mass,bleed_switch,rate,pixels\n print 'DGreduce run for ',inst_name,'run number ',sample_run\n print 'Output will be in absolute units of mb/str/mev/fu'\n\n #reducer.van_rmm =50.94\n reducer.van_mass=van_mass\n #sample info\n reducer.sample_mass=samp_mass\n reducer.sample_rmm =samp_rmm\n print 'Using vanadium mass: ',van_mass\n print ' sample mass: ',samp_mass \n print ' sample_rmm : ',samp_rmm \n # check if mono-vanadium is provided as multiple files list or just put in brackets ocasionally\n if isinstance(mono_van,list):\n if len(mono_van)>1:\n raise IOError(' Can currently work only with single monovan file but list supplied')\n else:\n mono_van = mono_van[0];\n\n \n try:\n n,r=lhs('both')\n wksp_out=r[0]\n except:\n if sample_run == 0:\n #deal with the current run being parsed as 0 rather than 00000\n sample_run='00000'\n wksp_out=str(sample_run)+'.spe'\n \n start_time=time.time()\n \n if sample_run=='00000' and mtd.doesExist(inst_name+'00000.raw')==True:\n print 'Deleteing previous instance of temp data'\n DeleteWorkspace(Workspace=inst_name+'00000.raw')\n \n if kwargs.has_key('norm_method'):\n reducer.normalise_method = kwargs.get('norm_method')\n print 'Setting normalisation method to ', kwargs.get('norm_method')\n else:\n reducer.normalise_method = 'monitor-1'\n \n if kwargs.has_key('mask_run'):\n mask_run = kwargs.get('mask_run')\n print 'Using run ', kwargs.get('mask_run'),' for diag'\n else:\n mask_run=sample_run\n \n if kwargs.has_key('background'):\n reducer.background = kwargs.get('background')\n print 'Setting background option to ', kwargs.get('background')\n else:\n reducer.background = False\n \n if kwargs.has_key('fixei'):\n reducer.fix_ei = kwargs.get('fixei')\n print 'Setting fixei to ', kwargs.get('fixei')\n else:\n reducer.fix_ei = False\n \n if kwargs.has_key('save_format'):\n reducer.save_formats = kwargs.get('save_format')\n print 'Setting save format to ', kwargs.get('save_format')\n else:\n reducer.save_formats = ['.spe']\n #Set parameters for the run\n \n if kwargs.has_key('detector_van_range'):\n reducer.wb_integr_range = kwargs.get('detector_van_range')\n print 'Setting detector van int range to ', kwargs.get('detector_van_range')\n else:\n reducer.wb_integr_range=[20,100]\n \n #######DIAG###########\n if kwargs.has_key('bkgd_range'):\n background_range = kwargs.get('bkgd_range')\n print 'Setting background intergration to ', kwargs.get('bkgd_range')\n else:\n background_range=[15000,19000]\n \n if kwargs.has_key('tiny'):\n tinyval = kwargs.get('tiny')\n print 'Setting tiny ratelimit to ', kwargs.get('tiny')\n else:\n tinyval=1e-10\n \n if kwargs.has_key('large'):\n largeval = kwargs.get('large')\n print 'Setting large limit to ', kwargs.get('large')\n else:\n largeval=1e10\n \n if kwargs.has_key('diag_remove_zero'):\n sampzero = kwargs.get('diag_remove_zero')\n print 'Setting diag to reject zero backgrounds '\n else:\n sampzero =False\n \n if kwargs.has_key('diag_van_median_rate_limit_hi'):\n vanouthi = kwargs.get('diag_van_median_rate_limit_hi')\n print 'Setting diag_van_median_rate_limit_hi to ', kwargs.get('diag_van_median_rate_limit_hi')\n else:\n vanouthi=100\n \n if kwargs.has_key('diag_van_median_rate_limit_lo'):\n vanoutlo = kwargs.get('diag_van_median_rate_limit_lo')\n print 'Setting diag_van_median_rate_limit_lo to ', kwargs.get('diag_van_median_rate_limit_lo')\n else:\n vanoutlo=0.01\n \n if kwargs.has_key('diag_van_median_sigma_lo'):\n vanlo = kwargs.get('diag_van_median_sigma_lo')\n print 'Setting diag_van_median_sigma_lo to ', kwargs.get('diag_van_median_sigma_lo')\n else:\n vanlo=0.1\n \n if kwargs.has_key('diag_van_median_sigma_hi'):\n vanhi = kwargs.get('diag_van_median_sigma_hi')\n print 'Setting diag_van_median_sigma_hi to ', kwargs.get('diag_van_median_sigma_hi')\n else:\n vanhi=1.5\n \n if kwargs.has_key('diag_van_median_sigma'):\n vansig = kwargs.get('diag_van_median_sigma')\n print 'Setting diag_van_median_sigma to ', kwargs.get('diag_van_median_sigma')\n else:\n vansig=0.0\n \n if kwargs.has_key('diag_samp_median_sigma_lo'):\n samplo = kwargs.get('diag_samp_median_sigma_lo')\n print 'Setting diag_samp_median_sigma_lo to ', kwargs.get('diag_samp_median_sigma_lo')\n else:\n samplo=0.0\n \n if kwargs.has_key('diag_samp_median_sigma_hi'):\n samphi = kwargs.get('diag_samp_median_sigma_hi')\n print 'Setting diag_samp_median_sigma_hi to ', kwargs.get('diag_samp_median_sigma_hi')\n else:\n samphi=2.0\n \n if kwargs.has_key('diag_samp_median_sigma'):\n sampsig = kwargs.get('diag_samp_median_sigma')\n print 'Setting diag_samp_median_sigma to ', kwargs.get('diag_samp_median_sigma')\n else:\n sampsig=3.0\n \n if kwargs.has_key('bleed'):\n bleed_switch = kwargs.get('bleed')\n print 'Setting bleed ', kwargs.get('bleed')\n else:\n print 'bleed set to default'\n #####diad end########\n \n \n if kwargs.has_key('det_cal_file'):\n reducer.det_cal_file = kwargs.get('det_cal_file')\n reducer.relocate_dets = True\n print 'Setting detector calibration file to ', kwargs.get('det_cal_file')\n else:\n print 'Setting detector calibration to detector block info from ', sample_run\n reducer.det_cal_file =None\n reducer.relocate_dets = False\n \n if mtd.doesExist(str(sample_run))==True and kwargs.has_key('det_cal_file')==False:\n print 'For data input type: workspace detector calibration must be specified'\n print 'use Keyword det_cal_file with a valid detctor file or run number'\n return\n \n \n if kwargs.has_key('one2one'):\n reducer.map_file =None\n map_file = \"\"\n print 'one2one selected'\n else:\n fileName, fileExtension = os.path.splitext(map_file)\n if (not fileExtension):\n map_file = map_file+'.map'\n reducer.map_file = map_file;\n \n if kwargs.has_key('hardmaskPlus'):\n HardMaskFile = kwargs.get('hardmaskPlus')\n print 'Use hardmask from ', HardMaskFile\n #hardMaskSpec=common.load_mask(HardMaskFile)\n #MaskDetectors(Workspace='masking',SpectraList=hardMaskSpec)\n else:\n HardMaskFile=None\n \n reducer.energy_bins = rebin\n #monovan info\n fileName, fileExtension = os.path.splitext(monovan_mapfile)\n if (not fileExtension):\n monovan_mapfile=monovan_mapfile+'.map'\n reducer.abs_map_file =monovan_mapfile \n\n if kwargs.has_key('abs_units_van_range'):\n reducer.monovan_integr_range = kwargs.get('abs_units_van_range')\n print 'Setting absolute units vanadium integration range to: ', kwargs.get('abs_units_van_range')\n else:\n reducer.monovan_integr_range=[-40,40]\n\n \n \n print 'output will be normalised to', reducer.normalise_method\n if (numpy.size(sample_run)) > 1 and kwargs.has_key('sum') and kwargs.get('sum')==True:\n #this sums the runs together before passing the summed file to the rest of the reduction\n #this circumvents the inbuilt method of summing which fails to sum the files for diag\n \n sumfilename=str(sample_run[0])+'sum'\n accum=sum_files(sumfilename, sample_run)\n #the D.E.C. tries to be too clever so we have to fool it into thinking the raw file is already exists as a workpsace\n RenameWorkspace(InputWorkspace=accum,OutputWorkspace=inst_name+str(sample_run[0])+'.raw')\n sample_run=sample_run[0]\n \n if kwargs.has_key('hardmaskOnly'):\n if (kwargs.get('hardmaskOnly')): \n totalmask = kwargs.get('hardmaskOnly')\n print 'Using hardmask from ', totalmask\n #next stable version can replace this with loadmask algoritum\n specs=diag_load_mask(totalmask)\n else:\n specs=\"\"\n \n CloneWorkspace(InputWorkspace=sample_run,OutputWorkspace='mask_wksp')\n MaskDetectors(Workspace='mask_wksp',SpectraList=specs)\n masking =mtd['mask_wksp']\n else:\n print '########### Run diagnose for sample run ##############'\n masking = reducer.diagnose(wb_run, \n sample=mask_run,\n second_white = None,\n tiny=tinyval, \n huge=largeval, \n van_out_lo=vanoutlo,\n van_out_hi=vanouthi,\n van_lo=vanlo,\n van_hi=vanhi,\n van_sig=vansig,\n samp_zero=sampzero,\n samp_lo=samplo,\n samp_hi=samphi,\n samp_sig=sampsig,\n bkgd_range=background_range, \n variation=1.1,\n print_results=True,\n bleed_test=bleed_switch,\n bleed_maxrate=rate,\n bleed_pixels=pixels,\n hard_mask=HardMaskFile)\n \n fail_list,n_total_spectra =get_failed_spectra_list_from_masks(masking) \n print 'first Diag found ', len(fail_list),'bad spectra out of: ',n_total_spectra,' ws spectra'\n \n if kwargs.has_key('use_sam_msk_on_monovan') and kwargs.get('use_sam_msk_on_monovan')==True:\n print 'applying sample run mask to mono van'\n reducer.spectra_masks=masking\n fail_list=get_failed_spectra_list(masking) \n else:\n print '########### Run diagnose for monochromatic vanadium run ##############'\n masking2 = reducer.diagnose(wb_mono, \n sample=mono_van,\n second_white = None,\n tiny=tinyval, \n huge=largeval, \n van_out_lo=vanoutlo,\n van_out_hi=vanouthi,\n van_lo=vanlo,\n van_hi=vanhi,\n van_sig=vansig,\n samp_zero=sampzero,\n samp_lo=samplo,\n samp_hi=samphi,\n samp_sig=sampsig,\n bkgd_range=background_range, \n variation=1.1,\n print_results=True,\n bleed_test=bleed_switch,\n bleed_maxrate=rate,\n bleed_pixels=pixels,\n hard_mask=HardMaskFile)\n \n total_mask=masking+masking2 \n reducer.spectra_masks=total_mask \n fail_list,n_total_spectra =get_failed_spectra_list_from_masks(total_mask)\n #fail_list=get_failed_spectra_list('total_mask')\n \n \n print 'Diag found ', len(fail_list),'bad spectra out of: ',n_total_spectra,' ws spectra'\n \n \n \n #Run the conversion first on the sample\n deltaE_wkspace_sample = reducer.convert_to_energy(sample_run, ei_guess, wb_run)\n\n \n if kwargs.has_key('mono_correction_factor'):\n absnorm_factor=kwargs.get('mono_correction_factor')\n print 'Using supplied correction factor for absolute units'\n else:\n print '##### Evaluate the integral from the monovan run and calculate the correction factor ######'\n print ' Using absolute units vanadion integration range : ', reducer.monovan_integr_range \n #now on the mono_vanadium run swap the mapping file\n reducer.map_file = monovan_mapfile \n deltaE_wkspace_monovan = reducer.convert_to_energy(mono_van, ei_guess, wb_mono)\n \n (absnorm_factorL,absnorm_factorSS,absnorm_factorP,absnorm_factTGP) = getAbsNormalizationFactor(deltaE_wkspace_monovan.getName(),str(reducer.monovan_integr_range[0]),str(reducer.monovan_integr_range[1])) \n \n print 'Absolute correction factor S^2 =',absnorm_factorSS,' Libisis: ',absnorm_factorL,' Puasonian: ',absnorm_factorP, ' TGP : ',absnorm_factTGP\n CreateSingleValuedWorkspace(OutputWorkspace='AbsFactor',DataValue=absnorm_factTGP)\n end_time=time.time()\n results_name=str(sample_run)+'.spe'\n ei= (deltaE_wkspace_sample.getRun().getLogData(\"Ei\").value)\n \n if mtd.doesExist('_wksp.spe-white')==True:\n DeleteWorkspace(Workspace='_wksp.spe-white')\n \n \n print 'Incident energy found for sample run ',ei,' meV'\n print 'Incident energy found for mono vanadium run ',ei,' meV'\n print 'Elapsed time =',end_time-start_time, 's'\n #get the name that convert to energy will use\n \n if mtd.doesExist(results_name)==False:\n RenameWorkspace(InputWorkspace=deltaE_wkspace_sample,OutputWorkspace=results_name)\n if results_name != wksp_out:\n RenameWorkspace(InputWorkspace=results_name,OutputWorkspace=wksp_out)\n Divide(LHSWorkspace=wksp_out,RHSWorkspace='AbsFactor',OutputWorkspace=wksp_out)\n DeleteWorkspace(Workspace='AbsFactor')\n return mtd[wksp_out]","def _plot_comparison(xs, pan, other_program_name, **kw):\n\n pans = ['Bmax', 'Emax']\n units = ['(mG)', '(kV/m)']\n title_app = [', Max Magnetic Field', ', Max Electric Field']\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\n '-%s-comparison-Emax' % other_program_name]\n\n for p,u,t,s in zip(pans, units, title_app, save_suf):\n #figure object and axes\n fig = plt.figure()\n ax_abs = fig.add_subplot(2,1,1)\n ax_per = ax_abs.twinx()\n ax_mag = fig.add_subplot(2,1,2)\n #Bmax\n #init handles and labels lists for legend\n kw['H'], kw['L'] = [], []\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\n other_program_name, **kw)\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\n _check_und_conds([xs], [ax_mag], **kw)\n ax_abs.set_title('Absolute and Percent Difference' + t)\n ax_mag.set_ylabel(p + ' ' + u)\n ax_mag.set_title('Model Results' + t)\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\n #_format_twin_axes(ax_abs, ax_per)\n _save_fig(xs.sheet + s, fig, **kw)","def ISM_fractions_per_cell(**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n # Load sim and cell data\n gal_ob = gal.galaxy(p.gal_index)\n cell_data = gal_ob.cell_data.get_dataframe()\n\n if p.add:\n ax = plt.gca()\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n\n x = ax.hist(np.log10(cell_data['mf_H2_grid']),bins=100,alpha=0.6,label='H2',color='r')\n x = ax.hist(np.log10(cell_data['mf_HI_grid']),bins=100,alpha=0.6,label='HI',color='orange')\n x = ax.hist(np.log10(cell_data['mf_HII_grid']),bins=100,alpha=0.4,label='HII',color='b')\n ax.set_xlabel('log Mass fraction per cell')\n ax.set_ylabel('# cells')\n ax.set_yscale('log')\n ax.legend()\n\n print('Mass fraction of cells with >90\\% ionized gas:')\n cell_data1 = cell_data[cell_data['mf_HII_grid'] > 0.9]\n print('%.4f %%' % (100.*np.sum(cell_data1['mf_HII_grid']*cell_data1['m'])/np.sum(cell_data['m'])))\n\n print('Mass fraction of total ionized gas:')\n print('%.4f %%' % (100.*np.sum(cell_data['mf_HII_grid']*cell_data['m'])/np.sum(cell_data['m'])))\n\n print('---')\n\n print('Mass fraction of cells with >90\\% atomic gas:')\n cell_data1 = cell_data[cell_data['mf_HI_grid'] > 0.9]\n print('%.4f %%' % (100.*np.sum(cell_data1['mf_HI_grid']*cell_data1['m'])/np.sum(cell_data['m'])))\n\n print('Mass fraction of total atomic gas:')\n print('%.4f %%' % (100.*np.sum(cell_data['mf_HI_grid']*cell_data['m'])/np.sum(cell_data['m'])))\n\n print('---')\n\n print('Mass fraction of cells with >90\\% molecular gas:')\n cell_data1 = cell_data[cell_data['mf_H2_grid'] > 0.9]\n print('%.4f %%' % (100.*np.sum(cell_data1['mf_H2_grid']*cell_data1['m'])/np.sum(cell_data['m'])))\n\n print('Mass fraction of total molecular gas:')\n print('%.4f %%' % (100.*np.sum(cell_data['mf_H2_grid']*cell_data['m'])/np.sum(cell_data['m'])))\n\n if p.xlim: ax.set_xlim(p.xlim)\n if p.ylim: ax.set_ylim(p.ylim)","def calculate_relative_mags(self):\n total = sum(self.mags)\n self.rel_mags = []\n for mag in self.mags:\n try:\n rel = mag/total\n except ZeroDivisionError:\n rel = 0\n self.rel_mags.append(rel)","def determinePlotLimits(self):\n max_str = \"up99\"\n min_str = \"dn99\"\n if self.keywords.get(\"limit_type\",\"99per\") == \"minmax\":\n max_str = \"max\"\n min_str = \"min\"\n \n # Determine the min/max of variables over all models\n limits = {}\n prune = False\n for fname in glob.glob(os.path.join(self.output_path,\"*.nc\")):\n with Dataset(fname) as dataset:\n if \"MeanState\" not in dataset.groups: continue\n group = dataset.groups[\"MeanState\"]\n variables = [v for v in group.variables.keys() if v not in group.dimensions.keys()]\n for vname in variables:\n var = group.variables[vname]\n pname = vname.split(\"_\")[0]\n region = vname.split(\"_\")[-1]\n if var[...].size <= 1: continue\n if space_opts.has_key(pname):\n if not limits.has_key(pname):\n limits[pname] = {}\n limits[pname][\"min\"] = +1e20\n limits[pname][\"max\"] = -1e20\n limits[pname][\"unit\"] = post.UnitStringToMatplotlib(var.getncattr(\"units\"))\n limits[pname][\"min\"] = min(limits[pname][\"min\"],var.getncattr(min_str))\n limits[pname][\"max\"] = max(limits[pname][\"max\"],var.getncattr(max_str))\n elif time_opts.has_key(pname):\n if not limits.has_key(pname): limits[pname] = {}\n if not limits[pname].has_key(region):\n limits[pname][region] = {}\n limits[pname][region][\"min\"] = +1e20\n limits[pname][region][\"max\"] = -1e20\n limits[pname][region][\"unit\"] = post.UnitStringToMatplotlib(var.getncattr(\"units\"))\n limits[pname][region][\"min\"] = min(limits[pname][region][\"min\"],var.getncattr(\"min\"))\n limits[pname][region][\"max\"] = max(limits[pname][region][\"max\"],var.getncattr(\"max\"))\n if not prune and \"Benchmark\" in fname and pname == \"timeint\":\n prune = True\n self.pruneRegions(Variable(filename = fname,\n variable_name = vname,\n groupname = \"MeanState\"))\n \n # Second pass to plot legends (FIX: only for master?)\n for pname in limits.keys():\n\n try:\n opts = space_opts[pname]\n except:\n continue\n \n # Determine plot limits and colormap\n if opts[\"sym\"]:\n vabs = max(abs(limits[pname][\"min\"]),abs(limits[pname][\"min\"]))\n limits[pname][\"min\"] = -vabs\n limits[pname][\"max\"] = vabs\n\n # if a score, force to be [0,1]\n if \"score\" in pname:\n limits[pname][\"min\"] = 0\n limits[pname][\"max\"] = 1\n\n limits[pname][\"cmap\"] = opts[\"cmap\"]\n if limits[pname][\"cmap\"] == \"choose\": limits[pname][\"cmap\"] = self.cmap\n\n # Plot a legend for each key\n if opts[\"haslegend\"]:\n fig,ax = plt.subplots(figsize=(6.8,1.0),tight_layout=True)\n label = opts[\"label\"]\n if label == \"unit\": label = limits[pname][\"unit\"]\n post.ColorBar(ax,\n vmin = limits[pname][\"min\"],\n vmax = limits[pname][\"max\"],\n cmap = limits[pname][\"cmap\"],\n ticks = opts[\"ticks\"],\n ticklabels = opts[\"ticklabels\"],\n label = label)\n fig.savefig(os.path.join(self.output_path,\"legend_%s.png\" % (pname))) \n plt.close()\n\n # Determine min/max of relationship variables\n for fname in glob.glob(os.path.join(self.output_path,\"*.nc\")):\n with Dataset(fname) as dataset:\n for g in dataset.groups.keys():\n if \"relationship\" not in g: continue\n grp = dataset.groups[g]\n if not limits.has_key(g):\n limits[g] = {}\n limits[g][\"xmin\"] = +1e20\n limits[g][\"xmax\"] = -1e20\n limits[g][\"ymin\"] = +1e20\n limits[g][\"ymax\"] = -1e20\n limits[g][\"xmin\"] = min(limits[g][\"xmin\"],grp.variables[\"ind_bnd\"][ 0, 0])\n limits[g][\"xmax\"] = max(limits[g][\"xmax\"],grp.variables[\"ind_bnd\"][-1,-1])\n limits[g][\"ymin\"] = min(limits[g][\"ymin\"],grp.variables[\"dep_bnd\"][ 0, 0])\n limits[g][\"ymax\"] = max(limits[g][\"ymax\"],grp.variables[\"dep_bnd\"][-1,-1])\n\n \n self.limits = limits","def ResBeam_Stats_plot(n, header_bmaj, header_bmin): \n\n file_dir = 'SpectralCube_BeamLogs'\n basename = '/beamlog.image.restored.' + imagebase + field\n\n # use different basename for the Milky Way range\n if not glob.glob(file_dir + basename +'*.txt'):\n basename = '/beamlog.image.restored.' + imagebase + 'MilkyWay.' + field\n\n \n BEAM_THRESHOLD = []\n \n title1 = 'Restoring beam bmaj standard deviation [arcsec]'\n plt_name1 = 'BmajStdev.png'\n saved_fig1 = fig_dir+'/'+plt_name1\n\n title2 = 'Restoring beam bmin standard deviation [arcsec]'\n plt_name2 = 'BminStdev.png'\n saved_fig2 = fig_dir+'/'+plt_name2\n\n title3 = 'Maximum ratio of beam area'\n plt_name3 = 'max_ratioBA.png'\n saved_fig3 = fig_dir+'/'+plt_name3\n\n title4 = 'Minimum ratio of beam area' \n plt_name4 = 'min_ratioBA.png'\n saved_fig4 = fig_dir+'/'+plt_name4\n \n params = {'axes.labelsize': 10,\n 'axes.titlesize': 10,\n 'font.size':10}\n\n pylab.rcParams.update(params)\n\n beamXPOS, beamYPOS = BeamPosition()\n fig1, ax1 = plt.subplots()\n fig2, ax2 = plt.subplots()\n fig3, ax3 = plt.subplots()\n fig4, ax4 = plt.subplots()\n \n for i in range(0,36):\n bnum = n[i]\n infile = file_dir + basename +'.beam%02d.txt'%(bnum)\n bmaj_stdev, bmin_stdev, beam_threshold, max_ratio_BA, min_ratio_BA = cal_ResBeam_Stats(infile, header_bmaj, header_bmin)\n BEAM_THRESHOLD.append(beam_threshold)\n\n ax1.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\n ax1.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax1.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmaj_stdev, 3), va='center', ha='center', fontsize=8, color='blue')\n\n ax2.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\n ax2.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax2.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmin_stdev,3), va='center', ha='center', fontsize=8, color='blue')\n\n maxplot = ax3.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[max_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\n ax3.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax3.text(beamXPOS[i], beamYPOS[i]-0.02, round(max_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\n \n minplot = ax4.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[min_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\n ax4.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\n ax4.text(beamXPOS[i], beamYPOS[i]-0.02, round(min_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\n \n ax1.set_xlim(0,0.7)\n ax1.set_ylim(0,1.4)\n ax1.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax1.set_title(title1)\n\n ax2.set_xlim(0,0.7)\n ax2.set_ylim(0,1.4)\n ax2.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax2.set_title(title2)\n\n ax3.set_xlim(0,0.7)\n ax3.set_ylim(0,1.4)\n ax3.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax3.set_title(title3)\n plt.colorbar(maxplot, ax=ax3)\n\n ax4.set_xlim(0,0.7)\n ax4.set_ylim(0,1.4)\n ax4.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\n ax4.set_title(title4)\n plt.colorbar(minplot, ax=ax4)\n\n fig1.savefig(saved_fig1, bbox_inches='tight')\n fig2.savefig(saved_fig2, bbox_inches='tight')\n fig3.savefig(saved_fig3, bbox_inches='tight')\n fig4.savefig(saved_fig4, bbox_inches='tight')\n\n plt.close('all')\n\n return saved_fig1, saved_fig2, plt_name1, plt_name2, saved_fig3, saved_fig4, plt_name3, plt_name4, BEAM_THRESHOLD","def comparison_plot(input_file, input_pm_file, output_file, titles=None, cut=None):\n\n # get titles for each subplot and dwarf proper motions\n titles, dwarf_pmra, dwarf_pmdec = load_dwarf_info(input_file, titles)\n\n # load stellar pm values\n ra, dec, pmra, pmdec, parallax, parallax_error = load_gaia_search_info(input_pm_file)\n\n # set fig size and shape\n fig, axs = plot_setup(3, 3)\n\n # choose how many dwarfs to compare\n counter = range(0, 3)\n\n # plot each dwarf in separate subplots\n for (i, title, *data) in zip(counter, titles, ra, dec, pmra, pmdec, parallax, parallax_error):\n # add quiver plot\n arrows = quiver_plot(fig, axs[i, 0], data, title, append_title=\" quiver\", cut=cut)\n\n # generate parallax histogram\n n, bins, patches = parallax_histogram(fig, axs[i, 1], data, title, append_title=\" parallax\", cut=cut)\n\n # add pm 2d histograms\n counts, xedges, yedges, im = pm_histogram(fig, axs[i, 2], data, title, append_title=\" pm histo\", dwarf_pmra=dwarf_pmra[i], dwarf_pmdec=dwarf_pmdec[i], cut=cut)\n\n plt.tight_layout()\n\n\n fig.savefig(output_file, bbox_inches='tight')","def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\r\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\r\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \r\n if listOfNames==None:\r\n listOfNames = listOfFilesToPlot\r\n if listOfColors==None:\r\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\r\n \r\n fig = pylab.figure(figsize=figsize)\r\n ax = fig.add_subplot(111, projection='3d')\r\n\r\n yTotal = len(listOfFilesToPlot)\r\n top = 0.0\r\n\r\n if not (subtractRef is None):\r\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\r\n #zsRef = list(numpy.array(zsRef)-fixedOffset\r\n zNorm = max(zsRef[len(zsRef)/2:])\r\n zsRef = numpy.array(zsRef)/zNorm\r\n \r\n for i,f in enumerate(listOfFilesToPlot):\r\n [xs, zs, name] = qMS.readMSSpectraFile(f)\r\n if fixedOffset:\r\n off = zs[len(zs)/2]\r\n print off\r\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\r\n zs = list(numpy.array(zs)-off)\r\n ys = [yTotal-i]*len(xs)\r\n ys = numpy.array(ys)*yScale\r\n if normalizeToN15:\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n if not (subtractRef is None):\r\n zNorm = max(zs[len(zs)/2:])\r\n zs = numpy.array(zs)/zNorm\r\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\r\n zs = zs*zNorm\r\n #xs = xs[:len(xs)/2]\r\n #ys = ys[:len(ys)/2]\r\n #zs = zs[:len(zs)/2]\r\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\r\n if (scaleP is True) and (i==scaleI):\r\n zs = numpy.array(zs)*scaleVal\r\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\r\n top = max([top, float(max(zs))])\r\n\r\n\r\n ax.w_xaxis.pane.set_visible(False)\r\n ax.w_yaxis.pane.set_visible(False)\r\n ax.w_zaxis.pane.set_visible(False)\r\n\r\n if gridLines: \r\n ax.w_xaxis.gridlines.set_linewidth(1)\r\n ax.w_yaxis.gridlines.set_linewidth(1)\r\n ax.w_zaxis.gridlines.set_linewidth(1)\r\n \r\n else:\r\n ax.w_xaxis.gridlines.set_visible(False)\r\n ax.w_yaxis.gridlines.set_visible(False)\r\n ax.w_zaxis.gridlines.set_visible(False)\r\n\r\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\r\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\r\n\r\n ax.w_xaxis.line.set_linewidth(1)\r\n ax.w_yaxis.line.set_linewidth(1)\r\n ax.w_zaxis.line.set_linewidth(1)\r\n \r\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\r\n ax.set_zlim3d([0, top])\r\n ax.set_ylim3d(yMin, yMax)\r\n ax.set_yticks(range(1,yTotal+1))\r\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\r\n ax.set_xlim3d([xMin, xMax])\r\n \r\n if noTicks:\r\n ax.set_zticks([])\r\n ax.set_xticks([])\r\n ax.set_yticks([])\r\n\r\n ax.set_xlabel(xlabel)\r\n ax.set_zlabel(zlabel)\r\n\r\n ax.view_init(15, -60)\r\n if legend:\r\n pylab.legend(loc=legendLoc)\r\n \r\n pylab.tight_layout()\r\n return ax","def perSaccPerObject(addExp2 = True, trim = True, spacing = .5, addSimulation = True, \\\n\t\texclOverlap = True):\n\n\t\n\tfig = plt.figure()\n\tplt.subplots_adjust(wspace = .5)\n\t#fig = plt.figure(figsize = (10,10))\n\ttitle = \"Average towards-handle landings per stimulus exclOverlap = %s\" % exclOverlap\n\tplt.suptitle(title)\n\t\n\t\n\t# Exp 1:\n\tdm1 = getDM.getDM(exp = \"004A\", excludeErrors = True, driftCorr = True)\n\t\n\tsubPlot = 1\n\t\n\tfor stim in dm1.unique(\"object\"):\n\n\t\t# New subplot:\n\t\tplt.subplot(2,7,subPlot)\n\t\t#plt.title(stim)\n\t\t_dm1 = dm1.select(\"object == '%s'\" % stim)\n\n\t\tlLandingsAbs = []\n\t\tlLandingsCorr = []\n\t\t\n\t\tfor sacc in [\"1\", \"2\", \"3\"]:\n\t\t\t\n\t\t\t# This is the same for corrected landing positions (the saccade\n\t\t\t# doesn't change; only the reference point does)\n\t\t\t_dm = _dm1.select(\"endX%sNorm != ''\" % sacc)\n\t\t\t_dm = _dm.select(\"endX%sNorm > -.5\" % sacc)\n\t\t\t_dm = _dm.select(\"endX%sNorm < .5\" % sacc)\n\t\t\t\n\t\t\tif trim:\n\t\t\t\t_dmAbs = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sNormToHandle\" % sacc)\n\t\t\t\t_dmCorr = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sCorrNormToHandle\" % sacc)\n\t\t\t\n\t\t\t# Determine avg landing position:\n\t\t\tavgAbs = _dmAbs[\"endX%sNormToHandle\" % sacc].mean()\n\t\t\tavgCorr = _dmCorr[\"endX%sCorrNormToHandle\" % sacc].mean()\n\t\t\t\n\t\t\t# TODO: determine error bars:\n\t\t\t\n\t\t\t\n\t\t\tlLandingsAbs.append(avgAbs)\n\t\t\tlLandingsCorr.append(avgCorr)\n\t\t\n\t\tplt.plot(lLandingsAbs, color = \"#f57900\", linewidth = 2, marker = \"o\")\n\t\tplt.plot(lLandingsCorr, color = \"#73d216\", linewidth = 2, marker = \"o\")\n\t\tplt.ylabel(stim)\n\t\t\n\t\t# The other 2 experiments can be treated equally:\n\t\tcolList = [\"#ef2929\", \"#3465a4\"]\n\t\t\n\t\tfor exp in [\"004B\", \"004C\"]:\n\t\t\t\n\t\t\tif not addExp2:\n\t\t\t\tif exp == \"004B\":\n\t\t\t\t\tcontinue\n\t\t\tif not addSimulation:\n\t\t\t\tif exp == \"004C\":\n\t\t\t\t\tcontinue\n\n\t\t\tdm = getDM.getDM(exp = exp, excludeErrors = True, driftCorr = True)\n\t\t\t_dm = dm.select(\"object == '%s'\" % stim)\n\t\t\t\n\t\t\tif exp == \"004C\":\n\t\t\t\tif exclOverlap:\n\t\t\t\t\t_dm = _dm.select(\"gap == 'zero'\")\n\t\t\t\n\t\t\tlLandingsAbs = []\n\t\t\t\n\t\t\tfor sacc in [\"1\", \"2\", \"3\"]:\n\t\t\t\t\n\t\t\t\t# TODO: how to filter only on-object saccades exp 2??\n\t\t\t\tsacc_dm = _dm.select(\"endX%sNorm != ''\" % sacc)\n\t\t\t\tsacc_dm = sacc_dm.select(\"endX%sNorm > -.5\" % sacc)\n\t\t\t\tsacc_dm = sacc_dm.select(\"endX%sNorm < .5\" % sacc)\n\t\t\t\t\n\t\t\t\tif trim:\n\t\t\t\t\tsacc_dm = sacc_dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sNormToHandle\" % sacc)\n\t\t\t\t\n\t\t\t\t# Determine avg landing position:\n\t\t\t\tavgAbs = sacc_dm[\"endX%sNormToHandle\" % sacc].mean()\n\t\t\t\t\n\t\t\t\t# TODO: determine error bars:\n\t\t\t\t\n\t\t\t\tlLandingsAbs.append(avgAbs)\n\t\t\tcol = colList.pop()\n\t\t\tplt.plot(lLandingsAbs, color = col, linewidth = 2, marker = \"o\")\n\t\t\t\n\t\t# Modify plot:\n\t\t#plt.legend([\"Exp1 abs\", \"Exp1 corr\", \"Exp2\", \"Sim\"])\n\t\t\t\n\t\tplt.axhline(0, color = \"#888a85\", linestyle = \"--\", linewidth = 2)\n\t\txLabels = [\"sacc 1\", \"sacc 2\", \"sacc 3\"]\n\t\txTicks = range(0,3)\n\t\t#plt.xticks(xTicks, xLabels, rotation = .5)\n\t\tplt.ylim([-.5, .5])\n\t\tplt.yticks([])\n\t\tplt.xticks([])\n\t\tplt.xlim(min(xTicks)-spacing, max(xTicks)+spacing)\n\t\t\n\t\tsubPlot +=1\n\t\t\n\tplt.savefig(\"%s.png\" % title)","def calculate_abs(self):\n ref_spectra_raw = np.array(self.raw_data['spectrum_0'].attrs['reference'])\n self.ref_spectra_arr = np.subtract(ref_spectra_raw,self.back_spectra_arr)\n abs=-np.log10(self.pre_proc_data.div(self.ref_spectra_arr))\n self.abs_data=abs\n return self.abs_data","def draco_comparison_plot(input_file, input_pm_file, output_file, cuts, dwarf=0, titles=None, radius=0):\n\n # get titles for each subplot and dwarf proper motions\n titles, dwarf_pmra, dwarf_pmdec = load_dwarf_info(input_file, titles)\n\n # load stellar pm values\n ra, dec, pmra, pmdec, parallax, parallax_error = load_gaia_search_info(input_pm_file)\n\n # set fig size and shape\n fig, axs = plot_setup(len(cuts), 3)\n\n # plot each dwarf in separate subplots\n for j, (title, *data) in enumerate(zip(titles, ra, dec, pmra, pmdec, parallax, parallax_error)):\n if j==dwarf:\n for i, cut in enumerate(cuts):\n # add quiver plot\n arrows = quiver_plot(fig, axs[i, 0], data, f\"{title.strip('NAME ')} quiver\", cut=cut, radius=radius)\n\n # generate parallax histogram\n n, bins, patches = parallax_histogram(fig, axs[i, 1], data, rf\"{title.strip('NAME ')} parallax, cut={cut}$\\sigma$\", cut=cut)\n\n # add pm 2d histograms\n counts, xedges, yedges, im = pm_histogram(fig, axs[i, 2], data, f\"{title.strip('NAME ')} pm histo\", dwarf_pmra=dwarf_pmra[j], dwarf_pmdec=dwarf_pmdec[j], cut=cut)\n\n plt.tight_layout()\n\n\n fig.savefig(output_file, bbox_inches='tight')","def plot_feeding_zones_and_power_law_fit_MMEN_per_system_observed_and_physical(sssp_per_sys, sssp, n_mult_min=2, n_mult_max=10, max_core_mass=10., prescription='CL2013', n=10., a0=1., p0=1., p1=-1.5, scale_up=False, N_sys=10):\n y_sym_star = '*' if scale_up else ''\n assert 2 <= n_mult_min <= n_mult_max\n count = 0\n for i,det_sys in enumerate(sssp_per_sys['det_all']):\n if count >= N_sys:\n break\n if n_mult_min <= np.sum(det_sys) <= n_mult_max:\n count += 1\n print('##### System %s (i=%s):' % (count, i))\n\n Mstar = sssp['Mstar_all'][i]\n Mp_sys = sssp_per_sys['mass_all'][i]\n core_mass_sys = np.copy(Mp_sys) # all planet masses including padded zeros\n core_mass_sys[core_mass_sys > max_core_mass] = max_core_mass\n R_sys = sssp_per_sys['radii_all'][i] # all planet radii including padded zeros\n a_sys = sssp_per_sys['a_all'][i] # all semimajor axes including padded zeros\n\n core_mass_sys_obs = np.copy(Mp_sys)[det_sys == 1] # masses of observed planets\n core_mass_sys_obs[core_mass_sys_obs > max_core_mass] = max_core_mass\n R_sys_obs = R_sys[det_sys == 1] # radii of observed planets\n a_sys_obs = a_sys[det_sys == 1] # semimajor axes of observed planets\n core_mass_sys = core_mass_sys[a_sys > 0] # masses of all planets\n R_sys = R_sys[a_sys > 0] # radii of all planets\n a_sys = a_sys[a_sys > 0] # semimajor axes of all planets\n\n sigma_sys = solid_surface_density_prescription(core_mass_sys, R_sys, a_sys, Mstar=Mstar, n=n, prescription=prescription) # using all planets\n sigma_sys_obs = solid_surface_density_prescription(core_mass_sys_obs, R_sys_obs, a_sys_obs, Mstar=Mstar, n=n, prescription=prescription) # using observed planets only\n\n if scale_up:\n sigma0, beta, scale_factor_sigma0 = fit_power_law_and_scale_up_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\n sigma0_obs, beta_obs, scale_factor_sigma0_obs = fit_power_law_and_scale_up_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\n else:\n sigma0, beta = fit_power_law_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\n scale_factor_sigma0 = 1.\n sigma0_obs, beta_obs = fit_power_law_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\n scale_factor_sigma0_obs = 1.\n\n # Plot the system:\n a_array = np.linspace(1e-3,2,1001)\n sigma_MMSN = MMSN(a_array)\n\n delta_a_sys_S2014 = feeding_zone_S2014(core_mass_sys, R_sys, a_sys, Mstar=Mstar)\n delta_a_sys_nHill = feeding_zone_nHill(core_mass_sys, a_sys, Mstar=Mstar, n=n)\n delta_a_sys_RC2014, a_bounds_sys = feeding_zone_RC2014(a_sys)\n\n fig = plt.figure(figsize=(12,8))\n plot = GridSpec(1,1,left=0.1,bottom=0.15,right=0.95,top=0.95,wspace=0,hspace=0)\n ax = plt.subplot(plot[0,0])\n plt.scatter(a_sys, np.log10(sigma_sys), marker='o', s=100.*R_sys**2., facecolors='none', edgecolors='k', label='All planets')\n plt.scatter(a_sys_obs, np.log10(sigma_sys_obs), marker='o', s=100.*R_sys_obs**2., color='k', label='Observed planets')\n for j,a in enumerate(a_sys):\n # Plot various feeding zones for each planet:\n da_S2014 = delta_a_sys_S2014[j]\n da_nHill = delta_a_sys_nHill[j]\n #da_RC2014 = delta_a_sys_RC2014[j]\n #plt.plot([0.5*a, 1.5*a], [np.log10(1.15*sigma_sys[j])]*2, lw=1, color='k')\n #plt.plot([a - da_S2014/2., a + da_S2014/2.], [np.log10(1.05*sigma_sys[j])]*2, lw=1, color='r')\n #plt.plot([a - da_nHill/2., a + da_nHill/2.], [np.log10(0.95*sigma_sys[j])]*2, lw=1, color='b')\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(0.85*sigma_sys[j])]*2, lw=1, color='m')\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(sigma_sys[j])]*2, lw=2, color='k') # lines for feeding zones\n plt.axvspan(a_bounds_sys[j], a_bounds_sys[j+1], alpha=0.2 if j%2==0 else 0.1, ec=None, fc='k')\n\n # To compare the planet masses to the integrated disk masses:\n Mp_core = core_mass_sys[j]\n plt.annotate(r'${:0.1f} M_\\oplus$'.format(Mp_core), (a, np.log10(1.5*sigma_sys[j])), ha='center', fontsize=16)\n if prescription == 'CL2013':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(1.5*a, 0.5*a, sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (CL2013): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n elif prescription == 'S2014':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_S2014/2., a - da_S2014/2., sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (S2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n elif prescription == 'nHill':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_nHill/2., a - da_nHill/2., sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (nHill): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n elif prescription == 'RC2014':\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a_bounds_sys[j+1], a_bounds_sys[j], sigma0, beta, a0=a0)\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (RC2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\n\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0, beta, a0=a0)), lw=3, ls='-', color='r', label=r'Fit to all planets ($\\Sigma_0^%s = {:0.0f}$, $\\beta = {:0.2f}$)'.format(sigma0, beta) % y_sym_star)\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0_obs, beta_obs, a0=a0)), lw=3, ls='--', color='r', label=r'Fit to observed planets ($\\Sigma_0^%s = {:0.0f}$, $\\beta = {:0.2f}$)'.format(sigma0_obs, beta_obs) % y_sym_star)\n plt.plot(a_array, np.log10(sigma_MMSN), lw=3, color='g', label=r'MMSN ($\\Sigma_0 = {:0.0f}$, $\\beta = {:0.2f}$)'.format(MMSN(a0), -1.5))\n ax.tick_params(axis='both', labelsize=20)\n plt.gca().set_xscale(\"log\")\n plt.xticks([0.05, 0.1, 0.2, 0.4, 0.8])\n ax.get_xaxis().set_major_formatter(ticker.ScalarFormatter())\n plt.xlim([0.04,0.9])\n plt.ylim([-0.5,5.5])\n plt.xlabel(r'Semimajor axis, $a$ (AU)', fontsize=20)\n plt.ylabel(r'Surface density, $\\log_{10}(\\Sigma/{\\rm g\\,cm}^{-2})$', fontsize=20)\n plt.legend(loc='lower left', bbox_to_anchor=(0.,0.), ncol=1, frameon=False, fontsize=16)\n\n plt.show()","def cauchy_rbins_fit(self, plotfig=False, plotrmax=50, normtype=1):\n A0 = self.rbins.max()\n gammaArr = np.arange(200)*.2 + .2 # double check\n Amin, gamma_min, rms, rmsArr = _cauchy_rbins_fit(self.rArr, self.rbins, A0=A0, gammaArr=gammaArr, normtype=normtype)\n self.rbins_pre = Amin/np.pi*(gamma_min/((self.rArr)**2+gamma_min**2) )\n self.Amin = Amin\n self.gamma_cauchy_rbins = gamma_min\n self.rms = rms\n temp = gammaArr[rmsArr<rms*1.1]\n self.gmax = temp.max(); self.gmin = temp.min()\n # print Amin, gamma_min, rms\n if plotfig:\n ax=plt.subplot()\n plt.plot(self.rArr, self.rbins, 'o', ms=10, label='observed')\n plt.plot(self.rArr, self.rbins_pre, 'k--', lw=3, label='Best fit Cauchy distribution')\n # plt.plot(self.rArr, self.rbins_pre_gauss, 'r--', lw=3, label='Best fit Gaussian distribution')\n plt.ylabel('PDF ', fontsize=30)\n plt.xlabel('Radius (nm)', fontsize=30)\n ax.tick_params(axis='x', labelsize=20)\n ax.tick_params(axis='y', labelsize=20)\n plt.legend(loc=0, fontsize=20, numpoints=1)\n plt.yscale('log', nonposy='clip')\n plt.xlim(0, plotrmax)\n plt.ylim(1e-8, 0.1)\n plt.show()","def val_input(self):\n global in_data\n val_result = True\n err_msg = ''\n h_to_check = 'P_NAME;AZM_BRNG;DIST'\n # Assign input to variables\n rp_lat_dms = self.dlg.leRefLat.text() # Latitude of the reference point\n rp_lon_dms = self.dlg.leRefLon.text() # Longitude of the reference point\n rp_mv = self.dlg.leRefMagVar.text() # Magnetic variation of the reference point\n in_csv = self.dlg.leInCsv.text() # Input csv file\n out_csv = self.dlg.leOutCsv.text() # Output csv file\n \n r_lat = lat_DMS_shdp2DD(rp_lat_dms)\n r_lon = lon_DMS_shdp2DD(rp_lon_dms)\n \n if r_lat == NOT_VALID: \n err_msg += 'Enter latitude of reference point in correct format\\n'\n val_result = False\n \n if r_lon == NOT_VALID:\n err_msg += 'Enter longitude of reference point in correct format\\n'\n val_result = False\n \n if rp_mv == '': # Magnetic Variation not enetered - assume magnetic variation as 0.0, \n r_mag = 0.0\n else:\n if validate_magvar(rp_mv)[0] == NOT_VALID:\n err_msg = err_msg + 'Enter magntic variation at the reference point in correct format, or leave blank if it is 0\\n'\n val_result = False\n else: \n r_mag = float(validate_magvar(rp_mv)[1])\n \n if in_csv == '':\n err_msg += 'Choose input file\\n'\n val_result = False\n else:\n if check_csv_header(in_csv, h_to_check) == NOT_VALID:\n err_msg += 'Inpute csv file header is not P_NAME;AZM_BRNG;DIST\\n'\n val_result = False\n \n if out_csv == '':\n err_msg += 'Choose output file\\n'\n val_result = False\n \n \n if val_result == True:\n input_data.assign_values(r_lat, r_lon, r_mag, in_csv, out_csv)\n else:\n QMessageBox.critical(w, \"Message\", err_msg) \n \n return val_result","def plot_reion_properties(rank, size, comm, reion_ini_files, gal_ini_files,\n model_tags, reion_plots, output_dir, output_format):\n\n # Check to see if the output directory exists.\n if rank == 0:\n if not os.path.exists(output_dir):\n os.makedirs(output_dir)\n print(\"Made output directory {0}\".format(output_dir))\n\n MC_dir = \"{0}/MC\".format(output_dir)\n os.makedirs(MC_dir)\n print(\"Made directory {0}\".format(MC_dir))\n\n # First calculate all the properties and statistics we need.\n reion_data = generate_data(rank, size, comm, reion_ini_files,\n gal_ini_files, reion_plots, output_dir,\n model_tags, output_format)\n\n # Gather all the fractions onto the master process.\n # This will be used for many different plots. \n master_mass_frac = collective.collect_hist_across_tasks(rank, comm, \n reion_data[\"mass_frac_allmodels\"]) \n master_mass_frac = comm.bcast(master_mass_frac, root = 0)\n\n # Then find out what we need and plot em!\n if reion_plots[\"history\"] and rank == 0:\n\n \n duration_z, duration_t, reion_completed = \\\n calc_duration(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n master_mass_frac, reion_plots[\"duration_definition\"])\n\n for model_number in range(len(master_mass_frac)):\n print(\"Model {0}: Start {1:.2f} \\tMid {2:.2f}\\tEnd {3:.2f}\\t\"\n \"dz {4:.2f}\\tdt {5:.1f}Myr\\tReion Completed {6}\" \\\n .format(model_number, duration_z[model_number][0],\n duration_z[model_number][1], duration_z[model_number][-1],\n duration_z[model_number][0]-duration_z[model_number][-1],\n duration_t[model_number][-1]-duration_t[model_number][0],\n reion_completed[model_number]))\n\n print(\"Plotting the reionization history.\")\n reionplot.plot_history(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_mass_frac,\n model_tags, output_dir, \"history\",\n output_format)\n\n\n\n if reion_plots[\"nion\"]:\n\n master_nion = collective.collect_hist_across_tasks(rank, comm, \n reion_data[\"nion_allmodels\"])\n\n if rank == 0:\n print(\"Plotting the ionizing emissivity.\")\n reionplot.plot_nion(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_nion,\n reion_data[\"nion_factor_allmodels\"], \n model_tags, output_dir, \"nion\", output_format)\n\n if reion_plots[\"ps_fixed_XHI\"]:\n k, P21, PHII = determine_ps_fixed_XHI(rank, size, comm,\n reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n master_mass_frac, \n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"])\n\n if rank == 0:\n print(\"Plotting PS at fixed neutral fraction.\")\n reionplot.plot_ps_fixed_XHI(k, P21, PHII,\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir, \"ps_fixed_XHI\",\n output_format)\n\n if reion_plots[\"contours\"] and rank == 0:\n # tau is used for multiple plots. So check if we need to calculate it.\n try:\n tau_allmodels\n except NameError:\n tau_allmodels = calc_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"helium_allmodels\"],\n master_mass_frac)\n\n # For the contours, only plot the optical depth at the highest z.\n tau_highz = []\n for model_number in range(len(tau_allmodels)):\n tau_highz.append(tau_allmodels[model_number][0])\n\n duration_z, duration_t, reion_completed = \\\n calc_duration(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n master_mass_frac, reion_plots[\"duration_definition\"])\n\n print(\"Plotting contours of constant tau.\")\n reionplot.plot_tau_contours(tau_highz, reion_completed,\n reion_plots[\"alpha_beta_limits\"],\n output_dir, \"tau_contours\", output_format)\n\n print(\"Plotting contours of constant reionization duration.\")\n reionplot.plot_duration_contours(duration_t, reion_completed,\n reion_plots[\"alpha_beta_limits\"],\n output_dir, \"duration_contours\",\n output_format)\n\n if reion_plots[\"optical_depth\"] and rank == 0:\n # tau is used for multiple plots. So check if we need to calculate it.\n try:\n tau_allmodels\n except NameError:\n tau_allmodels = calc_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"helium_allmodels\"],\n master_mass_frac)\n\n print(\"Plotting the optical depth.\")\n reionplot.plot_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"], \n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n tau_allmodels,\n model_tags, output_dir, \"optical_depth\",\n output_format)\n\n if reion_plots[\"optical_depth\"] and reion_plots[\"history\"] and rank == 0:\n print(\"Plotting the combined optical depth/ionization history.\")\n reionplot.plot_combined_history_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"], \n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_mass_frac, tau_allmodels, \n model_tags, output_dir,\n \"history_tau\", output_format)\n\n if reion_plots[\"optical_depth\"] and reion_plots[\"nion\"] and rank == 0:\n print(\"Plotting the combined optical depth/ionizing emissivity.\")\n reionplot.plot_combined_nion_tau(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n master_nion,\n reion_data[\"nion_factor_allmodels\"],\n tau_allmodels, model_tags, output_dir,\n \"nion_tau\", output_format)\n\n if reion_plots[\"ps_scales\"] or reion_plots[\"ps_scales_beta\"]:\n print(\"Gathering the 21cm Power Spectra across processors\")\n k, P21, PHII = gather_ps(rank, size, comm,\n reion_data[\"k_allmodels\"],\n reion_data[\"P21_allmodels\"],\n reion_data[\"PHII_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_data[\"last_snap_allmodels\"])\n\n if rank == 0:\n print(\"Plotting the large scale power as a function of small \"\n \"scale.\")\n\n if reion_plots[\"ps_scales_beta\"]:\n calc_beta = True\n else:\n calc_beta = False \n\n # Now that we have all the PS on the master rank, calculate the\n # amplitude at the specified scales.\n scale_power_dict = calc_scale_power(k, P21, PHII,\n reion_data[\"z_array_reion_allmodels\"], \n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n reion_plots[\"small_scale_err\"],\n reion_plots[\"large_scale_err\"],\n calc_beta=calc_beta)\n\n k_small_scale = scale_power_dict[\"k_small_scale\"]\n k_large_scale = scale_power_dict[\"k_large_scale\"]\n\n P21_small_scale = scale_power_dict[\"P21_small_scale\"]\n P21_large_scale = scale_power_dict[\"P21_large_scale\"]\n\n PHII_small_scale = scale_power_dict[\"PHII_small_scale\"]\n PHII_large_scale = scale_power_dict[\"PHII_large_scale\"]\n\n if reion_plots[\"ps_scales\"]:\n reionplot.plot_ps_scales(P21_small_scale,\n P21_large_scale, master_mass_frac, \n reion_data[\"z_array_reion_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n reion_plots[\"ps_scales_z\"],\n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n reion_plots[\"small_scale_err\"],\n reion_plots[\"large_scale_err\"],\n model_tags, output_dir, \"ps_scales\",\n output_format)\n\n if reion_plots[\"ps_scales_beta\"]:\n\n P21_beta = scale_power_dict[\"P21_beta\"]\n P21_beta_error = scale_power_dict[\"P21_beta_error\"]\n PHII_beta = scale_power_dict[\"PHII_beta\"]\n\n reionplot.plot_ps_beta(P21_beta, P21_beta_error,\n reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"lookback_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n reion_data[\"t_bigbang_allmodels\"],\n reion_plots[\"small_scale_def\"],\n reion_plots[\"large_scale_def\"],\n model_tags, output_dir,\n \"ps_scales_beta\", output_format)\n\n\n\n if reion_plots[\"slices_fixed_XHI\"] and rank == 0:\n print(\"Plotting slices at fixed XHI fractions.\")\n reionplot.plot_slices_XHI(reion_data[\"z_array_reion_allmodels\"],\n reion_data[\"cosmology_allmodels\"],\n master_mass_frac, \n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n reion_plots[\"cut_slice\"],\n reion_plots[\"cut_thickness\"],\n model_tags, output_dir, \"slices_XHI\",\n output_format)\n\n\n if reion_plots[\"bubble_size\"] and rank == 0:\n print(\"Determining bubble sizes at fixed XHI.\")\n reionplot.determine_bubble_size(reion_data[\"z_array_reion_allmodels\"],\n master_mass_frac,\n reion_data[\"first_snap_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir)\n\n if reion_plots[\"zreion_dens_cross\"] and rank == 0:\n print(\"Calculating the zreion-density cross correlation.\")\n k, crosspspec, crosscorr, bias = \\\n zreion_dens_cross(reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"zreion_path_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"boxsize_allmodels\"],\n reion_data[\"last_snap_allmodels\"])\n\n reionplot.plot_zreion_dens_cross(k, crosscorr, bias, model_tags,\n output_dir, \"zreion_dens_crosscorr\",\n output_format)\n\n if reion_plots[\"dens_ion_contours\"] and rank == 0:\n print(\"Plotting contours of density-ionization.\")\n reionplot.plot_dens_reion_contours(master_mass_frac,\n reion_data[\"XHII_fbase_allmodels\"],\n reion_data[\"XHII_precision_allmodels\"],\n reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"first_snap_allmodels\"],\n reion_plots[\"fixed_XHI_values\"],\n model_tags, output_dir,\n \"dens_ion_contours\", output_format)\n\n if reion_plots[\"dens_zreion_contours\"] and rank == 0:\n print(\"Plotting contours of density-zreion.\")\n reionplot.plot_dens_zreion_contours(reion_data[\"density_fbase_allmodels\"],\n reion_data[\"density_precision_allmodels\"],\n reion_data[\"zreion_path_allmodels\"],\n reion_data[\"GridSize_allmodels\"],\n reion_data[\"last_snap_allmodels\"],\n model_tags, output_dir,\n \"dens_zreion_contours\", output_format)","def calculate_relative(self, inputs):\n\n absolute_inputs = [\n {\n \"cx\": input[\"cx\"],\n \"cy\": input[\"cy\"],\n \"a\": math.tan(math.radians(input[\"ca\"]) + math.radians(input[\"ma\"])),\n }\n for input in inputs\n ]\n\n return self.calculate_absolute(absolute_inputs)","def ValidateInputs(lat_min, lat_max, lon_min, lon_max, lonres, latres, basepath, \\\n GFED_path, EDGAR_path, CAMS_path, behaviour_settings):\n # Assert sure extents fall within boundary\n assert -180 <= lon_min < 180 and -180 < lon_max <= 180, 'Longitude should be within range -180 -- 180!'\n assert -90 <= lat_min < 90 and -90 < lat_max <= 90, 'latitude should be within range -90 -- 90!'\n assert lon_min < lon_max, 'maximum longitude cannot be smaller than or equal to minimum!'\n assert lat_min < lat_max, 'maximum latitude cannot be smaller than or equal to minimum!'\n \n # Assert resolution is larger than TROPOMI minimum:\n assert lonres > 7, 'TROPOMI minimum longitude resolution is 7 km!'\n assert latres > 7, 'TROPOMI minimum latitude resolution is 7 km!'\n \n # Assert if given directories exist\n if behaviour_settings[1] == True:\n assert os.path.isdir(CAMS_path), f'Directory {CAMS_path} was not found!'\n if behaviour_settings[2] == True:\n assert os.path.isdir(GFED_path), f'Directory {GFED_path} was not found!'\n assert os.path.isdir(EDGAR_path), f'Directory {EDGAR_path} was not found!'\n\n \n return","def main():\n dpi = 1\n dpi = 2\n width = int(360)\n height = int(130)\n mywidth = int(width*dpi)\n myheight = int(height*dpi)\n FWHM = 7.5 # degrees\n FWHM = 10.0 # degrees\n FWHM = 5.0 # degrees\n FWHM = 3.0 # degrees\n FWHM = 1.0 # degrees\n weight = 1.\n\n nargs = len(sys.argv)\n if nargs < 2:\n print('GR: GRid Observations of integrated intensity produced by the T Command')\n print('GR produces fits images for each of the horns used for the observations.')\n print('For observations at the same coordinates, the ratios of intensities are also produced.')\n print('The FITS format files require header information, which is copied from the')\n print('Cold Load File provided by the user')\n print('GR RA|GAL <cold file name> <savefile1> [<savefile2> ... <savefileN>]')\n print(\"\")\n print('Glen Langston, National Science Foundation -- 20 May 12')\n exit()\n\n gridtype = sys.argv[1]\n gridtype = gridtype.upper()\n print('Grid Type: ', gridtype)\n\n # enable having ra going from 24 to 0 hours == 360 to 0 degrees\n xsign = 1.\n xoffset = 0.\n if gridtype == 'RA':\n xmin = 0.\n xmax = 360.\n ymin = -40.\n ymax = 90.\n maptype = 'RA'\n elif gridtype == '-RA':\n xmin = 0.\n xmax = 360.\n ymin = -40.\n ymax = 90.\n xsign = -1.\n xoffset = 360. # when x = 360. should be at zero.\n maptype = 'RA'\n elif gridtype == '-EL':\n xmin = 0.\n xmax = 360.\n ymin = 0.\n ymax = 90.\n xsign = -1.\n xoffset = 360. # when x = 360. should be at zero.\n maptype = 'AZEL'\n elif gridtype == 'RA0':\n xmin = 0.\n xmax = 360.\n ymin = -41.\n ymax = 89.\n xsign = -1.\n xoffset = 180. # when x = 360. should be at zero.\n gridtype = 'RA'\n elif gridtype == 'GAL':\n xmin = -180.\n xmax = 180.\n ymin = -90.\n ymax = 90.\n maptype = 'GAL'\n\n if gridtype != 'RA' and gridtype != 'GAL' and gridtype != '-RA' and gridtype != \"RA0\":\n print('Error parsing grid type: ', gridtype)\n print('1st argument should be either RA, -RA or GAL')\n exit()\n\n rs = radioastronomy.Spectrum()\n\n if doRatio: \n #create the grid with map parameters\n grid1 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n grid2 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n grid3 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n grid4 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n # put each telescope in a different grid\n grids = [grid1, grid2, grid3, grid4]\n\n gridall = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\n height=height, dpi=dpi, FWHM=FWHM, \\\n projection=\"-CAR\", gridtype=maptype)\n \n\n projection = \"-AIT\"\n# coldfile \n coldfile = sys.argv[2]\n# get telescope geographic location etc\n print(\"Reading Observing parameters from: %s\" % (coldfile))\n rs.read_spec_ast(coldfile)\n print(\"Observer: %s \" % (rs.observer))\n\n# first read through all data and find hot load\n names = sys.argv[3:]\n names = sorted(names)\n\n firsttime = \"\"\n lasttime = \"\"\n count = 0\n # setup grid indicies so that cpuIndex goes to the correct grid\n # This assumes telescopes 2,3,4,5 are being used] \n gridIndex = [0,0,0,1,2,3]\n # for all save Files to Grid\n for filename in names:\n print(\"File: %s\" % (filename))\n f = open(filename)\n\n date = \"Unknown\"\n while date != \"\":\n date, time, cpuIndex, telaz, telel, tSys, tRx, tRms, tint, KperC, tSourcemax, velSource, dV, tVSum, tVSumRms, tSumKmSec, dTSumKmSec, gainFactor = gainfactor.readSaveValues( f)\n dlen = len(date)\n if dlen < 1:\n break\n if date[0] == \"#\":\n continue\n # else not a comment process the line\n count = count + 1\n isodate = \"20\"+date+\"T\"+time\n# print(\"DateTime: %s\" % (isodate))\n rs.utc = datetime.datetime.strptime(isodate,\"%Y-%m-%dT%H:%M:%S\")\n# print(\"Utc: %s\" % (rs.utc))\n rs.telaz = telaz\n rs.telel = telel\n rs.azel2radec()\n\n ra = rs.ra\n dec = rs.dec\n lon = rs.gallon\n lat = rs.gallat\n tsum = tSumKmSec\n tsdv = dTSumKmSec\n tmax = tSourcemax\n vave = tVSum\n vsdv = tVSumRms\n if firsttime == \"\":\n firsttime = date\n else:\n lasttime = date\n\n# if vave > -100. and vave < 100:\n# mygrid.convolve( lon, lat, vave, 1.)\n iGrid = gridIndex[cpuIndex]\n gainCorr = telescopefactors[iGrid]\n tsum = tsum * gainCorr\n if gridtype == 'RA':\n if doRatio:\n grids[iGrid].convolve(ra, dec, tsum, weight)\n gridall.convolve( ra, dec, tsum, weight)\n elif gridtype == '-RA':\n x = (ra*xsign) + xoffset\n if doRatio:\n grids[iGrid].convolve(x, dec, tsum, weight)\n gridall.convolve( x, dec, tsum, weight)\n elif gridtype == 'RA0':\n x = (ra*xsign) + xoffset\n if x < 0:\n x = x + xmax\n elif x > xmax:\n x = x - xmax\n if doRatio:\n grids[iGrid].convolve(x, dec, tsum, weight)\n gridall.convolve( x, dec, tsum, weight)\n else:\n if doRatio:\n grids[iGrid].convolve(lon, lat, tsum, weight)\n gridall.convolve( lon, lat, tsum, weight)\n\n if count == 0:\n print('Convolving Coordinates: ', ra, dec, lon, lat)\n print('Convolving Intensities: ', tsum, tsdv, vave, vsdv)\n print('Convolvign Parameters : ', n, time)\n count = count + 1\n # end reading all lines in save file\n f.close()\n\n # normalize each of the gridded images\n if doRatio:\n grids[0].normalize()\n grids[1].normalize()\n grids[2].normalize()\n grids[3].normalize()\n gridall.normalize()\n# mygrid.check()\n# zmin = -1000.\n# zmax = 3000.\n# limit grid intensities for plotting\n# mygrid.set_ij( 0, 0, zmax, 1.)\n# mygrid.set_ij( 1, 1, zmin, 1.)\n# mygrid.limit(zmin, zmax)\n\n subplots = False\n\n if subplots:\n fig, ax = plt.subplots(figsize=(myheight, mywidth), dpi=dpi)\n\n if gridtype == 'RA':\n cax = fig.add_axes([-180, 180], [-90, 90])\n else:\n cax = fig.add_axes([0, 24], [-90, 90])\n\n cbar = fig.colorbar(cax, ticks=[zmin, zmax], orientation='horizontal')\n cbar.ax.set_yticklabels([str(zmin), str(zmax)])\n\n ax.set_title(\"Citizen Science: Horn observations of our Galaxy\")\n else:\n#y_ticks = ymin + (ymax-ymin)*ticks/myheight\n\n ticks = np.arange(0, mywidth, 30*dpi)\n x_ticks = xmin + ((xmax-xmin)*ticks/mywidth)\n\n plt.imshow(gridall.image, interpolation='nearest', cmap=plt.get_cmap('jet'))\n\n if firsttime != lasttime:\n plt.title(\"Citizen Science: Observing our Galaxy: %s to %s\" % (firsttime, lasttime))\n else:\n plt.title(\"Citizen Science: Observing our Galaxy: %s\" % (firsttime))\n if gridtype == 'RA':\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Declination (degrees)\")\n labels = ticks/(mywidth/24)\n yticks = np.arange(0, myheight, 15*dpi)\n elif gridtype == '-RA':\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Declination (degrees)\")\n labels = 24 - (ticks/(mywidth/24))\n labels[0] = 0\n labels[0] = 24\n yticks = np.arange(0, myheight, 15*dpi)\n elif gridtype == '-EL':\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Elevation (degrees)\")\n labels = 24 - (ticks/(mywidth/24))\n labels[0] = 0\n labels[0] = 24\n yticks = np.arange(0, myheight, 15*dpi)\n elif gridtype == 'RA0': # put 0 hours in middle of plot\n plt.xlabel(\"Right Ascension (hours)\")\n plt.ylabel(\"Declination (degrees)\")\n labels = 12 - (ticks/(mywidth/24))\n nlabels = len(labels)\n for iii in range(nlabels):\n if labels[iii] < 0:\n labels[iii] = 24 + labels[iii]\n if labels[iii] == 24:\n labels[iii] = 0\n yticks = np.arange(0, myheight, 15*dpi)\n else:\n yticks = np.arange(0, myheight, 30*dpi)\n ticks = np.arange(0, mywidth, 30*dpi)\n x_ticks = xmin + (xmax-xmin)*ticks/mywidth\n labels = x_ticks\n plt.xlabel(\"Galactic Longitude (degrees)\")\n plt.ylabel(\"Galactic Latitude (degrees)\")\n # wnat an integer list of labels\n# slabels = str(labels)\n print(ticks, labels)\n y_ticks = ymax - (ymax-ymin)*yticks/myheight\n plt.yticks(yticks, y_ticks)\n plt.xticks(ticks, labels, rotation='horizontal')\n plt.colorbar()\n\n crval2 = (xmin + xmax)/2.\n crval1 = (ymin + ymax)/2.\n cdelt1 = (-1./float(dpi)) - .001\n cdelt2 = (1./float(dpi)) + .001\n if doRatio:\n# now show eacsh of the images\n for iGrid in range(4):\n imagetemp = copy.deepcopy(grids[iGrid].image)\n imagetemp2 = copy.deepcopy(grids[iGrid].image)\n kkk = myheight - 1\n for jjj in range(myheight):\n imagetemp[:][kkk] = imagetemp2[:][jjj]\n kkk = kkk - 1\n grids[iGrid].image = imagetemp\n writeFitsImage( rs, iGrid+2, grids[iGrid], projection)\n\n # put each telescope in a different grid\n ratio1 = copy.deepcopy(grid1)\n ratio2 = copy.deepcopy(grid1)\n ratio3 = copy.deepcopy(grid1)\n gratios = [ratio1, ratio2, ratio3]\n ratios = np.zeros(3)\n rmss = np.zeros(3)\n\n jGrid = 3\n for iGrid in range(3):\n print(\"Gain Ratios for Telescopes T%d and T%d\" % (iGrid+2, jGrid+2))\n ratio, rms, aratio = gridratio(grids[iGrid], grids[jGrid])\n ratios[iGrid] = ratio\n rmss[iGrid] = rms\n writeFitsImage( rs, iGrid+2, aratio, projection)\n \n writeFitsImage( rs, 0, gridall, projection)\n plt.show()","def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\n plots_folder = os.path.join(output_path,'plots')\n if output_name is None: \n aux = ['PDs']\n input_file = os.path.join(output_path,'outputs_PDS.csv')\n else:\n aux = [output_name,'PDs']\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\n if normalized is True:\n aux.append('normalized')\n plot_file_name = '-'.join(aux)+'.png'\n plot_file_name = os.path.join(plots_folder,plot_file_name)\n\n \n data = pd.read_csv(input_file,index_col = 0)\n \n\n fig_size_aux = 15/(3-max_dim)\n plt.figure(figsize=(fig_size_aux,5))\n if(normalized):\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,1)); plt.ylim((0,1))\n frame = plt.legend(loc=4,frameon=True,title='normalized')\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, 1], [0, 1], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n else:\n for i in range(1,max_dim+2):\n plt.subplot(1,max_dim+1,i, aspect='equal')\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\n frame = plt.legend(loc=4,frameon=True)\n frame = frame.get_frame()\n frame.set_edgecolor('black')\n plt.xlabel('birth'); plt.ylabel('death')\n plt.plot([0, M_max], [0, M_max], ls=\"--\", c=\".3\")\n plt.suptitle('Persistence Diagrams')\n plt.savefig(plot_file_name)\n print 'Saved PDs plots in %s'%plot_file_name\n return()","def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\n other_program_name, **kw):\n\n #plot absolute error\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\n pan['absolute-difference'][field].values,\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\n ax_abs.set_ylabel('Absolute Difference ' + unit)\n #plot percentage error\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\n pan['percent-difference'][field].values,\n color='firebrick', zorder=-1)\n ax_per.set_ylabel('Percent Difference', color='firebrick')\n #set error axes legend\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\n #ax_per.get_legend().set_zorder(1)\n #plot full results profiles\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\n color=_colormap[1])[0],\n ax_mag.plot(pan['emf.fields-results'][field],\n color=_colormap[0])[0]]\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\n ax_mag.set_xlabel('Distance (ft)')","def line_ratio_per_pixel_AHIMSA(ratio_name='NII',quant='ne',phase='all',res=0.5, plane='xy',col='grey',add=False,**kwargs):\n\n fig = plt.figure(constrained_layout=True,figsize=(15,10))\n gs = fig.add_gridspec(3,2)\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n gal_ob = gal.galaxy(p.gal_index)\n \n location = aux.moment0_map_location(res=res,plane=plane,gal_index=p.gal_index)\n # Load sim and cell data\n try:\n moment_0_map = np.load(location, allow_pickle=True)\n print('Found stored momentmap data')\n except:\n print('Did not find stored momentmap data - creating')\n aux.convert_cell_data_to_regular_grid(gal_index=p.gal_index)\n moment_0_map = np.load(location, allow_pickle=True)\n\n cols = {'HII':'blue','HI':'orange','H2':'red'}\n for i,phase in enumerate(['HII','HI','H2']):\n ax = fig.add_subplot(gs[i,0])\n\n dataset= np.array(moment_0_map[:,3])\n\n # Do all pixels for comparison\n index1 = p.moment0_dict['L_[NII]122']\n index2 = p.moment0_dict['L_[NII]205']\n index3 = p.moment0_dict['m']\n index4 = p.moment0_dict['ne_mw']\n line1 = []\n line2 = []\n ne_mw = []\n m = []\n for row in dataset:\n try:\n line1.append(row[index1])\n line2.append(row[index2])\n m.append(row[index3])\n ne_mw.append(row[index4])\n except:\n print(row)\n m = np.array(m) \n ne_mw = np.array(ne_mw) \n line1 = np.array(line1)\n line2 = np.array(line2)\n # print(line2)\n ne_mw = np.array(ne_mw[line2 > 0])\n ratio = line1[line2 > 0]/line2[line2 > 0]\n ax.scatter(np.log10(ne_mw/m[line2 > 0]),ratio,color=col,label= 'All gas in moment0map pixels',alpha=0.3)\n\n # Now for one ISM phase\n index1 = p.moment0_dict['L_[NII]122_%s' % phase]\n index2 = p.moment0_dict['L_[NII]205_%s' % phase]\n index3 = p.moment0_dict['m_%s' % phase]\n index4 = p.moment0_dict['ne_%s_mw' % phase]\n line1 = []\n line2 = []\n ne_mw = []\n m_phase = []\n for row in dataset:\n try:\n line1.append(row[index1])\n line2.append(row[index2])\n m_phase.append(row[index3])\n ne_mw.append(row[index4])\n except:\n print(row)\n m_phase = np.array(m_phase) \n ne_mw = np.array(ne_mw) \n line1 = np.array(line1)\n line2 = np.array(line2)\n ne_mw = np.array(ne_mw[line2 > 0])\n ratio = line1[line2 > 0]/line2[line2 > 0]\n ax.scatter(np.log10(ne_mw/m[line2 > 0]),ratio,color=cols[phase],label= '%s gas in moment0map pixels' % phase,alpha=0.3)\n\n xs = np.arange(ax.get_xlim()[0],ax.get_xlim()[1],0.1)\n ax.plot(xs,aux.NII_from_logne(xs),'-b')\n if p.xlim: ax.set_xlim(p.xlim)\n if p.ylim: ax.set_ylim(p.ylim)\n ax.set_xlabel('log ' + getlabel('ne'))\n ax.set_ylabel(getlabel('NIIratio'))\n ax.legend()\n\n ax = fig.add_subplot(gs[:,-1])\n ax.set_ylabel('y [kpc]')\n ax.set_xlabel('x [kpc]')\n map_sim_property(prop='m',vmin=9,vmax=12.9,add=True,log=True,sim_type='simgas',ax=ax,**kwargs)\n plt.subplots_adjust(hspace = 0, wspace = 0.2)\n if p.savefig:\n if not os.path.isdir(p.d_plot + 'lineratios/NII/'): os.mkdir(p.d_plot + 'lineratios/NII/') \n plt.savefig(p.d_plot+'lineratios/NII/%s%s_G%i_NII_ne' % (p.sim_name,p.sim_run,p.gal_index)+'.png', dpi=200)","def run():\r\n square_s = input(\"Is your data file a square matrix file? [y/n]: \")\r\n assert(square_s == \"y\" or square_s == \"Y\" or square_s == \"n\" or square_s == \"N\"), \"Please enter in 'y' or 'n' format.\"\r\n if square_s == \"y\" or square_s == \"Y\":\r\n is_square = True\r\n else:\r\n is_square = False\r\n\r\n file_name = input(\"Please enter file name: \")\r\n\r\n conf_s = input(\"Please enter minimum confidence threshold: \")\r\n conf_f = float(conf_s)\r\n assert(is_float(conf_s)), \"Please enter a valid numerical value.\"\r\n\r\n print(\"Please select plot type number\")\r\n print(\"1. Orientation\")\r\n print(\"2. Confidence levels\")\r\n plottype_s = input(\"[1/2]: \")\r\n assert(plottype_s == \"1\" or plottype_s == \"2\"), \"Please enter either '1' or '2'.\"\r\n if plottype_s == \"1\":\r\n is_orient = True\r\n else:\r\n is_orient = False\r\n\r\n if is_square == True:\r\n sqm = SquareMic()\r\n sqm.load(file_name)\r\n if is_orient:\r\n misorien_s = input(\"Please enter misorientation threshold (default=1.0): \")\r\n try:\r\n assert(is_float(misorien_s))\r\n misorien_f = float(misorien_s)\r\n print(misorien_f)\r\n except:\r\n print(\"Input not a numerical value. Defaulting to 1.0\")\r\n misorien_f = 1.0\r\n #assert(is_float(misorien_s)), \"Please enter a numerical value.\"\r\n #misorien_f = float(misorien_s)\r\n\r\n sqm.plot_orientation([],minHitRatio=conf_f,misor_thresh=misorien_f)\r\n else:\r\n sqm.plot_hit_ratio()\r\n else:\r\n m = MicFile(file_name)\r\n if is_orient:\r\n plottype_i = 1\r\n else:\r\n plottype_i = 2\r\n m.plot_mic_patches(plottype_i,conf_f,1,False,[])\r\n return","def isrelative(self):\n return bool(self.control & gdef.SE_SELF_RELATIVE)","def jam_axi_rms(surf_lum, sigma_lum, qobs_lum, surf_pot, sigma_pot, qobs_pot,\n inc, mbh, distance, xbin, ybin, ml=None, normpsf=1., pixang=0.,\n pixsize=0., plot=True, rms=None, erms=None, sigmapsf=0.,\n goodbins=None, quiet=False, beta=None, step=0., nrad=20,\n nang=10, rbh=0.01, tensor='zz', vmin=None, vmax=None, **kwargs):\n if beta is None:\n beta = np.zeros_like(surf_lum) # Anisotropy parameter beta = 1 - (sig_z/sig_R)**2\n if not (surf_lum.size == sigma_lum.size == qobs_lum.size == beta.size):\n raise ValueError(\"The luminous MGE components do not match\")\n if not (surf_pot.size == sigma_pot.size == qobs_pot.size):\n raise ValueError(\"The total mass MGE components do not match\")\n if xbin.size != ybin.size:\n raise ValueError(\"xbin and ybin do not match\")\n if rms is not None:\n if erms is None:\n erms = np.full_like(rms, np.median(rms)*0.05) # Constant ~5% errors\n if goodbins is None:\n goodbins = np.ones_like(rms, dtype=bool)\n elif goodbins.dtype != bool:\n raise ValueError(\"goodbins must be a boolean vector\")\n if not (xbin.size == rms.size == erms.size == goodbins.size):\n raise ValueError(\"(rms, erms, goodbins) and (xbin, ybin) do not match\")\n\n sigmapsf = np.atleast_1d(sigmapsf)\n normpsf = np.atleast_1d(normpsf)\n if sigmapsf.size != normpsf.size:\n raise ValueError(\"sigmaPSF and normPSF do not match\")\n\n pc = distance*np.pi/0.648 # Constant factor to convert arcsec --> pc\n\n surf_lum_pc = surf_lum\n surf_pot_pc = surf_pot\n sigma_lum_pc = sigma_lum*pc # Convert from arcsec to pc\n sigma_pot_pc = sigma_pot*pc # Convert from arcsec to pc\n xbin_pc = xbin*pc # Convert all distances to pc\n ybin_pc = ybin*pc\n pixSize_pc = pixsize*pc\n sigmaPsf_pc = sigmapsf*pc\n step_pc = step*pc\n\n # Add a Gaussian with small sigma and the same total mass as the BH.\n # The Gaussian provides an excellent representation of the second moments\n # of a point-like mass, to 1% accuracy out to a radius 2*sigmaBH.\n # The error increses to 14% at 1*sigmaBH, independently of the BH mass.\n #\n if mbh > 0:\n sigmaBH_pc = rbh*pc # Adopt for the BH just a very small size\n surfBH_pc = mbh/(2*np.pi*sigmaBH_pc**2)\n surf_pot_pc = np.append(surfBH_pc, surf_pot_pc) # Add Gaussian to potential only!\n sigma_pot_pc = np.append(sigmaBH_pc, sigma_pot_pc)\n qobs_pot = np.append(1., qobs_pot) # Make sure vectors do not have extra dimensions\n\n qobs_lum = qobs_lum.clip(0, 0.999)\n qobs_pot = qobs_pot.clip(0, 0.999)\n\n t = clock()\n rmsModel = _vrms2(xbin_pc, ybin_pc, inc, surf_lum_pc, sigma_lum_pc,\n qobs_lum, surf_pot_pc, sigma_pot_pc, qobs_pot, beta,\n tensor, sigmaPsf_pc, normpsf, pixSize_pc, pixang,\n step_pc, nrad, nang)\n if not quiet:\n print('jam_axi_rms elapsed time sec: %.2f' % (clock() - t))\n\n if tensor in ('xx', 'yy', 'zz'):\n rmsModel = np.sqrt(rmsModel.clip(0)) # Return SQRT and fix possible rounding errors\n if tensor in ('xy', 'xz'):\n rmsModel *= np.sign(xbin*ybin) # Calculation was done in positive quadrant\n\n # Analytic convolution of the MGE model with an MGE circular PSF\n # using Equations (4,5) of Cappellari (2002, MNRAS, 333, 400)\n #\n lum = surf_lum_pc*qobs_lum*sigma_lum**2 # Luminosity/(2np.pi) of each Gaussian\n flux = np.zeros_like(xbin) # Total MGE surface brightness for plotting\n for sigp, norp in zip(sigmapsf, normpsf): # loop over the PSF Gaussians\n sigmaX = np.sqrt(sigma_lum**2 + sigp**2)\n sigmaY = np.sqrt((sigma_lum*qobs_lum)**2 + sigp**2)\n surfConv = lum / (sigmaX*sigmaY) # PSF-convolved in Lsun/pc**2\n for srf, sx, sy in zip(surfConv, sigmaX, sigmaY): # loop over the galaxy MGE Gaussians\n flux += norp*srf*np.exp(-0.5*((xbin/sx)**2 + (ybin/sy)**2))\n\n if rms is None:\n\n chi2 = None\n if ml is None:\n ml = 1.\n else:\n rmsModel *= np.sqrt(ml)\n\n else:\n\n if (ml is None) or (ml <= 0):\n\n # y1, dy1 = rms, erms # (y1 are the data, y2 the model)\n # scale = sum(y1*y2/dy1**2)/sum(y2**2/dy1**2) # (equation 51)\n #\n ml = (np.sum(rms[goodbins]*rmsModel[goodbins]/erms[goodbins]**2)\n / np.sum((rmsModel[goodbins]/erms[goodbins])**2))**2\n\n rmsModel *= np.sqrt(ml)\n chi2 = np.sum(((rms[goodbins]-rmsModel[goodbins])/erms[goodbins])**2) / goodbins.sum()\n\n if not quiet:\n print('inc=%.1f beta_z=%.2f M/L=%.3g BH=%.2e chi2/DOF=%.3g' % (inc, beta[0], ml, mbh*ml, chi2))\n mass = 2*np.pi*surf_pot_pc*qobs_pot*sigma_pot_pc**2\n print('Total mass MGE: %.4g' % np.sum(mass*ml))\n\n if plot:\n\n rms1 = rms.copy() # Only symmetrize good bins\n rms1[goodbins] = symmetrize_velfield(xbin[goodbins], ybin[goodbins], rms[goodbins])\n\n if (vmin is None) or (vmax is None):\n vmin, vmax = stats.scoreatpercentile(rms1[goodbins], [0.5, 99.5]) # Could use np.percentile in Numpy 1.10\n\n plt.clf()\n plt.subplot(121)\n plot_velfield(xbin, ybin, rms1, vmin=vmin, vmax=vmax, flux=flux, **kwargs)\n plt.title(r\"Input $V_{\\rm rms}$\")\n\n plt.subplot(122)\n plot_velfield(xbin, ybin, rmsModel, vmin=vmin, vmax=vmax, flux=flux, **kwargs)\n plt.plot(xbin[~goodbins], ybin[~goodbins], 'ok', mec='white')\n plt.title(r\"Model $V_{\\rm rms}$\")\n plt.tick_params(labelleft='off')\n plt.subplots_adjust(wspace=0.03)\n\n return rmsModel, ml, chi2, flux","def abs_units_old(wb_run,sample_run,mono_van,wb_mono,samp_rmm,samp_mass,ei_guess,rebin,map_file,monovan_mapfile,**kwargs): \n #available keywords\n #abs_units_van_range\n global reducer, rm_zero,inst_name,van_mass,bleed_switch,rate,pixels\n print 'DGreduce run for ',inst_name,'run number ',sample_run\n print 'Output will be in absolute units of mb/str/mev/fu'\n try:\n n,r=lhs('both')\n wksp_out=r[0]\n except:\n if sample_run == 0:\n #deal with the current run being parsed as 0 rather than 00000\n sample_run='00000'\n wksp_out=str(sample_run)+'.spe'\n \n start_time=time.time()\n \n if sample_run=='00000' and mtd.doesExist(inst_name+'00000.raw')==True:\n print 'Deleteing previous instance of temp data'\n DeleteWorkspace(Workspace=inst_name+'00000.raw')\n \n if kwargs.has_key('norm_method'):\n reducer.normalise_method = kwargs.get('norm_method')\n print 'Setting normalisation method to ', kwargs.get('norm_method')\n else:\n reducer.normalise_method = 'monitor-1'\n \n if kwargs.has_key('mask_run'):\n mask_run = kwargs.get('mask_run')\n print 'Using run ', kwargs.get('mask_run'),' for diag'\n else:\n mask_run=sample_run\n \n if kwargs.has_key('background'):\n reducer.background = kwargs.get('background')\n print 'Setting background option to ', kwargs.get('background')\n else:\n reducer.background = False\n \n if kwargs.has_key('fixei'):\n reducer.fix_ei = kwargs.get('fixei')\n print 'Setting fixei to ', kwargs.get('fixei')\n else:\n reducer.fix_ei = False\n \n if kwargs.has_key('save_format'):\n reducer.save_formats = kwargs.get('save_format')\n print 'Setting save format to ', kwargs.get('save_format')\n else:\n reducer.save_formats = ['.spe']\n #Set parameters for the run\n \n if kwargs.has_key('detector_van_range'):\n reducer.wb_integr_range = kwargs.get('detector_van_range')\n print 'Setting detector van int range to ', kwargs.get('detector_van_range')\n else:\n reducer.wb_integr_range=[20,100]\n \n #######DIAG###########\n if kwargs.has_key('bkgd_range'):\n background_range = kwargs.get('bkgd_range')\n print 'Setting background intergration to ', kwargs.get('bkgd_range')\n else:\n background_range=[15000,19000]\n \n if kwargs.has_key('tiny'):\n tinyval = kwargs.get('tiny')\n print 'Setting tiny ratelimit to ', kwargs.get('tiny')\n else:\n tinyval=1e-10\n \n if kwargs.has_key('large'):\n largeval = kwargs.get('large')\n print 'Setting large limit to ', kwargs.get('large')\n else:\n largeval=1e10\n \n if kwargs.has_key('diag_remove_zero'):\n sampzero = kwargs.get('diag_remove_zero')\n print 'Setting diag to reject zero backgrounds '\n else:\n sampzero =False\n \n if kwargs.has_key('diag_van_median_rate_limit_hi'):\n vanouthi = kwargs.get('diag_van_median_rate_limit_hi')\n print 'Setting diag_van_median_rate_limit_hi to ', kwargs.get('diag_van_median_rate_limit_hi')\n else:\n vanouthi=100\n \n if kwargs.has_key('diag_van_median_rate_limit_lo'):\n vanoutlo = kwargs.get('diag_van_median_rate_limit_lo')\n print 'Setting diag_van_median_rate_limit_lo to ', kwargs.get('diag_van_median_rate_limit_lo')\n else:\n vanoutlo=0.01\n \n if kwargs.has_key('diag_van_median_sigma_lo'):\n vanlo = kwargs.get('diag_van_median_sigma_lo')\n print 'Setting diag_van_median_sigma_lo to ', kwargs.get('diag_van_median_sigma_lo')\n else:\n vanlo=0.1\n \n if kwargs.has_key('diag_van_median_sigma_hi'):\n vanhi = kwargs.get('diag_van_median_sigma_hi')\n print 'Setting diag_van_median_sigma_hi to ', kwargs.get('diag_van_median_sigma_hi')\n else:\n vanhi=1.5\n \n if kwargs.has_key('diag_van_median_sigma'):\n vansig = kwargs.get('diag_van_median_sigma')\n print 'Setting diag_van_median_sigma to ', kwargs.get('diag_van_median_sigma')\n else:\n vansig=0.0\n \n if kwargs.has_key('diag_samp_median_sigma_lo'):\n samplo = kwargs.get('diag_samp_median_sigma_lo')\n print 'Setting diag_samp_median_sigma_lo to ', kwargs.get('diag_samp_median_sigma_lo')\n else:\n samplo=0.0\n \n if kwargs.has_key('diag_samp_median_sigma_hi'):\n samphi = kwargs.get('diag_samp_median_sigma_hi')\n print 'Setting diag_samp_median_sigma_hi to ', kwargs.get('diag_samp_median_sigma_hi')\n else:\n samphi=2.0\n \n if kwargs.has_key('diag_samp_median_sigma'):\n sampsig = kwargs.get('diag_samp_median_sigma')\n print 'Setting diag_samp_median_sigma to ', kwargs.get('diag_samp_median_sigma')\n else:\n sampsig=3.0\n \n if kwargs.has_key('bleed'):\n bleed_switch = kwargs.get('bleed')\n print 'Setting bleed ', kwargs.get('bleed')\n else:\n print 'bleed set to default'\n #####diad end########\n \n if kwargs.has_key('det_cal_file'):\n reducer.det_cal_file = kwargs.get('det_cal_file')\n reducer.relocate_dets = True\n print 'Setting detector calibration file to ', kwargs.get('det_cal_file')\n else:\n print 'Setting detector calibration to detector block info from ', sample_run\n reducer.det_cal_file =None\n reducer.relocate_dets = False\n \n if mtd.doesExist(str(sample_run))==True and kwargs.has_key('det_cal_file')==False:\n print 'For data input type: workspace detector calibration must be specified'\n print 'use Keyword det_cal_file with a valid detctor file or run number'\n return\n \n \n if kwargs.has_key('one2one'):\n reducer.map_file =None\n print 'one2one selected'\n \n else:\n fileName, fileExtension = os.path.splitext(map_file)\n if (not fileExtension):\n map_file=map_file+'.map' \n reducer.map_file = map_file\n \n if kwargs.has_key('hardmaskPlus'):\n HardMaskFile = kwargs.get('hardmaskPlus')\n print 'Use hardmask from ', HardMaskFile\n #hardMaskSpec=common.load_mask(HardMaskFile)\n #MaskDetectors(Workspace='masking',SpectraList=hardMaskSpec)\n else:\n HardMaskFile=None\n \n reducer.energy_bins = rebin\n #monovan info\n fileName, fileExtension = os.path.splitext(monovan_mapfile)\n if (not fileExtension):\n monovan_mapfile=monovan_mapfile+'.map'\n reducer.abs_map_file =monovan_mapfile \n\n if kwargs.has_key('abs_units_van_range'):\n reducer.monovan_integr_range = kwargs.get('abs_units_van_range')\n print 'Setting absolute units vanadium integratiOn range to ', kwargs.get('abs_units_van_range')\n else:\n reducer.monovan_integr_range=[-40,40]\n \n #reducer.van_rmm =50.94\n reducer.van_mass=van_mass\n #sample info\n reducer.sample_mass=samp_mass\n reducer.sample_rmm =samp_rmm\n \n print 'output will be normalised to', reducer.normalise_method\n if (numpy.size(sample_run)) > 1 and kwargs.has_key('sum') and kwargs.get('sum')==True:\n #this sums the runs together before passing the summed file to the rest of the reduction\n #this circumvents the inbuilt method of summing which fails to sum the files for diag\n \n sumfilename=str(sample_run[0])+'sum'\n accum=sum_files(sumfilename, sample_run)\n #the D.E.C. tries to be too clever so we have to fool it into thinking the raw file is already exists as a workpsace\n RenameWorkspace(InputWorkspace=accum,OutputWorkspace=inst_name+str(sample_run[0])+'.raw')\n sample_run=sample_run[0]\n \n if kwargs.has_key('hardmaskOnly'):\n hardmask = kwargs.get('hardmaskOnly')\n print 'Use hardmask from ', hardmask\n masking=hardmask\n else:\n \n masking = reducer.diagnose(wb_run, \n sample=mask_run,\n second_white = None,\n tiny=tinyval, \n huge=largeval, \n van_out_lo=vanoutlo,\n van_out_hi=vanouthi,\n van_lo=vanlo,\n van_hi=vanhi,\n van_sig=vansig,\n samp_zero=sampzero,\n samp_lo=samplo,\n samp_hi=samphi,\n samp_sig=sampsig,\n bkgd_range=background_range, \n variation=1.1,\n print_results=True,\n bleed_test=bleed_switch,\n bleed_maxrate=rate,\n bleed_pixels=pixels,\n hard_mask=HardMaskFile)\n \n masking2 = reducer.diagnose(wb_mono, \n sample=mono_van,\n second_white = None,\n tiny=tinyval, \n huge=largeval, \n van_out_lo=vanoutlo,\n van_out_hi=vanouthi,\n van_lo=vanlo,\n van_hi=vanhi,\n van_sig=vansig,\n samp_zero=sampzero,\n samp_lo=samplo,\n samp_hi=samphi,\n samp_sig=sampsig,\n bkgd_range=background_range, \n variation=1.1,\n print_results=True,\n bleed_test=bleed_switch,\n bleed_maxrate=rate,\n bleed_pixels=pixels,\n hard_mask=HardMaskFile)\n \n total_mask=masking+masking2\n \n \n if kwargs.has_key('use_sam_msk_on_monovan') and kwargs.get('use_sam_msk_on_monovan')==True:\n print 'applying sample run mask to mono van'\n reducer.spectra_masks=masking\n else:\n reducer.spectra_masks=total_mask\n \n fail_list=get_failed_spectra_list('total_mask')\n \n \n print 'Diag found ', len(fail_list),'bad spectra'\n \n \n #Run the conversion\n deltaE_wkspace = reducer.convert_to_energy(sample_run, ei_guess, wb_run, mono_van,ei_guess,wb_mono)\n end_time=time.time()\n results_name=str(sample_run)+'.spe'\n ei= (deltaE_wkspace.getRun().getLogData(\"Ei\").value)\n \n if mtd.doesExist('_wksp.spe-white')==True:\n DeleteWorkspace(Workspace='_wksp.spe-white')\n \n \n print 'Incident energy found ',ei,' meV'\n print 'Elapsed time =',end_time-start_time, 's'\n #get the name that convert to energy will use\n \n if mtd.doesExist(results_name)==False:\n RenameWorkspace(InputWorkspace=deltaE_wkspace,OutputWorkspace=results_name)\n RenameWorkspace(InputWorkspace=results_name,OutputWorkspace=wksp_out)\n \n return mtd[wksp_out]","def plot(self, plottitle, gof_fileroot, indir, outdir,\n cutoff=0, min_period=0.01, mode=None, colorset=None):\n\n # Pick components and labels\n start_comp = 0\n\n if min_period == 0.01:\n xtick_loc = XTICK_LOC_0_01\n xtick_label = XTICK_LABEL_0_01\n elif min_period == 0.1:\n xtick_loc = XTICK_LOC\n xtick_label = XTICK_LABEL\n else:\n raise bband_utils.ParameterError(\"invalid min_period: %f\" %\n (min_period))\n\n if mode == \"rd50\" or mode == \"rd50-single\":\n comp_ext = COMP_EXT_RD50\n comp_title = COMP_TITLE_RD50\n elif mode == \"rd100\":\n comp_ext = COMP_EXT_RD100\n comp_title = COMP_TITLE_RD100\n else:\n raise bband_utils.ParameterError(\"plot mode %s unsupported\" %\n (mode))\n #if mode == \"rd50-single\" or mode == \"rd100\":\n if mode == \"rd50-single\":\n # Only plot the last component\n # rd50 for rd50-single\n # rd100/rd50 ratio for rd100\n start_comp = 2\n\n # Select colorset\n if colorset is None:\n colorset_idx = 0\n else:\n colorset_idx = COLORSETS[colorset]\n\n # Set plot dims\n pylab.gcf().set_size_inches(6, 8)\n pylab.gcf().clf()\n\n pylab.subplots_adjust(left=0.125)\n pylab.subplots_adjust(right=0.9)\n pylab.subplots_adjust(top=0.85)\n pylab.subplots_adjust(hspace=0.4)\n pylab.subplots_adjust(wspace=0.5)\n\n period = [[], [], []]\n bias = [[], [], []]\n m90 = [[], [], []]\n p90 = [[], [], []]\n sigma = [[], [], []]\n sigma0 = [[], [], []]\n\n bias_l = [[], [], []]\n bias_h = [[], [], []]\n conf_l = [[], [], []]\n conf_h = [[], [], []]\n\n for compnum in xrange(0, len(comp_ext)):\n comp = comp_ext[compnum]\n filenamebase = os.path.join(indir, \"%s-%s\" % (gof_fileroot, comp))\n #print(\"Reading component files %s.*\" % (filenamebase))\n period[compnum], bias[compnum] = self.read_data(\"%s.bias\" %\n (filenamebase),\n min_period)\n period[compnum], m90[compnum] = self.read_data(\"%s.m90\" %\n (filenamebase),\n min_period)\n period[compnum], p90[compnum] = self.read_data(\"%s.p90\" %\n (filenamebase),\n min_period)\n period[compnum], sigma[compnum] = self.read_data(\"%s.sigma\" %\n (filenamebase),\n min_period)\n period[compnum], sigma0[compnum] = self.read_data(\"%s.sigma0\" %\n (filenamebase),\n min_period)\n\n # Compute bias and conf interval lower/upper bounds\n for i in xrange(0, len(bias[compnum])):\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\n conf_l[compnum].append(m90[compnum][i])\n conf_h[compnum].append(p90[compnum][i])\n\n # Make sure all components have same number of data points\n npts = [len(component) for component in period]\n if npts[1:] != npts[:-1]:\n print(\"Number of data points unequal across components\")\n return\n\n # Construct baseline\n baseline = []\n for i in xrange(0, len(period[0])):\n baseline.append(0.0)\n\n # Find max, min values\n min_x = min(period[0])\n max_x = max(period[0])\n for comp in period:\n min_x = min(min_x, min(comp))\n max_x = max(max_x, max(comp))\n min_y = MIN_Y_AXIS\n max_y = MAX_Y_AXIS\n\n # Draw each component\n for compnum in xrange(start_comp, 3):\n comp = comp_ext[compnum]\n offset = COMP_OFFSET[compnum]\n\n pylab.subplot(offset)\n pylab.title(comp_title[compnum], size=10)\n pylab.plot(period[compnum], bias[compnum],\n color=BIAS_COLORS[colorset_idx],\n label='_nolegend_')\n pylab.fill_between(period[compnum], bias_h[compnum],\n bias_l[compnum],\n color=BIAS_LH_COLORS[colorset_idx],\n label='_nolegend_')\n pylab.fill_between(period[compnum], conf_h[compnum],\n conf_l[compnum],\n color=CONF_LH_COLORS[colorset_idx],\n label='_nolegend_')\n pylab.plot(period[compnum], baseline, color='grey',\n label='_nolegend_')\n pylab.xlim(min_x, max_x)\n if comp == 'ratio':\n pylab.ylim(MIN_Y_AXIS_RATIO, MAX_Y_AXIS_RATIO)\n else:\n pylab.ylim(min_y, max_y)\n if compnum == 1:\n pylab.xlabel(\"Period (sec)\", size=8)\n pylab.ylabel(\"ln (data/model)\", size=8)\n pylab.xscale('log')\n pylab.xticks(xtick_loc, xtick_label)\n pylab.tick_params(labelsize=8)\n\n if cutoff == 0:\n pylab.suptitle('%s' % (plottitle), size=12)\n else:\n pylab.suptitle('%s\\nR < %d km' % (plottitle, cutoff), size=12)\n outfile = os.path.join(outdir, \"gof-%s.png\" % (gof_fileroot))\n print(\"==> Created GoF plot: %s\" % (outfile))\n pylab.savefig(outfile, format=\"png\",\n transparent=False, dpi=plot_config.dpi)\n pylab.close()","def plotDistributionWithLimitsOld(lXs, llYs ,out=\"out.png\", title=\"title\", xax=\"xax\", yax=\"yax\",legend=\"\"):\n\n fig = plt.Figure(figsize=(40,20))\n fig.suptitle(title, fontsize=32)\n nbPlots = len(llYs)\n sqrt = int(math.ceil(math.sqrt(nbPlots)))\n ymax = 0.0\n for val in llYs:\n ymax = max(max(val[0]),ymax)\n ymaxCurrent = max(max(val[2]),ymax)\n ymax = ymax*1.05\n xmax = 147\n gs = gridspec.GridSpec(1,2) \n ax = fig.add_subplot(gs[0])\n gsLimit = gridspec.GridSpecFromSubplotSpec(sqrt,sqrt, subplot_spec=gs[1])\n for i,val in enumerate(llYs):\n ax.plot(lXs,val[0],color=Graphics.lColors[i])\n ax.set_ylim(0,ymax)\n ax.set_xlim(1,xmax)\n axCurrent = fig.add_subplot(gsLimit[i]) \n axCurrent.fill_between(lXs, val[1], val[2], alpha=0.35, edgecolor='black', facecolor=Graphics.lColors[i])\n for j in val[3:]:\n axCurrent.plot(lXs,j,color='lightgray')\n axCurrent.plot(lXs,val[0],color=Graphics.lColors[i])\n axCurrent.set_ylim(0,ymaxCurrent)\n axCurrent.set_xlim(1,xmax)\n# CV = variation(val[0])\n# axCurrent.text(60, ymaxCurrent*0.7, \"CV = {}\".format(CV), fontsize=10)\n axis_font = {'size':'28'}\n ax.set_xlabel(xax, **axis_font)\n ax.set_ylabel(yax, **axis_font)\n ax.tick_params(labelsize=20)\n if legend:\n ax.legend(legend)\n canvas = FigureCanvasAgg(fig)\n canvas.print_figure(out, dpi=80)","def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\n interactive=False,**kwargs):\n\n# keyword parameters (for backward compatability)\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\n\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\n\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\n\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\n\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\n\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\n\n for k in ['bands']: band=kwargs.get(k,band)\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\n if not isinstance(par,list): par = [par]*len(band)\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\n\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\n if not isinstance(legend,list): legend = [legend]\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\n legend_fontscale=legend_fontscale*fontscale\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\n\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\n if not isinstance(xrng,list): xrng = [xrng]\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\n if not isinstance(yrng,list): yrng = [yrng]\n\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\n for k in ['file','filename']: output=kwargs.get(k,output)\n if not isinstance(output,str): output=''\n filetype = '.pdf'\n if output!='': filetype=output.split('.')[-1]\n\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\n comparison = None\n\n# some plotting constants\n xlabel_default = 'Wavelength'\n ylabel_deafult = 'Flux'\n\n# telluric bands in micron\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\n\n# assign features by group\n if not isinstance(features,list): features = [features]\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\n if young==True: features.extend(['vo'])\n if binary==True: features.extend(['sb'])\n\n# clean repeats in features while maintaining order - set does not do this\n if len(features)>0:\n fea = []\n for i in features:\n if i not in fea: fea.append(i)\n features = fea\n\n\n# if a list is passed, use this list\n splist = copy.deepcopy(inp)\n if isinstance(splist,list) == False: splist = [splist]\n \n# set up for multiplot\n if len(splist) == 1: multiplot = False\n \n# array of lists => force multiplot\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\n else: pass\n\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\n splist = [[s] for s in splist]\n\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\n splist = [splist]\n \n# flatten array if multiplot is not set\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\n splist = [[item for sublist in splist for item in sublist]] # flatten\n else: pass\n\n# total number of spectra - use to assign default legends\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\n if len(legend) == 0: legend=[sp.name for sp in allsps]\n if len(legend) < len(allsps):\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\n \n\n# now run a loop through the input subarrays\n plt.close('all')\n\n# set up here for multiple file output\n nplot = 1\n if multipage == True or multiplot == True:\n nplot = layout[0]*layout[1]\n numpages = int(len(splist) / nplot) + 1\n if (len(splist) % nplot == 0):\n numpages -= 1\n fig = []\n \n if multipage == True and filetype.lower() == 'pdf':\n pdf_pages = PdfPages(output)\n \n if multipage == False:\n if len(splist) > 1:\n filebase = output.replace('.{}'.format(filetype),'')\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\n else:\n files = [output]\n\n pg_n = 0 # page counter\n plt_n = 0 # plot per page counter\n lg_n = 0 # legend per plot counter\n\n for plts,sp in enumerate(splist):\n# set specific plot parameters\n if not isinstance(sp[0],splat.Spectrum):\n raise ValueError('\\nInput to plotSpectrum has wrong format:\\n\\n{}\\n\\n'.format(sp[0]))\n\n# set up plotting defaults for the list of spectra - REPLACE THIS\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\n if not isinstance(color,list): color = [color]*len(sp)\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\n\n# settings that work if the spectrum was read in as legitmate Spectrum object\n try:\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\n except:\n xlabel = kwargs.get('xlabel',xlabel_default)\n ylabel = kwargs.get('ylabel',ylabel_default)\n# initial plot range\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\n\n# set colormap if provided\n if colormap != None:\n values = numpy.arange(len(sp))\n color_map = plt.get_cmap(colormap)\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\n\n# GENERATE PLOTS\n if multiplot == True or multipage == True:\n plt_n = plts % nplot\n if (plt_n == 0):\n fig.append(plt.figure())\n pg_n += 1\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\n \n# plotting a single plot with all spectra\n else:\n plt.close('all')\n plt_n = 0\n fig = []\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\n else: fig.append(plt.figure())\n ax = fig[0].add_subplot(111)\n \n for ii, a in enumerate(sp):\n# zeropoint and stack\n flx = [i+zeropoint[ii] for i in a.flux.value]\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \n\n# add comparison\n if comparison != None:\n# zeropoint and stack\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\n \n# add residual\n if residual == True and len(sp) == 2:\n # Save flux values from first spectrum\n if ii == 0:\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\n \n # Subtract fluxes and plot\n elif ii == 1:\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\n \n # Fix bound[2] if residual goes below 0\n if numpy.nanmin(res) < bound[2]:\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\n bound[2] = numpy.nanmin(res[b0:b1])\n\n# noise\n if show_noise == True:\n ns = [i+zeropoint[ii] for i in a.noise.value]\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\n\n# zeropoint\n if show_zero == True:\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\n\n# save maximum flux among all spectra for plotting\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\n if len(features)>0:\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\n if ii == 0: \n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\n flxmax = numpy.array(f(wvmax))\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\n\n# legend counter\n lg_n = lg_n + 1 # Increment legend\n\n\n# label features\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\n if len(features) > 0:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\n for ftr in features:\n ftr = ftr.lower()\n if ftr in FEATURE_LABELS:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n# features must be contained in plot range (may change this)\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n\n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n else:\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\n\n# add grid\n if grid == True: ax.grid() \n\n# axis labels \n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\n ax.set_xlabel(xlabel, fontsize = fontsize)\n ax.set_ylabel(ylabel, fontsize = fontsize)\n ax.tick_params(axis='x', labelsize=fontsize)\n ax.tick_params(axis='y', labelsize=fontsize)\n\n# add title\n if title!='': ax.set_title(title)\n\n# log scale?\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\n\n# place legend\n if len(legend) > 0:\n if legend_location == 'outside':\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\n else:\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\n\n# overplot telluric absorption\n if telluric == True:\n yoff = 0.02*(bound[3]-bound[2]) # label offset\n for waveRng in telluric_bands:\n wR = waveRng.to(sp[0].wave.unit).value\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\n ax.add_patch(rect)\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\oplus$',horizontalalignment='center',fontsize=fontsize)\n\n# overplot color swaths for pre-specified bands\n if len(band) > 0:\n for i,b in enumerate(band):\n if not isinstance(b,list): \n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\n except:\n print('\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\n b = [0.,0.]\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\n ax.add_patch(rect)\n if band_label_position[i].lower() == 'top':\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n elif band_label_position[i].lower() == 'middle':\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\n else:\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\n\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\n if inset == True and len(inset_xrange) == 2:\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\n bound2 = inset_xrange\n if len(inset_yrange) == 0:\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\n bound2.extend(inset_yrange)\n db = (bound2[3]-bound2[2])\n bound2[2] = bound2[2]-0.05*db\n bound2[3] = bound2[3]+0.05*db\n ax_inset.axis(bound2)\n inset_fontsize = fontsize*0.7\n\n for ii,a in enumerate(sp):\n flx = [i+zeropoint[ii] for i in a.flux.value]\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \n ax_inset.set_xlabel('')\n ax_inset.set_ylabel('')\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\n# ax_inset.legend()\n\n# inset feature labels\n if len(inset_features) > 0:\n yoff = 0.05*(bound2[3]-bound2[2])\n for ftr in inset_features:\n ftrc = checkDict(ftr,FEATURE_LABELS)\n if ftrc != False:\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\n wRng = waveRng.to(sp[0].wave.unit).value\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\n y = numpy.nanmax(flxmax[wfeature])+yoff\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\n \n if FEATURE_LABELS[ftrc]['type'] == 'band':\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n else:\n for w in waveRng:\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\n \n# update offset\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\n ax_inset.axis(bound2)\n\n# finalize bounding\n if len(xrng) > 0: bound[0:2] = xrng\n if len(yrng) > 0: bound[2:4] = yrng\n if isUnit(bound[0]): bound = [x.value for x in bound]\n ax.axis(bound)\n \n# save to file or display\n# ERROR HERE - CHECK WHAT FILES\n if multipage == False:\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\n if kwargs.get('tight',True) == True: \n plt.savefig(files[plts], bbox_inches='tight')\n else:\n plt.savefig(files[plts])\n if output == '' and not kwargs.get('web',False):\n plt.show()\n if (kwargs.get('interactive',False) != False): plt.ion()\n else: plt.ioff()\n\n\n# save figures in multipage format and write off pdf file\n if multipage == True: \n for pg_n in numpy.arange(numpages):\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\n fig[pg_n].tight_layout\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\n pdf_pages.savefig(fig[pg_n])\n if filetype.lower() == 'pdf':\n pdf_pages.close()\n\n plt.clf()\n return fig","def plot_input_data(data_path,file_name,plots_folder,format_type,lower_matrix,upper_matrix,normalized=False,output_name=None):\n if output_name is None:\n aux = ['input_data']\n else:\n aux = [output_name,'input_data']\n if normalized is True:\n aux.append('normalized')\n plot_file_name = '-'.join(aux)+'.png'\n plot_file_name = os.path.join(plots_folder,plot_file_name)\n\n M_max, M = check_format_input(data_path,file_name,lower_matrix,upper_matrix,format_type,return_M = True,create_input_file=False)\n plt.figure()\n plt.subplot(111,aspect='equal')\n if(normalized):\n plt.imshow(M/float(M_max), cmap=plt.cm.Oranges, interpolation=\"nearest\")\n plt.colorbar()\n plt.title('Input data (normalized)')\n\n plt.savefig(plot_file_name)\n print 'Saved input data plot in %s' % plot_file_name\n else:\n plt.imshow(M, cmap=plt.cm.Oranges, interpolation=\"nearest\")\n plt.colorbar()\n plt.title('Input data')\n plt.savefig(plot_file_name)\n print 'Saved input data plot in %s' % plot_file_name\n return()","def updateParameters(self):\n\n if self.params[1].value:\n if arcpy.Exists(self.params[1].value):\n try:\n min_value = arcpy.GetRasterProperties_management(self.params[1].value, \"MINIMUM\")[0]\n\n if str(self.params[8].value) != str(self.params[1].value):\n self.params[7].value = True\n self.params[8].value = str(self.params[1].value)\n else:\n self.params[7].value = False\n\n if str(min_value) == \"0\":\n if self.params[7].value == True:\n self.params[2].value = True\n self.params[3].enabled = True\n self.params[7].value = False\n else:\n self.params[2].value = False\n self.params[3].enabled = False\n\n except arcpy.ExecuteError:\n pass\n\n if self.params[2].value == True:\n self.params[3].enabled = True\n else:\n self.params[3].enabled = False","def spider(inputfiles, names, type=\"M1\", threshold=0.1, spinwindow=[], Eg_low=0, Eg_high=1e9, Ex_low=0, Ex_high=1e9, scale=2):\n\n Nsp = np.ceil(np.sqrt(len(inputfiles))).astype(int)\n f, ax_list = plt.subplots(Nsp,Nsp,squeeze=False,sharex='col', sharey='row')\n\n for i in range(len(inputfiles)):\n inputfile = inputfiles[i]\n name = names[i]\n ax = ax_list[i%Nsp][int((i-i%Nsp)/Nsp)]\n\n\n levels = read_energy_levels(inputfile)\n Egs = levels[0,0]\n\n Ex_high = min(Ex_high, levels[:,0].max()-Egs)\n Eg_high = min(Eg_high, levels[:,0].max()-Egs)\n \n \n levels_plot_J = []\n levels_plot_Ex = []\n for iEx in range(len(levels[:,0])):\n # print levels[iEx,:]\n J2 = levels[iEx,1]\n par = levels[iEx,2]\n if len(spinwindow) > 0 and not ([J2,par] in spinwindow or [J2-2,par] in spinwindow or [J2+2,par] in spinwindow):\n continue\n Ex = levels[iEx,0]-Egs\n if Ex < Ex_low or Ex > Ex_high:\n continue\n \n levels_plot_J.append(J2/2)\n levels_plot_Ex.append(Ex)\n \n ax.plot(levels_plot_J, levels_plot_Ex, 'o', color='grey', linewidth=0.5)\n ax.set_xlim([levels[:,1].min()/2-1,levels[:,1].max()/2+1])\n ax.set_title(name+r'$\\,E_\\gamma\\in[{:.1f},{:.1f}]$'.format(Eg_low,Eg_high))\n ax.set_ylabel(r'$E_x\\,\\mathrm{[MeV]}$')\n ax.set_xlabel(r'$J\\,\\mathrm{[\\hbar]}$')\n \n \n \n transitions = read_transition_strengths(inputfile, type=type)\n for iEx in range(len(transitions[:,0])):\n J2i = int(transitions[iEx,0])\n pari = int(transitions[iEx,1])\n if len(spinwindow) > 0 and not [J2i,pari] in spinwindow:\n continue\n B = transitions[iEx,7]\n Eg = transitions[iEx,6]\n if B < threshold or Eg<Eg_low or Eg>Eg_high:\n continue\n Ei = transitions[iEx,2]-Egs\n if Ei < Ex_low or Ei > Ex_high:\n continue\n J2f = int(transitions[iEx,3])\n parf = int(transitions[iEx,4])\n Ef = transitions[iEx,5]-Egs\n ax.plot([J2i/2,J2f/2],[Ei,Ef], color='teal', linewidth=(scale*B))\n \n return f, ax_list","def minmax ( self , nshoots = 100000 ) :\n ## try to get minmax directly from pdf/function \n if self.tricks and hasattr ( self.pdf , 'function' ) :\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \n f = self.pdf.function()\n if hasattr ( f , 'minmax' ) :\n try :\n mn , mx = f.minmax()\n if 0<= mn and mn <= mx and 0 < mx : \n return mn , mx\n except :\n pass\n if hasattr ( f , 'max' ) :\n try :\n mx = f.max()\n if 0 < mx : return 0 , mx\n except :\n pass\n\n ## check RooAbsReal functionality\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\n if 0 < code :\n mx = self.pdf.maxVal ( code )\n if 0 < mx : return 0 , mx\n \n ## not try to use random\n \n mn , mx = -1 , -10\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\n \n if not self.xminmax() : return ()\n if not self.yminmax() : return ()\n \n mn , mx = -1 , -10\n xmn , xmx = self.xminmax()\n ymn , ymx = self.yminmax()\n for i in range ( nshoots ) : \n xx = random.uniform ( xmn , xmx )\n yy = random.uniform ( ymn , ymx )\n with SETVAR ( self.xvar ) :\n with SETVAR ( self.yvar ) :\n self.xvar.setVal ( xx )\n self.yvar.setVal ( yy )\n vv = self.pdf.getVal()\n if mn < 0 or vv < mn : mn = vv\n if mx < 0 or vv > mx : mx = vv\n \n return mn , mx","def percentile_plots_ref(plot_var, i_case, plot_var_ref, i_case_ref, plot_settings_abs, plot_settings_rel):\n column_titles = [\"5th percentile\", \"32nd percentile\", \"50th percentile\"]\n row_titles = ['Absolute value', 'Relative to reference case']\n plot_var_suffix = [\"_perc5\", \"_perc32\", \"_perc50\"]\n\n # Read data from NetCDF source file.\n plot_items = [[], []]\n plot_data_max, plot_data_relative_max = 0, 0\n for s in plot_var_suffix:\n d = nc.variables[plot_var+s][i_case, :, :]\n if plot_var[0] == \"p\":\n d *= 1e-3\n plot_items[0].append({'data': d})\n if np.amax(d) > plot_data_max:\n plot_data_max = np.amax(d)\n\n d_ref = nc.variables[plot_var_ref+s][i_case_ref, :, :]\n if plot_var[0] == \"p\":\n d_ref *= 1e-3\n d_relative = d/d_ref\n plot_items[1].append({'data': d_relative})\n if np.amax(d_relative) > plot_data_relative_max:\n plot_data_relative_max = np.amax(d_relative)\n\n print(\"Max absolute and relative value are respectively {:.2f} and {:.2f}\"\n .format(plot_data_max, plot_data_relative_max))\n\n # Mapping plot properties and splitting up into individual and shared properties.\n plot_handling = plot_settings_abs[\"plot_handling\"]\n contour_fill_levels = plot_handling[\"contour_fill_levels\"]\n contour_line_levels = plot_handling.get(\"contour_line_levels\", 3*[contour_fill_levels])\n colorbar_ticks = plot_handling.get(\"colorbar_ticks\", contour_fill_levels)\n\n contour_fill_levels_rel = plot_settings_rel[\"contour_fill_levels\"]\n contour_line_levels_rel = plot_settings_rel.get(\"contour_line_levels\", 3*[contour_fill_levels_rel])\n colorbar_ticks_rel = plot_settings_rel.get(\"colorbar_ticks\", contour_fill_levels_rel)\n\n # Write the contour handling to plot_items.\n for i, plot_item in enumerate(plot_items[0]):\n plot_item['contour_line_levels'] = contour_line_levels[i]\n for i, plot_item in enumerate(plot_items[1]):\n plot_item['contour_line_levels'] = contour_line_levels_rel[i]\n\n # Write the row dependent settings to row_items.\n row_items = []\n for i in range(2):\n row_items.append({\n 'title': row_titles[i],\n })\n row_items[0]['colorbar_ticks'] = colorbar_ticks\n row_items[0]['colorbar_label'] = plot_settings_abs[\"color_label\"]\n row_items[0]['contour_fill_levels'] = contour_fill_levels\n if 'colorbar_tick_fmt' in plot_handling:\n row_items[0]['colorbar_tick_fmt'] = plot_handling[\"colorbar_tick_fmt\"]\n row_items[0]['contour_line_label_fmt'] = '%.1f'\n\n row_items[1]['colorbar_ticks'] = colorbar_ticks_rel\n row_items[1]['colorbar_label'] = \"Increase factor [-]\"\n row_items[1]['contour_fill_levels'] = contour_fill_levels_rel\n if 'colorbar_tick_fmt' in plot_settings_rel:\n row_items[1]['colorbar_tick_fmt'] = plot_settings_rel[\"colorbar_tick_fmt\"]\n row_items[1]['extend'] = plot_settings_rel.get('extend', \"neither\")\n\n plot_panel_2x3(plot_items, column_titles, row_items)","def doParametersOfInterest(self):\n ''' ref : physicsmodel -> rvf\n self.modelBuilder.out.var(\"MH\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\n self.modelBuilder.out.var(\"MH\").setConstant(False)\n '''\n\n self.modelBuilder.doVar(\"mu[0,0,1000]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doVar(\"Fvbf[0,0,1]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doSet(\"POI\",\"mu,Fvbf\")\n self.modelBuilder.doVar(\"\")\n self.modelBuilder.factory_('expr::ggH_s_func(\"(@0-sqrt(@0))*(1.-@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::ggH_b_func(\"(1-sqrt(@0))*(1.-@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\"sqrt(@0)*(1.-@1)\", mu,Fvbf)')\n\n self.modelBuilder.factory_('expr::vbfH_s_func(\"(@0-sqrt(@0))*(@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\"(1-sqrt(@0))*(@1)\", mu,Fvbf)')\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\"sqrt(@0)*(@1)\", mu,Fvbf)')","def plot_shape_mcnp(self, e_min, e_max, logy=False, norm=False, marker='o', ax_mpl=None, plt_arrow=True):\n assert self.shape_dict_mcnp is not None\n if norm:\n _shape_df = self.shape_df_mcnp_norm\n _y_label = 'Ratio out of max flux of each energy'\n else:\n _shape_df = self.shape_df_mcnp\n _y_label = 'Flux (n/sterad/pulse)'\n\n # Only the energy provided by MCNPX simulation will be filtered\n _energy_list_dropped = self._form_energy_list_dropped(e_min=e_min, e_max=e_max)\n if ax_mpl is None:\n fig, ax_mpl = plt.subplots()\n ax_mpl.set_prop_cycle(default_cycler)\n for each in _energy_list_dropped:\n if logy:\n ax_mpl.semilogy(_shape_df['t_us'],\n _shape_df[each],\n linestyle='-',\n marker=marker,\n # fmt=marker,\n label=str(each) + ' eV (MCNPX)')\n else:\n ax_mpl.plot(_shape_df['t_us'],\n _shape_df[each],\n linestyle='-',\n marker=marker,\n # fmt=marker,\n label=str(each) + ' eV (MCNPX)')\n ax_mpl.set_ylabel(_y_label)\n ax_mpl.set_xlabel(u'Time (\\u03BCs)')\n ax_mpl.grid()\n if len(_energy_list_dropped) <= 7:\n ax_mpl.legend()\n else:\n if plt_arrow:\n _plot_ev_arrow_as_legend(ax=ax_mpl, ev_list=_energy_list_dropped)\n ax_mpl.set_title('Energy dependent neutron pulse shape (MCNPX)')\n ax_mpl.set_xlim(left=mcnp_plot_lim_dict['x_min'], right=mcnp_plot_lim_dict['x_max'])\n return ax_mpl","def sac_paper_plot(log_dir, det_policy_sublocation,act_0,act_1,act_2,is_tri,actions_to_plot_large=10,\n actions_to_plot_small = 100,actions_per_log = 6000, custom_colors=None,prot_linewidth=2.7,\n reward_linewidth = None,plot_file_name = None,small_action_ylim=None,large_action_ylim=None,\n reward_ylim=None,reward_ylabel=None, reward_plot_extra_args = None,\n reward_plot_extra_kwargs = None,extra_cycles=None,extra_cycles_linewidth=None,\n reward_legend_labels=None,action_legend_lines=None,action_legend_text=None,\n action_legend_location=None):\n\n #get location of files\n running_reward_file, _, actions_file = \\\n sac_logs_file_location(log_dir, is_tri, None,None,None)\n\n #font size\n matplotlib.rcParams.update({'font.size': 14, \"text.usetex\": True,\n 'text.latex.preamble' : r'\\usepackage{amsmath}\\usepackage{physics}'})\n\n #create the axis (subplots)\n fig = plt.figure(constrained_layout=True, figsize=(6,5))\n gs = gridspec.GridSpec(3, 3, figure=fig, height_ratios = [1,0.7,1])\n reward_ax = fig.add_subplot(gs[0, :])\n prot_0_ax = fig.add_subplot(gs[1, 0])\n prot_1_ax = fig.add_subplot(gs[1, 1],sharey=prot_0_ax)\n prot_2_ax = fig.add_subplot(gs[1, 2],sharey=prot_0_ax)\n prot_final_ax = fig.add_subplot(gs[2, :])\n plt.setp(prot_1_ax.get_yticklabels(), visible=False)\n plt.setp(prot_2_ax.get_yticklabels(), visible=False) \n\n #set the reward axis\n plot_running_reward_on_axis(running_reward_file, reward_ax, plot_to_file_line = None, linewidth=reward_linewidth,\n custom_color = \"black\", lines_to_mark = [nearest_int(act_0/actions_per_log),\n nearest_int(act_1/actions_per_log),nearest_int(act_2/actions_per_log)],\n custom_mark_color=\"black\",ylim=reward_ylim,ylabel=reward_ylabel,\n plot_extra_args=reward_plot_extra_args, plot_extra_kwargs=reward_plot_extra_kwargs,\n legend_labels=reward_legend_labels)\n\n #set the three actions axis\n plot_actions_on_axis(actions_file, prot_0_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n actions_ylim=small_action_ylim,plot_to_file_line=act_0,\n custom_colors=custom_colors,constant_steps=True, linewidth = prot_linewidth,\n two_xticks=True)\n plot_actions_on_axis(actions_file, prot_1_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n plot_to_file_line=act_1,ylabel=\"\",custom_colors=custom_colors,\n constant_steps=True, linewidth = prot_linewidth,two_xticks=True)\n plot_actions_on_axis(actions_file, prot_2_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\n plot_to_file_line=act_2, ylabel=\"\",custom_colors=custom_colors,\n constant_steps=True, linewidth = prot_linewidth, two_xticks=True)\n\n #set the final protocol axis\n plot_actions_on_axis(log_dir + det_policy_sublocation, prot_final_ax, is_tri, actions_to_plot=actions_to_plot_large,\n actions_ylim=large_action_ylim,plot_to_file_line=None,\n custom_colors=custom_colors, constant_steps=True, k_notation=False, x_count_from_zero=True,\n linewidth = prot_linewidth, xlabel=\"$t[dt]$\",extra_cycles=extra_cycles,\n extra_cycles_linewidth=extra_cycles_linewidth, legend_lines=action_legend_lines,\n legend_text=action_legend_text, legend_location=action_legend_location)\n\n #add the (a) (b) (c) labels\n reward_ax.text(-0.11,-0.38, r'\\textbf{(a)}', transform=reward_ax.transAxes )\n prot_0_ax.text(-0.4,-0.55, r'\\textbf{(b)}', transform=prot_0_ax.transAxes )\n prot_final_ax.text(-0.11,-0.38, r'\\textbf{(c)}', transform=prot_final_ax.transAxes )\n\n #save if necessary\n if plot_file_name is not None:\n plot_folder = os.path.join(log_dir, PLOT_DIR_NAME)\n Path(plot_folder).mkdir(parents=True, exist_ok=True)\n plot_file_name = os.path.join(plot_folder, plot_file_name)\n plt.savefig(plot_file_name)\n\n #show\n plt.show()","def plot_lineratios(modeldata,modeldata2='None',line1='CIV1551',line2='CIII1908',line3='CIV1551',line4='HeII1640',\n plotname='./TESTPLOT.pdf',Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\n logx=True,logy=True,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\n showobs=None,noobserr=False,verbose=True):\n NFalse = 0\n freeparam = []\n inforstr = \"\"\n # - - - - - - - - - - - - - - - - - - - - - - - -\n legenddic = {}\n legenddic['Zgas'] = r'Z$_\\textrm{gas}$'\n legenddic['logUs'] = r'log$_\\textrm{10}$(U)'\n legenddic['xid'] = r'$\\xi_\\textrm{d}$'\n legenddic['nh'] = r'n$_\\textrm{H}$ / [cm$^3$]'\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\textrm{sun}$'\n legenddic['mup'] = r'M$_\\textrm{cut IMF}$ / [M$_\\textrm{sun}]$'\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Zgas:\n Zgasrange = [0.0,1.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Zgas:vary, '\n freeparam.append('Zgas')\n else:\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not logU:\n logUrange = [-5.0,0.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' logU:vary, '\n freeparam.append('logUs')\n else:\n logUrange = [logU-0.1,logU+0.1]\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not xid:\n xidrange = [0.0,0.6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' xid:vary, '\n freeparam.append('xid')\n else:\n xidrange = [xid-0.01,xid+0.01]\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not nh:\n nhrange = [0.0,1.0e6]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' nH:vary, '\n freeparam.append('nh')\n else:\n nhrange = [nh-1.0,nh+1.0]\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not COratio:\n COratiorange = [0.0,2.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' C/O:vary, '\n freeparam.append('COCOsol')\n else:\n COratiorange = [COratio-0.001,COratio+0.001]\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if not Mcutoff:\n Mcutoffrange = [0.0,400.0]\n NFalse = NFalse + 1.0\n #inforstr = inforstr+' Mcutoff:vary, '\n freeparam.append('mup')\n else:\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\n # - - - - - - - - - - - - - - - - - - - - - - - -\n\n if NFalse != 2:\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\n ' parameters where not set')\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\n\n Ngoodent = len(goodent[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying (SFR)model selection ')\n param1_1 = modeldata[freeparam[0]][goodent]\n if logp1:\n param1_1 = np.log10(param1_1)\n\n param1_2 = modeldata[freeparam[1]][goodent]\n if logp2:\n param1_2 = np.log10(param1_2)\n\n ratio1_1 = modeldata[line1][goodent]/modeldata[line2][goodent]\n ratio1_2 = modeldata[line3][goodent]/modeldata[line4][goodent]\n else:\n if verbose: print(' WARNING: Less than 2 (SFR)model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - - - - - - - - - - - - - -\n if modeldata2 != 'None':\n goodent2 = np.where( (modeldata2['Zgas'] > Zgasrange[0]) & (modeldata2['Zgas'] < Zgasrange[1]) &\n (modeldata2['logUs'] > logUrange[0]) & (modeldata2['logUs'] < logUrange[1]) &\n (modeldata2['xid'] > xidrange[0]) & (modeldata2['xid'] < xidrange[1]) &\n (modeldata2['nh'] > nhrange[0]) & (modeldata2['nh'] < nhrange[1]) )\n\n Ngoodent2 = len(goodent2[0])\n\n if Ngoodent > 1:\n if verbose: print(' - Getting data for '+str(Ngoodent2)+' data points satisfying (AGN)model selection ')\n param2_1 = modeldata2[freeparam[0]][goodent2]\n if logp1:\n param2_1 = np.log10(param2_1)\n\n param2_2 = modeldata2[freeparam[1]][goodent2]\n if logp2:\n param2_2 = np.log10(param2_2)\n\n l2s = ['x','x','x','x'] # line names to use for Feltre+16 file\n for ll, linestr in enumerate([line1,line2,line3,line4]):\n if '1908' in linestr:\n l2 = linestr.replace('1908','1907')\n else:\n l2 = linestr\n\n l2s[ll] = l2\n\n ratio2_1 = modeldata2[l2s[0]][goodent2]/modeldata2[l2s[1]][goodent2]\n ratio2_2 = modeldata2[l2s[2]][goodent2]/modeldata2[l2s[3]][goodent2]\n else:\n if verbose: print(' WARNING: Less than 2 (AGN)model grid points to plot; no output generated')\n return\n\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\n if verbose: print(' - Setting up and generating plot')\n plotname = plotname\n fig = plt.figure(figsize=(9, 5))\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\n Fsize = 10\n lthick = 1\n marksize = 3\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif',size=Fsize)\n plt.rc('xtick', labelsize=Fsize)\n plt.rc('ytick', labelsize=Fsize)\n plt.clf()\n plt.ioff()\n plt.title(inforstr[:-2],fontsize=Fsize)\n\n margin = 0.1\n dx = np.abs(np.max(ratio1_1)-np.min(ratio1_1))\n dy = np.abs(np.max(ratio1_2)-np.min(ratio1_2))\n\n\n if fixxrange:\n xrange = fixxrange\n else:\n if logx:\n xrange = [np.min(ratio1_1)-np.min(ratio1_1)/2.,np.max(ratio1_1)+np.max(ratio1_1)/2.]\n else:\n xrange = [np.min(ratio1_1)-dx*margin,np.max(ratio1_1)+dx*margin]\n\n if fixyrange:\n yrange = fixyrange\n else:\n if logy:\n yrange = [np.min(ratio1_2)-np.min(ratio1_2)/2.,np.max(ratio1_2)+np.max(ratio1_2)/2.]\n else:\n yrange = [np.min(ratio1_2)-dy*margin,np.max(ratio1_2)+dy*margin]\n\n # ------------ PARAM1 ------------\n cmap = plt.cm.get_cmap('winter')\n cmin = np.min(param1_1)\n cmax = np.max(param1_1)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb1 = plt.colorbar(mm)#shrink=0.25\n\n pstr1 = legenddic[freeparam[0]]\n if logp1:\n pstr1 = r'log$_\\textrm{10}$('+pstr1+')'\n\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\n\n for p1 in np.unique(param1_1):\n p1col = cmap(colnorm(p1))\n p1ent = np.where(param1_1 == p1)\n\n plt.plot(ratio1_1[p1ent],ratio1_2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(ratio1_1[p1ent],ratio1_2[p1ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n if modeldata2 is not 'None':\n p1ent = np.where(param2_1 == p1)\n\n plt.plot(ratio2_1[p1ent],ratio2_2[p1ent],'-',lw=lthick, color='k',zorder=1)\n\n plt.errorbar(ratio2_1[p1ent],ratio2_2[p1ent],xerr=None,yerr=None,\n marker='D',lw=0, markersize=marksize*3,\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\n\n\n # ------------ PARAM2 ------------\n cmap = plt.cm.get_cmap('spring')\n cmin = np.min(param1_2)\n cmax = np.max(param1_2)\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\n mm = plt.cm.ScalarMappable(cmap=cmap)\n mm.set_array(cmaparr)\n cb2 = plt.colorbar(mm)#shrink=0.25\n\n pstr2 = legenddic[freeparam[1]]\n if logp2:\n pstr2 = 'log10('+pstr2+')'\n\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\n\n for p2 in np.unique(param1_2):\n p2col = cmap(colnorm(p2))\n p2ent = np.where(param1_2 == p2)\n\n plt.plot(ratio1_1[p2ent],ratio1_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(ratio1_1[p2ent],ratio1_2[p2ent],xerr=None,yerr=None,\n marker='o',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n if modeldata2 is not 'None':\n p2ent = np.where(param2_2 == p2)\n\n plt.plot(ratio2_1[p2ent],ratio2_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\n\n plt.errorbar(ratio2_1[p2ent],ratio2_2[p2ent],xerr=None,yerr=None,\n marker='D',lw=0, markersize=marksize*1.5,\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\n\n\n if showobs != None:\n for ii, objid in enumerate(showobs[:,0]):\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\n\n if noobserr:\n obsxerr = None\n obsyerr = None\n else:\n obsxerr = showobs[:,8][ii]\n obsyerr = showobs[:,10][ii]\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\n marker='*',lw=lthick, markersize=marksize*2,\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\n\n plt.xlabel(line1+'/'+line2)\n plt.ylabel(line3+'/'+line4)\n\n plt.xlim(xrange)\n plt.ylim(yrange)\n\n if logx:\n plt.xscale('log')\n if logy:\n plt.yscale('log')\n\n #--------- LEGEND ---------\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\n #\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\n # leg.get_frame().set_alpha(0.7)\n #--------------------------\n\n if verbose: print(' Saving plot to'+plotname)\n plt.savefig(plotname)\n plt.clf()\n plt.close('all')","def relative_range(self):\n self.calculate_relative_mags()\n string = '{:.0f}-{:.0f}Hz: {:.5f}'\n s_ind = self.get_bin(self.s_freq)\n e_ind = self.get_bin(self.e_freq)\n lst = self.rel_mags[s_ind:e_ind+1]\n return sum(lst)/len(lst)","def main(config_file, pre_nfiles=None, post_nfiles=None,\n cutoffs=[12.0, 60.0]):\n imu_complement_fig = (config_file[:-4] +\n \"_IMU_complementary_spectra.pdf\")\n imu_spectra_fig = (config_file[:-4] + \"_IMU_spectra.pdf\")\n nperseg1 = 60 * 5 * 10\n nperseg2 = 60 * 10\n fig, axs, leg = check.plot_IMU_euler_angles_spectra(config_file,\n nperseg=nperseg2,\n nfiles=pre_nfiles)\n fig.savefig(imu_complement_fig, bbox_extra_artists=(leg,),\n bbox_inches=\"tight\")\n plt.close(fig)\n fig_rate, _, fig_acc, _ = check.plot_IMU_spectra(config_file,\n nperseg=nperseg2,\n nfiles=pre_nfiles)\n with PdfPages(imu_spectra_fig) as pdf:\n pdf.savefig(fig_rate, bbox_inches=\"tight\")\n plt.close(fig_rate)\n pdf.savefig(fig_acc, bbox_inches=\"tight\")\n plt.close(fig_acc)\n\n # Look at individual periods\n config = db_flux.parse_config(config_file)\n input_files = config[\"EC Inputs\"][\"input_files\"]\n if post_nfiles is not None and post_nfiles < len(input_files):\n input_files = np.random.choice(input_files, post_nfiles,\n replace=False)\n imu2anem_pos = config[\"EC Motion Correction\"][\"imu2anemometer_pos\"]\n sample_freq_hz = config[\"EC Inputs\"][\"sample_frequency\"]\n Tcf, Ta = cutoffs\n for ifile in input_files:\n file_idx = ifile.index(ifile)\n ec_prep, _ = db_flux.prepare_period(ifile, config)\n wind = ec_prep[[\"wind_speed_u\", \"wind_speed_v\", \"wind_speed_w\"]]\n acceleration = ec_prep[[\"acceleration_x\",\n \"acceleration_y\",\n \"acceleration_z\"]]\n rate = ec_prep[[\"rate_x\", \"rate_y\", \"rate_z\"]]\n ec_corr = db_flux.wind3D_correct(wind.values, acceleration.values,\n rate.values,\n ec_prep.heading.values,\n ec_prep.speed_over_ground.values,\n imu2anem_pos, sample_freq_hz,\n Tcf, Ta)\n fig, _, leg = check.plot1_IMU_complementary_spectra(config_file,\n file_idx,\n Tcf=Tcf,\n Ta=Ta,\n nperseg=nperseg1)\n fig.savefig((ifile[:-4] + \"_euler_angle_spectra.pdf\"),\n bbox_extra_artists=(leg,), bbox_inches=\"tight\")\n plt.close()\n fig, axs, leg = check.plot_wind3D_spectra(wind.values,\n ec_corr.uvw_ship,\n nperseg=nperseg2)\n fig.savefig((ifile[:-4] + \"_uvw_spectra.pdf\"),\n bbox_extra_artists=(leg,), bbox_inches=\"tight\")\n plt.close()\n # Plot corrected wind cospectra\n fig, _, leg = check.plot_wind3D_cospectra(wind.values,\n ec_corr.uvw_ship,\n nperseg=nperseg2)\n fig.savefig((ifile[:-4] + \"_uvw_cospectra.pdf\"),\n bbox_extra_artists=(leg,), bbox_inches=\"tight\")\n plt.close()","def growth_curve(userinputs, filter, catalog):\n logging.info('Running growth curve analysis on {}'.format(catalog))\n # Load the photometry results from the catalog (that is returned by the phot\n # function)\n aper_st, flux_st = np.loadtxt(catalog, unpack=True, usecols=(0,3))\n\n #Growth curve is only done on the ref image so we get the filter from userinp.\n ref_filter = filter\n\n ratio_st = np.empty(len(aper_st))\n\n #number of apertures\n naper = 20\n\n # Calculate the number of stars, make sure it is an integer\n nstar = int(len(aper_st)/naper)\n logging.info('Number of stars used: {}'.format(nstar))\n aper_ind = naper - 1\n\n for k in range(nstar):\n\n for i in range(naper):\n\n ratio_st[i + k*naper] = flux_st[i + k*naper]/flux_st[aper_ind + k*naper]\n\n\n # Find median ratio at each aperture between all the stars and all the clusters\n med_st = np.empty(naper)\n\n for i in range(naper):\n\n med_st[i] = np.median(ratio_st[i::naper])\n\n\n # Plot growth curves\n logging.info('Creating Growth curve plots')\n fig = plt.figure(figsize = (7,7))\n\n aper_x = np.arange(naper) + 1\n\n for i in range(nstar):\n\n ratio_y = ratio_st[i*naper:(i + 1)*naper]\n plt.plot(aper_x, ratio_y, 'y-')\n plt.annotate(str(i + 1), xy=(8.0, ratio_y[7]),\n horizontalalignment='left', verticalalignment='top', fontsize=6)\n\n\n plt.plot(aper_x, med_st, 'r-' , linewidth=4.0)\n plt.hlines(0.5, 0, 20, color='black', linewidth=2, zorder=10)\n plt.vlines(4, 0, 1.1, color='black', linewidth=2, linestyle='dashed', zorder=10)\n plt.vlines(5, 0, 1.1, color='black', linewidth=2, linestyle='dashed', zorder=10)\n plt.vlines(6, 0, 1.1, color='black', linewidth=2, linestyle='dashed', zorder=10)\n\n plt.ylabel('Normalized Flux ' + ref_filter.upper())\n plt.xlabel('Radius (pix)')\n plt.xlim(1,20)\n plt.minorticks_on()\n\n fig.savefig(userinputs['OUTDIR'] + '/plots/plot_growth_curve_{}.pdf'.format(ref_filter))","def calculate_allowable_angles(self, angular_resolution=0.01, visualize=0, optimized=False):\n #Could be optimized more, if required.\n \n if visualize:\n pylab.ion() #Turns interaction on (?)\n print \"Calculation started\"\n\n if angular_resolution < self.ANGULAR_RESOLUTION_MIN:\n warnings.warn(\"Requested too small angular resolution. Using %s\" % self.ANGULAR_RESOLUTION_MIN)\n angular_resolution = self.ANGULAR_RESOLUTION_MIN\n\n #We do not need to look at more than the motor step size in phi, since the sample rotational\n # motor does the rest.\n self.phi_range = 0.99 * (self.sample_motor_step_size / 2)\n #Arbitrary max ranges here. TODO: User setting?\n self.chi_range = pi/8\n self.omega_range = pi/6\n\n #Make the lists\n self.phi_list = array([-self.phi_range, 0, self.phi_range])\n self.phi_list = np.append(np.arange(-self.phi_range, self.phi_range, angular_resolution), (self.phi_range) )\n self.chi_list = np.arange(-self.chi_range, self.chi_range, angular_resolution)\n self.omega_list = np.arange(-self.omega_range, self.omega_range, angular_resolution)\n\n #Create the allowed angle map, all false\n self.allowed = np.zeros( (self.phi_list.size, self.chi_list.size, self.omega_list.size), dtype=np.bool )\n\n #Make sure the limits are calculated\n self.calculate_leg_xy_limits()\n\n\n #Loop through all the angles\n for i_phi in range(self.phi_list.size):\n phi = self.phi_list[i_phi]\n print 'Calculating phi = %s' % phi\n was_anything_in_line = False\n for i_chi in range(self.chi_list.size):\n chi = self.chi_list[i_chi]\n was_allowed = False\n for i_omega in range(self.omega_list.size):\n omega = self.omega_list[i_omega]\n\n #Calcualte the leg position from these angles\n self.getplatepos(phi, chi, omega)\n #Make sure the legs are not in fault\n self.check_limits()\n allowed = not any(self.leg_fault)\n #Save it\n self.allowed[i_phi, i_chi, i_omega] = allowed\n if optimized:\n #Check that we have reached an unallowed section, to speed calculation\n if allowed: was_allowed = True\n if was_allowed and (not allowed):\n break #All other omega values in this chi will be false. Exit to the next line\n #(end of omega loop)\n\n if optimized:\n #Is there anything allowed in this chi line?\n anything_in_line = any(self.allowed[i_phi, i_chi, :])\n #Once we reach a completely disallowed line, all others after will be too\n if anything_in_line: was_anything_in_line = True\n if was_anything_in_line and (not anything_in_line):\n break #we don't need to look at the remaining lines.\n #(end of chi loop)\n #(end of phi loop)\n\n print \"Done!\"\n \n if visualize==1:\n #2D Animated plot\n for i_phi in range(self.phi_list.size):\n phi = self.phi_list[i_phi]\n #Here we are still in the phi loop\n if visualize:\n pylab.figure(0)\n pylab.imshow(self.allowed[i_phi, :, :], interpolation='nearest', extent=(-self.omega_range, self.omega_range, -self.chi_range, self.chi_range))\n pylab.xlabel(\"Omega\")\n pylab.ylabel(\"Chi\")\n pylab.title(\"Allowable angles for phi=%s\" % phi)\n pylab.draw()\n time.sleep(0.2)\n pylab.draw()\n time.sleep(1)\n pylab.ion()\n \n\n if visualize==2:\n #Single 3D plot of allowed angles.\n mlab.clf() #Clear figure\n mlab.contour3d(self.allowed.astype(float), contours=[0.5])\n mlab.xlabel(\"Phi\")\n mlab.ylabel(\"Chi\")\n mlab.zlabel(\"Omega\")\n mlab.axes()\n mlab.show()\n\n #Done calculating\n return None","def describe(name, values):\n log.info(\"Describing %s component.\" % name)\n abs_max_indices = np.unravel_index(np.argmax(np.abs(values), axis=None), values.shape)\n abs_max_polar = zdi_geometry.centers()[0][abs_max_indices]\n abs_max_azimuth = zdi_geometry.centers()[1][abs_max_indices]\n abs_max = np.abs(values[abs_max_indices])\n\n abs_mean = np.sum(np.abs(values) * zdi_geometry.areas()) / (4 * np.pi)\n abs_rms = (np.sum(values**2 * zdi_geometry.areas()) / (4 * np.pi))**.5\n abs_std = (np.sum((np.abs(values) - abs_mean)**2 * zdi_geometry.areas()) / (4 * np.pi))**.5\n\n # This is a statistical identity.\n assert np.isclose(abs_rms**2, abs_mean**2 + abs_std**2), \"RMS does not match mean and std.\"\n\n dest[f\"magnetogram.{name}.abs.max\"] = abs_max\n log.info(f\"{name} |B|_max = %4.4g Gauss\" % abs_max)\n log.info(f\"{name} |B|_max at az=%2.2f deg, pl=%3.2f deg\" % (np.rad2deg(abs_max_azimuth),\n np.rad2deg(abs_max_polar)))\n log.info(f\"{name} |B|_mean = %4.4g Gauss\" % abs_mean)\n log.info(f\"{name} |B|_var = %4.4g Gauss\" % abs_std)\n dest[f\"magnetogram.{name}.abs.mean\"] = abs_mean\n dest[f\"magnetogram.{name}.abs.rms\"] = abs_rms\n dest[f\"magnetogram.{name}.abs.std\"] = abs_std\n\n return abs_mean","def mlmc_massplot():\n out = parse_output_allg([\"t(\", \"Energy\", \"Mass\", \"InFlowRate\", \"OutFlowRate\"])\n t = out[0]\n mass = out[2]\n inflow = out[3]\n dt_3 = 64\n ndt = [dt_3, 2 * dt_3, 4 * dt_3]\n l = [3, 4, 5]\n nl = [10, 0, 0]\n n = 0\n colors = [\"darkred\", \"red\", \"#ff9966\"]\n mconly = True\n\n for i in range(len(l)):\n fig = plt.figure(i)\n for j in range(nl[i]):\n plt.plot(t[n:n + ndt[i] + 1], mass[n:n + ndt[i] + 1], label=\"Level \" + str(l[i]) + \" Sample \" + str(j))\n if (j == -1):\n plt.plot(t[n:n + ndt[i] + 1], inflow[n:n + ndt[i] + 1], color=\"black\",\n label=\"Inflow Level \" + str(l[i]) + \" Sample \" + str(j))\n n += ndt[i] + 1\n if i > 0 and not mconly:\n plt.plot(t[n:n + ndt[i - 1] + 1], mass[n:n + ndt[i - 1] + 1],\n label=\"Level \" + str(l[i - 1]) + \" Sample \" + str(j))\n n += ndt[i - 1] + 1\n plt.legend()\n\n plt.savefig(\"MLMCMassPlot.jpg\")","def plot_q_values(self):\n\n sim_freq = self.conf['Simulation']['params']['frequency']\n sim_wvlgth = 1e9*consts.c / sim_freq\n leg_str = ''\n for mat, matpath in self.conf['Materials'].items():\n n, k = get_nk(matpath, sim_freq)\n mat_wv = 1e-3*sim_wvlgth / n\n mat_q = 2*np.pi/mat_wv\n leg_str += '{}: {:.2f} [rads/$\\mu$m]\\n'.format(mat, mat_q)\n leg_str = leg_str[0:-1]\n for lname, l_obj in self.layers.items():\n qarr = self.data['{}_qvals'.format(lname)]\n max_pos_freq = np.amax(qarr.real)\n max_neg_freq = np.amin(qarr.real)\n min_pos_wv = 1e3*2*np.pi/max_pos_freq\n if max_neg_freq == 0:\n min_neg_wv = 0\n else:\n min_neg_wv = 1e3*2*np.pi/max_neg_freq\n plt.figure()\n inc_q = 2*np.pi/(1e-3*sim_wvlgth)\n title = 'Layer: {}, Incident q: {:.2f} [rads/$\\mu$m]'.format(lname, inc_q)\n # title += 'Min Positive $\\\\lambda$: {:.2f} nm, '\n # title += 'Min Negative $\\\\lambda$: {:.2f} nm'\n # title = title.format(lname, sim_wvlgth, min_pos_wv, min_neg_wv)\n # title = title.format(lname, sim_wvlgth)\n plt.title(title)\n # plt.scatter(1e3*2*np.pi/qarr.real, 1e4*qarr.imag/2*np.pi, c='b', s=.5,\n # marker='o', label=leg_str)\n plt.scatter(qarr.real, qarr.imag/(2*np.pi), c='b', s=.75,\n marker='o', label=leg_str)\n # pt = (qarr[0].real, qarr[0].imag)\n # theta = np.linspace(0, 1.48, 200)\n # plt.plot(pt[0]*np.cos(theta), pt[1]/np.cos(theta), 'r--')\n plt.legend(loc='best')\n # plt.annotate(leg_str, xy=(.95,.95), xycoords='axes fraction',\n # size=14, ha='right', va='top',\n # bbox=dict(boxstyle='round', fc='w'))\n plt.xlabel('Re(q) [radians/micron]')\n plt.ylabel('Im(q) [1/microns]')\n plot_path = os.path.join(self.dir, '{}_qvals.png'.format(lname))\n plt.grid(True)\n plt.savefig(plot_path)\n plt.close()","def cal_mass(self):\n\n if not self.check_def(['E','px','py','pz']):\n sys.exit('Particle error: Quadri impulsion not define (error for mass routine)')\n\n\n \n if self.E**2-self.px**2-self.py**2-self.pz**2>1e-7: #precision problem\n self.mass=math.sqrt(self.E**2-self.px**2-self.py**2-self.pz**2)\n else:\n self.mass=0","def aminusb_ax2( mv1, mv2 ):\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\n print \"WARING: aminusb_ax2 is subtracting variables with different units!\",mv1,mv1\n axes1 = allAxes(mv1)\n axes2 = allAxes(mv2)\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\n # But for now, we'll just check a bit ...\n ax1=axes1[0]\n ax2=axes2[0]\n if ax1.shape!=ax2.shape:\n print \"ERROR aminusb_ax2 requires same axes, but shape differs:\",ax1.shape,ax2.shape\n print \"ax1,ax2\"\n return None\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\n if ax1.units=='mb':\n ax1.units = 'mbar' # udunits uses mb for something else\n if ax2.units=='mb':\n ax2.units = 'mbar' # udunits uses mb for something else\n tmp = udunits(1.0,ax2.units)\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\n # crude substitute for a real units library:\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\n # print \"ERROR aminusb_ax2 requires same axes, but units differ:\",ax1.units,ax2,units\n # print \"ax1,ax2\"\n # return None\n ab_axes = [ax1]\n if len(axes1[1])<=len(axes2[1]):\n a = mv1\n b = interp2( axes1[1], mv2 )\n ab_axes.append(axes1[1])\n else:\n a = interp2( axes2[1], mv1 )\n b = mv2\n ab_axes.append(axes2[1])\n aminusb = a - b\n aminusb.id = mv1.id\n aminusb.initDomain( ab_axes )\n return aminusb","def plotDistributionWithLimits(lXs, llYs, lKClassif,out=\"out.png\", title=\"title\", xax=\"xax\", yax=\"yax\",legend=\"\"):\n\n fig = plt.Figure(figsize=(40,20))\n fig.suptitle(title, fontsize=32)\n nbPlots = len(llYs)\n sqrt = int(math.ceil(math.sqrt(nbPlots)))\n ymax = 0.0\n for val in llYs:\n ymax = max(max(val[0]),ymax)\n ymaxCurrent = max(max(val[2]),ymax)\n ymax = ymax*1.05\n xmax = 147\n gs = gridspec.GridSpec(1,2) \n ax = fig.add_subplot(gs[0])\n gsLimit = gridspec.GridSpecFromSubplotSpec(sqrt,sqrt, subplot_spec=gs[1])\n for i,val in enumerate(llYs):\n ax.plot(lXs,val[0],color=Graphics.lColors[i%25])\n axCurrent = fig.add_subplot(gsLimit[i]) \n axCurrent.fill_between(lXs, val[1], val[2], alpha=0.35, edgecolor='black', facecolor=Graphics.lColors[i%25])\n axCurrent.set_title(\"Cluster K{}, (position: {})\".format(i,lKClassif[i]))\n axCurrent.fill_between(lXs, val[3], val[4], alpha=0.85, edgecolor='darkgray', facecolor='lightgray')\n axCurrent.plot(lXs,val[0],color=Graphics.lColors[i%25])\n axCurrent.set_ylim(0,ymaxCurrent)\n axCurrent.set_xlim(1,xmax)\n axCurrent.text(10, ymaxCurrent*0.90, \"#nucleosomes: {}\".format(legend[i]), fontsize=12)\n axis_font = {'size':'28'}\n ax.set_ylim(0,ymax)\n ax.set_xlim(1,xmax)\n ax.legend([\"K{}\".format(x) for x in range(0,nbPlots)])\n ax.set_title(\"all nucleosomes\", **axis_font)\n ax.set_xlabel(xax, **axis_font)\n ax.set_ylabel(yax, **axis_font)\n ax.tick_params(labelsize=20)\n canvas = FigureCanvasAgg(fig)\n canvas.print_figure(out, dpi=80)","def parseArguments():\n # Create argument parser\n #parser = argparse.ArgumentParser()\n parser = ArgumentParser()\n\n\n # Positional mandatory arguments\n parser.add_argument(\"input\", nargs='+',help=\"Input Image with .fits ending. A folder or multiple Images also work\", type=str)\n parser.add_argument(\"-c\", \"--catalog\", help=\"Catalog to use for position reference ('PS', '2MASS' or 'GAIA') or name of local file\", type=str, default=\"PS\")\n\n parser.add_argument(\"-s\", \"--save_images\", help=\"Set True to create _image_before.pdf and _image_after.pdf\", type=bool, default=False)\n parser.add_argument(\"-p\", \"--images\", help=\"Set 0 to not create the plots.\", type=int, default=1)\n\n parser.add_argument(\"-v\", \"--verbose\", help=\"More console output about what is happening. Helpfull for debugging.\", type=bool, default=False)\n parser.add_argument(\"-silent\", \"--silent\", help=\"Almost no console output. Use when running many files. turns verbose off, turns plots off, turns ignore warning on. \", type=bool, default=False)\n\n\n\n parser.add_argument(\"-w\", \"--ignore_warnings\", help=\"Set False to see all Warnings about the header if there is problems. Default is to ignore most warnings.\", type=bool, default=True)\n\n parser.add_argument(\"-ra\", \"--ra\", help=\"Set ra by hand in degrees. Should not be necessary if the info is in the fits header.\", type=float, default=None)\n parser.add_argument(\"-dec\", \"--dec\", help=\"Set dec by hand in degrees. Should not be necessary if the info is in the fits header.\", type=float, default=None)\n\n parser.add_argument(\"-proj1\", \"--projection_ra\", help=\"Set the projection by hand. Should not be necessary if the info is in the fits header. example: -proj1 RA---TAN -proj2 DEC--TAN\", type=str, default=None)\n parser.add_argument(\"-proj2\", \"--projection_dec\", help=\"Set the projection by hand. Should not be necessary if the info is in the fits header. example: -proj1 RA---TAN -proj2 DEC--TAN\", type=str, default=None)\n\n\n parser.add_argument(\"-rot_scale\", \"--rotation_scaling\", help=\"By default rotation and scaling is determined. If wcs already contains this info and the fit fails you can try deactivating this part by setting it to 0\", type=int, default=1)\n parser.add_argument(\"-xy_trafo\", \"--xy_transformation\", help=\"By default the x and y offset is determined. If wcs already contains this info and the fit fails you can try deactivating this part by setting it to 0\", type=int, default=1)\n parser.add_argument(\"-fine\", \"--fine_transformation\", help=\"By default a fine transformation is applied in the end. You can try deactivating this part by setting it to 0\", type=int, default=1)\n\n parser.add_argument(\"-vignette\", \"--vignette\", help=\"Do not use corner of the image. Only use the data in a circle around the center with certain radius. Default: not used. Set to 1 for circle that touches the sides. Less to cut off more\", type=float, default=3)\n parser.add_argument(\"-vignette_rec\", \"--vignette_rectangular\", help=\"Do not use corner of the image. Cutoff 1- <value> on each side of the image. Default: not used. 1 uses the full image, 0.9 cuts 10%% on each side\", type=float, default=1.)\n\n parser.add_argument(\"-cutout\", \"--cutout\", help=\"Cutout bad recangle from Image. Specify corners in pixel as -cutout xstart xend ystart yend. You can give multiple cutouts \", nargs='+',action=\"append\", type=int)\n\n parser.add_argument(\"-ignore_header_rot\", \"--ignore_header_rot\", help=\"Set to 0 to ignore rotation information contained in header\", type=int, default=0)\n\n parser.add_argument(\"-r\", \"--radius\", help=\"Change the download radius for how many catalog objects should be downloaded in arcmin. \", type=float, default=-1)\n parser.add_argument(\"-save_bad_result\", \"--save_bad_result\", help=\"Save result even when it is considered bad by setting this to 1. By default bad results will not be saved\", type=int, default=0)\n\n parser.add_argument(\"-sigma_threshold_for_source_detection\", \"--sigma_threshold_for_source_detection\", help=\"Sigma threshold for source detection on the image\", type=float, default=5)\n parser.add_argument(\"-seeing\", \"--seeing\", help=\"Average FWHM of sources. Default 4px\", type=float, default=4)\n\n parser.add_argument(\"-high_res\", \"--high_resolution\", help=\"Set true to indicate higher resolution image like HST to allow larger steps for fine transformation. Default False for smaller telescopes\", type=bool, default=False)\n parser.add_argument(\"-hdul_idx\", \"--hdul_idx\", help=\"Index of the image data in the fits file. Default 0\", type=int, default=0)\n parser.add_argument(\"-filename_for_sources\", \"--filename_for_sources\", help=\"Save the sky positions of the sources to file to calibrate another image with it. Set to the filename without extension. Default: not used\", type=str, default=None)\n\n # Print version\n parser.add_argument(\"--version\", action=\"version\", version='%%(prog)s - Version 1.5') #\n #changelog\n #version 0.0 proof of concept\n #version 0.1 alpha version\n #version 1.0 first public version\n #version 1.2 included option to not show images\n #version 1.3 improved support for high resolution images\n #version 1.4 bugfixes and ability to calibrate based on another image\n #version 1.5 added compatibility with photutils v1.4\n\n # Parse arguments\n args = parser.parse_args()\n\n return args","def add_is_approximation(self):\n \n if (self.mf_steps == 0 or self.alpha ==0) and (not self.mixture)\\\n and (self.gibbs_steps ==0):\n print(\"Importance distribution is uniform\")\n weight_term = T.log(self.num_samples) + self.num_vars*T.log(0.5)\n \n elif (self.mf_steps > 0 and self.alpha > 0) and (not self.mixture)\\\n and (self.gibbs_steps ==0):\n print(\"Importance distribution is not uniform\")\n weight_term = T.log(self.num_samples)+\\\n self.get_importance_evals(T.transpose(self.x_tilda), \n T.transpose(self.sampler_theta))\n \n if self.resample:\n weight_term = T.reshape(weight_term, \n [self.batch_size, self.num_samples])\n \n elif self.mixture:\n \n if self.resample:\n n_iters = self.num_samples*self.batch_size \n else:\n n_iters = self.num_samples \n \n weight_term, _ =\\\n theano.scan(lambda j: \n self.get_mixture_evals(T.transpose(self.x_tilda[j,:])),\n sequences = [T.arange(n_iters)])\n \n if self.resample:\n weight_term = T.reshape(weight_term, \n [self.batch_size, self.num_samples]) \n \n weight_term = T.log(self.num_samples) + weight_term \n \n elif self.gibbs_steps > 0:\n print(\"Importance distribution is gibbs sampler\") \n weight_term = T.log(self.num_samples)+\\\n self.get_importance_evals(T.transpose(self.x_tilda), \n T.transpose(self.sampler_theta))\n \n if self.resample:\n weight_term = T.reshape(weight_term, \n [self.batch_size, self.num_samples]) \n \n \n if self.resample and self.num_hidden ==0:\n \n approx_Z = -self.compute_energy(self.x_tilda, \n self.num_samples*self.batch_size)\n \n elif (not self.resample) and self.num_hidden ==0:\n \n approx_Z = -self.compute_energy(self.x_tilda, \n self.num_samples)\n \n elif self.resample and self.num_hidden > 0:\n \n approx_Z = -self.compute_free_energy(self.x_tilda)\n \n elif (not self.resample) and self.num_hidden >0:\n \n approx_Z = -self.compute_free_energy(self.x_tilda)\n \n if self.resample:\n \n approx_Z = T.reshape(approx_Z, \n [self.batch_size, self.num_samples])\n \n approx_Z = approx_Z - weight_term\n \n return approx_Z","def plot(self, plot_limits=None, which_data_rows='all',\r\n which_data_ycols='all', which_parts='all', fixed_inputs=[],\r\n plot_raw=False,\r\n levels=20, samples=0, fignum=None, ax=None, resolution=None):\r\n #deal work out which ax to plot on\r\n #Need these because we use which_data_rows in this function not just base\r\n if which_data_rows == 'all':\r\n which_data_rows = slice(None)\r\n if which_data_ycols == 'all':\r\n which_data_ycols = np.arange(self.output_dim)\r\n if ax is None:\r\n fig = pb.figure(num=fignum)\r\n ax = fig.add_subplot(111)\r\n\r\n #work out what the inputs are for plotting (1D or 2D)\r\n fixed_dims = np.array([i for i,v in fixed_inputs])\r\n free_dims = np.setdiff1d(np.arange(self.input_dim),fixed_dims)\r\n\r\n #call the base plotting\r\n GPBase.plot(self, samples=samples, plot_limits=plot_limits,\r\n which_data_rows=which_data_rows,\r\n which_data_ycols=which_data_ycols, fixed_inputs=fixed_inputs,\r\n which_parts=which_parts, resolution=resolution, levels=20,\r\n fignum=fignum, ax=ax)\r\n\r\n if len(free_dims) == 1:\r\n #plot errorbars for the uncertain inputs\r\n if self.has_uncertain_inputs:\r\n Xu = self.X * self._Xscale + self._Xoffset # NOTE self.X are the normalized values now\r\n ax.errorbar(Xu[which_data_rows, 0], self.likelihood.data[which_data_rows, 0],\r\n xerr=2 * np.sqrt(self.X_variance[which_data_rows, 0]),\r\n ecolor='k', fmt=None, elinewidth=.5, alpha=.5)\r\n\r\n #plot the inducing inputs\r\n Zu = self.Z * self._Xscale + self._Xoffset\r\n ax.plot(Zu, np.zeros_like(Zu) + ax.get_ylim()[0], 'r|', mew=1.5, markersize=12)\r\n\r\n elif len(free_dims) == 2:\r\n Zu = self.Z * self._Xscale + self._Xoffset\r\n ax.plot(Zu[:, 0], Zu[:, 1], 'wo')\r\n\r\n else:\r\n raise NotImplementedError, \"Cannot define a frame with more than two input dimensions\"","def cal_abs_coeff(self, filepath, thickness, sub_filepath,\n start, end,\n output_path='/Users/nakayamahidenori/UCSB_data/spectra/abs_coeff',\n output=True):\n \n NM_TO_EV_CONST = 1240. #lambda = 1240/E\n \n filename = filepath.split('/')[-1].split('.')[0]\n \n from scipy import interpolate\n\n \n def interp(wl, absorbance, start=start, end=end, step=1.): \n f = interpolate.interp1d(wl, absorbance)\n new_wl = np.arange(start, end + step, step)\n new_abs = f(new_wl)\n \n return new_wl, new_abs\n \n f_abs = Clab_UV().read_file(filepath, absorbance=True)\n sub_abs = Clab_UV().read_file(sub_filepath, absorbance=True)\n \n wl, f_abs_intp = interp(f_abs.ix[:,0], f_abs.ix[:,1])\n wl, sub_abs_intp = interp(sub_abs.ix[:,0], sub_abs.ix[:,1])\n abs_coeff_wl = (f_abs_intp - sub_abs_intp)/(thickness*1e-7)\n \n ev_converted = NM_TO_EV_CONST/wl\n ev_start = round(NM_TO_EV_CONST/end + 0.01, 2)\n ev_end = round(NM_TO_EV_CONST/start - 0.01, 2)\n \n\n ev, abs_coeff_ev = interp(ev_converted, abs_coeff_wl,\n start=ev_start, end=ev_end, step=.01)\n\n \n if output:\n df = pd.DataFrame([np.array(wl),\n np.array(abs_coeff_wl),\n np.array(ev),\n np.array(abs_coeff_ev)],\n index=['wl_[nm]',\n 'abs_coeff_wl_[cm-1]',\n 'energy_[eV]',\n 'abs_coeff_ev_[cm-1]']).T\n \n df.to_csv(output_path + '/' + filename + '.csv')\n\n return wl, abs_coeff_wl, ev, abs_coeff_ev","def main():\n\n parser = argparse.ArgumentParser(description=main.__doc__,\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\n epilog=\"Homepage: https://github.com/kbat/mc-tools\")\n parser.add_argument('com', type=str, help='plot requests file name', nargs='?', default=\"/tmp/foo.c\")\n parser.add_argument('comout', type=str, help='COMOUT file name', nargs='?', default=\"zoom\")\n\n args = parser.parse_args()\n\n cmd = {} # dictionary of commands\n\n bas = False\n plane = False\n \n with open(args.com) as f:\n for line in f.readlines():\n words = line.strip().split()\n if len(words) is 0:\n continue\n\n for i,w in enumerate(words):\n if re.search(\"^bas\", w):\n cmd['bas'] = list(map(float, words[i+1:i+7]))\n if plane is False: bas = True # basis was before plane cuts\n elif re.search(\"^or\", w):\n cmd['or'] = list(map(float, words[i+1:i+4]))\n elif re.search(\"^ex\", w):\n try: # both x and y scales are given\n cmd['ex'] = list(map(float, words[i+1:i+3]))\n continue\n except ValueError: # just 1 scale is given\n cmd['ex'] = list(map(float, words[i+1:i+2]))\n elif re.search(\"^lab\", w):\n cmd['label'] = list(map(int, map(float, words[i+1:i+3]))) #+ [words[i+3]]\n elif re.search(\"^p[xyz]\", w):\n cmd[w] = [float(words[i+1])]\n if bas is False: plane = True # plane cuts were before basis\n elif re.search(\"^legend\", w):\n cmd[w] = [words[i+1]]\n elif w == \"scale\":\n print(w)\n if int(words[i+1]): # no need to put 'scale 0'\n cmd[w] = [words[i+1]]\n elif w in (\"mesh\"):\n if int(words[i+1])==1: # no need to put 'mesh 1'\n cmd[w] = [words[i+1]]\n\n print(bas, plane)\n\n if plane: # bas was first\n keys = ('bas', 'or', 'ex', 'px', 'py', 'pz', 'label', 'mesh', 'legend', 'scale')\n elif bas:\n keys = ('or', 'ex', 'px', 'py', 'pz', 'bas', 'label', 'mesh', 'legend', 'scale')\n else:\n keys = {'or', 'ex', 'label', 'mesh', 'legend', 'scale'}\n \n with open(args.comout, 'w') as f:\n for key in keys:\n if key in cmd:\n # newline required by mcplot:\n if key in ('mesh', 'legend', 'scale', 'label'):\n f.write(\"\\n\")\n f.write(\"%s %s \" % (key,\" \".join(str(e) for e in cmd[key]),))\n f.write(\"\\n\")","def plot_shifts(\n ax: Any,\n relative_shifts: np.ndarray,\n) -> None:\n\n # Determine the grid size from the shifts array\n grid_size = relative_shifts.shape[0]\n\n # Compute the positions of the centers of the subapertures\n x, y = get_subaperture_centers(grid_size=grid_size)\n\n # Draw the grid of subapertures\n for z in np.linspace(-1 / np.sqrt(2), 1 / np.sqrt(2), grid_size + 1):\n ax.plot((z, z), (-1 / np.sqrt(2), 1 / np.sqrt(2)), color=\"black\")\n ax.plot((-1 / np.sqrt(2), 1 / np.sqrt(2)), (z, z), color=\"black\")\n\n # Plot the centers of the subapertures\n ax.plot(x.flatten(), y.flatten(), \"x\", ms=4, color=\"C2\", alpha=0.5)\n\n # Add a red circle indicating the unit disk\n ax.add_artist(plt.Circle((0, 0), 1, color=\"red\", ls=\"--\", fill=False))\n\n # Determine a shrinkage factor to map the relative shifts into the right\n # reference frame (i.e., scale to the size of a subaperture in the plot)\n factor = np.sqrt(2) / grid_size / 2\n\n # Plot the observed position for each subapertures, which differs from the\n # center of the subaperture by the given shift vector\n ax.plot(\n x.flatten() + factor * relative_shifts[:, :, 0].flatten(),\n y.flatten() + factor * relative_shifts[:, :, 1].flatten(),\n \".\",\n color=\"C0\",\n )\n\n # Fix the x- and y-limits of the plot\n ax.set_xlim(-1.1, 1.1)\n ax.set_ylim(-1.1, 1.1)\n\n # Fix the aspect ratio of the plot\n ax.set_aspect(\"equal\")","def vis_eval_sysu(distmat, q_pids, g_pids, q_camids, g_camids, max_rank=20,img_paths=[]):\n num_q, num_g = distmat.shape\n if num_g < max_rank:\n max_rank = num_g\n print(\"Note: number of gallery samples is quite small, got {}\".format(num_g))\n indices = np.argsort(distmat, axis=1)\n pred_label = g_pids[indices]\n matches = (g_pids[indices] == q_pids[:, np.newaxis]).astype(np.int32)\n sysumm_save_sample(indices=indices,matches=matches, img_paths=img_paths)\n # compute cmc curve for each query\n new_all_cmc = []\n all_cmc = []\n all_AP = []\n num_valid_q = 0. # number of valid query\n for q_idx in range(num_q):\n # get query pid and camid\n q_pid = q_pids[q_idx]\n q_camid = q_camids[q_idx]\n\n # remove gallery samples that have the same pid and camid with query\n order = indices[q_idx]\n remove = (q_camid == 3) & (g_camids[order] == 2)\n keep = np.invert(remove)\n\n # compute cmc curve\n # the cmc calculation is different from standard protocol\n # we follow the protocol of the author's released code\n new_cmc = pred_label[q_idx][keep]\n new_index = np.unique(new_cmc, return_index=True)[1]\n new_cmc = [new_cmc[index] for index in sorted(new_index)]\n new_match = (new_cmc == q_pid).astype(np.int32)\n new_cmc = new_match.cumsum()\n new_all_cmc.append(new_cmc[:max_rank])\n\n orig_cmc = matches[q_idx][keep] # binary vector, positions with value 1 are correct matches\n if not np.any(orig_cmc):\n # this condition is true when query identity does not appear in gallery\n continue\n\n cmc = orig_cmc.cumsum()\n cmc[cmc > 1] = 1\n\n all_cmc.append(cmc[:max_rank])\n num_valid_q += 1.\n\n # compute average precision\n # reference: https://en.wikipedia.org/wiki/Evaluation_measures_(information_retrieval)#Average_precision\n num_rel = orig_cmc.sum()\n tmp_cmc = orig_cmc.cumsum()\n tmp_cmc = [x / (i + 1.) for i, x in enumerate(tmp_cmc)]\n tmp_cmc = np.asarray(tmp_cmc) * orig_cmc\n AP = tmp_cmc.sum() / num_rel\n all_AP.append(AP)\n\n assert num_valid_q > 0, \"Error: all query identities do not appear in gallery\"\n\n all_cmc = np.asarray(all_cmc).astype(np.float32)\n all_cmc = all_cmc.sum(0) / num_valid_q\n\n new_all_cmc = np.asarray(new_all_cmc).astype(np.float32)\n new_all_cmc = new_all_cmc.sum(0) / num_valid_q\n mAP = np.mean(all_AP)\n\n return new_all_cmc, mAP","def plotDistributionWithLimitsRefine(lXs, llYs, lKClassif,out=\"out.png\", title=\"title\", xax=\"xax\", yax=\"yax\",legend=\"\"):\n\n fig = plt.Figure(figsize=(40,20))\n fig.suptitle(title, fontsize=32)\n nbPlots = len(llYs)\n sqrt = int(math.ceil(math.sqrt(nbPlots)))\n ymax = 0.0\n for i,val in enumerate(llYs):\n if lKClassif[i] != \"refine\":\n ymax = max(max(val[0]),ymax)\n ymaxCurrent = max(max(val[2]),ymax)\n ymax = ymax*1.05\n xmax = 147\n gs = gridspec.GridSpec(1,2) \n ax = fig.add_subplot(gs[0])\n gsLimit = gridspec.GridSpecFromSubplotSpec(sqrt,sqrt, subplot_spec=gs[1])\n for i,val in enumerate(llYs):\n if lKClassif[i] != \"refine\":\n ax.plot(lXs,val[0],color=Graphics.lColors[i%25])\n axCurrent = fig.add_subplot(gsLimit[i]) \n axCurrent.fill_between(lXs, val[1], val[2], alpha=0.35, edgecolor='black', facecolor=Graphics.lColors[i%25])\n axCurrent.set_title(\"Cluster K{}, (position: {})\".format(i,lKClassif[i]))\n axCurrent.fill_between(lXs, val[3], val[4], alpha=0.85, edgecolor='darkgray', facecolor='lightgray')\n axCurrent.plot(lXs,val[0],color=Graphics.lColors[i%25])\n axCurrent.set_ylim(0,ymaxCurrent)\n axCurrent.set_xlim(1,xmax)\n axCurrent.text(10, ymaxCurrent*0.90, \"#nucleosomes: {}\".format(legend[i]), fontsize=12)\n axis_font = {'size':'28'}\n ax.set_ylim(0,ymax)\n ax.set_xlim(1,xmax)\n ax.legend([\"K{}\".format(x) for x in range(0,nbPlots)])\n ax.set_title(\"all nucleosomes\", **axis_font)\n ax.set_xlabel(xax, **axis_font)\n ax.set_ylabel(yax, **axis_font)\n ax.tick_params(labelsize=20)\n canvas = FigureCanvasAgg(fig)\n canvas.print_figure(out, dpi=80)","def frac_diff_groups_model(param_dict, proj_dict, plot_opt='mhalo',\n nlim_min=5, nlim_threshold=False, arr_len=10, bin_statval='left',\n fig_fmt='pdf', figsize=(10, 8), fig_number=1):\n file_msg = param_dict['Prog_msg']\n ## Matplotlib option\n matplotlib.rcParams['axes.linewidth'] = 2.5\n matplotlib.rcParams['axes.edgecolor'] = 'black'\n ##\n # Constants\n cm = plt.cm.get_cmap('viridis')\n plot_dict = param_dict['plot_dict']\n ham_color = 'red'\n alpha = 0.6\n alpha_mass = 0.2\n zorder_mass = 10\n zorder_shade = zorder_mass - 1\n zorder_ml = zorder_mass + 1\n bin_width = param_dict['ml_args'].mass_bin_width\n ##\n ## Figure name\n fname = os.path.join( proj_dict['figure_dir'],\n 'Fig_{0}a_{1}_group_mass_comparison.{2}'.format(\n fig_number,\n param_dict['catl_str_fig'],\n fig_fmt))\n ##\n ## Paper Figure\n fname_paper = os.path.join( proj_dict['paper_fig_dir'],\n 'Figure_01a.{0}'.format(fig_fmt))\n ##\n ## Reading in 'master' combined catalogue\n catl_pd_tot = param_dict['ml_args'].extract_merged_catl_info(\n opt='combined')\n ##\n ## Only selecting groups with `nlim_min` galaxies or larger\n if nlim_threshold:\n catl_pd_tot = catl_pd_tot.loc[(catl_pd_tot['GG_ngals'] >= nlim_min)]\n ##\n ## Temporarily fixing `GG_mdyn_rproj`\n # catl_pd_tot.loc[:, 'GG_mdyn_rproj'] /= 0.96\n ##\n ## Dropping NaN's\n catl_pd_tot.dropna(how='any', inplace=True)\n ##\n ## Selecting only 'Good' groups\n good_p_opt = int(1)\n catl_cols_arr = ['GG_pointing', 'GG_mhalo_point', 'GG_M_group',\n 'GG_mdyn_rproj', 'groupid']\n catl_pd_tot_mod = catl_pd_tot.loc[catl_pd_tot['GG_pointing'] == good_p_opt,\n catl_cols_arr].drop_duplicates().reset_index(drop=True)\n ##\n ## Selecting Masses\n # - HAM Mass -\n ham_cols = ['GG_M_group', 'GG_mhalo_point']\n ( ham_pred,\n ham_true) = catl_pd_tot_mod.loc[:, ham_cols].values.T\n ham_frac_diff = 100. * (ham_pred - ham_true) / ham_true\n # - DYN Mass -\n dyn_cols = ['GG_mdyn_rproj', 'GG_mhalo_point']\n ( dyn_pred,\n dyn_true) = catl_pd_tot_mod.loc[\n catl_pd_tot_mod['GG_mdyn_rproj'] >= 11.0,\n dyn_cols].values.T\n dyn_frac_diff = 100. * (dyn_pred - dyn_true) / dyn_true\n ##\n ## Choosing which mass to plot\n if (plot_opt == 'mgroup'):\n ham_x = ham_pred\n dyn_x = dyn_pred\n elif (plot_opt == 'mhalo'):\n ham_x = ham_true\n dyn_x = dyn_true\n ##\n ## Binning the data\n ## -- HAM --\n ( x_stat_ham ,\n y_stat_ham ,\n y_std_ham ,\n y_std_err_ham) = cstats.Stats_one_arr( ham_x,\n ham_frac_diff,\n base=bin_width,\n arr_len=arr_len,\n bin_statval=bin_statval)\n y1_ham = y_stat_ham - y_std_ham\n y2_ham = y_stat_ham + y_std_ham\n ## -- DYN --\n ( x_stat_dyn ,\n y_stat_dyn ,\n y_std_dyn ,\n y_std_err_dyn) = cstats.Stats_one_arr( dyn_x,\n dyn_frac_diff,\n base=bin_width,\n arr_len=arr_len,\n bin_statval=bin_statval)\n y1_dyn = y_stat_dyn - y_std_dyn\n y2_dyn = y_stat_dyn + y_std_dyn\n ## Figure details\n # Labels\n # X-label\n if (plot_opt == 'mgroup'):\n xlabel = r'\\boldmath$\\log M_{predicted} \\textrm{ - Groups}\\left[ h^{-1} M_{\\odot}\\right]$'\n elif (plot_opt == 'mhalo'):\n xlabel = r'\\boldmath$\\log M_{halo,\\textrm{true}} \\textrm{ - Groups}\\left[ h^{-1} M_{\\odot}\\right]$'\n # Y-label\n ylabel = r'Frac. Difference - Groups \\boldmath$[\\%]$'\n ##\n plt.clf()\n plt.close()\n fig = plt.figure(figsize=figsize)\n ax1 = fig.add_subplot(111, facecolor='white')\n ## Horizontal line\n ax1.axhline(y=0, color='black', linestyle='--', zorder=10)\n ##\n ## HAM Masses\n ax1.plot( x_stat_ham,\n y_stat_ham,\n color=plot_dict['color_ham'],\n linestyle='-',\n marker='o',\n zorder=zorder_mass)\n ax1.fill_between( x_stat_ham,\n y1_ham,\n y2_ham, \n color=plot_dict['color_ham'],\n alpha=alpha_mass,\n label='HAM',\n zorder=zorder_shade)\n ## Dynamical Masses\n ax1.plot( x_stat_dyn,\n y_stat_dyn,\n color=plot_dict['color_dyn'],\n linestyle='-',\n marker='o',\n zorder=zorder_mass)\n ax1.fill_between( x_stat_dyn,\n y1_dyn,\n y2_dyn, \n color=plot_dict['color_dyn'],\n alpha=alpha_mass,\n label='Dynamical',\n zorder=zorder_shade)\n ## Legend\n leg = ax1.legend(loc='upper left', numpoints=1, frameon=False,\n prop={'size':14})\n leg.get_frame().set_facecolor('none')\n ## Ticks\n # Y-axis\n xaxis_major_ticker = 1\n xaxis_minor_ticker = 0.2\n ax_xaxis_major_loc = ticker.MultipleLocator(xaxis_major_ticker)\n ax_xaxis_minor_loc = ticker.MultipleLocator(xaxis_minor_ticker)\n ax1.xaxis.set_major_locator(ax_xaxis_major_loc)\n ax1.xaxis.set_minor_locator(ax_xaxis_minor_loc)\n # Y-axis\n yaxis_major_ticker = 5\n yaxis_minor_ticker = 2\n ax_yaxis_major_loc = ticker.MultipleLocator(yaxis_major_ticker)\n ax_yaxis_minor_loc = ticker.MultipleLocator(yaxis_minor_ticker)\n ax1.yaxis.set_major_locator(ax_yaxis_major_loc)\n ax1.yaxis.set_minor_locator(ax_yaxis_minor_loc)\n ## Labels\n ax1.set_xlabel(xlabel, fontsize=plot_dict['size_label'])\n ax1.set_ylabel(ylabel, fontsize=plot_dict['size_label'])\n ##\n ## Limits\n ax1.set_ylim(-10, 10)\n ##\n ## Saving figure\n if fig_fmt=='pdf':\n plt.savefig(fname, bbox_inches='tight')\n plt.savefig(fname_paper, bbox_inches='tight')\n else:\n plt.savefig(fname, bbox_inches='tight', dpi=400)\n plt.savefig(fname_paper, bbox_inches='tight', dpi=400)\n ##\n ##\n print('{0} Figure saved as: {1}'.format(file_msg, fname))\n print('{0} Paper Figure saved as: {1}'.format(file_msg, fname_paper))\n plt.clf()\n plt.close()","def plot_normalized_density_est(self):\n # The true density is in self.x_all, num_cells x sim_steps.\n # the first num_cells row is the density\n dens = np.flipud(self.est_density[0:self.num_cells, :])\n\n # normalize the density [0, rho_max] to [0,1] for all cells\n rho_max = np.flipud(np.matrix(self.rhomax_cells).reshape((self.num_cells, 1)))\n\n norm_dens = dens / rho_max\n\n fig = plt.figure(figsize=(10, 10), dpi=100)\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])\n im = ax.imshow(norm_dens, cmap=plt.get_cmap('jet'),\n interpolation='nearest',\n vmin=0, vmax=1)\n ax.autoscale(False)\n\n # ==============================================================\n # plot the sensors, and on/off ramps\n # plot onramps\n onramp_ytick = {}\n onramp_ytick['tick'] = []\n onramp_ytick['label'] = []\n if self.cell_onramp is not None:\n for cell_id in self.cell_onramp:\n # the onramp will be drawn as a line in the middle of the cell\n val = self.num_cells - 1 - cell_id\n onramp_ytick['tick'].append(val)\n onramp_ytick['label'].append('Onramp {0}'.format(cell_id))\n ax.plot([-0.5, self.num_steps - 0.5], [val, val], color='k', linewidth=1)\n\n # plot offramps\n offramp_ytick = {}\n offramp_ytick['tick'] = []\n offramp_ytick['label'] = []\n if self.cell_offramp is not None:\n for cell_id in self.cell_offramp:\n # the offramp will be drawn as a line in the middle of the cell\n val = self.num_cells - 1 - cell_id\n offramp_ytick['tick'].append(val)\n offramp_ytick['label'].append('Offramp {0}'.format(cell_id))\n ax.plot([-0.5, self.num_steps - 0.5], [val, val], color='k', linewidth=1)\n\n # plot flow sensors\n flow_sensor_ytick = {}\n flow_sensor_ytick['tick'] = []\n flow_sensor_ytick['label'] = []\n if len(self.sensors['freeway']) != 0:\n for s_id in self.sensors['freeway']:\n # the flow sensor will be drawn as a line in the begining of the cells.\n cell_id = self.sensors[s_id]['cell']\n\n val = self.num_cells - 0.5 - cell_id\n flow_sensor_ytick['tick'].append(val)\n flow_sensor_ytick['label'].append('Flow Sensor {0}'.format(cell_id))\n ax.plot([-0.5, self.num_steps - 0.5], [val, val], color='k', linewidth=1)\n\n # set y ticks\n ax.set_yticks(onramp_ytick['tick'] + offramp_ytick['tick'] + flow_sensor_ytick['tick'])\n ax.set_yticklabels(onramp_ytick['label'] + offramp_ytick['label'] + flow_sensor_ytick['label'])\n\n ax.set_title('Estimated density profile')\n cax = fig.add_axes([0.95, 0.25, 0.01, 0.5])\n fig.colorbar(im, cax=cax, orientation='vertical')\n plt.draw()","def check_sizes(self, show=True):\n # find pixel with common RA \n comRApix = np.where((self.coords1[0]<=np.max(self.coords2[0]))&\n (self.coords1[0]>=np.min(self.coords2[0]))\n )[0]\n \n # find pixels with common DEC \n comDECpix = np.where((self.coords1[1]<=np.max(self.coords2[1]))&\n (self.coords1[1]>=np.min(self.coords2[1]))\n )[0]\n \n print('Image 1 common pixels size: ({:}, {:})'.format(comRApix.size,\n comDECpix.size))\n \n # Corner coordinates \n minRA = np.min(self.coords1[0][comRApix])\n maxRA = np.max(self.coords1[0][comRApix])\n minDEC = np.min(self.coords1[1][comDECpix])\n maxDEC = np.max(self.coords1[1][comDECpix])\n if show:\n comFrame = plt.Rectangle(xy=(minRA, minDEC), width=maxRA-minRA,\n height=maxDEC-minDEC, hatch='\\\\', fill=True,\n color='g', alpha=.3)\n fig = plt.figure(figsize=(10,10))\n ax = fig.add_subplot(111)\n ax.add_patch(comFrame)\n ax.add_patch(self.image1.plotframe(color='r'))\n ax.add_patch(self.image2.plotframe(color='b'))\n ax.annotate('Image 1', xy=(minRA,maxDEC), color='r')\n ax.plot() \n plt.show()\n \n self.boundRA = np.array([minRA, maxRA])\n self.boundDEC = np.array([minDEC, maxDEC]) \n self.bounds1 = np.array([[comRApix[0], comRApix[-1]], \n [comDECpix[0], comDECpix[-1]]])\n \n if self.image1.get_pix_area() < self.image2.get_pix_area():\n print('Image 1 have smaller pixels than 2. \\n')\n self.pix_1_smaller = True \n else:\n print('Image 2 have smaller pixels than 1. \\n')\n self.pix_1_smaller = False","def show_relative_ratio_with_base(base_list, ratio_list, title: str = \"\", block: bool = True):\n fig, ax = plt.subplots()\n ax.plot(base_list, ratio_list)\n\n ax.set_xlabel(\"Number of Clusters in Batch K-means\")\n ax.set_ylabel(\"Relative Ratio\")\n ax.set_title(title)\n\n if block:\n plt.show()\n\n return fig, ax","def _show_relative_ratio_with_base_all():\n fig, ax = plt.subplots()\n base_list = np.linspace(0, 100, num=11).astype(np.int)\n base_list[0] = 1\n\n # MNIST\n ratio_list = [1.0, 1.16, 1.1949999999999998,\n 1.1766666666666665, 1.165, 1.1740000000000002, 1.175,\n 1.1585714285714286, 1.19, 1.18, 1.179]\n ax.plot(base_list, ratio_list, label=\"MNIST\")\n\n # Fashion MNIST\n ratio_list = [1.0, 1.1199999999999999, 1.175,\n 1.1533333333333333, 1.2, 1.15,\n 1.1866666666666668, 1.1857142857142857, 1.23, 1.2044444444444444, 1.202]\n ax.plot(base_list, ratio_list, label=\"Fashion MNIST\")\n\n # 20 news groups\n ratio_list = [1.0, 1.4300000000000002, 1.58, 1.7633333333333332,\n 1.8275, 1.838, 1.8599999999999999,\n 1.9428571428571428, 2.05375, 2.148888888888889, 2.135]\n ax.plot(base_list, ratio_list, label=\"Newsgroups\")\n\n ax.set_xlabel(\"Number of Clusters in Batch K-means\")\n ax.set_ylabel(\"Relative Ratio\")\n ax.set_title(\"Relative Ratio Curve\")\n ax.legend()\n\n plt.show()","def line_ratio_per_cell(ratio_name,**kwargs):\n\n p = copy.copy(params)\n for key,val in kwargs.items():\n setattr(p,key,val)\n\n # Load sim and cell data\n gal_ob = gal.galaxy(p.gal_index)\n cell_data = gal_ob.cell_data.get_dataframe()\n\n if ratio_name == 'NII':\n xlim = [0.2,1.4]\n line1,line2 = '[NII]122','[NII]205'\n L_line1 = cell_data['L_'+line1].values\n L_line2 = cell_data['L_'+line2].values\n # Get ratio where the two samples overlap:\n ratio = L_line1 / L_line2\n if p.weight == 'm': weights = cell_data.m.values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\n if p.weight == 'light': weights = cell_data['L_'+line2].values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\n ratio = ratio[(ratio >= xlim[0]) & (ratio <= xlim[1])]\n label = '%s / %s' % (line1,line2)\n\n if ratio_name == 'OICII':\n xlim = [0,1]\n line1,line2 = '[OI]63','[CII]'\n L_line1 = cell_data['L_'+line1].values\n L_line2 = cell_data['L_'+line2].values\n # Get ratio where the two samples overlap:\n ratio = L_line1 / L_line2\n ratio = ratio[ratio > 1e-2]\n if p.weight == 'm': weights = cell_data.m.values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\n if p.weight == 'light': weights = cell_data['L_'+line1].values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\n ratio = np.log10(ratio[ratio != 0])\n label = 'log %s / %s' % (line1,line2)\n\n if p.add:\n ax = plt.gca()\n else:\n fig,ax = plt.subplots(figsize=(8,6))\n if p.weight == '':\n h = ax.hist(ratio,bins=p.bins,color=p.color,alpha=0.6,density=True)\n ax.set_ylabel('Number of cells',fontsize=15)\n if p.weight != '':\n h = ax.hist(ratio,bins=p.bins,color=p.color,alpha=0.6,weights=weights,density=True)\n if p.weight == 'm':\n ax.set_title('Mass-weighted distribution',fontsize=15)\n if p.weight == 'light':\n ax.set_title('Luminosity-weighted (%s) distribution' % line2,fontsize=15)\n\n # Overplot global line ratio\n GR = glo.global_results()\n ratio = getattr(GR,'L_'+line1+'_sun')[p.gal_index] / getattr(GR,'L_'+line2+'_sun')[p.gal_index]\n # print(ratio)\n # print(np.sum(cell_data['L_'+line1].values)/np.sum(cell_data['L_'+line2].values))\n ax.plot([ratio,ratio],ax.get_ylim(),'--',c=p.color)\n\n # ax.legend()\n ax.set_xlim(xlim)\n # ax.set_yscale('log')\n ax.set_xlabel(label,fontsize=15)\n ax.set_ylabel('Density of cells',fontsize=15)\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \n plt.savefig(p.d_plot + 'luminosity/res_ratio_%s_%s' % (ratio_name,p.weight),dpi=300)","def scale_sky_spectrum(wlm, sky_spectrum, spectra, cut_sky=4., fmax=10, fmin=1, valid_wave_min=0, valid_wave_max=0, \n fibre_list=[100,200,300,400,500,600,700,800,900], plot=True, verbose=True, warnings=True): \n \n# # Read sky lines provided by 2dFdr\n# sky_line_,flux_sky_line_ = read_table(\"sky_lines_2dfdr.dat\", [\"f\", \"f\"] )\n# # Choose those lines in the range\n# sky_line=[]\n# flux_sky_line=[]\n# valid_wave_min = 6240\n# valid_wave_max = 7355\n# for i in range(len(sky_line_)):\n# if valid_wave_min < sky_line_[i] < valid_wave_max:\n# sky_line.append(sky_line_[i])\n# flux_sky_line.append(flux_sky_line_[i])\n \n \n if valid_wave_min == 0: valid_wave_min = wlm[0]\n if valid_wave_max == 0: valid_wave_max = wlm[-1]\n \n if verbose: print(\"\\n> Identifying sky lines using cut_sky =\",cut_sky,\", allowed SKY/OBJ values = [\",fmin,\",\",fmax,\"]\")\n if verbose: print(\" Using fibres = \",fibre_list)\n\n peaks,peaks_name,peaks_rest,continuum_limits=search_peaks(wlm,sky_spectrum, plot=plot, cut=cut_sky, fmax=fmax, only_id_lines=False, verbose=False) \n\n ratio_list=[]\n valid_peaks=[]\n \n if verbose: print(\"\\n Sky line Gaussian ratio Flux ratio\")\n n_sky_lines_found=0\n for i in range(len(peaks)):\n sky_spectrum_data=fluxes(wlm,sky_spectrum, peaks[i], fcal=False, lowlow=50,highhigh=50, plot=False, verbose=False, warnings=False)\n \n sky_median_continuum = np.nanmedian(sky_spectrum_data[11])\n \n object_spectrum_data_gauss=[]\n object_spectrum_data_integrated=[] \n median_list=[]\n for fibre in fibre_list: \n object_spectrum_flux=fluxes(wlm, spectra[fibre], peaks[i], fcal=False, lowlow=50,highhigh=50, plot=False, verbose=False, warnings=False)\n object_spectrum_data_gauss.append(object_spectrum_flux[3]) # Gaussian flux is 3\n object_spectrum_data_integrated.append(object_spectrum_flux[7]) # integrated flux is 7\n median_list.append(np.nanmedian(object_spectrum_flux[11]))\n object_spectrum_data=np.nanmedian(object_spectrum_data_gauss)\n object_spectrum_data_i=np.nanmedian(object_spectrum_data_integrated)\n \n object_median_continuum=np.nanmin(median_list) \n \n if fmin < object_spectrum_data/sky_spectrum_data[3] * sky_median_continuum/object_median_continuum < fmax :\n n_sky_lines_found = n_sky_lines_found + 1\n valid_peaks.append(peaks[i])\n ratio_list.append(object_spectrum_data/sky_spectrum_data[3])\n if verbose: print(\"{:3.0f} {:5.3f} {:2.3f} {:2.3f}\".format(n_sky_lines_found,peaks[i],object_spectrum_data/sky_spectrum_data[3], object_spectrum_data_i/sky_spectrum_data[7])) \n\n\n #print \"ratio_list =\", ratio_list\n #fit = np.polyfit(valid_peaks, ratio_list, 0) # This is the same that doing an average/mean\n #fit_line = fit[0]+0*wlm\n fit_line =np.nanmedian(ratio_list) # We just do a median\n #fit_line = fit[1]+fit[0]*wlm\n #fit_line = fit[2]+fit[1]*wlm+fit[0]*wlm**2\n #fit_line = fit[3]+fit[2]*wlm+fit[1]*wlm**2+fit[0]*wlm**3\n \n \n if plot:\n plt.plot(valid_peaks,ratio_list,\"+\")\n #plt.plot(wlm,fit_line)\n plt.axhline(y=fit_line, color='k', linestyle='--')\n plt.xlim(valid_wave_min-10, valid_wave_max+10) \n #if len(ratio_list) > 0:\n plt.ylim(np.nanmin(ratio_list)-0.2,np.nanmax(ratio_list)+0.2)\n plt.title(\"Scaling sky spectrum to object spectra\")\n plt.xlabel(\"Wavelength [$\\mathrm{\\AA}$]\")\n plt.ylabel(\"OBJECT / SKY\")\n plt.minorticks_on()\n plt.show()\n plt.close()\n \n if verbose: print(\" Using this fit to scale sky spectrum to object, the median value is \",np.round(fit_line,3),\"...\") \n \n sky_corrected = sky_spectrum * fit_line\n\n# plt.plot(wlm,sky_spectrum, \"r\", alpha=0.3)\n# plt.plot(wlm,sky_corrected, \"g\", alpha=0.3)\n# plt.show()\n# plt.close()\n \n return sky_corrected, np.round(fit_line,3)","def plot_instructions_lim_mags(self):\n return self.__plot_instructions_lim_mags","def asses_space(meas):\n truth = list(meas.spec.central)\n truth[meas.spec.ipar('syst_s1')] = 1\n data = meas.spec(truth)\n meas.spec.set_data(data)\n\n lls, xs, rels, prob = minutils.find_minima(meas.spec)\n\n print(\"Found %d minima with likelihoods:\" % len(lls))\n print(', '.join([\"%.3f\" % l for l in lls]))\n\n print(\"Global minimum is found %.3f%% of the time\" % (100*prob))\n\n l0 = draw_spectrum(meas, truth, True, label='truth', linestyle='--')\n l1 = draw_spectrum(meas, xs[0], True, label='fit')\n plt.legend(handles=[l0, l1])\n plt.savefig('spectrum-ll_0.pdf', format='pdf')\n plt.clf()\n\n for imin in range(1, len(lls)):\n print(\"Local minimum %.3f\" % lls[imin])\n\n isort = np.argsort(np.fabs(rels[imin]))[::-1]\n par1 = meas.spec.pars[isort[0]]\n par2 = meas.spec.pars[isort[1]]\n print(\"Differs in %s, %s\" % (par1, par2))\n\n print(\"%s_0: %.3f, %s_%d: %.3f\" % (\n par1,\n xs[0][meas.spec.ipar(par1)],\n par1, imin,\n xs[imin][meas.spec.ipar(par1)]))\n\n print(\"%s_0: %.3f, %s_%d: %.3f\" % (\n par2,\n xs[0][meas.spec.ipar(par2)],\n par2, imin,\n xs[imin][meas.spec.ipar(par2)]))\n\n draw_spectrum(meas, truth, True, label='truth', linestyle='--')\n draw_spectrum(meas, xs[imin], True, label='fit')\n plt.legend(handles=[l0, l1])\n plt.savefig('spectrum-ll_%d.pdf'%imin, format='pdf')\n plt.clf()\n\n vals = minutils.slice2d(meas.spec, xs[imin], par1, par2)\n plt.hist2d(\n vals.T[0], \n vals.T[1], \n weights=np.exp(vals.T[2]), \n bins=len(vals)**0.5,\n normed=True)\n \n plt.xlabel(par1)\n plt.ylabel(par2)\n\n cbar = plt.colorbar()\n cbar.set_label('Likelihood density')\n\n plt.savefig('min_%d.pdf' % imin, format='pdf')\n plt.clf()","def normalize_plot(self):\n\n kwargs = dict(stretch = self.stretch,\n vmin = self.vmin_button.get_value(),\n vmax = self.vmax_button.get_value())\n norm = aplpy.normalize.APLpyNormalize(**kwargs)\n self.parent.aplpy_plot.image.set_norm(norm)\n self.parent.aplpy_plot.refresh()","def perSaccAcrossGroups(addExp2 = True, trim = True, spacing = .5, \\\n\t\taddSimulation = True, exclOverlap = True, exclY = True):\n\t\n\tfig = plt.figure(figsize = (5,10))\n\ttitle = \"Average towards-handle landings across groups - exclOverlap = %s - exclY = %s\" % (exclOverlap, exclY)\n\tplt.suptitle(title)\n\t\n\t# The first experiment has to be treated differently, because\n\t# it contains two dependent variables: absolute and corrected\n\tdm1 = getDM.getDM(exp = \"004A\", excludeErrors = True, driftCorr = True)\n\tlLandingsAbs = []\n\tlLandingsCorr = []\n\t\n\tfor sacc in [\"1\", \"2\", \"3\"]:\n\t\t\n\t\t# This is the same for corrected landing positions (the saccade\n\t\t# doesn't change; only the reference point does)\n\t\t_dm = dm1.select(\"endX%sNorm != ''\" % sacc)\n\t\t_dm = _dm.select(\"endX%sNorm > -.5\" % sacc)\n\t\t_dm = _dm.select(\"endX%sNorm < .5\" % sacc)\n\t\t\n\t\tif exclY:\n\t\t\t_dm = _dm.select(\"endY%sNorm != ''\" % sacc)\n\t\t\t_dm = _dm.select(\"endY%sNorm > -.5\" % sacc)\n\t\t\t_dm = _dm.select(\"endY%sNorm < .5\" % sacc)\n\t\t\n\t\t\n\t\tif trim:\n\t\t\t_dmAbs = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sNormToHandle\" % sacc)\n\t\t\t_dmCorr = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sCorrNormToHandle\" % sacc)\n\t\t\n\t\t# Determine avg landing position:\n\t\tavgAbs = _dmAbs[\"endX%sNormToHandle\" % sacc].mean()\n\t\tavgCorr = _dmCorr[\"endX%sCorrNormToHandle\" % sacc].mean()\n\t\t\n\t\t# TODO: determine error bars:\n\n\t\tlLandingsAbs.append(avgAbs)\n\t\tlLandingsCorr.append(avgCorr)\n\t\n\tplt.plot(lLandingsAbs, color = \"#f57900\", linewidth = 2, marker = \"o\")\n\tplt.plot(lLandingsCorr, color = \"#73d216\", linewidth = 2, marker = \"o\")\n\t\n\t# The other 2 experiments can be treated equally:\n\tcolList = [\"#ef2929\", \"#3465a4\"]\n\n\tfor exp in [\"004B\", \"004C\"]:\n\t\t\n\t\tcontinue\n\t\t\n\t\tif not addExp2:\n\t\t\tif exp == \"004B\":\n\t\t\t\tcontinue\n\t\tif not addSimulation:\n\t\t\tif exp == \"004C\":\n\t\t\t\tcontinue\n\n\t\tdm = getDM.getDM(exp = exp, excludeErrors = True, driftCorr = True)\n\t\t\n\t\tif exp == \"004C\":\n\t\t\tprint 'xxx'\n\t\t\tif exclOverlap:\n\t\t\t\tdm = dm.select(\"gap == 'zero'\")\n\n\t\tlLandingsAbs = []\n\t\t\n\t\tfor sacc in [\"1\", \"2\", \"3\", '4']:\n\t\t\t\n\t\t\t# TODO: how to filter only on-object saccades exp 2??\n\t\t\t_dm = dm.select(\"endX%sNorm != ''\" % sacc)\n\t\t\t_dm = _dm.select(\"endX%sNorm > -.5\" % sacc)\n\t\t\t_dm = _dm.select(\"endX%sNorm < .5\" % sacc)\n\t\t\t\n\t\t\tif exclY:\n\t\t\t\n\t\t\t\t_dm = _dm.select(\"endY%sNorm != ''\" % sacc)\n\t\t\t\t_dm = _dm.select(\"endY%sNorm > -.5\" % sacc)\n\t\t\t\t_dm = _dm.select(\"endY%sNorm < .5\" % sacc)\n\n\t\t\tif trim:\n\t\t\t\t_dm = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sNormToHandle\" % sacc)\n\t\t\t\n\t\t\t# Determine avg landing position:\n\t\t\tavgAbs = _dm[\"endX%sNormToHandle\" % sacc].mean()\n\t\t\tlLandingsAbs.append(avgAbs)\n\t\t\t\n\t\t\t\n\t\tcol = colList.pop()\n\t\tplt.plot(lLandingsAbs, color = col, linewidth = 2, marker = \"o\")\n\t\n\t# Modify plot:\n\tplt.legend([\"Exp1 abs\", \"Exp1 corr\", \"Exp2\", \"Sim\"])\n\t\t\n\tplt.axhline(0, color = \"#888a85\", linestyle = \"--\", linewidth = 2)\n\txLabels = [\"sacc 1\", \"sacc 2\", \"sacc 3\"]\n\txTicks = range(0,3)\n\tplt.xticks(xTicks, xLabels, rotation = .5)\n\tplt.xlim(min(xTicks)-spacing, max(xTicks)+spacing)\n\t\n\tplt.ylim([-.5, .5])\n\t\n\tplt.savefig(\"%s.png\" % title)","def init_plot_force(nb_mus):\n # --- Curve graph --- #\n # app = pg.mkQApp(\"force\")\n # remote = []\n # layout = pg.LayoutWidget()\n # layout.resize(800, 800)\n # label = QtGui.QLabel()\n # box = []\n # rplt = []\n # row_count = 0\n # col_span = 4 if nb_mus > 8 else 8\n # for mus in range(nb_mus):\n # remote.append(rgv.RemoteGraphicsView())\n # remote[mus].pg.setConfigOptions(antialias=True)\n # app.aboutToQuit.connect(remote[mus].close)\n # box.append(QtGui.QCheckBox(f\"muscle_{mus}\"))\n # if mus >= 8:\n # layout.addWidget(box[mus], row=1, col=mus-8)\n # layout.addWidget(remote[mus], row=mus - 8 + 2, col=4, colspan=col_span)\n # else:\n # layout.addWidget(box[mus], row=0, col=mus)\n # layout.addWidget(remote[mus], row=mus + 2, col=0, colspan=col_span)\n # rplt.append(remote[mus].pg.PlotItem())\n # rplt[mus]._setProxyOptions(deferGetattr=True) ## speeds up access to rplt.plot\n # remote[mus].setCentralItem(rplt[mus])\n # layout.addWidget(label)\n # layout.show()\n # row_count += 1\n # return rplt, layout, app , box\n\n # --- Progress bar graph --- #\n # app = pg.mkQApp(\"force\")\n # layout = pg.LayoutWidget()\n # layout.resize(400, 800)\n # layout.move(0, 0)\n # box = []\n # rplt = []\n # row_count = 0\n # for mus in range(nb_mus):\n # rplt.append(QProgressBar())\n # rplt[mus].setMaximum(1000)\n # layout.addWidget(rplt[mus], row=mus, col=0)\n # layout.show()\n # row_count += 1\n # return rplt, layout, app\n\n # --- Bar graph --- #\n app = pg.mkQApp()\n layout = pg.plot()\n layout.resize(800, 800)\n rplt = pg.BarGraphItem(x=range(nb_mus), height=np.zeros((nb_mus)), width=0.3, brush=\"r\")\n layout.addItem(rplt)\n return rplt, layout, app","def _preprocess_and_checks(self, das, params):\n das, params = super()._preprocess_and_checks(das, params)\n\n # Convert grouping and check if allowed:\n sim = das[\"sim\"]\n ref = das[\"ref\"]\n\n # Check if common coordinates are identical.\n newsim, newref = xr.broadcast(sim, ref)\n for dim in set(sim.dims).union(ref.dims):\n if [sim[dim].size, ref[dim].size] != [newsim[dim].size, newref[dim].size]:\n raise ValueError(\n f\"Common dimension {dim} has different coordinates between ref and sim.\"\n )\n\n units_sim = units2pint(sim)\n units_ref = units2pint(ref)\n\n if units_sim != units_ref:\n das[\"sim\"] = convert_units_to(sim, ref)\n\n return das, params","def coadd_spectra(spec_list_fits, out_name, scale_spectra=True,\r\n use_ratios=False, ratio_range=[4200, 4300], \r\n one_side=True):\r\n\r\n spec_list_txt = [f.replace('fits', 'txt') for f in spec_list_fits]\r\n\r\n # first spectrum in the list is always the reference spectrum\r\n hdr = pyfits.getheader(spec_list_fits[0])\r\n #mjd = hdr['MJD']\r\n #date_obs = hdr['DATE-OBS']\r\n #epoch = hdr['EPOCH']\r\n #observat = hdr['OBSERVAT']\r\n exptime = hdr['EXPTIME']\r\n seeing = hdr['FWHM']\r\n # save some keywords\r\n keys = ['OBJECT', 'OBSERVER', 'DICHROIC', 'APERTURE', 'LAMPS', 'UTSHUT', 'OBSLST', 'RA', 'DEC', 'HOURANG', 'HA', 'TELFOCUS', 'CASSPA', 'PARALLAC', 'CCDTEMP', 'ANGLE', 'GRATING', 'AIRMASS']\r\n #mjd_blue = hdr['MJD']\r\n exptime_blue = hdr['EXPTIME']\r\n hdr_save = {}\r\n for key in keys:\r\n hdr_save[key] = hdr[key]\r\n verr = np.float(hdr['VERR'])**2\r\n spec_ref = np.genfromtxt(spec_list_txt[0], names='wave, flux', \r\n dtype='f4, f4')\r\n err_ref = np.genfromtxt(spec_list_txt[0].replace('spec', 'err'), \r\n names='wave, flux', dtype='f4, f4')\r\n wave = spec_ref['wave']\r\n spec_ref = spec_ref['flux'].view(np.ma.masked_array)\r\n err_ref = err_ref['flux'].view(np.ma.masked_array)\r\n\r\n\r\n # err_ref['flux'] = np.where(err_ref['flux'] <= 0, 1, err_ref['flux']) # reset bad error values to 1\r\n # boolean array: mask out invalid regions so average excludes zeros\r\n bad_err = err_ref <= 0\r\n spec_ref[bad_err] = np.ma.masked\r\n err_ref[bad_err] = np.ma.masked\r\n\r\n\r\n # spectra and their errors will be stored here\r\n spectra = np.ma.zeros((spec_ref.size, len(spec_list_fits)), dtype='f4')\r\n spectra_err = np.ma.zeros((spec_ref.size, len(spec_list_fits)), dtype='f4')\r\n\r\n spectra[:, 0] = spec_ref\r\n spectra_err[:, 0] = err_ref\r\n\r\n ratio = [1]\r\n\r\n for i, fname in enumerate(spec_list_fits[1:]):\r\n fname_txt = spec_list_txt[i+1]\r\n hdr = pyfits.getheader(fname)\r\n exptime += hdr['EXPTIME']\r\n seeing += hdr['FWHM']\r\n verr += np.float(hdr['VERR'])**2\r\n spec = np.genfromtxt(fname_txt, names='wave, flux', dtype='f4, f4')\r\n err = np.genfromtxt(fname_txt.replace('spec', 'err'), \r\n names='wave, flux', dtype='f4, f4')\r\n spec = spec['flux'].view(np.ma.masked_array)\r\n err = err['flux'].view(np.ma.masked_array)\r\n # reset bad error values to 1\r\n # err['flux'] = np.where(err['flux'] <= 0, 1, err['flux']) \r\n bad_err = err <= 0\r\n spec[bad_err] = np.ma.masked\r\n err[bad_err] = np.ma.masked\r\n\r\n spectra[:, i+1] = spec\r\n spectra_err[:, i+1] = err\r\n if scale_spectra:\r\n if use_ratios:\r\n # use the specified region to determine te ratio of spectra\r\n good = np.where((spec > ratio_range[0]) & \r\n (spec < ratio_range[1]))\r\n ratio.append(np.median(spec_ref[good]/spec[good]))\r\n else:\r\n spec_good_err = err > 0\r\n # identify overlap between sides\r\n wgd = (err_ref > 0) & (err > 0)\r\n\r\n ratio.append(match_spectra_leastsq(spec[wgd], \r\n spec_ref[wgd], err[wgd], \r\n err_ref[wgd]))\r\n\r\n \r\n\r\n spec_avg, sum_weights = np.average(spectra*ratio, weights=1./(spectra_err*ratio)**2, axis=1, returned=True)\r\n spec_err = 1./np.sqrt(sum_weights)\r\n # output coadded spectra and uncertainties\r\n f = open('%s.spec.txt' % out_name, 'w')\r\n g = open('%s.err.txt' % out_name, 'w')\r\n h = open('%s.snr.txt' % out_name, 'w')\r\n # add some header keywords\r\n for key in hdr_save.keys():\r\n f.write('# %s = %s\\n' % (key, hdr_save[key]))\r\n if one_side:\r\n # exposure time and velocity error are only well-defined for\r\n # data combined from a single side\r\n f.write('# FWHM = %.2f\\n' % float(seeing/len(spec_list_fits)))\r\n f.write('# VERR = %.2f\\n' % np.sqrt(verr))\r\n #f.write('# MJD = %.6f\\n' % (mjd + exptime/(2.*60.*60.*24.)))\r\n else:\r\n # when combining sides, use the MJD and EXPTIME from the combined blue side\r\n f.write('# EXPTIME = %.0f\\n' % exptime_blue)\r\n #f.write('# MJD = %.6f\\n' % mjd_blue)\r\n\r\n for x, y, z in zip(wave, spec_avg, spec_err):\r\n f.write('%.3f %.5g\\n' % (x, y))\r\n g.write('%.3f %.5g\\n' % (x, z))\r\n h.write('%.3f %.5g\\n' % (x, y/z))\r\n f.close()\r\n g.close()\r\n h.close()\r\n # save as 1D IRAF FITS files\r\n iraf.delete('%s.spec.fits' % out_name, verify=\"no\")\r\n iraf.delete('%s.err.fits' % out_name, verify=\"no\")\r\n iraf.delete('%s.snr.fits' % out_name, verify=\"no\")\r\n iraf.rspectext('%s.spec.txt' % out_name, '%s.spec.fits' % out_name, \r\n crval1 = hdr['CRVAL1'], cdelt1 = hdr['CDELT1'])\r\n iraf.rspectext('%s.err.txt' % out_name, '%s.err.fits' % out_name, \r\n crval1 = hdr['CRVAL1'], cdelt1 = hdr['CDELT1'])\r\n iraf.rspectext('%s.snr.txt' % out_name, '%s.snr.fits' % out_name, \r\n crval1 = hdr['CRVAL1'], cdelt1 = hdr['CDELT1'])\r\n # add keywords\r\n f = pyfits.open('%s.spec.fits' % out_name)\r\n for key in hdr_save.keys():\r\n #f[0].header.update(key, hdr_save[key])\r\n f[0].header[key]= hdr_save[key]\r\n #f[0].header.update('DATE-OBS', date_obs)\r\n #f[0].header.update('OBSERVAT', observat)\r\n #f[0].header.update('EPOCH', epoch)\r\n #f[0].header['DATE-OBS']= date_obs\r\n #f[0].header['OBSERVAT']= observat\r\n #f[0].header['EPOCH']= epoch\r\n if one_side:\r\n # exposure time and velocity error are only well-defined for\r\n # data combined from a single side\r\n #f[0].header.update('EXPTIME', exptime)\r\n #f[0].header.update('FWHM', seeing/len(spec_list_fits))\r\n #f[0].header.update('VERR', '%.2f' % np.sqrt(verr), 'Uncertainty in km/s')\r\n f[0].header['EXPTIME']= exptime\r\n f[0].header['FWHM']= seeing/len(spec_list_fits)\r\n f[0].header['VERR']= '%.2f' %np.sqrt(verr)\r\n #mjd += exptime/(2.*60.*60.*24.)\r\n else:\r\n # when combining sides, use the EXPTIME from the combined blue side\r\n #f[0].header.update('EXPTIME', exptime_blue)\r\n f[0].header['EXPTIME']= exptime_blue\r\n #del f[0].header['VERR'] #DaveC\r\n #f[0].header.update('MJD', np.round(mjd, decimals=6))\r\n #f[0].header['MJD']= np.round(mjd, decimals=6)\r\n\r\n f.writeto('%s.spec.fits' % out_name, clobber=True)\r\n f.close()","def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \n MC_runs, price_tree):\n x_values = []\n pi_M = []\n pi_M_RMSE = []\n for i in range(1,MC_runs,1):\n Mi=M*i\n x_values.append([Mi])\n paths = sample_paths(S0, N, u, d, q, Mi)\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \n barrier_type, option)\n if option == 'Call':\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\n elif option == 'Put':\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\n payoffs = list(payoffs)\n while len(payoffs) < Mi:\n payoffs.append([0])\n mean_payoff = np.mean(payoffs)[0]\n pi_M.append(mean_payoff)\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\n pi_M_RMSE.append(RMSE[0])\n \n # plotting\n plt.figure(figsize=(8,6))\n plt.subplot(2, 1, 1)\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\n plt.plot(x_values, pi_M, 'o', label='price via MC')\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \n label='price via tree')\n plt.legend()\n plt.title('Monte Carlo price, for increasing number of paths')\n plt.ylabel('Expected Value')\n #The following will plot the root mean square error\n plt.subplot(2, 1, 2)\n plt.plot(x_values, pi_M_RMSE, '-')\n plt.xlabel('number of paths')\n plt.ylabel('Root Mean Square Error')\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\n plt.show()","def assign_inputs(self):\n if self.sam_sys_inputs.get(\"ui_calculations_only\"):\n msg = ('reV requires model run - cannot set '\n '\"ui_calculations_only\" to `True` (1). Automatically '\n 'setting to `False` (0)!')\n logger.warning(msg)\n warn(msg)\n self.sam_sys_inputs[\"ui_calculations_only\"] = 0\n super().assign_inputs()","def __init__(self, refstd, fig=None, rect=111, label='_', srange=(0, 1.5)):\n\n from matplotlib.projections import PolarAxes\n import mpl_toolkits.axisartist.floating_axes as FA\n import mpl_toolkits.axisartist.grid_finder as GF\n\n self.refstd = refstd # Reference standard deviation\n\n tr = PolarAxes.PolarTransform()\n\n # Correlation labels\n rlocs = NP.concatenate((NP.arange(10)/10., [0.95, 0.99]))\n tlocs = NP.arccos(rlocs) # Conversion to polar angles\n gl1 = GF.FixedLocator(tlocs) # Positions\n tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))\n\n # Standard deviation axis extent (in units of reference stddev)\n self.smin = srange[0]*self.refstd\n self.smax = srange[1]*self.refstd\n\n ghelper = FA.GridHelperCurveLinear(tr,\n extremes=(0, NP.pi/2, # 1st quadrant\n self.smin, self.smax),\n grid_locator1=gl1,\n tick_formatter1=tf1)\n\n if fig is None:\n fig = PLT.figure()\n\n ax = FA.FloatingSubplot(fig, rect, grid_helper=ghelper)\n fig.add_subplot(ax)\n\n # Adjust axes\n ax.axis[\"top\"].set_axis_direction(\"bottom\") # \"Angle axis\"\n ax.axis[\"top\"].toggle(ticklabels=True, label=True)\n ax.axis[\"top\"].major_ticklabels.set_axis_direction(\"top\")\n ax.axis[\"top\"].label.set_axis_direction(\"top\")\n ax.axis[\"top\"].label.set_text(\"Correlation\")\n\n ax.axis[\"left\"].set_axis_direction(\"bottom\") # \"X axis\"\n ax.axis[\"left\"].label.set_text(\"Standard deviation\")\n\n ax.axis[\"right\"].set_axis_direction(\"top\") # \"Y axis\"\n ax.axis[\"right\"].toggle(ticklabels=True)\n ax.axis[\"right\"].major_ticklabels.set_axis_direction(\"left\")\n #ax.axis[\"right\"].label.set_text(\"Standard deviation\")\n\n ax.axis[\"bottom\"].set_visible(False) # Useless\n\n self._ax = ax # Graphical axes\n self.ax = ax.get_aux_axes(tr) # Polar coordinates\n\n # Add reference point and stddev contour\n l, = self.ax.plot([0], self.refstd, 'k*',\n ls='', ms=10, label=label)\n t = NP.linspace(0, NP.pi/2)\n r = NP.zeros_like(t) + self.refstd\n self.ax.plot(t, r, 'k--', label='_')\n\n # Collect sample points for latter use (e.g. legend)\n self.samplePoints = [l]","def __init__(self, refstd, fig=None, rect=111, label='_', srange=(0, 1.5)):\n\n from matplotlib.projections import PolarAxes\n import mpl_toolkits.axisartist.floating_axes as FA\n import mpl_toolkits.axisartist.grid_finder as GF\n\n self.refstd = refstd # Reference standard deviation\n\n tr = PolarAxes.PolarTransform()\n\n # Correlation labels\n rlocs = NP.concatenate((NP.arange(10)/10., [0.95, 0.99]))\n tlocs = NP.arccos(rlocs) # Conversion to polar angles\n gl1 = GF.FixedLocator(tlocs) # Positions\n tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))\n\n # Standard deviation axis extent (in units of reference stddev)\n self.smin = srange[0]*self.refstd\n self.smax = srange[1]*self.refstd\n\n ghelper = FA.GridHelperCurveLinear(tr,\n extremes=(0, NP.pi, # 1st quadrant\n self.smin, self.smax),\n grid_locator1=gl1,\n tick_formatter1=tf1)\n\n if fig is None:\n fig = PLT.figure()\n\n ax = FA.FloatingSubplot(fig, rect, grid_helper=ghelper)\n fig.add_subplot(ax)\n\n # Adjust axes\n ax.axis[\"top\"].set_axis_direction(\"bottom\") # \"Angle axis\"\n ax.axis[\"top\"].toggle(ticklabels=True, label=True)\n ax.axis[\"top\"].major_ticklabels.set_axis_direction(\"top\")\n ax.axis[\"top\"].label.set_axis_direction(\"top\")\n ax.axis[\"top\"].label.set_text(\"Correlation\")\n\n ax.axis[\"left\"].set_axis_direction(\"bottom\") # \"X axis\"\n ax.axis[\"left\"].label.set_text(\"Standard deviation\")\n\n ax.axis[\"right\"].set_axis_direction(\"top\") # \"Y axis\"\n ax.axis[\"right\"].toggle(ticklabels=True)\n ax.axis[\"right\"].major_ticklabels.set_axis_direction(\"left\")\n #ax.axis[\"right\"].label.set_text(\"Standard deviation\")\n\n ax.axis[\"bottom\"].set_visible(False) # Useless\n\n self._ax = ax # Graphical axes\n self.ax = ax.get_aux_axes(tr) # Polar coordinates\n\n # Add reference point and stddev contour\n l, = self.ax.plot([0], self.refstd, 'k*',\n ls='', ms=10, label=label)\n t = NP.linspace(0, NP.pi/2)\n r = NP.zeros_like(t) + self.refstd\n self.ax.plot(t, r, 'k--', label='_')\n\n # Collect sample points for latter use (e.g. legend)\n self.samplePoints = [l]","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 doParametersOfInterest(self):\n self.modelBuilder.doVar(\"mu[1,0,100]\") ##mu is what we want to return (in string) name[starting_value,min,max] \n self.modelBuilder.doSet(\"POI\",\"mu\")\n self.modelBuilder.factory_('expr::ggH_s_func(\"@0-sqrt(@0)\", mu)')\n self.modelBuilder.factory_( 'expr::ggH_b_func(\"1-sqrt(@0)\", mu)')\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\"sqrt(@0)\", mu)')","def plot_colour_mag_diagram(params,mags, colours, local_mags, local_colours,\n target, source, blend, RC, blue_filter, red_filter,\n yaxis_filter, tol, log):\n\n def calc_colour_lightcurve(blue_lc, red_lc, y_lc):\n\n idx1 = np.where( red_lc['mag_err'] > 0.0 )[0]\n idx2 = np.where( blue_lc['mag_err'] > 0.0 )[0]\n idx3 = np.where( y_lc['mag_err'] > 0.0 )[0]\n idx = set(idx1).intersection(set(idx2))\n idx = list(idx.intersection(set(idx3)))\n\n mags = y_lc['mag'][idx]\n magerr = y_lc['mag_err'][idx]\n cols = blue_lc['mag'][idx] - red_lc['mag'][idx]\n colerr = np.sqrt(blue_lc['mag_err'][idx]**2 + red_lc['mag_err'][idx]**2)\n\n return mags, magerr, cols, colerr\n\n\n add_source_trail = False\n add_target_trail = True\n add_crosshairs = True\n add_source = True\n add_blend = True\n add_rc_centroid = True\n add_extinction_vector = True\n\n fig = plt.figure(1,(10,10))\n\n ax = plt.subplot(111)\n\n plt.rcParams.update({'font.size': 18})\n\n plt.scatter(colours,mags,\n c='#E1AE13', marker='.', s=1,\n label='Stars within ROME field')\n\n plt.scatter(local_colours,local_mags,\n c='#8c6931', marker='*', s=4,\n label='Stars < '+str(round(tol,1))+'arcmin of target')\n\n col_key = blue_filter+red_filter\n\n if getattr(source,blue_filter) != None and getattr(source,red_filter) != None\\\n and add_source:\n\n plt.errorbar(getattr(source,col_key), getattr(source,yaxis_filter),\n yerr = getattr(source,'sig_'+yaxis_filter),\n xerr = getattr(source,'sig_'+col_key), color='m',\n marker='d',markersize=10, label='Source crosshairs')\n\n if add_crosshairs:\n plot_crosshairs(fig,getattr(source,col_key),getattr(source,yaxis_filter),'m')\n\n if add_source_trail:\n red_lc = source.lightcurves[red_filter]\n blue_lc = source.lightcurves[blue_filter]\n y_lc = source.lightcurves[yaxis_filter]\n\n (smags, smagerr, scols, scolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\n\n plt.errorbar(scols, smags, yerr = smagerr, xerr = scolerr,\n color='m', marker='d',markersize=10, label='Source')\n\n if getattr(blend,blue_filter) != None and getattr(blend,red_filter) != None \\\n and add_blend:\n\n plt.errorbar(getattr(blend,col_key), getattr(blend,yaxis_filter),\n yerr = getattr(blend,'sig_'+yaxis_filter),\n xerr = getattr(blend,'sig_'+col_key), color='b',\n marker='v',markersize=10, label='Blend')\n\n if getattr(target,blue_filter) != None and getattr(target,red_filter) != None \\\n and add_target_trail:\n\n plt.errorbar(getattr(target,col_key), getattr(target,yaxis_filter),\n yerr = getattr(target,'sig_'+yaxis_filter),\n xerr = getattr(target,'sig_'+col_key), color='k',\n marker='x',markersize=10)\n\n red_lc = target.lightcurves[red_filter]\n blue_lc = target.lightcurves[blue_filter]\n y_lc = target.lightcurves[yaxis_filter]\n\n (tmags, tmagerr, tcols, tcolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\n\n plt.errorbar(tcols, tmags, yerr = tmagerr,xerr = tcolerr,\n color='k', marker='+',markersize=10, alpha=0.4,\n label='Blended target')\n\n if add_rc_centroid:\n plt.errorbar(getattr(RC,col_key), getattr(RC,yaxis_filter),\n yerr=getattr(RC,'sig_'+yaxis_filter),\n xerr=getattr(RC,'sig_'+col_key),\n color='g', marker='s',markersize=10, label='Red Clump centroid')\n\n plt.xlabel('SDSS ('+blue_filter+'-'+red_filter+') [mag]')\n\n plt.ylabel('SDSS-'+yaxis_filter+' [mag]')\n\n [xmin,xmax,ymin,ymax] = plt.axis()\n\n plt.axis([xmin,xmax,ymax,ymin])\n\n xticks = np.arange(xmin,xmax,0.1)\n yticks = np.arange(ymin,ymax,0.2)\n\n ax.set_xticks(xticks,minor=True)\n ax.set_yticks(yticks,minor=True)\n\n plot_file = path.join(params['red_dir'],'colour_magnitude_diagram_'+\\\n yaxis_filter+'_vs_'+blue_filter+red_filter\\\n +'.pdf')\n\n plt.grid()\n\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'i':\n plt.axis([0.5,2.0,20.2,13.5])\n\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'r':\n plt.axis([0.0,1.5,21.0,13.5])\n\n if red_filter == 'r' and blue_filter == 'g':\n plt.axis([0.5,3.0,22.0,14.0])\n\n if red_filter == 'i' and blue_filter == 'g':\n plt.axis([0.5,4.4,22.0,14.0])\n\n if add_extinction_vector:\n plot_extinction_vector(fig,params,yaxis_filter)\n\n box = ax.get_position()\n ax.set_position([box.x0, box.y0 + box.height * -0.025,\n box.width, box.height * 0.95])\n\n l = ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.2), ncol=2)\n\n l.legendHandles[0]._sizes = [50]\n l.legendHandles[1]._sizes = [50]\n\n plt.rcParams.update({'legend.fontsize':18})\n plt.rcParams.update({'font.size':18})\n plt.rc('xtick', labelsize=18)\n plt.rc('ytick', labelsize=18)\n\n plt.savefig(plot_file,bbox_inches='tight')\n\n plt.close(1)\n\n log.info('Colour-magnitude diagram output to '+plot_file)","def plot_multi_abundance(\n bracken_combined, plot_file, min_percent\n):\n\n nrow, ncol = 1, 2\n\n fig, ax = plt.subplots(\n nrows=nrow, ncols=ncol, figsize=(\n ncol*14, nrow*14\n )\n )\n\n data = pandas.read_csv(bracken_combined, sep='\\t', index_col='name', header=0)\n # Use percentage rather than total reads across samples\n data = data[[c for c in data.columns if 'bracken_frac' in c]]\n data.columns = [d.replace(\".bracken_frac\", \"\") for d in data.columns]\n\n if min_percent > 0:\n keep_idx = []\n for i, row in data.iterrows():\n keep_col = [True for v in row if v >= min_percent]\n if any(keep_col):\n keep_idx.append(row.name)\n data = data[data.index.isin(keep_idx)]\n\n # Separate viruses\n viruses = []\n for name in data.index.tolist():\n if 'virus' in name.lower():\n viruses.append(data[data.index == name])\n viruses = pandas.concat(viruses)\n data = data.drop(viruses.index.tolist())\n\n human = data[data.index == 'Homo sapiens']\n data = data.drop('Homo sapiens')\n print(human)\n\n REMAINING_PATHOGENS = [p for p in PATHOGENS if p in data.index.tolist()]\n pathogens = data[data.index.isin(REMAINING_PATHOGENS)].sort_index()\n data = data.drop(REMAINING_PATHOGENS)\n\n REMAINING_CONTAMINATION = [p for p in CONTAM if p in data.index.tolist()]\n contams = data[data.index.isin(REMAINING_CONTAMINATION)].sort_index()\n data = data.drop(REMAINING_CONTAMINATION)\n\n print(pathogens)\n print(contams)\n\n viruses_collapsed = collapse_taxa(viruses, suffix=\"virus\")\n\n print(viruses_collapsed)\n\n other_collapsed = collapse_taxa(data, genus=True)\n\n print(other_collapsed)\n\n combined = []\n for name, df in {\n 'Human': human, 'Pathogens': pathogens, 'Contamination': contams,\n 'Viruses': viruses_collapsed, 'Microbes': other_collapsed\n }.items():\n df['domain'] = [name for _ in range(len(df))]\n combined.append(df)\n combined = pandas.concat(combined)\n\n print(combined)\n\n panel1 = combined[combined['domain'] != 'Microbes']\n panel2 = combined[combined['domain'] == 'Microbes']\n\n panel1.reset_index(level=0, inplace=True)\n panel2.reset_index(level=0, inplace=True)\n panel1.rename(columns={'index': 'taxon'}, inplace=True)\n panel2.rename(columns={'index': 'taxon'}, inplace=True)\n\n print(panel1)\n print(panel2)\n #\n panel1_melt = panel1.melt(id_vars=['taxon', 'domain'], value_name=\"abundance\", var_name=\"sample\")\n panel2_melt = panel2.melt(id_vars=['taxon', 'domain'], value_name=\"abundance\", var_name=\"sample\")\n\n print(panel1_melt)\n print(panel2_melt)\n\n panel1_melt['abundance'] = [None if ab == 0. else ab for ab in panel1_melt['abundance']]\n panel2_melt['abundance'] = [None if ab == 0. else ab for ab in panel2_melt['abundance']]\n p1 = sns.scatterplot(\n data=panel1_melt, x=\"sample\", y=\"taxon\", hue=\"domain\",\n size=\"abundance\", legend=False, sizes=(70, 2000), ax=ax[0]\n )\n\n p2 = sns.scatterplot(\n data=panel2_melt, x=\"sample\", y=\"taxon\", hue=\"domain\", size=\"abundance\", legend=False, sizes=(50, 2000), ax=ax[1]\n )\n\n # plot grid behind markers\n # p1.grid(ls=\"dotted\", zorder=1, linewidth=0.1)\n # p2.grid(ls=\"dotted\", zorder=1, linewidth=0.1)\n # take care of long labels\n fig.autofmt_xdate()\n\n plt.tight_layout()\n p1.set_ylabel(\"\")\n p1.set_ylabel(\"\")\n p2.set_ylabel(\"\")\n p2.set_ylabel(\"\")\n fig.savefig(f'{plot_file}')","def _plot(self):\n # Read results\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\n x1, y1, _ = read_results('openmc', path)\n if self.code == 'serpent':\n path = self.other_dir / 'input_det0.m'\n else:\n path = self.other_dir / 'outp'\n x2, y2, sd = read_results(self.code, path)\n\n # Convert energies to eV\n x1 *= 1e6\n x2 *= 1e6\n\n # Normalize the spectra\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\n\n # Compute the relative error\n err = np.zeros_like(y2)\n idx = np.where(y2 > 0)\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\n \n # Set up the figure\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\n ax1 = fig.add_subplot(111)\n \n # Create a second y-axis that shares the same x-axis, keeping the first\n # axis in front\n ax2 = ax1.twinx()\n ax1.set_zorder(ax2.get_zorder() + 1)\n ax1.patch.set_visible(False)\n \n # Plot the spectra\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\n \n # Plot the relative error and uncertainties\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\n \n # Set grid and tick marks\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\n ax1.grid(b=False, axis='both', which='both')\n ax2.tick_params(axis='y', which='both', right=False)\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\n \n # Set axes labels and limits\n ax1.set_xlim([self._min_energy, self.energy])\n ax1.set_xlabel('Energy (eV)', size=12)\n ax1.set_ylabel('Spectrum', size=12)\n ax1.legend()\n ax2.set_ylabel(\"Relative error\", size=12)\n title = f'{self.nuclide}'\n if self.thermal is not None:\n name, suffix = self.thermal.split('.')\n thermal_name = openmc.data.thermal.get_thermal_name(name)\n title += f' + {thermal_name}'\n title += f', {self.energy:.1e} eV Source'\n plt.title(title)\n \n # Save plot\n os.makedirs('plots', exist_ok=True)\n if self.name is not None:\n name = self.name\n else:\n name = f'{self.nuclide}'\n if self.thermal is not None:\n name += f'-{thermal_name}'\n name += f'-{self.energy:.1e}eV'\n if self._temperature is not None:\n name += f'-{self._temperature:.1f}K'\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\n plt.close()","def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\n fontsize=12):\n n_model = len(source_model_list)\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\n axes[0, 1].axis('off')\n ax = axes[0, 0]\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n ax.set_title(\"true source\", fontsize=fontsize)\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n plot_util.nice_colorbar(im, label=\"flux\", fontsize=fontsize)\n \n i = 1\n for source_model, name in zip(source_model_list, name_list):\n print(\"min/max for source model '{}': {}/{}\".format(name, source_model.min(), source_model.max()))\n\n residuals_source = source_model - source_truth\n\n ax = axes[i, 0]\n ax.set_title(\"model '{}'\".format(name), fontsize=fontsize)\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n im = ax.imshow(source_model, cmap=cmap)\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n plot_util.nice_colorbar(im, label=\"flux\", fontsize=fontsize)\n \n ax = axes[i, 1]\n #ax.get_xaxis().set_visible(False)\n #ax.get_yaxis().set_visible(False)\n ax.set_title(\"difference\", fontsize=fontsize)\n #ax.set_xlim(*lims)\n #ax.set_ylim(*lims)\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\n label=r\"f${}_{\\rm model}$ - f${}_{\\rm truth}$\", fontsize=fontsize)\n \n print(\"SDR for model '{}' = {:.3f}\".format(name, metrics_util.SDR(source_truth, source_model)))\n i += 1\n\n return fig","def calculate_ratio_data(self, z, normalize = True, pos_norm = 2, _SAVING = True):\n\n try:\n z_digits = len((self.z_names[0].replace(self.z_str+'_','')).split('p')[1]) ##counts digits in a key like z_red_0p123456\n z_request = self.z_str+'_'+'{1:.{0}f}'.format(z_digits, z).replace('.','p')\n except:\n z_request = z\n if z_request not in self.z_names: ## this allows to request numbers not exactly in z_vals if precision is still withing z_digits (usually 6)\n raise ValueError('Requested redshift'' is not contained in dataframe')\n\n\n\n ## if ratio mode is not used, the spectra are divided by a reference spectrum\n if self.ratio_mode == True:\n reftheo = 1\n else:\n reftheo = self.df_ref.loc[(self.data_type, z_request)].values\n\n exnoi = self.df_ext.loc[self.data_type, z_request].values / reftheo\n\n ## binwise normalization: we shift by the mean and divide by standard devitaion\n if normalize == True:\n binwise_mean = exnoi.mean(axis=0)\n binwise_std = exnoi.std(axis=0)\n else:\n binwise_mean = 0\n binwise_std = 1\n\n self.binwise_mean = binwise_mean\n self.binwise_std = binwise_std\n \n ## dictionary with data as keys and array of normalized spectra as values (e.g. {\"theo\": array([[...],[...],...])})\n matrix_z = (exnoi - binwise_mean) / binwise_std\n\n if _SAVING == True:\n self.matrix_z = matrix_z\n self.z_requested = z_request\n self.multiple_z = False\n else:\n return matrix_z","def inputToInternal(self, currentInputs):\n if type(currentInputs) != list:\n currentInputs = [currentInputs]\n hasPointSet = False\n hasHistorySet = False\n #Check for invalid types\n for currentInput in currentInputs:\n inputType = None\n if hasattr(currentInput, 'type'):\n inputType = currentInput.type\n\n if isinstance(currentInput, Files.File):\n self.raiseAnError(IOError, \"Input type '\", inputType, \"' can not be accepted\")\n elif isinstance(currentInput, Distributions.Distribution):\n pass #Allowed type\n elif inputType == 'HDF5':\n self.raiseAnError(IOError, \"Input type '\", inputType, \"' can not be accepted\")\n elif inputType == 'PointSet':\n hasPointSet = True\n elif inputType == 'HistorySet':\n hasHistorySet = True\n if self.multiOutput == 'raw_values':\n self.dynamic = True\n if self.pivotParameter not in currentInput.getVars('indexes'):\n self.raiseAnError(IOError, self, 'Pivot parameter', self.pivotParameter,'has not been found in DataObject', currentInput.name)\n if not currentInput.checkIndexAlignment(indexesToCheck=self.pivotParameter):\n self.raiseAnError(IOError, \"HistorySet\", currentInput.name,\" is not syncronized, please use Interfaced PostProcessor HistorySetSync to pre-process it\")\n pivotValues = currentInput.asDataset()[self.pivotParameter].values\n if len(self.pivotValues) == 0:\n self.pivotValues = pivotValues\n elif set(self.pivotValues) != set(pivotValues):\n self.raiseAnError(IOError, \"Pivot values for pivot parameter\",self.pivotParameter, \"in provided HistorySets are not the same\")\n else:\n self.raiseAnError(IOError, \"Metric cannot process \"+inputType+ \" of type \"+str(type(currentInput)))\n if self.multiOutput == 'raw_values' and hasPointSet and hasHistorySet:\n self.multiOutput = 'mean'\n self.raiseAWarning(\"Reset 'multiOutput' to 'mean', since both PointSet and HistorySet are provided as Inputs. Calculation outputs will be aggregated by averaging\")\n\n measureList = []\n\n for cnt in range(len(self.features)):\n feature = self.features[cnt]\n target = self.targets[cnt]\n featureData = self.__getMetricSide(feature, currentInputs)\n targetData = self.__getMetricSide(target, currentInputs)\n measureList.append((featureData, targetData))\n\n return measureList","def plot_alleles(folder):\n\n abs_alt,perc_alt = parse_geno_file(folder,False)\n\n strain_matcher = re.compile('(.*) \\(.*\\)') ## regex to get strain name from radio button click\n strain_matcher2 = re.compile('(.*)-(.*)')\n \n fig, ax = plt.subplots()\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\n ax.set_ylabel('Alternate Allele Percentage (MC)')\n ax.set_xlabel('Alternate Allele Percentage (MC)')\n \n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\n\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\n\n #for strain in perc_alt.keys():\n #print strain\n \n #ylabel = plt.axes([1,1,0.08,0.08])\n\n def update1(strain):\n if strain not in [\"Rock-MZ\",\"Sand-MC\",\"Rock-MC\",\"Sand-MZ\",\"Rock-Sand\"]:\n match = re.match(strain_matcher,strain)\n strain = match.group(1)\n global base\n base = 'MC'\n else:\n match = re.match(strain_matcher2,strain)\n strain = match.group(1)\n #global base \n base = match.group(2)\n\n #print D\n if(D == \"%\"):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[strain])\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n else:\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[strain])\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n\n ax.relim()\n ax.autoscale()\n fig.canvas.draw_idle()\n global S \n #print S\n S = strain\n\n\n def update2(data):\n if(data == '%'):\n l.set_xdata(perc_alt[base])\n l.set_ydata(perc_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\n fig.canvas.draw_idle()\n if(data == 'Abs'):\n l.set_xdata(abs_alt[base])\n l.set_ydata(abs_alt[S])\n ax.relim()\n ax.autoscale()\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\n fig.canvas.draw_idle()\n \n global D\n D = data\n\n radio1.on_clicked(update1)\n radio2.on_clicked(update2)\n plt.show()","def main():\n # Load properties that will be needed\n store = [Storage.Storage(2), Storage.Storage(4)] \n pre_energy = [s.get(\"free_energy\") for s in store]\n post_energy = [s.get(\"post_energy\") for s in store]\n x_range = store[0].get(\"x_range\")\n xlocs = np.arange(x_range[0], x_range[1], x_range[2])\n y_range = store[0].get(\"y_range\")\n ylocs = np.arange(y_range[0], y_range[1], y_range[2])\n # Calculate step size\n xb2steps = stepsize(pre_energy[0], post_energy[0], xlocs) \n xb4steps = stepsize(pre_energy[1], post_energy[1], xlocs) \n # Set up the figure\n fig = plt.figure(1, figsize=(7.5,2.5)) \n axe = (fig.add_subplot(1, 2, 1), fig.add_subplot(1, 2, 2))\n # Plot the results\n axe[0].plot(ylocs, xb4steps, color='#FF466F', lw=4)\n axe[1].plot(ylocs, xb2steps, color='#76D753', lw=4)\n # Annotate the plots\n axe[0].set_title(\"4sXB step size\")\n axe[0].set_xlabel(\"Lattice spacing (nm)\") \n axe[0].set_ylabel(\"Step size (nm)\")\n axe[0].set_xlim((25.5, 39))\n axe[0].set_ylim((1, 8))\n axe[1].set_title(\"2sXB step size\")\n axe[1].set_xlabel(\"Lattice spacing (nm)\") \n axe[1].set_ylabel(\"Step size (nm)\")\n axe[1].set_xlim((25.5, 39))\n axe[1].set_ylim((1, 8))\n # Display the plots\n fig.subplots_adjust(wspace=0.25, hspace=0.48,\n left=0.08, right=0.98,\n top=0.85, bottom=0.21)\n plt.show()","def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\n xval='x', adjustRadial=True):\n outdirs = np.sort(os.listdir(path))\n plt.figure()\n\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\n for i,outdir in enumerate(outdirs):\n pointsFile = os.path.join(path, outdir, 'points.h5')\n #print(pointsFile)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\n #Load data\n\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\n #Y = uz / yscale\n if xval == 'x':\n X = x / xscale\n Y1 = ux / yscale\n elif xval == 'r':\n X = np.hypot(x,y) / xscale\n ur_fem = np.hypot(ux,uy)\n Y1 = ur_fem / yscale\n if adjustRadial: #fix sign from hypot square root\n ur_fem = pu.radial2negative(Y1)\n\n x_fem = X #/ xscale #double scaling!\n ur_fem = Y1 #/ yscale\n uz_fem = uz / yscale\n\n #print(pointsFile)\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\n\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\n\n # Annotate\n plt.axhline(color='k',lw=0.5)\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\n plt.legend()\n\n #NOTE: custom annotations for 3d heterogeneity\n #plt.title('Elastic Heterogeneity Effects')\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\n\n if outname: plt.savefig(outname)\n if show: plt.show()","def checkmaxmin(droi):\n \n # Loads data.\n fd = load_frames('gofparams')\n rawdata = loadresultsfile('results1.txt', 'Mean1')\n \n pardir = cmn.makepardir_data()\n movie = os.path.basename(os.path.abspath('.'))\n \n d = {}\n rois = droi.keys()\n \n # Finds the max and min points using the parameters specified in the list droi.\n for roi in rois:\n\n maxsurr, maxwinlen, maxtrshift, minsurr, minwinlen, mintrshift = droi[roi]\n \n dmax, dmin = peaklib.maxminanalysis(rawdata, maxsurr, maxwinlen, maxtrshift, minsurr,\n minwinlen, mintrshift)\n \n d[roi+'_dmax'] = dmax\n d[roi+'_dmin'] = dmin\n\n # Plots the raw traces with the max and min points indicated.\n for roi in rois:\n plt.figure(figsize=(14,10))\n peaklib.plotminmax(d[roi+'_dmax'], d[roi+'_dmin'], 'b', 1, 0)\n \n figname = movie+'_'+roi\n plt.title('{0} \\n {1} \\n frames = {2}-{3} ({4} total)'.format(figname, fd['condition'], \n fd['f1'], fd['f_end'], fd['f_end']-fd['f1']))\n \n figpath = peaklib.makefilepath(pardir, ANALYSISFOLDPNG, figname)\n plt.savefig(figpath)\n plt.close()\n \n # Writes the min/max data into a file with the function writei.\n \n ifilefold = ANALYSISFOLDTXT + '/' + movie + '/'\n ipath = peaklib.makesubdir(pardir, ifilefold)\n peaklib.writei(d, fd, ipath)","def sample_pin_position_range():\n #Create a sample goniometer\n g = TopazInHouseGoniometer()\n\n #Initialize the leg limits\n g.relative_sample_position = column([0.0, 0.0, 0.0])\n g.getplatepos(0.0, 0.0, 0.0)\n g.calculate_leg_xy_limits(visualize=True)\n\n# if True:\n# pylab.show()\n# return\n\n n = 17\n positions = np.linspace(-8, 8, n) #Range calculated in mm\n allowed = np.zeros( (n,n,n) )\n for (ix, x) in enumerate(positions):\n print \"Calculating x\", x\n for (iy, y) in enumerate(positions):\n for (iz, z) in enumerate(positions):\n #Set up\n g.relative_sample_position = column([x, y, z])\n allowed[ix,iy,iz] = g.are_angles_allowed([0., 0., 0.], return_reason=False)\n\n #Do a plot\n\n pylab.figure(1, figsize=[15,15])\n pylab.title(\"Allowable XZ sample positions\")\n for (iy, y) in enumerate(positions):\n print \"At y of\", y, \", # of points = \", np.sum( allowed[:, iy,:])\n if iy < 16:\n pylab.subplot(4,4,iy+1)\n pylab.pcolor(positions, positions, allowed[:, iy, :].transpose(), norm=pylab.Normalize(0, 1))\n pylab.xlabel(\"x\")\n pylab.ylabel(\"z\")\n pylab.title(\"y = %.3f mm\" % y)\n pylab.draw()\n pylab.axis('equal')\n pylab.show()\n #pylab.","def do_plot_abs(the_input):\n pressurefield = None\n\n if the_input is None:\n raise Exception(\"You must supply a pressurefield or world:cueBeamCore2.CueBeamWorld\")\n\n if (type(the_input) is CueBeamWorld):\n world = the_input\n pressurefield = world.rxPlane.pressurefield\n\n if (type(the_input) is numpy.ndarray):\n world = CueBeamWorld() # create new, default world\n pressurefield = the_input\n\n if pressurefield is None:\n raise Exception(\"Something wrong: pressurefield is still None\")\n\n hfig = plt.figure(num=1, figsize=(8, 6), dpi=90, facecolor='white', edgecolor='black')\n\n imgplot = plt.imshow(\n X=numpy.real(pressurefield),\n extent=(\n world.rxPlane.z0, world.rxPlane.z0 + world.rxPlane.nz * world.rxPlane.dz,\n world.rxPlane.y0, world.rxPlane.y0 + world.rxPlane.ny * world.rxPlane.dy\n ),\n # interpolation=\"spline36\",\n interpolation=\"nearest\",\n clim=(0, 8.0),\n origin=\"lower\")\n # end imshow\n plt.set_cmap(\"plasma\") # black-to-yellow color map\n plt.xlabel(\"z-axis[m]\")\n plt.ylabel(\"y-axis[m]\")\n plt.show()","def plot_lognormal_relative_likelihoods(tmin, tmax, min_shape, max_shape, step_shape,\n min_scale, max_scale, step_scale, label_as_confidence=False,\n ax=None):\n dist_fun = lognorm\n ax = _plot_shape_scale_confidence_regions(tmin, tmax, min_shape, max_shape, step_shape,\n min_scale, max_scale, step_scale, dist_fun,\n label_as_confidence, ax=ax)\n plt.xlabel(r'$m$')\n plt.ylabel(r'$\\sigma$')\n\n return ax","def fraction():\n global correct_fraction\n S1,S2,S3 = {\"molar_mass\":1.008, \"name\":\"A\"},{\"molar_mass\":16.00, \"name\":\"B\"},{\"molar_mass\":44.01, \"name\":\"C\"}\n M1,M2,M3 = randint(1,50),randint(1,20),randint(1,20) # Really really shitty but I'm lazy rn\n total_mass = S1[\"molar_mass\"]*M1 + S2[\"molar_mass\"]*M2 + S3[\"molar_mass\"]*M3\n\n print(\"\\n\\nThis is a mass and molar fractions question.\\n\")\n print(\"\\nFor a substance made out of '{}' with a molar mass of '{}'\".format(S1[\"name\"], S1[\"molar_mass\"]))\n print(\"'{}' with a molar mass of '{}'\".format(S2[\"name\"], S2[\"molar_mass\"]))\n print(\"and '{}' with a molar mass of '{}'\".format(S3[\"name\"], S3[\"molar_mass\"]))\n\n # Chance at being molar or mass fraction\n if choice([True, False]):\n print(\"If there are {} moles of {} what is the mass fraction of a substance weighing {:0.2f}g ?\\n\".format(M1, S1[\"name\"],total_mass))\n guess = get_user_input(float)\n answer = (M1*S1[\"molar_mass\"])/(total_mass)*100\n else:\n print(\"If the mass of {} is {} and {} is {} what is the molar fraction of {} \\nin a substance weighing {:0.2f}g ?\\n\".format(S1[\"name\"], M1*S1[\"molar_mass\"], S2[\"name\"], M2*S2[\"molar_mass\"], S3[\"name\"], total_mass))\n guess = get_user_input(float)\n answer = M1/(M1+M2+M3)*100\n\n if check_answer(guess,answer,0.3):\n print(\"correct\")\n correct_fraction += 1\n else:\n print(\"false the answer is {:0.2f}\".format(answer))","def awGrid(vis,HA,uvw,image_params,obs_params,Mterms,Mterms_ij):\t\n\tStokes = image_params['Stokes']\n\t\n\n\n\tprint '--------------Gridding X pol--------------------'\n\txgrid_wt, xgrid_uv = gridOnePolAWproj(vis[0],HA,uvw,image_params,obs_params,Mterms[0],Mterms_ij[0])\n\tprint '--------------Gridding Y pol--------------------'\n\tygrid_wt, ygrid_uv = gridOnePolAWproj(vis[1],HA,uvw,image_params,obs_params,Mterms[1],Mterms_ij[1])\n\n\tN = np.shape(xgrid_wt)[0]\n\tgrid_uv = np.zeros([N, N], dtype=complex)\n\tgrid_wt = np.zeros([N, N], dtype=complex)\n\t\n\tif Stokes == 'I':\n\t\t#combine X and Y gridded vis to create the I pol gridded vis\n\t\t# I = (XX+YY)/2\n\t\tgrid_uv.real = (ygrid_uv.real + xgrid_uv.real)/2\n\t\tgrid_uv.imag = (ygrid_uv.imag + xgrid_uv.imag)/2\n\n\t\t#combine X and Y gridded wt to create the I pol gridded wt\n\t\tgrid_wt.real = (ygrid_wt.real + xgrid_wt.real)/2\n\t\tgrid_wt.imag = (ygrid_wt.imag + xgrid_wt.imag)/2\n\n\telif Stokes == 'Q':\n\t\t#combine X and Y gridded vis to create the I pol gridded vis\n\t\t# Q = (XX-YY)/2\n\t\tgrid_uv.real = (ygrid_uv.real - xgrid_uv.real)/2\n\t\tgrid_uv.imag = (ygrid_uv.imag - xgrid_uv.imag)/2\n\n\t\t#combine X and Y gridded wt to create the I pol gridded wt\n\t\tgrid_wt.real = (ygrid_wt.real - xgrid_wt.real)/2\n\t\tgrid_wt.imag = (ygrid_wt.imag - xgrid_wt.imag)/2\n\n\n\tdty_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_uv)))\n\tpsf_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_wt)))\n\n\treturn dty_image, psf_image","def perSaccPerGroup(addExp2 = True, trim = True, spacing = .5, addSimulation = True, \\\n\t\texclOverlap = True):\n\n\tfig = plt.figure(figsize = (10,10))\n\ttitle = \"Average towards-handle landings per group - exclOverlap = %s\" % exclOverlap\n\tplt.title(title)\n\t\n\t\n\t# Exp 1:\n\tdm1 = getDM.getDM(exp = \"004A\", excludeErrors = True, driftCorr = True)\n\t\n\t\n\tsubPlot = 1\n\t\n\tfor group in dm1.unique(\"corrDirection\"):\n\n\t\t# New subplot:\n\t\tplt.subplot(1,2,subPlot)\n\t\tplt.title(group)\n\t\t_dm1 = dm1.select(\"corrDirection == '%s'\" % group)\n\n\t\tlLandingsAbs = []\n\t\tlLandingsCorr = []\n\t\t\n\t\tfor sacc in [\"1\", \"2\", \"3\"]:\n\t\t\t\n\t\t\t# This is the same for corrected landing positions (the saccade\n\t\t\t# doesn't change; only the reference point does)\n\t\t\t_dm = _dm1.select(\"endX%sNorm != ''\" % sacc)\n\t\t\t_dm = _dm.select(\"endX%sNorm > -.5\" % sacc)\n\t\t\t_dm = _dm.select(\"endX%sNorm < .5\" % sacc)\n\t\t\t\n\t\t\tif trim:\n\t\t\t\t_dmAbs = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sNormToHandle\" % sacc)\n\t\t\t\t_dmCorr = _dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sCorrNormToHandle\" % sacc)\n\t\t\t\n\t\t\t# Determine avg landing position:\n\t\t\tavgAbs = _dmAbs[\"endX%sNormToHandle\" % sacc].mean()\n\t\t\tavgCorr = _dmCorr[\"endX%sCorrNormToHandle\" % sacc].mean()\n\t\t\t\n\t\t\t# TODO: determine error bars:\n\t\t\t\n\t\t\t\n\t\t\tlLandingsAbs.append(avgAbs)\n\t\t\tlLandingsCorr.append(avgCorr)\n\t\t\n\t\tplt.plot(lLandingsAbs, color = \"#f57900\", linewidth = 2, marker = \"o\")\n\t\tplt.plot(lLandingsCorr, color = \"#73d216\", linewidth = 2, marker = \"o\")\n\t\t\n\t\t# The other 2 experiments can be treated equally:\n\t\tcolList = [\"#ef2929\", \"#3465a4\"]\n\t\t\n\t\tfor exp in [\"004B\", \"004C\"]:\n\t\t\t\n\t\t\tif not addExp2:\n\t\t\t\tif exp == \"004B\":\n\t\t\t\t\tcontinue\n\t\t\tif not addSimulation:\n\t\t\t\tif exp == \"004C\":\n\t\t\t\t\tcontinue\n\n\t\t\tdm = getDM.getDM(exp = exp, excludeErrors = True, driftCorr = True)\n\t\t\t_dm = dm.select(\"corrDirection == '%s'\" % group)\n\n\t\t\tif exp == \"004C\":\n\t\t\t\tif exclOverlap:\n\t\t\t\t\t_dm = _dm.select(\"gap == 'zero'\")\n\n\t\t\t\n\t\t\tlLandingsAbs = []\n\t\t\t\n\t\t\tfor sacc in [\"1\", \"2\", \"3\"]:\n\t\t\t\t\n\t\t\t\t# TODO: how to filter only on-object saccades exp 2??\n\t\t\t\tsacc_dm = _dm.select(\"endX%sNorm != ''\" % sacc)\n\t\t\t\tsacc_dm = sacc_dm.select(\"endX%sNorm > -.5\" % sacc)\n\t\t\t\tsacc_dm = sacc_dm.select(\"endX%sNorm < .5\" % sacc)\n\t\t\t\t\n\t\t\t\tif trim:\n\t\t\t\t\tsacc_dm = sacc_dm.selectByStdDev(keys = [\"file\"], dv = \"endX%sNormToHandle\" % sacc)\n\t\t\t\t\n\t\t\t\t# Determine avg landing position:\n\t\t\t\tavgAbs = sacc_dm[\"endX%sNormToHandle\" % sacc].mean()\n\t\t\t\t\n\t\t\t\t# TODO: determine error bars:\n\t\t\t\t\n\t\t\t\tlLandingsAbs.append(avgAbs)\n\t\t\tcol = colList.pop()\n\t\t\tplt.plot(lLandingsAbs, color = col, linewidth = 2, marker = \"o\")\n\t\t\t\n\t\t# Modify plot:\n\t\tplt.legend([\"Exp1 abs\", \"Exp1 corr\", \"Exp2\", \"Sim\"])\n\t\t\t\n\t\tplt.axhline(0, color = \"#888a85\", linestyle = \"--\", linewidth = 2)\n\t\txLabels = [\"sacc 1\", \"sacc 2\", \"sacc 3\"]\n\t\txTicks = range(0,3)\n\t\tplt.xticks(xTicks, xLabels, rotation = .5)\n\t\tplt.ylim([-.5, .5])\n\t\tplt.xlim(min(xTicks)-spacing, max(xTicks)+spacing)\n\t\t\n\t\tsubPlot +=1\n\t\t\n\tplt.savefig(\"%s.png\" % title)","def _adjust_data_range_using_min_ratio(c_min, c_max, c_axis_range, *, min_ratio=0.01):\n c_range = c_max - c_min\n if c_range < c_axis_range * min_ratio:\n c_center = (c_max + c_min) / 2\n c_new_range = c_axis_range * min_ratio\n c_min = c_center - c_new_range / 2\n c_max = c_center + c_new_range / 2\n return c_min, c_max","def normalizeMinRes(resolution, lbcs, modeNames):\n\n nModes = len(modeNames)\n\n volPtsIn = getVolumePoints(32, 64, \"in\")\n volPtsOut = getVolumePoints(32, 64, \"out\")\n print \"Total number of volume points for minimizing L2 error: \", len(volPtsIn) + len(volPtsOut)\n\n # get mx fields from simulation\n # calculate analytic fields at points if data does not already exist in simulation directory\n mxVolFieldsIn = []\n mxVolFieldsOut = []\n anVolFieldsIn = []\n anVolFieldsOut = []\n for mode in modeNames:\n print \" Mode \" + mode + \":\"\n print \" calculating simulation volume field values...\"\n mxVolFieldsIn.append(mxFieldValuesAtPoints(resolution, lbcs, 'E', mode, volPtsIn, \"volume_in\").ravel())\n mxVolFieldsOut.append(mxFieldValuesAtPoints(resolution, lbcs, 'E', mode, volPtsOut, \"volume_out\").ravel())\n print \" calculating analytic volume field values...\"\n anVolFieldsIn.append(analyticFieldValuesAtPoints(\"./analytic/\", mode, volPtsIn, \"volume_in\").ravel())\n anVolFieldsOut.append(analyticFieldValuesAtPoints(\"./analytic/\", mode, volPtsOut, \"volume_out\").ravel())\n mxVolFieldsIn = numpy.asarray(mxVolFieldsIn)\n mxVolFieldsOut = numpy.asarray(mxVolFieldsOut)\n anVolFieldsIn = numpy.asarray(anVolFieldsIn)\n anVolFieldsOut = numpy.asarray(anVolFieldsOut)\n\n # dot product matrix of degenerate mx fields\n dotProds = eps * numpy.dot(mxVolFieldsIn, mxVolFieldsIn.T)\n dotProds += numpy.dot(mxVolFieldsOut, mxVolFieldsOut.T)\n invDotProds = numpy.linalg.inv(dotProds)\n\n rhs = eps * numpy.dot(mxVolFieldsIn, anVolFieldsIn.T)\n rhs += numpy.dot(mxVolFieldsOut, anVolFieldsOut.T)\n return numpy.dot(invDotProds, rhs)"],"string":"[\n \"def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\\n\\n# alt keyword check\\n for k in ['file','filename']: \\n if kwargs.get(k,'') != '': output = kwargs[k]\\n for k in ['legends','labels']: \\n if kwargs.get(k,'') != '': legend = kwargs[k]\\n\\n# force input into a list\\n if isinstance(inp,list): inputlist = copy.deepcopy(inp)\\n else: inputlist = [inp]\\n\\n# if input is a string of filenames, read in each file to a spectrum object\\n if isinstance(inputlist[0],str):\\n# try a glob search string \\n files = glob.glob(os.path.normpath(inputlist[0]))\\n if len(files) > 1 or (len(files) == 1 and inputlist[0].find('*') != -1):\\n inputlist = files\\n# try reading in files into Spectrum object\\n try:\\n splist = [splat.Spectrum(file = f) for f in inputlist]\\n except:\\n raise ValueError('\\\\nCould not read in list of files {} - make sure the full path is specified and the files are correctly formatted'.format(inputlist))\\n\\n# if filenames, read in each file to a spectrum object\\n elif isinstance(inputlist[0],splat.Spectrum):\\n splist = copy.deepcopy(inputlist)\\n else:\\n raise ValueError('\\\\nInput should be list of splat.Spectrum objects or filenames')\\n\\n# normalize if desired\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in splist]\\n\\n# comparison files are present\\n complist = []\\n if comparisons != None:\\n comp = copy.deepcopy(comparisons)\\n if not isinstance(comp,list): comp = [comp]\\n if isinstance(comp[0],str):\\n try:\\n complist = [splat.Spectrum(file = f) for f in comp]\\n except:\\n print('\\\\nCould not read in comparison files: ignoring comparisons')\\n if isinstance(comp[0],splat.Spectrum):\\n complist = comp\\n if len(complist) < len(splist):\\n while len(complist) < len(splist):\\n complist.append(complist[-1])\\n# normalize\\n if normalize==True:\\n tmp = [sp.normalize(normrange) for sp in complist]\\n\\n# set comparison files to be standards for spectral classification\\n# overrules input comparison sample\\n if classify == True:\\n complist = []\\n base_kwargs={\\n 'return_standard': True,\\n 'method': 'kirkpatrick',\\n }\\n base_kwargs.update(classify_kwargs)\\n for sp in splist:\\n complist.append(splat.classifyByStandard(sp,**base_kwargs))\\n\\n# prep for plotting\\n plotlist = []\\n clist = []\\n for i,sp in enumerate(splist):\\n if len(complist) == len(splist):\\n plotlist.append([sp,complist[i]])\\n clist.extend(basecolors)\\n else:\\n plotlist.append([sp])\\n clist.extend(basecolors[0])\\n\\n# manage legends\\n if len(legend) != 0:\\n if not isinstance(legend,list): legend = [legend]\\n if len(legend) < (len(splist)+len(complist)):\\n# guess: just left out the comparison legends \\n if len(complist) > 0 and len(legend) == len(splist):\\n legtmp = []\\n for i,l in enumerate(legend):\\n legtmp.extend([l,'{}'.format(complist[i].name)])\\n legend = legtmp\\n else:\\n# otherwise: pad the remaining legends with the last legend (pairs) \\n while len(legend) < (len(splist)+len(complist)):\\n if len(complist)>0:\\n legend.extend([legend[-2],legend[-1]])\\n else:\\n legend.extend([legend[-1]])\\n if len(legend) > (len(splist)+len(complist)):\\n legend = legend[0:(len(splist)+len(complist))]\\n else:\\n legend = []\\n for i,sp in enumerate(splist):\\n l = []\\n if 'name' in list(sp.__dict__.keys()): l.append(sp.name)\\n else: l.append(os.path.basename(sp.filename))\\n if len(complist)>0:\\n if 'name' in list(complist[i].__dict__.keys()): l.append(complist[i].name)\\n else: l.append(os.path.basename(complist[i].filename))\\n legend.extend(l)\\n\\n# generate plot\\n base_kwargs={\\n 'multiplot': True,\\n 'multipage': True,\\n 'legends': legend,\\n 'colors': clist,\\n 'layout': layout,\\n 'fontscale': fontscale,\\n 'output': output,\\n }\\n base_kwargs.update(plot_kwargs)\\n fig = plotSpectrum(plotlist,**base_kwargs)\\n\\n return fig\",\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 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_checks(inputfile, outputfile, absetamin, absetamax, max_pt, pu_min, pu_max):\\n\\n print \\\"Doing eta bin: %g - %g, max L1 jet pt: %g\\\" % (absetamin, absetamax, max_pt)\\n\\n # Input tree\\n tree_raw = inputfile.Get(\\\"valid\\\")\\n\\n # Output folders\\n output_f = outputfile.mkdir('eta_%g_%g' % (absetamin, absetamax))\\n output_f_hists = output_f.mkdir(\\\"Histograms\\\")\\n\\n # Eta cut string\\n eta_cutStr = \\\" TMath::Abs(eta)<%g && TMath::Abs(eta) > %g \\\" % (absetamax, absetamin)\\n # Pt cut string\\n pt_cutStr = \\\"pt < %g\\\" % max_pt\\n # PU cut string\\n pu_cutStr = \\\"numPUVertices <= %f && numPUVertices >= %f\\\" % (pu_max, pu_min)\\n # Avoid L1 saturated jets cut (from 2017 any l1 jet with a saturated tower is auto given pt=1024GeV)\\n avoidSaturation_cut = \\\"pt < 1023.1\\\"\\n cutStr = \\\" && \\\".join([eta_cutStr, pt_cutStr, pu_cutStr, avoidSaturation_cut])\\n\\n # Draw response (pT^L1/pT^Gen) for all pt bins\\n tree_raw.Draw(\\\"rsp>>hrsp_eta_%g_%g(100,0,5)\\\" % (absetamin, absetamax), cutStr)\\n hrsp_eta = ROOT.gROOT.FindObject(\\\"hrsp_eta_%g_%g\\\" % (absetamin, absetamax))\\n hrsp_eta.SetTitle(\\\";response (p_{T}^{L1}/p_{T}^{Ref});\\\")\\n if absetamin < 2.9:\\n fit_result = hrsp_eta.Fit(\\\"gaus\\\", \\\"QER\\\", \\\"\\\",\\n hrsp_eta.GetMean() - hrsp_eta.GetRMS(),\\n hrsp_eta.GetMean() + hrsp_eta.GetRMS())\\n else:\\n peak = hrsp_eta.GetBinCenter(hrsp_eta.GetMaximumBin())\\n fit_result = hrsp_eta.Fit(\\\"gaus\\\", \\\"QER\\\", \\\"\\\",\\n peak - (0.5 * hrsp_eta.GetRMS()),\\n peak + (0.5 * hrsp_eta.GetRMS()))\\n\\n # mean = hrsp_eta.GetFunction(\\\"gaus\\\").GetParameter(1)\\n # err = hrsp_eta.GetFunction(\\\"gaus\\\").GetParError(1)\\n output_f_hists.WriteTObject(hrsp_eta)\\n\\n # nb_pt, pt_min, pt_max = 63, 0, 252 # for GCT/Stage 1\\n nb_pt, pt_min, pt_max = 512, 0, 1024 # for Stage 2\\n nb_rsp, rsp_min, rsp_max = 100, 0, 5\\n\\n # Draw rsp (pT^L1/pT^Gen) Vs GenJet pT\\n tree_raw.Draw(\\\"rsp:ptRef>>h2d_rsp_gen(%d,%g,%g,%d,%g,%g)\\\" % (nb_pt, pt_min, pt_max, nb_rsp, rsp_min, rsp_max), cutStr)\\n h2d_rsp_gen = ROOT.gROOT.FindObject(\\\"h2d_rsp_gen\\\")\\n h2d_rsp_gen.SetTitle(\\\";p_{T}^{Ref} [GeV];response (p_{T}^{L1}/p_{T}^{Ref})\\\")\\n output_f_hists.WriteTObject(h2d_rsp_gen)\\n\\n h2d_rsp_gen_norm = cu.norm_vertical_bins(h2d_rsp_gen)\\n output_f_hists.WriteTObject(h2d_rsp_gen_norm)\\n\\n # Draw rsp (pT^L1/pT^Gen) Vs L1 pT\\n tree_raw.Draw(\\\"rsp:pt>>h2d_rsp_l1(%d,%g,%g,%d,%g,%g)\\\" % (nb_pt, pt_min, pt_max, nb_rsp, rsp_min, rsp_max), cutStr)\\n h2d_rsp_l1 = ROOT.gROOT.FindObject(\\\"h2d_rsp_l1\\\")\\n h2d_rsp_l1.SetTitle(\\\";p_{T}^{L1} [GeV];response (p_{T}^{L1}/p_{T}^{Ref})\\\")\\n output_f_hists.WriteTObject(h2d_rsp_l1)\\n\\n h2d_rsp_l1_norm = cu.norm_vertical_bins(h2d_rsp_l1)\\n output_f_hists.WriteTObject(h2d_rsp_l1_norm)\\n\\n # Draw pT^Gen Vs pT^L1\\n tree_raw.Draw(\\\"pt:ptRef>>h2d_gen_l1(%d,%g,%g,%d,%g,%g)\\\" % (nb_pt, pt_min, pt_max, nb_pt, pt_min, pt_max), cutStr)\\n h2d_gen_l1 = ROOT.gROOT.FindObject(\\\"h2d_gen_l1\\\")\\n h2d_gen_l1.SetTitle(\\\";p_{T}^{Ref} [GeV];p_{T}^{L1} [GeV]\\\")\\n output_f_hists.WriteTObject(h2d_gen_l1)\",\n \"def compute_and_plot_mass_hist(raw_images, gen_sample_raw, display=True, ax=None, log=True, lim=lim_hist, confidence=None, ylim=None, fractional_difference=False, algo='relative', loc=1, **kwargs):\\n# raw_max = 250884 \\n# lim = [np.log10(1), np.log10(raw_max/3)]\\n y_real, y_fake, x = stats.mass_hist_real_fake(raw_images, gen_sample_raw, log=log, lim=lim, mean=False)\\n# l2, logel2, l1, logel1 = stats.diff_vec(np.mean(y_real, axis=0), np.mean(y_fake, axis=0))\\n# rel_diff = None\\n# if confidence is not None:\\n# rel_diff = stats.relative_diff(y_real, y_fake).mean()\\n# if display:\\n# print('Log l2 Mass histogram loss: {}\\\\n'\\n# 'L2 Peak Mass histogram: {}\\\\n'\\n# 'Log l1 Mass histogram loss: {}\\\\n'\\n# 'L1 Mass histogram loss: {}'.format(logel2, l2, logel1, l1))\\n npix = np.prod(raw_images.shape[1:])\\n d = safe_fd(y_real,y_fake, npix)\\n score = fd2score(d)\\n if display:\\n print('Mass Frechet Distance: {}\\\\n'\\n 'Mass Score : {}\\\\n'.format(d, score))\\n \\n plot_cmp(x, y_fake, y_real, title='Mass histogram', xlabel='Number of particles', ylabel='Pixel count', ax=ax, xscale='log' if log else 'linear', shade=True, confidence=confidence, ylim=ylim, fractional_difference=fractional_difference, algorithm=algo, loc=loc)\\n return score\",\n \"def testIsAbs(self, mock_abs):\\n mock_abs.return_value = True\\n\\n self.assertTrue(\\n self.mr.is_abs\\n )\\n\\n mock_abs.assert_called_once_with(\\n os.path.join(self.directory, self.filename)\\n )\\n\\n mock_abs.return_value = False\\n\\n self.assertFalse(\\n self.mr.is_abs\\n )\",\n \"def _init_mass(self, mmin, mmax, nmbin):\\n self.lgmass, self.dlgmass = np.linspace(log10(mmin), log10(mmax), \\n num=nmbin, retstep=True)\\n self.mass = np.power(10.0, self.lgmass) \\n self.scale = np.power(self.r3conv*self.mass, 1.0/3.0) \\n self.lgmmax = self.lgmass[-1]\\n self.lgmmin = self.lgmass[0]\",\n \"def abs_units(wb_run,sample_run,mono_van,wb_mono,samp_rmm,samp_mass,ei_guess,rebin,map_file,monovan_mapfile,**kwargs): \\n #available keywords\\n #abs_units_van_range\\n global reducer, rm_zero,inst_name,van_mass,bleed_switch,rate,pixels\\n print 'DGreduce run for ',inst_name,'run number ',sample_run\\n print 'Output will be in absolute units of mb/str/mev/fu'\\n\\n #reducer.van_rmm =50.94\\n reducer.van_mass=van_mass\\n #sample info\\n reducer.sample_mass=samp_mass\\n reducer.sample_rmm =samp_rmm\\n print 'Using vanadium mass: ',van_mass\\n print ' sample mass: ',samp_mass \\n print ' sample_rmm : ',samp_rmm \\n # check if mono-vanadium is provided as multiple files list or just put in brackets ocasionally\\n if isinstance(mono_van,list):\\n if len(mono_van)>1:\\n raise IOError(' Can currently work only with single monovan file but list supplied')\\n else:\\n mono_van = mono_van[0];\\n\\n \\n try:\\n n,r=lhs('both')\\n wksp_out=r[0]\\n except:\\n if sample_run == 0:\\n #deal with the current run being parsed as 0 rather than 00000\\n sample_run='00000'\\n wksp_out=str(sample_run)+'.spe'\\n \\n start_time=time.time()\\n \\n if sample_run=='00000' and mtd.doesExist(inst_name+'00000.raw')==True:\\n print 'Deleteing previous instance of temp data'\\n DeleteWorkspace(Workspace=inst_name+'00000.raw')\\n \\n if kwargs.has_key('norm_method'):\\n reducer.normalise_method = kwargs.get('norm_method')\\n print 'Setting normalisation method to ', kwargs.get('norm_method')\\n else:\\n reducer.normalise_method = 'monitor-1'\\n \\n if kwargs.has_key('mask_run'):\\n mask_run = kwargs.get('mask_run')\\n print 'Using run ', kwargs.get('mask_run'),' for diag'\\n else:\\n mask_run=sample_run\\n \\n if kwargs.has_key('background'):\\n reducer.background = kwargs.get('background')\\n print 'Setting background option to ', kwargs.get('background')\\n else:\\n reducer.background = False\\n \\n if kwargs.has_key('fixei'):\\n reducer.fix_ei = kwargs.get('fixei')\\n print 'Setting fixei to ', kwargs.get('fixei')\\n else:\\n reducer.fix_ei = False\\n \\n if kwargs.has_key('save_format'):\\n reducer.save_formats = kwargs.get('save_format')\\n print 'Setting save format to ', kwargs.get('save_format')\\n else:\\n reducer.save_formats = ['.spe']\\n #Set parameters for the run\\n \\n if kwargs.has_key('detector_van_range'):\\n reducer.wb_integr_range = kwargs.get('detector_van_range')\\n print 'Setting detector van int range to ', kwargs.get('detector_van_range')\\n else:\\n reducer.wb_integr_range=[20,100]\\n \\n #######DIAG###########\\n if kwargs.has_key('bkgd_range'):\\n background_range = kwargs.get('bkgd_range')\\n print 'Setting background intergration to ', kwargs.get('bkgd_range')\\n else:\\n background_range=[15000,19000]\\n \\n if kwargs.has_key('tiny'):\\n tinyval = kwargs.get('tiny')\\n print 'Setting tiny ratelimit to ', kwargs.get('tiny')\\n else:\\n tinyval=1e-10\\n \\n if kwargs.has_key('large'):\\n largeval = kwargs.get('large')\\n print 'Setting large limit to ', kwargs.get('large')\\n else:\\n largeval=1e10\\n \\n if kwargs.has_key('diag_remove_zero'):\\n sampzero = kwargs.get('diag_remove_zero')\\n print 'Setting diag to reject zero backgrounds '\\n else:\\n sampzero =False\\n \\n if kwargs.has_key('diag_van_median_rate_limit_hi'):\\n vanouthi = kwargs.get('diag_van_median_rate_limit_hi')\\n print 'Setting diag_van_median_rate_limit_hi to ', kwargs.get('diag_van_median_rate_limit_hi')\\n else:\\n vanouthi=100\\n \\n if kwargs.has_key('diag_van_median_rate_limit_lo'):\\n vanoutlo = kwargs.get('diag_van_median_rate_limit_lo')\\n print 'Setting diag_van_median_rate_limit_lo to ', kwargs.get('diag_van_median_rate_limit_lo')\\n else:\\n vanoutlo=0.01\\n \\n if kwargs.has_key('diag_van_median_sigma_lo'):\\n vanlo = kwargs.get('diag_van_median_sigma_lo')\\n print 'Setting diag_van_median_sigma_lo to ', kwargs.get('diag_van_median_sigma_lo')\\n else:\\n vanlo=0.1\\n \\n if kwargs.has_key('diag_van_median_sigma_hi'):\\n vanhi = kwargs.get('diag_van_median_sigma_hi')\\n print 'Setting diag_van_median_sigma_hi to ', kwargs.get('diag_van_median_sigma_hi')\\n else:\\n vanhi=1.5\\n \\n if kwargs.has_key('diag_van_median_sigma'):\\n vansig = kwargs.get('diag_van_median_sigma')\\n print 'Setting diag_van_median_sigma to ', kwargs.get('diag_van_median_sigma')\\n else:\\n vansig=0.0\\n \\n if kwargs.has_key('diag_samp_median_sigma_lo'):\\n samplo = kwargs.get('diag_samp_median_sigma_lo')\\n print 'Setting diag_samp_median_sigma_lo to ', kwargs.get('diag_samp_median_sigma_lo')\\n else:\\n samplo=0.0\\n \\n if kwargs.has_key('diag_samp_median_sigma_hi'):\\n samphi = kwargs.get('diag_samp_median_sigma_hi')\\n print 'Setting diag_samp_median_sigma_hi to ', kwargs.get('diag_samp_median_sigma_hi')\\n else:\\n samphi=2.0\\n \\n if kwargs.has_key('diag_samp_median_sigma'):\\n sampsig = kwargs.get('diag_samp_median_sigma')\\n print 'Setting diag_samp_median_sigma to ', kwargs.get('diag_samp_median_sigma')\\n else:\\n sampsig=3.0\\n \\n if kwargs.has_key('bleed'):\\n bleed_switch = kwargs.get('bleed')\\n print 'Setting bleed ', kwargs.get('bleed')\\n else:\\n print 'bleed set to default'\\n #####diad end########\\n \\n \\n if kwargs.has_key('det_cal_file'):\\n reducer.det_cal_file = kwargs.get('det_cal_file')\\n reducer.relocate_dets = True\\n print 'Setting detector calibration file to ', kwargs.get('det_cal_file')\\n else:\\n print 'Setting detector calibration to detector block info from ', sample_run\\n reducer.det_cal_file =None\\n reducer.relocate_dets = False\\n \\n if mtd.doesExist(str(sample_run))==True and kwargs.has_key('det_cal_file')==False:\\n print 'For data input type: workspace detector calibration must be specified'\\n print 'use Keyword det_cal_file with a valid detctor file or run number'\\n return\\n \\n \\n if kwargs.has_key('one2one'):\\n reducer.map_file =None\\n map_file = \\\"\\\"\\n print 'one2one selected'\\n else:\\n fileName, fileExtension = os.path.splitext(map_file)\\n if (not fileExtension):\\n map_file = map_file+'.map'\\n reducer.map_file = map_file;\\n \\n if kwargs.has_key('hardmaskPlus'):\\n HardMaskFile = kwargs.get('hardmaskPlus')\\n print 'Use hardmask from ', HardMaskFile\\n #hardMaskSpec=common.load_mask(HardMaskFile)\\n #MaskDetectors(Workspace='masking',SpectraList=hardMaskSpec)\\n else:\\n HardMaskFile=None\\n \\n reducer.energy_bins = rebin\\n #monovan info\\n fileName, fileExtension = os.path.splitext(monovan_mapfile)\\n if (not fileExtension):\\n monovan_mapfile=monovan_mapfile+'.map'\\n reducer.abs_map_file =monovan_mapfile \\n\\n if kwargs.has_key('abs_units_van_range'):\\n reducer.monovan_integr_range = kwargs.get('abs_units_van_range')\\n print 'Setting absolute units vanadium integration range to: ', kwargs.get('abs_units_van_range')\\n else:\\n reducer.monovan_integr_range=[-40,40]\\n\\n \\n \\n print 'output will be normalised to', reducer.normalise_method\\n if (numpy.size(sample_run)) > 1 and kwargs.has_key('sum') and kwargs.get('sum')==True:\\n #this sums the runs together before passing the summed file to the rest of the reduction\\n #this circumvents the inbuilt method of summing which fails to sum the files for diag\\n \\n sumfilename=str(sample_run[0])+'sum'\\n accum=sum_files(sumfilename, sample_run)\\n #the D.E.C. tries to be too clever so we have to fool it into thinking the raw file is already exists as a workpsace\\n RenameWorkspace(InputWorkspace=accum,OutputWorkspace=inst_name+str(sample_run[0])+'.raw')\\n sample_run=sample_run[0]\\n \\n if kwargs.has_key('hardmaskOnly'):\\n if (kwargs.get('hardmaskOnly')): \\n totalmask = kwargs.get('hardmaskOnly')\\n print 'Using hardmask from ', totalmask\\n #next stable version can replace this with loadmask algoritum\\n specs=diag_load_mask(totalmask)\\n else:\\n specs=\\\"\\\"\\n \\n CloneWorkspace(InputWorkspace=sample_run,OutputWorkspace='mask_wksp')\\n MaskDetectors(Workspace='mask_wksp',SpectraList=specs)\\n masking =mtd['mask_wksp']\\n else:\\n print '########### Run diagnose for sample run ##############'\\n masking = reducer.diagnose(wb_run, \\n sample=mask_run,\\n second_white = None,\\n tiny=tinyval, \\n huge=largeval, \\n van_out_lo=vanoutlo,\\n van_out_hi=vanouthi,\\n van_lo=vanlo,\\n van_hi=vanhi,\\n van_sig=vansig,\\n samp_zero=sampzero,\\n samp_lo=samplo,\\n samp_hi=samphi,\\n samp_sig=sampsig,\\n bkgd_range=background_range, \\n variation=1.1,\\n print_results=True,\\n bleed_test=bleed_switch,\\n bleed_maxrate=rate,\\n bleed_pixels=pixels,\\n hard_mask=HardMaskFile)\\n \\n fail_list,n_total_spectra =get_failed_spectra_list_from_masks(masking) \\n print 'first Diag found ', len(fail_list),'bad spectra out of: ',n_total_spectra,' ws spectra'\\n \\n if kwargs.has_key('use_sam_msk_on_monovan') and kwargs.get('use_sam_msk_on_monovan')==True:\\n print 'applying sample run mask to mono van'\\n reducer.spectra_masks=masking\\n fail_list=get_failed_spectra_list(masking) \\n else:\\n print '########### Run diagnose for monochromatic vanadium run ##############'\\n masking2 = reducer.diagnose(wb_mono, \\n sample=mono_van,\\n second_white = None,\\n tiny=tinyval, \\n huge=largeval, \\n van_out_lo=vanoutlo,\\n van_out_hi=vanouthi,\\n van_lo=vanlo,\\n van_hi=vanhi,\\n van_sig=vansig,\\n samp_zero=sampzero,\\n samp_lo=samplo,\\n samp_hi=samphi,\\n samp_sig=sampsig,\\n bkgd_range=background_range, \\n variation=1.1,\\n print_results=True,\\n bleed_test=bleed_switch,\\n bleed_maxrate=rate,\\n bleed_pixels=pixels,\\n hard_mask=HardMaskFile)\\n \\n total_mask=masking+masking2 \\n reducer.spectra_masks=total_mask \\n fail_list,n_total_spectra =get_failed_spectra_list_from_masks(total_mask)\\n #fail_list=get_failed_spectra_list('total_mask')\\n \\n \\n print 'Diag found ', len(fail_list),'bad spectra out of: ',n_total_spectra,' ws spectra'\\n \\n \\n \\n #Run the conversion first on the sample\\n deltaE_wkspace_sample = reducer.convert_to_energy(sample_run, ei_guess, wb_run)\\n\\n \\n if kwargs.has_key('mono_correction_factor'):\\n absnorm_factor=kwargs.get('mono_correction_factor')\\n print 'Using supplied correction factor for absolute units'\\n else:\\n print '##### Evaluate the integral from the monovan run and calculate the correction factor ######'\\n print ' Using absolute units vanadion integration range : ', reducer.monovan_integr_range \\n #now on the mono_vanadium run swap the mapping file\\n reducer.map_file = monovan_mapfile \\n deltaE_wkspace_monovan = reducer.convert_to_energy(mono_van, ei_guess, wb_mono)\\n \\n (absnorm_factorL,absnorm_factorSS,absnorm_factorP,absnorm_factTGP) = getAbsNormalizationFactor(deltaE_wkspace_monovan.getName(),str(reducer.monovan_integr_range[0]),str(reducer.monovan_integr_range[1])) \\n \\n print 'Absolute correction factor S^2 =',absnorm_factorSS,' Libisis: ',absnorm_factorL,' Puasonian: ',absnorm_factorP, ' TGP : ',absnorm_factTGP\\n CreateSingleValuedWorkspace(OutputWorkspace='AbsFactor',DataValue=absnorm_factTGP)\\n end_time=time.time()\\n results_name=str(sample_run)+'.spe'\\n ei= (deltaE_wkspace_sample.getRun().getLogData(\\\"Ei\\\").value)\\n \\n if mtd.doesExist('_wksp.spe-white')==True:\\n DeleteWorkspace(Workspace='_wksp.spe-white')\\n \\n \\n print 'Incident energy found for sample run ',ei,' meV'\\n print 'Incident energy found for mono vanadium run ',ei,' meV'\\n print 'Elapsed time =',end_time-start_time, 's'\\n #get the name that convert to energy will use\\n \\n if mtd.doesExist(results_name)==False:\\n RenameWorkspace(InputWorkspace=deltaE_wkspace_sample,OutputWorkspace=results_name)\\n if results_name != wksp_out:\\n RenameWorkspace(InputWorkspace=results_name,OutputWorkspace=wksp_out)\\n Divide(LHSWorkspace=wksp_out,RHSWorkspace='AbsFactor',OutputWorkspace=wksp_out)\\n DeleteWorkspace(Workspace='AbsFactor')\\n return mtd[wksp_out]\",\n \"def _plot_comparison(xs, pan, other_program_name, **kw):\\n\\n pans = ['Bmax', 'Emax']\\n units = ['(mG)', '(kV/m)']\\n title_app = [', Max Magnetic Field', ', Max Electric Field']\\n save_suf = ['-%s-comparison-Bmax' % other_program_name,\\n '-%s-comparison-Emax' % other_program_name]\\n\\n for p,u,t,s in zip(pans, units, title_app, save_suf):\\n #figure object and axes\\n fig = plt.figure()\\n ax_abs = fig.add_subplot(2,1,1)\\n ax_per = ax_abs.twinx()\\n ax_mag = fig.add_subplot(2,1,2)\\n #Bmax\\n #init handles and labels lists for legend\\n kw['H'], kw['L'] = [], []\\n _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, p, u,\\n other_program_name, **kw)\\n _plot_wires(ax_mag, xs.hot, xs.gnd, pan['emf.fields-results'][p], **kw)\\n _check_und_conds([xs], [ax_mag], **kw)\\n ax_abs.set_title('Absolute and Percent Difference' + t)\\n ax_mag.set_ylabel(p + ' ' + u)\\n ax_mag.set_title('Model Results' + t)\\n ax_mag.legend(kw['H'], kw['L'], **_leg_kw)\\n _color_twin_axes(ax_abs, mpl.rcParams['axes.labelcolor'], ax_per, 'firebrick')\\n _format_line_axes_legends(ax_abs, ax_per, ax_mag)\\n #_format_twin_axes(ax_abs, ax_per)\\n _save_fig(xs.sheet + s, fig, **kw)\",\n \"def ISM_fractions_per_cell(**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n # Load sim and cell data\\n gal_ob = gal.galaxy(p.gal_index)\\n cell_data = gal_ob.cell_data.get_dataframe()\\n\\n if p.add:\\n ax = plt.gca()\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n\\n x = ax.hist(np.log10(cell_data['mf_H2_grid']),bins=100,alpha=0.6,label='H2',color='r')\\n x = ax.hist(np.log10(cell_data['mf_HI_grid']),bins=100,alpha=0.6,label='HI',color='orange')\\n x = ax.hist(np.log10(cell_data['mf_HII_grid']),bins=100,alpha=0.4,label='HII',color='b')\\n ax.set_xlabel('log Mass fraction per cell')\\n ax.set_ylabel('# cells')\\n ax.set_yscale('log')\\n ax.legend()\\n\\n print('Mass fraction of cells with >90\\\\% ionized gas:')\\n cell_data1 = cell_data[cell_data['mf_HII_grid'] > 0.9]\\n print('%.4f %%' % (100.*np.sum(cell_data1['mf_HII_grid']*cell_data1['m'])/np.sum(cell_data['m'])))\\n\\n print('Mass fraction of total ionized gas:')\\n print('%.4f %%' % (100.*np.sum(cell_data['mf_HII_grid']*cell_data['m'])/np.sum(cell_data['m'])))\\n\\n print('---')\\n\\n print('Mass fraction of cells with >90\\\\% atomic gas:')\\n cell_data1 = cell_data[cell_data['mf_HI_grid'] > 0.9]\\n print('%.4f %%' % (100.*np.sum(cell_data1['mf_HI_grid']*cell_data1['m'])/np.sum(cell_data['m'])))\\n\\n print('Mass fraction of total atomic gas:')\\n print('%.4f %%' % (100.*np.sum(cell_data['mf_HI_grid']*cell_data['m'])/np.sum(cell_data['m'])))\\n\\n print('---')\\n\\n print('Mass fraction of cells with >90\\\\% molecular gas:')\\n cell_data1 = cell_data[cell_data['mf_H2_grid'] > 0.9]\\n print('%.4f %%' % (100.*np.sum(cell_data1['mf_H2_grid']*cell_data1['m'])/np.sum(cell_data['m'])))\\n\\n print('Mass fraction of total molecular gas:')\\n print('%.4f %%' % (100.*np.sum(cell_data['mf_H2_grid']*cell_data['m'])/np.sum(cell_data['m'])))\\n\\n if p.xlim: ax.set_xlim(p.xlim)\\n if p.ylim: ax.set_ylim(p.ylim)\",\n \"def calculate_relative_mags(self):\\n total = sum(self.mags)\\n self.rel_mags = []\\n for mag in self.mags:\\n try:\\n rel = mag/total\\n except ZeroDivisionError:\\n rel = 0\\n self.rel_mags.append(rel)\",\n \"def determinePlotLimits(self):\\n max_str = \\\"up99\\\"\\n min_str = \\\"dn99\\\"\\n if self.keywords.get(\\\"limit_type\\\",\\\"99per\\\") == \\\"minmax\\\":\\n max_str = \\\"max\\\"\\n min_str = \\\"min\\\"\\n \\n # Determine the min/max of variables over all models\\n limits = {}\\n prune = False\\n for fname in glob.glob(os.path.join(self.output_path,\\\"*.nc\\\")):\\n with Dataset(fname) as dataset:\\n if \\\"MeanState\\\" not in dataset.groups: continue\\n group = dataset.groups[\\\"MeanState\\\"]\\n variables = [v for v in group.variables.keys() if v not in group.dimensions.keys()]\\n for vname in variables:\\n var = group.variables[vname]\\n pname = vname.split(\\\"_\\\")[0]\\n region = vname.split(\\\"_\\\")[-1]\\n if var[...].size <= 1: continue\\n if space_opts.has_key(pname):\\n if not limits.has_key(pname):\\n limits[pname] = {}\\n limits[pname][\\\"min\\\"] = +1e20\\n limits[pname][\\\"max\\\"] = -1e20\\n limits[pname][\\\"unit\\\"] = post.UnitStringToMatplotlib(var.getncattr(\\\"units\\\"))\\n limits[pname][\\\"min\\\"] = min(limits[pname][\\\"min\\\"],var.getncattr(min_str))\\n limits[pname][\\\"max\\\"] = max(limits[pname][\\\"max\\\"],var.getncattr(max_str))\\n elif time_opts.has_key(pname):\\n if not limits.has_key(pname): limits[pname] = {}\\n if not limits[pname].has_key(region):\\n limits[pname][region] = {}\\n limits[pname][region][\\\"min\\\"] = +1e20\\n limits[pname][region][\\\"max\\\"] = -1e20\\n limits[pname][region][\\\"unit\\\"] = post.UnitStringToMatplotlib(var.getncattr(\\\"units\\\"))\\n limits[pname][region][\\\"min\\\"] = min(limits[pname][region][\\\"min\\\"],var.getncattr(\\\"min\\\"))\\n limits[pname][region][\\\"max\\\"] = max(limits[pname][region][\\\"max\\\"],var.getncattr(\\\"max\\\"))\\n if not prune and \\\"Benchmark\\\" in fname and pname == \\\"timeint\\\":\\n prune = True\\n self.pruneRegions(Variable(filename = fname,\\n variable_name = vname,\\n groupname = \\\"MeanState\\\"))\\n \\n # Second pass to plot legends (FIX: only for master?)\\n for pname in limits.keys():\\n\\n try:\\n opts = space_opts[pname]\\n except:\\n continue\\n \\n # Determine plot limits and colormap\\n if opts[\\\"sym\\\"]:\\n vabs = max(abs(limits[pname][\\\"min\\\"]),abs(limits[pname][\\\"min\\\"]))\\n limits[pname][\\\"min\\\"] = -vabs\\n limits[pname][\\\"max\\\"] = vabs\\n\\n # if a score, force to be [0,1]\\n if \\\"score\\\" in pname:\\n limits[pname][\\\"min\\\"] = 0\\n limits[pname][\\\"max\\\"] = 1\\n\\n limits[pname][\\\"cmap\\\"] = opts[\\\"cmap\\\"]\\n if limits[pname][\\\"cmap\\\"] == \\\"choose\\\": limits[pname][\\\"cmap\\\"] = self.cmap\\n\\n # Plot a legend for each key\\n if opts[\\\"haslegend\\\"]:\\n fig,ax = plt.subplots(figsize=(6.8,1.0),tight_layout=True)\\n label = opts[\\\"label\\\"]\\n if label == \\\"unit\\\": label = limits[pname][\\\"unit\\\"]\\n post.ColorBar(ax,\\n vmin = limits[pname][\\\"min\\\"],\\n vmax = limits[pname][\\\"max\\\"],\\n cmap = limits[pname][\\\"cmap\\\"],\\n ticks = opts[\\\"ticks\\\"],\\n ticklabels = opts[\\\"ticklabels\\\"],\\n label = label)\\n fig.savefig(os.path.join(self.output_path,\\\"legend_%s.png\\\" % (pname))) \\n plt.close()\\n\\n # Determine min/max of relationship variables\\n for fname in glob.glob(os.path.join(self.output_path,\\\"*.nc\\\")):\\n with Dataset(fname) as dataset:\\n for g in dataset.groups.keys():\\n if \\\"relationship\\\" not in g: continue\\n grp = dataset.groups[g]\\n if not limits.has_key(g):\\n limits[g] = {}\\n limits[g][\\\"xmin\\\"] = +1e20\\n limits[g][\\\"xmax\\\"] = -1e20\\n limits[g][\\\"ymin\\\"] = +1e20\\n limits[g][\\\"ymax\\\"] = -1e20\\n limits[g][\\\"xmin\\\"] = min(limits[g][\\\"xmin\\\"],grp.variables[\\\"ind_bnd\\\"][ 0, 0])\\n limits[g][\\\"xmax\\\"] = max(limits[g][\\\"xmax\\\"],grp.variables[\\\"ind_bnd\\\"][-1,-1])\\n limits[g][\\\"ymin\\\"] = min(limits[g][\\\"ymin\\\"],grp.variables[\\\"dep_bnd\\\"][ 0, 0])\\n limits[g][\\\"ymax\\\"] = max(limits[g][\\\"ymax\\\"],grp.variables[\\\"dep_bnd\\\"][-1,-1])\\n\\n \\n self.limits = limits\",\n \"def ResBeam_Stats_plot(n, header_bmaj, header_bmin): \\n\\n file_dir = 'SpectralCube_BeamLogs'\\n basename = '/beamlog.image.restored.' + imagebase + field\\n\\n # use different basename for the Milky Way range\\n if not glob.glob(file_dir + basename +'*.txt'):\\n basename = '/beamlog.image.restored.' + imagebase + 'MilkyWay.' + field\\n\\n \\n BEAM_THRESHOLD = []\\n \\n title1 = 'Restoring beam bmaj standard deviation [arcsec]'\\n plt_name1 = 'BmajStdev.png'\\n saved_fig1 = fig_dir+'/'+plt_name1\\n\\n title2 = 'Restoring beam bmin standard deviation [arcsec]'\\n plt_name2 = 'BminStdev.png'\\n saved_fig2 = fig_dir+'/'+plt_name2\\n\\n title3 = 'Maximum ratio of beam area'\\n plt_name3 = 'max_ratioBA.png'\\n saved_fig3 = fig_dir+'/'+plt_name3\\n\\n title4 = 'Minimum ratio of beam area' \\n plt_name4 = 'min_ratioBA.png'\\n saved_fig4 = fig_dir+'/'+plt_name4\\n \\n params = {'axes.labelsize': 10,\\n 'axes.titlesize': 10,\\n 'font.size':10}\\n\\n pylab.rcParams.update(params)\\n\\n beamXPOS, beamYPOS = BeamPosition()\\n fig1, ax1 = plt.subplots()\\n fig2, ax2 = plt.subplots()\\n fig3, ax3 = plt.subplots()\\n fig4, ax4 = plt.subplots()\\n \\n for i in range(0,36):\\n bnum = n[i]\\n infile = file_dir + basename +'.beam%02d.txt'%(bnum)\\n bmaj_stdev, bmin_stdev, beam_threshold, max_ratio_BA, min_ratio_BA = cal_ResBeam_Stats(infile, header_bmaj, header_bmin)\\n BEAM_THRESHOLD.append(beam_threshold)\\n\\n ax1.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\\n ax1.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax1.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmaj_stdev, 3), va='center', ha='center', fontsize=8, color='blue')\\n\\n ax2.scatter([beamXPOS[i]], [beamYPOS[i]], s=1400, edgecolors='black', facecolors='none')\\n ax2.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax2.text(beamXPOS[i], beamYPOS[i]-0.02, round(bmin_stdev,3), va='center', ha='center', fontsize=8, color='blue')\\n\\n maxplot = ax3.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[max_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\\n ax3.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax3.text(beamXPOS[i], beamYPOS[i]-0.02, round(max_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\\n \\n minplot = ax4.scatter([beamXPOS[i]], [beamYPOS[i]], s=1300, c=[min_ratio_BA], cmap='summer', edgecolors='black', vmin=0, vmax=1.1)\\n ax4.text(beamXPOS[i], beamYPOS[i]+0.02, n[i], va='center', ha='center')\\n ax4.text(beamXPOS[i], beamYPOS[i]-0.02, round(min_ratio_BA,3), va='center', ha='center', fontsize=8, color='blue')\\n \\n ax1.set_xlim(0,0.7)\\n ax1.set_ylim(0,1.4)\\n ax1.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax1.set_title(title1)\\n\\n ax2.set_xlim(0,0.7)\\n ax2.set_ylim(0,1.4)\\n ax2.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax2.set_title(title2)\\n\\n ax3.set_xlim(0,0.7)\\n ax3.set_ylim(0,1.4)\\n ax3.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax3.set_title(title3)\\n plt.colorbar(maxplot, ax=ax3)\\n\\n ax4.set_xlim(0,0.7)\\n ax4.set_ylim(0,1.4)\\n ax4.tick_params(axis='both',which='both', bottom=False,top=False,right=False,left=False,labelbottom=False, labelleft=False)\\n ax4.set_title(title4)\\n plt.colorbar(minplot, ax=ax4)\\n\\n fig1.savefig(saved_fig1, bbox_inches='tight')\\n fig2.savefig(saved_fig2, bbox_inches='tight')\\n fig3.savefig(saved_fig3, bbox_inches='tight')\\n fig4.savefig(saved_fig4, bbox_inches='tight')\\n\\n plt.close('all')\\n\\n return saved_fig1, saved_fig2, plt_name1, plt_name2, saved_fig3, saved_fig4, plt_name3, plt_name4, BEAM_THRESHOLD\",\n \"def comparison_plot(input_file, input_pm_file, output_file, titles=None, cut=None):\\n\\n # get titles for each subplot and dwarf proper motions\\n titles, dwarf_pmra, dwarf_pmdec = load_dwarf_info(input_file, titles)\\n\\n # load stellar pm values\\n ra, dec, pmra, pmdec, parallax, parallax_error = load_gaia_search_info(input_pm_file)\\n\\n # set fig size and shape\\n fig, axs = plot_setup(3, 3)\\n\\n # choose how many dwarfs to compare\\n counter = range(0, 3)\\n\\n # plot each dwarf in separate subplots\\n for (i, title, *data) in zip(counter, titles, ra, dec, pmra, pmdec, parallax, parallax_error):\\n # add quiver plot\\n arrows = quiver_plot(fig, axs[i, 0], data, title, append_title=\\\" quiver\\\", cut=cut)\\n\\n # generate parallax histogram\\n n, bins, patches = parallax_histogram(fig, axs[i, 1], data, title, append_title=\\\" parallax\\\", cut=cut)\\n\\n # add pm 2d histograms\\n counts, xedges, yedges, im = pm_histogram(fig, axs[i, 2], data, title, append_title=\\\" pm histo\\\", dwarf_pmra=dwarf_pmra[i], dwarf_pmdec=dwarf_pmdec[i], cut=cut)\\n\\n plt.tight_layout()\\n\\n\\n fig.savefig(output_file, bbox_inches='tight')\",\n \"def plotMSSpectra3D(listOfFilesToPlot, listOfNames=None, listOfColors=None, gridLines=False, yMin=0.5, yMax=2.5, yScale = 1.0,\\r\\n legend=True, normalizeToN15=False, subtractRef=None, legendLoc=4, lw=1.5, xMin=0, xMax=2000, scaleP=False, scaleI=0, scaleVal=1.0,\\r\\n figsize=(10,10), tLeft=0, tRight=-1, fixedOffset=False, noTicks=False, xlabel='mass', zlabel='intensity', a14=1.0): \\r\\n if listOfNames==None:\\r\\n listOfNames = listOfFilesToPlot\\r\\n if listOfColors==None:\\r\\n listOfColors = [pylab.cm.jet(float(i)/float(len(listOfFilesToPlot))) for i in range(len(listOfFilesToPlot))]\\r\\n \\r\\n fig = pylab.figure(figsize=figsize)\\r\\n ax = fig.add_subplot(111, projection='3d')\\r\\n\\r\\n yTotal = len(listOfFilesToPlot)\\r\\n top = 0.0\\r\\n\\r\\n if not (subtractRef is None):\\r\\n [bhah, zsRef, blah] = qMS.readMSSpectraFile(listOfFilesToPlot[subtractRef])\\r\\n #zsRef = list(numpy.array(zsRef)-fixedOffset\\r\\n zNorm = max(zsRef[len(zsRef)/2:])\\r\\n zsRef = numpy.array(zsRef)/zNorm\\r\\n \\r\\n for i,f in enumerate(listOfFilesToPlot):\\r\\n [xs, zs, name] = qMS.readMSSpectraFile(f)\\r\\n if fixedOffset:\\r\\n off = zs[len(zs)/2]\\r\\n print off\\r\\n #zs = list(numpy.array(zs)-zs[len(zs)/2])\\r\\n zs = list(numpy.array(zs)-off)\\r\\n ys = [yTotal-i]*len(xs)\\r\\n ys = numpy.array(ys)*yScale\\r\\n if normalizeToN15:\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n if not (subtractRef is None):\\r\\n zNorm = max(zs[len(zs)/2:])\\r\\n zs = numpy.array(zs)/zNorm\\r\\n zs[:len(zsRef)/2] = zs[:len(zs)/2]-zsRef[:len(zsRef)/2]\\r\\n zs = zs*zNorm\\r\\n #xs = xs[:len(xs)/2]\\r\\n #ys = ys[:len(ys)/2]\\r\\n #zs = zs[:len(zs)/2]\\r\\n zs[:len(zs)/2] = numpy.array(zs[:len(zs)/2])*a14\\r\\n if (scaleP is True) and (i==scaleI):\\r\\n zs = numpy.array(zs)*scaleVal\\r\\n ax.plot(numpy.array(xs[tLeft:tRight]),numpy.array(ys[tLeft:tRight]),numpy.array(zs[tLeft:tRight]), color=listOfColors[i], lw=lw, label=listOfNames[i])\\r\\n top = max([top, float(max(zs))])\\r\\n\\r\\n\\r\\n ax.w_xaxis.pane.set_visible(False)\\r\\n ax.w_yaxis.pane.set_visible(False)\\r\\n ax.w_zaxis.pane.set_visible(False)\\r\\n\\r\\n if gridLines: \\r\\n ax.w_xaxis.gridlines.set_linewidth(1)\\r\\n ax.w_yaxis.gridlines.set_linewidth(1)\\r\\n ax.w_zaxis.gridlines.set_linewidth(1)\\r\\n \\r\\n else:\\r\\n ax.w_xaxis.gridlines.set_visible(False)\\r\\n ax.w_yaxis.gridlines.set_visible(False)\\r\\n ax.w_zaxis.gridlines.set_visible(False)\\r\\n\\r\\n [i.set_linewidth(1) for i in ax.w_xaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_yaxis.get_ticklines()]\\r\\n [i.set_linewidth(1) for i in ax.w_zaxis.get_ticklines()]\\r\\n\\r\\n ax.w_xaxis.line.set_linewidth(1)\\r\\n ax.w_yaxis.line.set_linewidth(1)\\r\\n ax.w_zaxis.line.set_linewidth(1)\\r\\n \\r\\n ax.set_zticks([round(i,1) for i in [0, top/3, 2*top/3, top]])\\r\\n ax.set_zlim3d([0, top])\\r\\n ax.set_ylim3d(yMin, yMax)\\r\\n ax.set_yticks(range(1,yTotal+1))\\r\\n pylab.yticks(range(1,yTotal+1), ['']*yTotal)\\r\\n ax.set_xlim3d([xMin, xMax])\\r\\n \\r\\n if noTicks:\\r\\n ax.set_zticks([])\\r\\n ax.set_xticks([])\\r\\n ax.set_yticks([])\\r\\n\\r\\n ax.set_xlabel(xlabel)\\r\\n ax.set_zlabel(zlabel)\\r\\n\\r\\n ax.view_init(15, -60)\\r\\n if legend:\\r\\n pylab.legend(loc=legendLoc)\\r\\n \\r\\n pylab.tight_layout()\\r\\n return ax\",\n \"def perSaccPerObject(addExp2 = True, trim = True, spacing = .5, addSimulation = True, \\\\\\n\\t\\texclOverlap = True):\\n\\n\\t\\n\\tfig = plt.figure()\\n\\tplt.subplots_adjust(wspace = .5)\\n\\t#fig = plt.figure(figsize = (10,10))\\n\\ttitle = \\\"Average towards-handle landings per stimulus exclOverlap = %s\\\" % exclOverlap\\n\\tplt.suptitle(title)\\n\\t\\n\\t\\n\\t# Exp 1:\\n\\tdm1 = getDM.getDM(exp = \\\"004A\\\", excludeErrors = True, driftCorr = True)\\n\\t\\n\\tsubPlot = 1\\n\\t\\n\\tfor stim in dm1.unique(\\\"object\\\"):\\n\\n\\t\\t# New subplot:\\n\\t\\tplt.subplot(2,7,subPlot)\\n\\t\\t#plt.title(stim)\\n\\t\\t_dm1 = dm1.select(\\\"object == '%s'\\\" % stim)\\n\\n\\t\\tlLandingsAbs = []\\n\\t\\tlLandingsCorr = []\\n\\t\\t\\n\\t\\tfor sacc in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\n\\t\\t\\t\\n\\t\\t\\t# This is the same for corrected landing positions (the saccade\\n\\t\\t\\t# doesn't change; only the reference point does)\\n\\t\\t\\t_dm = _dm1.select(\\\"endX%sNorm != ''\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endX%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endX%sNorm < .5\\\" % sacc)\\n\\t\\t\\t\\n\\t\\t\\tif trim:\\n\\t\\t\\t\\t_dmAbs = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sNormToHandle\\\" % sacc)\\n\\t\\t\\t\\t_dmCorr = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sCorrNormToHandle\\\" % sacc)\\n\\t\\t\\t\\n\\t\\t\\t# Determine avg landing position:\\n\\t\\t\\tavgAbs = _dmAbs[\\\"endX%sNormToHandle\\\" % sacc].mean()\\n\\t\\t\\tavgCorr = _dmCorr[\\\"endX%sCorrNormToHandle\\\" % sacc].mean()\\n\\t\\t\\t\\n\\t\\t\\t# TODO: determine error bars:\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tlLandingsAbs.append(avgAbs)\\n\\t\\t\\tlLandingsCorr.append(avgCorr)\\n\\t\\t\\n\\t\\tplt.plot(lLandingsAbs, color = \\\"#f57900\\\", linewidth = 2, marker = \\\"o\\\")\\n\\t\\tplt.plot(lLandingsCorr, color = \\\"#73d216\\\", linewidth = 2, marker = \\\"o\\\")\\n\\t\\tplt.ylabel(stim)\\n\\t\\t\\n\\t\\t# The other 2 experiments can be treated equally:\\n\\t\\tcolList = [\\\"#ef2929\\\", \\\"#3465a4\\\"]\\n\\t\\t\\n\\t\\tfor exp in [\\\"004B\\\", \\\"004C\\\"]:\\n\\t\\t\\t\\n\\t\\t\\tif not addExp2:\\n\\t\\t\\t\\tif exp == \\\"004B\\\":\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\tif not addSimulation:\\n\\t\\t\\t\\tif exp == \\\"004C\\\":\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tdm = getDM.getDM(exp = exp, excludeErrors = True, driftCorr = True)\\n\\t\\t\\t_dm = dm.select(\\\"object == '%s'\\\" % stim)\\n\\t\\t\\t\\n\\t\\t\\tif exp == \\\"004C\\\":\\n\\t\\t\\t\\tif exclOverlap:\\n\\t\\t\\t\\t\\t_dm = _dm.select(\\\"gap == 'zero'\\\")\\n\\t\\t\\t\\n\\t\\t\\tlLandingsAbs = []\\n\\t\\t\\t\\n\\t\\t\\tfor sacc in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# TODO: how to filter only on-object saccades exp 2??\\n\\t\\t\\t\\tsacc_dm = _dm.select(\\\"endX%sNorm != ''\\\" % sacc)\\n\\t\\t\\t\\tsacc_dm = sacc_dm.select(\\\"endX%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t\\tsacc_dm = sacc_dm.select(\\\"endX%sNorm < .5\\\" % sacc)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif trim:\\n\\t\\t\\t\\t\\tsacc_dm = sacc_dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sNormToHandle\\\" % sacc)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Determine avg landing position:\\n\\t\\t\\t\\tavgAbs = sacc_dm[\\\"endX%sNormToHandle\\\" % sacc].mean()\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# TODO: determine error bars:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tlLandingsAbs.append(avgAbs)\\n\\t\\t\\tcol = colList.pop()\\n\\t\\t\\tplt.plot(lLandingsAbs, color = col, linewidth = 2, marker = \\\"o\\\")\\n\\t\\t\\t\\n\\t\\t# Modify plot:\\n\\t\\t#plt.legend([\\\"Exp1 abs\\\", \\\"Exp1 corr\\\", \\\"Exp2\\\", \\\"Sim\\\"])\\n\\t\\t\\t\\n\\t\\tplt.axhline(0, color = \\\"#888a85\\\", linestyle = \\\"--\\\", linewidth = 2)\\n\\t\\txLabels = [\\\"sacc 1\\\", \\\"sacc 2\\\", \\\"sacc 3\\\"]\\n\\t\\txTicks = range(0,3)\\n\\t\\t#plt.xticks(xTicks, xLabels, rotation = .5)\\n\\t\\tplt.ylim([-.5, .5])\\n\\t\\tplt.yticks([])\\n\\t\\tplt.xticks([])\\n\\t\\tplt.xlim(min(xTicks)-spacing, max(xTicks)+spacing)\\n\\t\\t\\n\\t\\tsubPlot +=1\\n\\t\\t\\n\\tplt.savefig(\\\"%s.png\\\" % title)\",\n \"def calculate_abs(self):\\n ref_spectra_raw = np.array(self.raw_data['spectrum_0'].attrs['reference'])\\n self.ref_spectra_arr = np.subtract(ref_spectra_raw,self.back_spectra_arr)\\n abs=-np.log10(self.pre_proc_data.div(self.ref_spectra_arr))\\n self.abs_data=abs\\n return self.abs_data\",\n \"def draco_comparison_plot(input_file, input_pm_file, output_file, cuts, dwarf=0, titles=None, radius=0):\\n\\n # get titles for each subplot and dwarf proper motions\\n titles, dwarf_pmra, dwarf_pmdec = load_dwarf_info(input_file, titles)\\n\\n # load stellar pm values\\n ra, dec, pmra, pmdec, parallax, parallax_error = load_gaia_search_info(input_pm_file)\\n\\n # set fig size and shape\\n fig, axs = plot_setup(len(cuts), 3)\\n\\n # plot each dwarf in separate subplots\\n for j, (title, *data) in enumerate(zip(titles, ra, dec, pmra, pmdec, parallax, parallax_error)):\\n if j==dwarf:\\n for i, cut in enumerate(cuts):\\n # add quiver plot\\n arrows = quiver_plot(fig, axs[i, 0], data, f\\\"{title.strip('NAME ')} quiver\\\", cut=cut, radius=radius)\\n\\n # generate parallax histogram\\n n, bins, patches = parallax_histogram(fig, axs[i, 1], data, rf\\\"{title.strip('NAME ')} parallax, cut={cut}$\\\\sigma$\\\", cut=cut)\\n\\n # add pm 2d histograms\\n counts, xedges, yedges, im = pm_histogram(fig, axs[i, 2], data, f\\\"{title.strip('NAME ')} pm histo\\\", dwarf_pmra=dwarf_pmra[j], dwarf_pmdec=dwarf_pmdec[j], cut=cut)\\n\\n plt.tight_layout()\\n\\n\\n fig.savefig(output_file, bbox_inches='tight')\",\n \"def plot_feeding_zones_and_power_law_fit_MMEN_per_system_observed_and_physical(sssp_per_sys, sssp, n_mult_min=2, n_mult_max=10, max_core_mass=10., prescription='CL2013', n=10., a0=1., p0=1., p1=-1.5, scale_up=False, N_sys=10):\\n y_sym_star = '*' if scale_up else ''\\n assert 2 <= n_mult_min <= n_mult_max\\n count = 0\\n for i,det_sys in enumerate(sssp_per_sys['det_all']):\\n if count >= N_sys:\\n break\\n if n_mult_min <= np.sum(det_sys) <= n_mult_max:\\n count += 1\\n print('##### System %s (i=%s):' % (count, i))\\n\\n Mstar = sssp['Mstar_all'][i]\\n Mp_sys = sssp_per_sys['mass_all'][i]\\n core_mass_sys = np.copy(Mp_sys) # all planet masses including padded zeros\\n core_mass_sys[core_mass_sys > max_core_mass] = max_core_mass\\n R_sys = sssp_per_sys['radii_all'][i] # all planet radii including padded zeros\\n a_sys = sssp_per_sys['a_all'][i] # all semimajor axes including padded zeros\\n\\n core_mass_sys_obs = np.copy(Mp_sys)[det_sys == 1] # masses of observed planets\\n core_mass_sys_obs[core_mass_sys_obs > max_core_mass] = max_core_mass\\n R_sys_obs = R_sys[det_sys == 1] # radii of observed planets\\n a_sys_obs = a_sys[det_sys == 1] # semimajor axes of observed planets\\n core_mass_sys = core_mass_sys[a_sys > 0] # masses of all planets\\n R_sys = R_sys[a_sys > 0] # radii of all planets\\n a_sys = a_sys[a_sys > 0] # semimajor axes of all planets\\n\\n sigma_sys = solid_surface_density_prescription(core_mass_sys, R_sys, a_sys, Mstar=Mstar, n=n, prescription=prescription) # using all planets\\n sigma_sys_obs = solid_surface_density_prescription(core_mass_sys_obs, R_sys_obs, a_sys_obs, Mstar=Mstar, n=n, prescription=prescription) # using observed planets only\\n\\n if scale_up:\\n sigma0, beta, scale_factor_sigma0 = fit_power_law_and_scale_up_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\\n sigma0_obs, beta_obs, scale_factor_sigma0_obs = fit_power_law_and_scale_up_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\\n else:\\n sigma0, beta = fit_power_law_MMEN(a_sys, sigma_sys, a0=a0, p0=p0, p1=p1)\\n scale_factor_sigma0 = 1.\\n sigma0_obs, beta_obs = fit_power_law_MMEN(a_sys_obs, sigma_sys_obs, a0=a0, p0=p0, p1=p1)\\n scale_factor_sigma0_obs = 1.\\n\\n # Plot the system:\\n a_array = np.linspace(1e-3,2,1001)\\n sigma_MMSN = MMSN(a_array)\\n\\n delta_a_sys_S2014 = feeding_zone_S2014(core_mass_sys, R_sys, a_sys, Mstar=Mstar)\\n delta_a_sys_nHill = feeding_zone_nHill(core_mass_sys, a_sys, Mstar=Mstar, n=n)\\n delta_a_sys_RC2014, a_bounds_sys = feeding_zone_RC2014(a_sys)\\n\\n fig = plt.figure(figsize=(12,8))\\n plot = GridSpec(1,1,left=0.1,bottom=0.15,right=0.95,top=0.95,wspace=0,hspace=0)\\n ax = plt.subplot(plot[0,0])\\n plt.scatter(a_sys, np.log10(sigma_sys), marker='o', s=100.*R_sys**2., facecolors='none', edgecolors='k', label='All planets')\\n plt.scatter(a_sys_obs, np.log10(sigma_sys_obs), marker='o', s=100.*R_sys_obs**2., color='k', label='Observed planets')\\n for j,a in enumerate(a_sys):\\n # Plot various feeding zones for each planet:\\n da_S2014 = delta_a_sys_S2014[j]\\n da_nHill = delta_a_sys_nHill[j]\\n #da_RC2014 = delta_a_sys_RC2014[j]\\n #plt.plot([0.5*a, 1.5*a], [np.log10(1.15*sigma_sys[j])]*2, lw=1, color='k')\\n #plt.plot([a - da_S2014/2., a + da_S2014/2.], [np.log10(1.05*sigma_sys[j])]*2, lw=1, color='r')\\n #plt.plot([a - da_nHill/2., a + da_nHill/2.], [np.log10(0.95*sigma_sys[j])]*2, lw=1, color='b')\\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(0.85*sigma_sys[j])]*2, lw=1, color='m')\\n #plt.plot([a_bounds_sys[j], a_bounds_sys[j+1]], [np.log10(sigma_sys[j])]*2, lw=2, color='k') # lines for feeding zones\\n plt.axvspan(a_bounds_sys[j], a_bounds_sys[j+1], alpha=0.2 if j%2==0 else 0.1, ec=None, fc='k')\\n\\n # To compare the planet masses to the integrated disk masses:\\n Mp_core = core_mass_sys[j]\\n plt.annotate(r'${:0.1f} M_\\\\oplus$'.format(Mp_core), (a, np.log10(1.5*sigma_sys[j])), ha='center', fontsize=16)\\n if prescription == 'CL2013':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(1.5*a, 0.5*a, sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (CL2013): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n elif prescription == 'S2014':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_S2014/2., a - da_S2014/2., sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (S2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n elif prescription == 'nHill':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a + da_nHill/2., a - da_nHill/2., sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (nHill): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n elif prescription == 'RC2014':\\n Mp_intdisk = solid_mass_integrated_r0_to_r_given_power_law_profile(a_bounds_sys[j+1], a_bounds_sys[j], sigma0, beta, a0=a0)\\n print('Planet (core) mass: {:0.2f} M_earth --- Integrated disk mass (RC2014): {:0.2f} M_earth'.format(Mp_core, Mp_intdisk))\\n\\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0, beta, a0=a0)), lw=3, ls='-', color='r', label=r'Fit to all planets ($\\\\Sigma_0^%s = {:0.0f}$, $\\\\beta = {:0.2f}$)'.format(sigma0, beta) % y_sym_star)\\n plt.plot(a_array, np.log10(MMEN_power_law(a_array, sigma0_obs, beta_obs, a0=a0)), lw=3, ls='--', color='r', label=r'Fit to observed planets ($\\\\Sigma_0^%s = {:0.0f}$, $\\\\beta = {:0.2f}$)'.format(sigma0_obs, beta_obs) % y_sym_star)\\n plt.plot(a_array, np.log10(sigma_MMSN), lw=3, color='g', label=r'MMSN ($\\\\Sigma_0 = {:0.0f}$, $\\\\beta = {:0.2f}$)'.format(MMSN(a0), -1.5))\\n ax.tick_params(axis='both', labelsize=20)\\n plt.gca().set_xscale(\\\"log\\\")\\n plt.xticks([0.05, 0.1, 0.2, 0.4, 0.8])\\n ax.get_xaxis().set_major_formatter(ticker.ScalarFormatter())\\n plt.xlim([0.04,0.9])\\n plt.ylim([-0.5,5.5])\\n plt.xlabel(r'Semimajor axis, $a$ (AU)', fontsize=20)\\n plt.ylabel(r'Surface density, $\\\\log_{10}(\\\\Sigma/{\\\\rm g\\\\,cm}^{-2})$', fontsize=20)\\n plt.legend(loc='lower left', bbox_to_anchor=(0.,0.), ncol=1, frameon=False, fontsize=16)\\n\\n plt.show()\",\n \"def cauchy_rbins_fit(self, plotfig=False, plotrmax=50, normtype=1):\\n A0 = self.rbins.max()\\n gammaArr = np.arange(200)*.2 + .2 # double check\\n Amin, gamma_min, rms, rmsArr = _cauchy_rbins_fit(self.rArr, self.rbins, A0=A0, gammaArr=gammaArr, normtype=normtype)\\n self.rbins_pre = Amin/np.pi*(gamma_min/((self.rArr)**2+gamma_min**2) )\\n self.Amin = Amin\\n self.gamma_cauchy_rbins = gamma_min\\n self.rms = rms\\n temp = gammaArr[rmsArr<rms*1.1]\\n self.gmax = temp.max(); self.gmin = temp.min()\\n # print Amin, gamma_min, rms\\n if plotfig:\\n ax=plt.subplot()\\n plt.plot(self.rArr, self.rbins, 'o', ms=10, label='observed')\\n plt.plot(self.rArr, self.rbins_pre, 'k--', lw=3, label='Best fit Cauchy distribution')\\n # plt.plot(self.rArr, self.rbins_pre_gauss, 'r--', lw=3, label='Best fit Gaussian distribution')\\n plt.ylabel('PDF ', fontsize=30)\\n plt.xlabel('Radius (nm)', fontsize=30)\\n ax.tick_params(axis='x', labelsize=20)\\n ax.tick_params(axis='y', labelsize=20)\\n plt.legend(loc=0, fontsize=20, numpoints=1)\\n plt.yscale('log', nonposy='clip')\\n plt.xlim(0, plotrmax)\\n plt.ylim(1e-8, 0.1)\\n plt.show()\",\n \"def val_input(self):\\n global in_data\\n val_result = True\\n err_msg = ''\\n h_to_check = 'P_NAME;AZM_BRNG;DIST'\\n # Assign input to variables\\n rp_lat_dms = self.dlg.leRefLat.text() # Latitude of the reference point\\n rp_lon_dms = self.dlg.leRefLon.text() # Longitude of the reference point\\n rp_mv = self.dlg.leRefMagVar.text() # Magnetic variation of the reference point\\n in_csv = self.dlg.leInCsv.text() # Input csv file\\n out_csv = self.dlg.leOutCsv.text() # Output csv file\\n \\n r_lat = lat_DMS_shdp2DD(rp_lat_dms)\\n r_lon = lon_DMS_shdp2DD(rp_lon_dms)\\n \\n if r_lat == NOT_VALID: \\n err_msg += 'Enter latitude of reference point in correct format\\\\n'\\n val_result = False\\n \\n if r_lon == NOT_VALID:\\n err_msg += 'Enter longitude of reference point in correct format\\\\n'\\n val_result = False\\n \\n if rp_mv == '': # Magnetic Variation not enetered - assume magnetic variation as 0.0, \\n r_mag = 0.0\\n else:\\n if validate_magvar(rp_mv)[0] == NOT_VALID:\\n err_msg = err_msg + 'Enter magntic variation at the reference point in correct format, or leave blank if it is 0\\\\n'\\n val_result = False\\n else: \\n r_mag = float(validate_magvar(rp_mv)[1])\\n \\n if in_csv == '':\\n err_msg += 'Choose input file\\\\n'\\n val_result = False\\n else:\\n if check_csv_header(in_csv, h_to_check) == NOT_VALID:\\n err_msg += 'Inpute csv file header is not P_NAME;AZM_BRNG;DIST\\\\n'\\n val_result = False\\n \\n if out_csv == '':\\n err_msg += 'Choose output file\\\\n'\\n val_result = False\\n \\n \\n if val_result == True:\\n input_data.assign_values(r_lat, r_lon, r_mag, in_csv, out_csv)\\n else:\\n QMessageBox.critical(w, \\\"Message\\\", err_msg) \\n \\n return val_result\",\n \"def plot_reion_properties(rank, size, comm, reion_ini_files, gal_ini_files,\\n model_tags, reion_plots, output_dir, output_format):\\n\\n # Check to see if the output directory exists.\\n if rank == 0:\\n if not os.path.exists(output_dir):\\n os.makedirs(output_dir)\\n print(\\\"Made output directory {0}\\\".format(output_dir))\\n\\n MC_dir = \\\"{0}/MC\\\".format(output_dir)\\n os.makedirs(MC_dir)\\n print(\\\"Made directory {0}\\\".format(MC_dir))\\n\\n # First calculate all the properties and statistics we need.\\n reion_data = generate_data(rank, size, comm, reion_ini_files,\\n gal_ini_files, reion_plots, output_dir,\\n model_tags, output_format)\\n\\n # Gather all the fractions onto the master process.\\n # This will be used for many different plots. \\n master_mass_frac = collective.collect_hist_across_tasks(rank, comm, \\n reion_data[\\\"mass_frac_allmodels\\\"]) \\n master_mass_frac = comm.bcast(master_mass_frac, root = 0)\\n\\n # Then find out what we need and plot em!\\n if reion_plots[\\\"history\\\"] and rank == 0:\\n\\n \\n duration_z, duration_t, reion_completed = \\\\\\n calc_duration(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n master_mass_frac, reion_plots[\\\"duration_definition\\\"])\\n\\n for model_number in range(len(master_mass_frac)):\\n print(\\\"Model {0}: Start {1:.2f} \\\\tMid {2:.2f}\\\\tEnd {3:.2f}\\\\t\\\"\\n \\\"dz {4:.2f}\\\\tdt {5:.1f}Myr\\\\tReion Completed {6}\\\" \\\\\\n .format(model_number, duration_z[model_number][0],\\n duration_z[model_number][1], duration_z[model_number][-1],\\n duration_z[model_number][0]-duration_z[model_number][-1],\\n duration_t[model_number][-1]-duration_t[model_number][0],\\n reion_completed[model_number]))\\n\\n print(\\\"Plotting the reionization history.\\\")\\n reionplot.plot_history(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_mass_frac,\\n model_tags, output_dir, \\\"history\\\",\\n output_format)\\n\\n\\n\\n if reion_plots[\\\"nion\\\"]:\\n\\n master_nion = collective.collect_hist_across_tasks(rank, comm, \\n reion_data[\\\"nion_allmodels\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting the ionizing emissivity.\\\")\\n reionplot.plot_nion(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_nion,\\n reion_data[\\\"nion_factor_allmodels\\\"], \\n model_tags, output_dir, \\\"nion\\\", output_format)\\n\\n if reion_plots[\\\"ps_fixed_XHI\\\"]:\\n k, P21, PHII = determine_ps_fixed_XHI(rank, size, comm,\\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n master_mass_frac, \\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting PS at fixed neutral fraction.\\\")\\n reionplot.plot_ps_fixed_XHI(k, P21, PHII,\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir, \\\"ps_fixed_XHI\\\",\\n output_format)\\n\\n if reion_plots[\\\"contours\\\"] and rank == 0:\\n # tau is used for multiple plots. So check if we need to calculate it.\\n try:\\n tau_allmodels\\n except NameError:\\n tau_allmodels = calc_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"helium_allmodels\\\"],\\n master_mass_frac)\\n\\n # For the contours, only plot the optical depth at the highest z.\\n tau_highz = []\\n for model_number in range(len(tau_allmodels)):\\n tau_highz.append(tau_allmodels[model_number][0])\\n\\n duration_z, duration_t, reion_completed = \\\\\\n calc_duration(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n master_mass_frac, reion_plots[\\\"duration_definition\\\"])\\n\\n print(\\\"Plotting contours of constant tau.\\\")\\n reionplot.plot_tau_contours(tau_highz, reion_completed,\\n reion_plots[\\\"alpha_beta_limits\\\"],\\n output_dir, \\\"tau_contours\\\", output_format)\\n\\n print(\\\"Plotting contours of constant reionization duration.\\\")\\n reionplot.plot_duration_contours(duration_t, reion_completed,\\n reion_plots[\\\"alpha_beta_limits\\\"],\\n output_dir, \\\"duration_contours\\\",\\n output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and rank == 0:\\n # tau is used for multiple plots. So check if we need to calculate it.\\n try:\\n tau_allmodels\\n except NameError:\\n tau_allmodels = calc_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"helium_allmodels\\\"],\\n master_mass_frac)\\n\\n print(\\\"Plotting the optical depth.\\\")\\n reionplot.plot_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"], \\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n tau_allmodels,\\n model_tags, output_dir, \\\"optical_depth\\\",\\n output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and reion_plots[\\\"history\\\"] and rank == 0:\\n print(\\\"Plotting the combined optical depth/ionization history.\\\")\\n reionplot.plot_combined_history_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"], \\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_mass_frac, tau_allmodels, \\n model_tags, output_dir,\\n \\\"history_tau\\\", output_format)\\n\\n if reion_plots[\\\"optical_depth\\\"] and reion_plots[\\\"nion\\\"] and rank == 0:\\n print(\\\"Plotting the combined optical depth/ionizing emissivity.\\\")\\n reionplot.plot_combined_nion_tau(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n master_nion,\\n reion_data[\\\"nion_factor_allmodels\\\"],\\n tau_allmodels, model_tags, output_dir,\\n \\\"nion_tau\\\", output_format)\\n\\n if reion_plots[\\\"ps_scales\\\"] or reion_plots[\\\"ps_scales_beta\\\"]:\\n print(\\\"Gathering the 21cm Power Spectra across processors\\\")\\n k, P21, PHII = gather_ps(rank, size, comm,\\n reion_data[\\\"k_allmodels\\\"],\\n reion_data[\\\"P21_allmodels\\\"],\\n reion_data[\\\"PHII_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"])\\n\\n if rank == 0:\\n print(\\\"Plotting the large scale power as a function of small \\\"\\n \\\"scale.\\\")\\n\\n if reion_plots[\\\"ps_scales_beta\\\"]:\\n calc_beta = True\\n else:\\n calc_beta = False \\n\\n # Now that we have all the PS on the master rank, calculate the\\n # amplitude at the specified scales.\\n scale_power_dict = calc_scale_power(k, P21, PHII,\\n reion_data[\\\"z_array_reion_allmodels\\\"], \\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n reion_plots[\\\"small_scale_err\\\"],\\n reion_plots[\\\"large_scale_err\\\"],\\n calc_beta=calc_beta)\\n\\n k_small_scale = scale_power_dict[\\\"k_small_scale\\\"]\\n k_large_scale = scale_power_dict[\\\"k_large_scale\\\"]\\n\\n P21_small_scale = scale_power_dict[\\\"P21_small_scale\\\"]\\n P21_large_scale = scale_power_dict[\\\"P21_large_scale\\\"]\\n\\n PHII_small_scale = scale_power_dict[\\\"PHII_small_scale\\\"]\\n PHII_large_scale = scale_power_dict[\\\"PHII_large_scale\\\"]\\n\\n if reion_plots[\\\"ps_scales\\\"]:\\n reionplot.plot_ps_scales(P21_small_scale,\\n P21_large_scale, master_mass_frac, \\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n reion_plots[\\\"ps_scales_z\\\"],\\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n reion_plots[\\\"small_scale_err\\\"],\\n reion_plots[\\\"large_scale_err\\\"],\\n model_tags, output_dir, \\\"ps_scales\\\",\\n output_format)\\n\\n if reion_plots[\\\"ps_scales_beta\\\"]:\\n\\n P21_beta = scale_power_dict[\\\"P21_beta\\\"]\\n P21_beta_error = scale_power_dict[\\\"P21_beta_error\\\"]\\n PHII_beta = scale_power_dict[\\\"PHII_beta\\\"]\\n\\n reionplot.plot_ps_beta(P21_beta, P21_beta_error,\\n reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"lookback_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n reion_data[\\\"t_bigbang_allmodels\\\"],\\n reion_plots[\\\"small_scale_def\\\"],\\n reion_plots[\\\"large_scale_def\\\"],\\n model_tags, output_dir,\\n \\\"ps_scales_beta\\\", output_format)\\n\\n\\n\\n if reion_plots[\\\"slices_fixed_XHI\\\"] and rank == 0:\\n print(\\\"Plotting slices at fixed XHI fractions.\\\")\\n reionplot.plot_slices_XHI(reion_data[\\\"z_array_reion_allmodels\\\"],\\n reion_data[\\\"cosmology_allmodels\\\"],\\n master_mass_frac, \\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n reion_plots[\\\"cut_slice\\\"],\\n reion_plots[\\\"cut_thickness\\\"],\\n model_tags, output_dir, \\\"slices_XHI\\\",\\n output_format)\\n\\n\\n if reion_plots[\\\"bubble_size\\\"] and rank == 0:\\n print(\\\"Determining bubble sizes at fixed XHI.\\\")\\n reionplot.determine_bubble_size(reion_data[\\\"z_array_reion_allmodels\\\"],\\n master_mass_frac,\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir)\\n\\n if reion_plots[\\\"zreion_dens_cross\\\"] and rank == 0:\\n print(\\\"Calculating the zreion-density cross correlation.\\\")\\n k, crosspspec, crosscorr, bias = \\\\\\n zreion_dens_cross(reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"zreion_path_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"boxsize_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"])\\n\\n reionplot.plot_zreion_dens_cross(k, crosscorr, bias, model_tags,\\n output_dir, \\\"zreion_dens_crosscorr\\\",\\n output_format)\\n\\n if reion_plots[\\\"dens_ion_contours\\\"] and rank == 0:\\n print(\\\"Plotting contours of density-ionization.\\\")\\n reionplot.plot_dens_reion_contours(master_mass_frac,\\n reion_data[\\\"XHII_fbase_allmodels\\\"],\\n reion_data[\\\"XHII_precision_allmodels\\\"],\\n reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"first_snap_allmodels\\\"],\\n reion_plots[\\\"fixed_XHI_values\\\"],\\n model_tags, output_dir,\\n \\\"dens_ion_contours\\\", output_format)\\n\\n if reion_plots[\\\"dens_zreion_contours\\\"] and rank == 0:\\n print(\\\"Plotting contours of density-zreion.\\\")\\n reionplot.plot_dens_zreion_contours(reion_data[\\\"density_fbase_allmodels\\\"],\\n reion_data[\\\"density_precision_allmodels\\\"],\\n reion_data[\\\"zreion_path_allmodels\\\"],\\n reion_data[\\\"GridSize_allmodels\\\"],\\n reion_data[\\\"last_snap_allmodels\\\"],\\n model_tags, output_dir,\\n \\\"dens_zreion_contours\\\", output_format)\",\n \"def calculate_relative(self, inputs):\\n\\n absolute_inputs = [\\n {\\n \\\"cx\\\": input[\\\"cx\\\"],\\n \\\"cy\\\": input[\\\"cy\\\"],\\n \\\"a\\\": math.tan(math.radians(input[\\\"ca\\\"]) + math.radians(input[\\\"ma\\\"])),\\n }\\n for input in inputs\\n ]\\n\\n return self.calculate_absolute(absolute_inputs)\",\n \"def ValidateInputs(lat_min, lat_max, lon_min, lon_max, lonres, latres, basepath, \\\\\\n GFED_path, EDGAR_path, CAMS_path, behaviour_settings):\\n # Assert sure extents fall within boundary\\n assert -180 <= lon_min < 180 and -180 < lon_max <= 180, 'Longitude should be within range -180 -- 180!'\\n assert -90 <= lat_min < 90 and -90 < lat_max <= 90, 'latitude should be within range -90 -- 90!'\\n assert lon_min < lon_max, 'maximum longitude cannot be smaller than or equal to minimum!'\\n assert lat_min < lat_max, 'maximum latitude cannot be smaller than or equal to minimum!'\\n \\n # Assert resolution is larger than TROPOMI minimum:\\n assert lonres > 7, 'TROPOMI minimum longitude resolution is 7 km!'\\n assert latres > 7, 'TROPOMI minimum latitude resolution is 7 km!'\\n \\n # Assert if given directories exist\\n if behaviour_settings[1] == True:\\n assert os.path.isdir(CAMS_path), f'Directory {CAMS_path} was not found!'\\n if behaviour_settings[2] == True:\\n assert os.path.isdir(GFED_path), f'Directory {GFED_path} was not found!'\\n assert os.path.isdir(EDGAR_path), f'Directory {EDGAR_path} was not found!'\\n\\n \\n return\",\n \"def main():\\n dpi = 1\\n dpi = 2\\n width = int(360)\\n height = int(130)\\n mywidth = int(width*dpi)\\n myheight = int(height*dpi)\\n FWHM = 7.5 # degrees\\n FWHM = 10.0 # degrees\\n FWHM = 5.0 # degrees\\n FWHM = 3.0 # degrees\\n FWHM = 1.0 # degrees\\n weight = 1.\\n\\n nargs = len(sys.argv)\\n if nargs < 2:\\n print('GR: GRid Observations of integrated intensity produced by the T Command')\\n print('GR produces fits images for each of the horns used for the observations.')\\n print('For observations at the same coordinates, the ratios of intensities are also produced.')\\n print('The FITS format files require header information, which is copied from the')\\n print('Cold Load File provided by the user')\\n print('GR RA|GAL <cold file name> <savefile1> [<savefile2> ... <savefileN>]')\\n print(\\\"\\\")\\n print('Glen Langston, National Science Foundation -- 20 May 12')\\n exit()\\n\\n gridtype = sys.argv[1]\\n gridtype = gridtype.upper()\\n print('Grid Type: ', gridtype)\\n\\n # enable having ra going from 24 to 0 hours == 360 to 0 degrees\\n xsign = 1.\\n xoffset = 0.\\n if gridtype == 'RA':\\n xmin = 0.\\n xmax = 360.\\n ymin = -40.\\n ymax = 90.\\n maptype = 'RA'\\n elif gridtype == '-RA':\\n xmin = 0.\\n xmax = 360.\\n ymin = -40.\\n ymax = 90.\\n xsign = -1.\\n xoffset = 360. # when x = 360. should be at zero.\\n maptype = 'RA'\\n elif gridtype == '-EL':\\n xmin = 0.\\n xmax = 360.\\n ymin = 0.\\n ymax = 90.\\n xsign = -1.\\n xoffset = 360. # when x = 360. should be at zero.\\n maptype = 'AZEL'\\n elif gridtype == 'RA0':\\n xmin = 0.\\n xmax = 360.\\n ymin = -41.\\n ymax = 89.\\n xsign = -1.\\n xoffset = 180. # when x = 360. should be at zero.\\n gridtype = 'RA'\\n elif gridtype == 'GAL':\\n xmin = -180.\\n xmax = 180.\\n ymin = -90.\\n ymax = 90.\\n maptype = 'GAL'\\n\\n if gridtype != 'RA' and gridtype != 'GAL' and gridtype != '-RA' and gridtype != \\\"RA0\\\":\\n print('Error parsing grid type: ', gridtype)\\n print('1st argument should be either RA, -RA or GAL')\\n exit()\\n\\n rs = radioastronomy.Spectrum()\\n\\n if doRatio: \\n #create the grid with map parameters\\n grid1 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n grid2 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n grid3 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n grid4 = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n # put each telescope in a different grid\\n grids = [grid1, grid2, grid3, grid4]\\n\\n gridall = GridClass.Grid(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax, width=width, \\\\\\n height=height, dpi=dpi, FWHM=FWHM, \\\\\\n projection=\\\"-CAR\\\", gridtype=maptype)\\n \\n\\n projection = \\\"-AIT\\\"\\n# coldfile \\n coldfile = sys.argv[2]\\n# get telescope geographic location etc\\n print(\\\"Reading Observing parameters from: %s\\\" % (coldfile))\\n rs.read_spec_ast(coldfile)\\n print(\\\"Observer: %s \\\" % (rs.observer))\\n\\n# first read through all data and find hot load\\n names = sys.argv[3:]\\n names = sorted(names)\\n\\n firsttime = \\\"\\\"\\n lasttime = \\\"\\\"\\n count = 0\\n # setup grid indicies so that cpuIndex goes to the correct grid\\n # This assumes telescopes 2,3,4,5 are being used] \\n gridIndex = [0,0,0,1,2,3]\\n # for all save Files to Grid\\n for filename in names:\\n print(\\\"File: %s\\\" % (filename))\\n f = open(filename)\\n\\n date = \\\"Unknown\\\"\\n while date != \\\"\\\":\\n date, time, cpuIndex, telaz, telel, tSys, tRx, tRms, tint, KperC, tSourcemax, velSource, dV, tVSum, tVSumRms, tSumKmSec, dTSumKmSec, gainFactor = gainfactor.readSaveValues( f)\\n dlen = len(date)\\n if dlen < 1:\\n break\\n if date[0] == \\\"#\\\":\\n continue\\n # else not a comment process the line\\n count = count + 1\\n isodate = \\\"20\\\"+date+\\\"T\\\"+time\\n# print(\\\"DateTime: %s\\\" % (isodate))\\n rs.utc = datetime.datetime.strptime(isodate,\\\"%Y-%m-%dT%H:%M:%S\\\")\\n# print(\\\"Utc: %s\\\" % (rs.utc))\\n rs.telaz = telaz\\n rs.telel = telel\\n rs.azel2radec()\\n\\n ra = rs.ra\\n dec = rs.dec\\n lon = rs.gallon\\n lat = rs.gallat\\n tsum = tSumKmSec\\n tsdv = dTSumKmSec\\n tmax = tSourcemax\\n vave = tVSum\\n vsdv = tVSumRms\\n if firsttime == \\\"\\\":\\n firsttime = date\\n else:\\n lasttime = date\\n\\n# if vave > -100. and vave < 100:\\n# mygrid.convolve( lon, lat, vave, 1.)\\n iGrid = gridIndex[cpuIndex]\\n gainCorr = telescopefactors[iGrid]\\n tsum = tsum * gainCorr\\n if gridtype == 'RA':\\n if doRatio:\\n grids[iGrid].convolve(ra, dec, tsum, weight)\\n gridall.convolve( ra, dec, tsum, weight)\\n elif gridtype == '-RA':\\n x = (ra*xsign) + xoffset\\n if doRatio:\\n grids[iGrid].convolve(x, dec, tsum, weight)\\n gridall.convolve( x, dec, tsum, weight)\\n elif gridtype == 'RA0':\\n x = (ra*xsign) + xoffset\\n if x < 0:\\n x = x + xmax\\n elif x > xmax:\\n x = x - xmax\\n if doRatio:\\n grids[iGrid].convolve(x, dec, tsum, weight)\\n gridall.convolve( x, dec, tsum, weight)\\n else:\\n if doRatio:\\n grids[iGrid].convolve(lon, lat, tsum, weight)\\n gridall.convolve( lon, lat, tsum, weight)\\n\\n if count == 0:\\n print('Convolving Coordinates: ', ra, dec, lon, lat)\\n print('Convolving Intensities: ', tsum, tsdv, vave, vsdv)\\n print('Convolvign Parameters : ', n, time)\\n count = count + 1\\n # end reading all lines in save file\\n f.close()\\n\\n # normalize each of the gridded images\\n if doRatio:\\n grids[0].normalize()\\n grids[1].normalize()\\n grids[2].normalize()\\n grids[3].normalize()\\n gridall.normalize()\\n# mygrid.check()\\n# zmin = -1000.\\n# zmax = 3000.\\n# limit grid intensities for plotting\\n# mygrid.set_ij( 0, 0, zmax, 1.)\\n# mygrid.set_ij( 1, 1, zmin, 1.)\\n# mygrid.limit(zmin, zmax)\\n\\n subplots = False\\n\\n if subplots:\\n fig, ax = plt.subplots(figsize=(myheight, mywidth), dpi=dpi)\\n\\n if gridtype == 'RA':\\n cax = fig.add_axes([-180, 180], [-90, 90])\\n else:\\n cax = fig.add_axes([0, 24], [-90, 90])\\n\\n cbar = fig.colorbar(cax, ticks=[zmin, zmax], orientation='horizontal')\\n cbar.ax.set_yticklabels([str(zmin), str(zmax)])\\n\\n ax.set_title(\\\"Citizen Science: Horn observations of our Galaxy\\\")\\n else:\\n#y_ticks = ymin + (ymax-ymin)*ticks/myheight\\n\\n ticks = np.arange(0, mywidth, 30*dpi)\\n x_ticks = xmin + ((xmax-xmin)*ticks/mywidth)\\n\\n plt.imshow(gridall.image, interpolation='nearest', cmap=plt.get_cmap('jet'))\\n\\n if firsttime != lasttime:\\n plt.title(\\\"Citizen Science: Observing our Galaxy: %s to %s\\\" % (firsttime, lasttime))\\n else:\\n plt.title(\\\"Citizen Science: Observing our Galaxy: %s\\\" % (firsttime))\\n if gridtype == 'RA':\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Declination (degrees)\\\")\\n labels = ticks/(mywidth/24)\\n yticks = np.arange(0, myheight, 15*dpi)\\n elif gridtype == '-RA':\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Declination (degrees)\\\")\\n labels = 24 - (ticks/(mywidth/24))\\n labels[0] = 0\\n labels[0] = 24\\n yticks = np.arange(0, myheight, 15*dpi)\\n elif gridtype == '-EL':\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Elevation (degrees)\\\")\\n labels = 24 - (ticks/(mywidth/24))\\n labels[0] = 0\\n labels[0] = 24\\n yticks = np.arange(0, myheight, 15*dpi)\\n elif gridtype == 'RA0': # put 0 hours in middle of plot\\n plt.xlabel(\\\"Right Ascension (hours)\\\")\\n plt.ylabel(\\\"Declination (degrees)\\\")\\n labels = 12 - (ticks/(mywidth/24))\\n nlabels = len(labels)\\n for iii in range(nlabels):\\n if labels[iii] < 0:\\n labels[iii] = 24 + labels[iii]\\n if labels[iii] == 24:\\n labels[iii] = 0\\n yticks = np.arange(0, myheight, 15*dpi)\\n else:\\n yticks = np.arange(0, myheight, 30*dpi)\\n ticks = np.arange(0, mywidth, 30*dpi)\\n x_ticks = xmin + (xmax-xmin)*ticks/mywidth\\n labels = x_ticks\\n plt.xlabel(\\\"Galactic Longitude (degrees)\\\")\\n plt.ylabel(\\\"Galactic Latitude (degrees)\\\")\\n # wnat an integer list of labels\\n# slabels = str(labels)\\n print(ticks, labels)\\n y_ticks = ymax - (ymax-ymin)*yticks/myheight\\n plt.yticks(yticks, y_ticks)\\n plt.xticks(ticks, labels, rotation='horizontal')\\n plt.colorbar()\\n\\n crval2 = (xmin + xmax)/2.\\n crval1 = (ymin + ymax)/2.\\n cdelt1 = (-1./float(dpi)) - .001\\n cdelt2 = (1./float(dpi)) + .001\\n if doRatio:\\n# now show eacsh of the images\\n for iGrid in range(4):\\n imagetemp = copy.deepcopy(grids[iGrid].image)\\n imagetemp2 = copy.deepcopy(grids[iGrid].image)\\n kkk = myheight - 1\\n for jjj in range(myheight):\\n imagetemp[:][kkk] = imagetemp2[:][jjj]\\n kkk = kkk - 1\\n grids[iGrid].image = imagetemp\\n writeFitsImage( rs, iGrid+2, grids[iGrid], projection)\\n\\n # put each telescope in a different grid\\n ratio1 = copy.deepcopy(grid1)\\n ratio2 = copy.deepcopy(grid1)\\n ratio3 = copy.deepcopy(grid1)\\n gratios = [ratio1, ratio2, ratio3]\\n ratios = np.zeros(3)\\n rmss = np.zeros(3)\\n\\n jGrid = 3\\n for iGrid in range(3):\\n print(\\\"Gain Ratios for Telescopes T%d and T%d\\\" % (iGrid+2, jGrid+2))\\n ratio, rms, aratio = gridratio(grids[iGrid], grids[jGrid])\\n ratios[iGrid] = ratio\\n rmss[iGrid] = rms\\n writeFitsImage( rs, iGrid+2, aratio, projection)\\n \\n writeFitsImage( rs, 0, gridall, projection)\\n plt.show()\",\n \"def plot_PDs(output_path,M_max,max_dim,normalized=False,output_name=None):\\n plots_folder = os.path.join(output_path,'plots')\\n if output_name is None: \\n aux = ['PDs']\\n input_file = os.path.join(output_path,'outputs_PDS.csv')\\n else:\\n aux = [output_name,'PDs']\\n input_file = os.path.join(output_path,'%s_PDS.csv' % output_name)\\n if normalized is True:\\n aux.append('normalized')\\n plot_file_name = '-'.join(aux)+'.png'\\n plot_file_name = os.path.join(plots_folder,plot_file_name)\\n\\n \\n data = pd.read_csv(input_file,index_col = 0)\\n \\n\\n fig_size_aux = 15/(3-max_dim)\\n plt.figure(figsize=(fig_size_aux,5))\\n if(normalized):\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values/np.float(M_max),data[data.dimH==i-1].death.values/np.float(M_max),'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,1)); plt.ylim((0,1))\\n frame = plt.legend(loc=4,frameon=True,title='normalized')\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, 1], [0, 1], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n else:\\n for i in range(1,max_dim+2):\\n plt.subplot(1,max_dim+1,i, aspect='equal')\\n plt.plot(data[data.dimH==i-1].birth.values,data[data.dimH==i-1].death.values,'bo',alpha=.3,label='dim %i'%(i-1))\\n plt.xlim((0,M_max)); plt.ylim((0,M_max))\\n frame = plt.legend(loc=4,frameon=True)\\n frame = frame.get_frame()\\n frame.set_edgecolor('black')\\n plt.xlabel('birth'); plt.ylabel('death')\\n plt.plot([0, M_max], [0, M_max], ls=\\\"--\\\", c=\\\".3\\\")\\n plt.suptitle('Persistence Diagrams')\\n plt.savefig(plot_file_name)\\n print 'Saved PDs plots in %s'%plot_file_name\\n return()\",\n \"def _plot_comparison_repeatables(ax_abs, ax_per, ax_mag, pan, field, unit,\\n other_program_name, **kw):\\n\\n #plot absolute error\\n h_abs = ax_abs.plot(pan['absolute-difference'][field].index.values,\\n pan['absolute-difference'][field].values,\\n color=mpl.rcParams['axes.labelcolor'], zorder=-2)\\n ax_abs.set_ylabel('Absolute Difference ' + unit)\\n #plot percentage error\\n h_per = ax_per.plot(pan['percent-difference'][field].index.values,\\n pan['percent-difference'][field].values,\\n color='firebrick', zorder=-1)\\n ax_per.set_ylabel('Percent Difference', color='firebrick')\\n #set error axes legend\\n #ax_per.legend(h_abs + h_per, ['Absolute Difference','Percent Difference'], **_leg_kw)\\n #ax_per.get_legend().set_zorder(1)\\n #plot full results profiles\\n kw['H'] += [ax_mag.plot(pan['%s-results' % other_program_name][field],\\n color=_colormap[1])[0],\\n ax_mag.plot(pan['emf.fields-results'][field],\\n color=_colormap[0])[0]]\\n kw['L'] += [other_program_name + ' Results', 'emf.fields Results']\\n ax_mag.set_xlabel('Distance (ft)')\",\n \"def line_ratio_per_pixel_AHIMSA(ratio_name='NII',quant='ne',phase='all',res=0.5, plane='xy',col='grey',add=False,**kwargs):\\n\\n fig = plt.figure(constrained_layout=True,figsize=(15,10))\\n gs = fig.add_gridspec(3,2)\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n gal_ob = gal.galaxy(p.gal_index)\\n \\n location = aux.moment0_map_location(res=res,plane=plane,gal_index=p.gal_index)\\n # Load sim and cell data\\n try:\\n moment_0_map = np.load(location, allow_pickle=True)\\n print('Found stored momentmap data')\\n except:\\n print('Did not find stored momentmap data - creating')\\n aux.convert_cell_data_to_regular_grid(gal_index=p.gal_index)\\n moment_0_map = np.load(location, allow_pickle=True)\\n\\n cols = {'HII':'blue','HI':'orange','H2':'red'}\\n for i,phase in enumerate(['HII','HI','H2']):\\n ax = fig.add_subplot(gs[i,0])\\n\\n dataset= np.array(moment_0_map[:,3])\\n\\n # Do all pixels for comparison\\n index1 = p.moment0_dict['L_[NII]122']\\n index2 = p.moment0_dict['L_[NII]205']\\n index3 = p.moment0_dict['m']\\n index4 = p.moment0_dict['ne_mw']\\n line1 = []\\n line2 = []\\n ne_mw = []\\n m = []\\n for row in dataset:\\n try:\\n line1.append(row[index1])\\n line2.append(row[index2])\\n m.append(row[index3])\\n ne_mw.append(row[index4])\\n except:\\n print(row)\\n m = np.array(m) \\n ne_mw = np.array(ne_mw) \\n line1 = np.array(line1)\\n line2 = np.array(line2)\\n # print(line2)\\n ne_mw = np.array(ne_mw[line2 > 0])\\n ratio = line1[line2 > 0]/line2[line2 > 0]\\n ax.scatter(np.log10(ne_mw/m[line2 > 0]),ratio,color=col,label= 'All gas in moment0map pixels',alpha=0.3)\\n\\n # Now for one ISM phase\\n index1 = p.moment0_dict['L_[NII]122_%s' % phase]\\n index2 = p.moment0_dict['L_[NII]205_%s' % phase]\\n index3 = p.moment0_dict['m_%s' % phase]\\n index4 = p.moment0_dict['ne_%s_mw' % phase]\\n line1 = []\\n line2 = []\\n ne_mw = []\\n m_phase = []\\n for row in dataset:\\n try:\\n line1.append(row[index1])\\n line2.append(row[index2])\\n m_phase.append(row[index3])\\n ne_mw.append(row[index4])\\n except:\\n print(row)\\n m_phase = np.array(m_phase) \\n ne_mw = np.array(ne_mw) \\n line1 = np.array(line1)\\n line2 = np.array(line2)\\n ne_mw = np.array(ne_mw[line2 > 0])\\n ratio = line1[line2 > 0]/line2[line2 > 0]\\n ax.scatter(np.log10(ne_mw/m[line2 > 0]),ratio,color=cols[phase],label= '%s gas in moment0map pixels' % phase,alpha=0.3)\\n\\n xs = np.arange(ax.get_xlim()[0],ax.get_xlim()[1],0.1)\\n ax.plot(xs,aux.NII_from_logne(xs),'-b')\\n if p.xlim: ax.set_xlim(p.xlim)\\n if p.ylim: ax.set_ylim(p.ylim)\\n ax.set_xlabel('log ' + getlabel('ne'))\\n ax.set_ylabel(getlabel('NIIratio'))\\n ax.legend()\\n\\n ax = fig.add_subplot(gs[:,-1])\\n ax.set_ylabel('y [kpc]')\\n ax.set_xlabel('x [kpc]')\\n map_sim_property(prop='m',vmin=9,vmax=12.9,add=True,log=True,sim_type='simgas',ax=ax,**kwargs)\\n plt.subplots_adjust(hspace = 0, wspace = 0.2)\\n if p.savefig:\\n if not os.path.isdir(p.d_plot + 'lineratios/NII/'): os.mkdir(p.d_plot + 'lineratios/NII/') \\n plt.savefig(p.d_plot+'lineratios/NII/%s%s_G%i_NII_ne' % (p.sim_name,p.sim_run,p.gal_index)+'.png', dpi=200)\",\n \"def run():\\r\\n square_s = input(\\\"Is your data file a square matrix file? [y/n]: \\\")\\r\\n assert(square_s == \\\"y\\\" or square_s == \\\"Y\\\" or square_s == \\\"n\\\" or square_s == \\\"N\\\"), \\\"Please enter in 'y' or 'n' format.\\\"\\r\\n if square_s == \\\"y\\\" or square_s == \\\"Y\\\":\\r\\n is_square = True\\r\\n else:\\r\\n is_square = False\\r\\n\\r\\n file_name = input(\\\"Please enter file name: \\\")\\r\\n\\r\\n conf_s = input(\\\"Please enter minimum confidence threshold: \\\")\\r\\n conf_f = float(conf_s)\\r\\n assert(is_float(conf_s)), \\\"Please enter a valid numerical value.\\\"\\r\\n\\r\\n print(\\\"Please select plot type number\\\")\\r\\n print(\\\"1. Orientation\\\")\\r\\n print(\\\"2. Confidence levels\\\")\\r\\n plottype_s = input(\\\"[1/2]: \\\")\\r\\n assert(plottype_s == \\\"1\\\" or plottype_s == \\\"2\\\"), \\\"Please enter either '1' or '2'.\\\"\\r\\n if plottype_s == \\\"1\\\":\\r\\n is_orient = True\\r\\n else:\\r\\n is_orient = False\\r\\n\\r\\n if is_square == True:\\r\\n sqm = SquareMic()\\r\\n sqm.load(file_name)\\r\\n if is_orient:\\r\\n misorien_s = input(\\\"Please enter misorientation threshold (default=1.0): \\\")\\r\\n try:\\r\\n assert(is_float(misorien_s))\\r\\n misorien_f = float(misorien_s)\\r\\n print(misorien_f)\\r\\n except:\\r\\n print(\\\"Input not a numerical value. Defaulting to 1.0\\\")\\r\\n misorien_f = 1.0\\r\\n #assert(is_float(misorien_s)), \\\"Please enter a numerical value.\\\"\\r\\n #misorien_f = float(misorien_s)\\r\\n\\r\\n sqm.plot_orientation([],minHitRatio=conf_f,misor_thresh=misorien_f)\\r\\n else:\\r\\n sqm.plot_hit_ratio()\\r\\n else:\\r\\n m = MicFile(file_name)\\r\\n if is_orient:\\r\\n plottype_i = 1\\r\\n else:\\r\\n plottype_i = 2\\r\\n m.plot_mic_patches(plottype_i,conf_f,1,False,[])\\r\\n return\",\n \"def isrelative(self):\\n return bool(self.control & gdef.SE_SELF_RELATIVE)\",\n \"def jam_axi_rms(surf_lum, sigma_lum, qobs_lum, surf_pot, sigma_pot, qobs_pot,\\n inc, mbh, distance, xbin, ybin, ml=None, normpsf=1., pixang=0.,\\n pixsize=0., plot=True, rms=None, erms=None, sigmapsf=0.,\\n goodbins=None, quiet=False, beta=None, step=0., nrad=20,\\n nang=10, rbh=0.01, tensor='zz', vmin=None, vmax=None, **kwargs):\\n if beta is None:\\n beta = np.zeros_like(surf_lum) # Anisotropy parameter beta = 1 - (sig_z/sig_R)**2\\n if not (surf_lum.size == sigma_lum.size == qobs_lum.size == beta.size):\\n raise ValueError(\\\"The luminous MGE components do not match\\\")\\n if not (surf_pot.size == sigma_pot.size == qobs_pot.size):\\n raise ValueError(\\\"The total mass MGE components do not match\\\")\\n if xbin.size != ybin.size:\\n raise ValueError(\\\"xbin and ybin do not match\\\")\\n if rms is not None:\\n if erms is None:\\n erms = np.full_like(rms, np.median(rms)*0.05) # Constant ~5% errors\\n if goodbins is None:\\n goodbins = np.ones_like(rms, dtype=bool)\\n elif goodbins.dtype != bool:\\n raise ValueError(\\\"goodbins must be a boolean vector\\\")\\n if not (xbin.size == rms.size == erms.size == goodbins.size):\\n raise ValueError(\\\"(rms, erms, goodbins) and (xbin, ybin) do not match\\\")\\n\\n sigmapsf = np.atleast_1d(sigmapsf)\\n normpsf = np.atleast_1d(normpsf)\\n if sigmapsf.size != normpsf.size:\\n raise ValueError(\\\"sigmaPSF and normPSF do not match\\\")\\n\\n pc = distance*np.pi/0.648 # Constant factor to convert arcsec --> pc\\n\\n surf_lum_pc = surf_lum\\n surf_pot_pc = surf_pot\\n sigma_lum_pc = sigma_lum*pc # Convert from arcsec to pc\\n sigma_pot_pc = sigma_pot*pc # Convert from arcsec to pc\\n xbin_pc = xbin*pc # Convert all distances to pc\\n ybin_pc = ybin*pc\\n pixSize_pc = pixsize*pc\\n sigmaPsf_pc = sigmapsf*pc\\n step_pc = step*pc\\n\\n # Add a Gaussian with small sigma and the same total mass as the BH.\\n # The Gaussian provides an excellent representation of the second moments\\n # of a point-like mass, to 1% accuracy out to a radius 2*sigmaBH.\\n # The error increses to 14% at 1*sigmaBH, independently of the BH mass.\\n #\\n if mbh > 0:\\n sigmaBH_pc = rbh*pc # Adopt for the BH just a very small size\\n surfBH_pc = mbh/(2*np.pi*sigmaBH_pc**2)\\n surf_pot_pc = np.append(surfBH_pc, surf_pot_pc) # Add Gaussian to potential only!\\n sigma_pot_pc = np.append(sigmaBH_pc, sigma_pot_pc)\\n qobs_pot = np.append(1., qobs_pot) # Make sure vectors do not have extra dimensions\\n\\n qobs_lum = qobs_lum.clip(0, 0.999)\\n qobs_pot = qobs_pot.clip(0, 0.999)\\n\\n t = clock()\\n rmsModel = _vrms2(xbin_pc, ybin_pc, inc, surf_lum_pc, sigma_lum_pc,\\n qobs_lum, surf_pot_pc, sigma_pot_pc, qobs_pot, beta,\\n tensor, sigmaPsf_pc, normpsf, pixSize_pc, pixang,\\n step_pc, nrad, nang)\\n if not quiet:\\n print('jam_axi_rms elapsed time sec: %.2f' % (clock() - t))\\n\\n if tensor in ('xx', 'yy', 'zz'):\\n rmsModel = np.sqrt(rmsModel.clip(0)) # Return SQRT and fix possible rounding errors\\n if tensor in ('xy', 'xz'):\\n rmsModel *= np.sign(xbin*ybin) # Calculation was done in positive quadrant\\n\\n # Analytic convolution of the MGE model with an MGE circular PSF\\n # using Equations (4,5) of Cappellari (2002, MNRAS, 333, 400)\\n #\\n lum = surf_lum_pc*qobs_lum*sigma_lum**2 # Luminosity/(2np.pi) of each Gaussian\\n flux = np.zeros_like(xbin) # Total MGE surface brightness for plotting\\n for sigp, norp in zip(sigmapsf, normpsf): # loop over the PSF Gaussians\\n sigmaX = np.sqrt(sigma_lum**2 + sigp**2)\\n sigmaY = np.sqrt((sigma_lum*qobs_lum)**2 + sigp**2)\\n surfConv = lum / (sigmaX*sigmaY) # PSF-convolved in Lsun/pc**2\\n for srf, sx, sy in zip(surfConv, sigmaX, sigmaY): # loop over the galaxy MGE Gaussians\\n flux += norp*srf*np.exp(-0.5*((xbin/sx)**2 + (ybin/sy)**2))\\n\\n if rms is None:\\n\\n chi2 = None\\n if ml is None:\\n ml = 1.\\n else:\\n rmsModel *= np.sqrt(ml)\\n\\n else:\\n\\n if (ml is None) or (ml <= 0):\\n\\n # y1, dy1 = rms, erms # (y1 are the data, y2 the model)\\n # scale = sum(y1*y2/dy1**2)/sum(y2**2/dy1**2) # (equation 51)\\n #\\n ml = (np.sum(rms[goodbins]*rmsModel[goodbins]/erms[goodbins]**2)\\n / np.sum((rmsModel[goodbins]/erms[goodbins])**2))**2\\n\\n rmsModel *= np.sqrt(ml)\\n chi2 = np.sum(((rms[goodbins]-rmsModel[goodbins])/erms[goodbins])**2) / goodbins.sum()\\n\\n if not quiet:\\n print('inc=%.1f beta_z=%.2f M/L=%.3g BH=%.2e chi2/DOF=%.3g' % (inc, beta[0], ml, mbh*ml, chi2))\\n mass = 2*np.pi*surf_pot_pc*qobs_pot*sigma_pot_pc**2\\n print('Total mass MGE: %.4g' % np.sum(mass*ml))\\n\\n if plot:\\n\\n rms1 = rms.copy() # Only symmetrize good bins\\n rms1[goodbins] = symmetrize_velfield(xbin[goodbins], ybin[goodbins], rms[goodbins])\\n\\n if (vmin is None) or (vmax is None):\\n vmin, vmax = stats.scoreatpercentile(rms1[goodbins], [0.5, 99.5]) # Could use np.percentile in Numpy 1.10\\n\\n plt.clf()\\n plt.subplot(121)\\n plot_velfield(xbin, ybin, rms1, vmin=vmin, vmax=vmax, flux=flux, **kwargs)\\n plt.title(r\\\"Input $V_{\\\\rm rms}$\\\")\\n\\n plt.subplot(122)\\n plot_velfield(xbin, ybin, rmsModel, vmin=vmin, vmax=vmax, flux=flux, **kwargs)\\n plt.plot(xbin[~goodbins], ybin[~goodbins], 'ok', mec='white')\\n plt.title(r\\\"Model $V_{\\\\rm rms}$\\\")\\n plt.tick_params(labelleft='off')\\n plt.subplots_adjust(wspace=0.03)\\n\\n return rmsModel, ml, chi2, flux\",\n \"def abs_units_old(wb_run,sample_run,mono_van,wb_mono,samp_rmm,samp_mass,ei_guess,rebin,map_file,monovan_mapfile,**kwargs): \\n #available keywords\\n #abs_units_van_range\\n global reducer, rm_zero,inst_name,van_mass,bleed_switch,rate,pixels\\n print 'DGreduce run for ',inst_name,'run number ',sample_run\\n print 'Output will be in absolute units of mb/str/mev/fu'\\n try:\\n n,r=lhs('both')\\n wksp_out=r[0]\\n except:\\n if sample_run == 0:\\n #deal with the current run being parsed as 0 rather than 00000\\n sample_run='00000'\\n wksp_out=str(sample_run)+'.spe'\\n \\n start_time=time.time()\\n \\n if sample_run=='00000' and mtd.doesExist(inst_name+'00000.raw')==True:\\n print 'Deleteing previous instance of temp data'\\n DeleteWorkspace(Workspace=inst_name+'00000.raw')\\n \\n if kwargs.has_key('norm_method'):\\n reducer.normalise_method = kwargs.get('norm_method')\\n print 'Setting normalisation method to ', kwargs.get('norm_method')\\n else:\\n reducer.normalise_method = 'monitor-1'\\n \\n if kwargs.has_key('mask_run'):\\n mask_run = kwargs.get('mask_run')\\n print 'Using run ', kwargs.get('mask_run'),' for diag'\\n else:\\n mask_run=sample_run\\n \\n if kwargs.has_key('background'):\\n reducer.background = kwargs.get('background')\\n print 'Setting background option to ', kwargs.get('background')\\n else:\\n reducer.background = False\\n \\n if kwargs.has_key('fixei'):\\n reducer.fix_ei = kwargs.get('fixei')\\n print 'Setting fixei to ', kwargs.get('fixei')\\n else:\\n reducer.fix_ei = False\\n \\n if kwargs.has_key('save_format'):\\n reducer.save_formats = kwargs.get('save_format')\\n print 'Setting save format to ', kwargs.get('save_format')\\n else:\\n reducer.save_formats = ['.spe']\\n #Set parameters for the run\\n \\n if kwargs.has_key('detector_van_range'):\\n reducer.wb_integr_range = kwargs.get('detector_van_range')\\n print 'Setting detector van int range to ', kwargs.get('detector_van_range')\\n else:\\n reducer.wb_integr_range=[20,100]\\n \\n #######DIAG###########\\n if kwargs.has_key('bkgd_range'):\\n background_range = kwargs.get('bkgd_range')\\n print 'Setting background intergration to ', kwargs.get('bkgd_range')\\n else:\\n background_range=[15000,19000]\\n \\n if kwargs.has_key('tiny'):\\n tinyval = kwargs.get('tiny')\\n print 'Setting tiny ratelimit to ', kwargs.get('tiny')\\n else:\\n tinyval=1e-10\\n \\n if kwargs.has_key('large'):\\n largeval = kwargs.get('large')\\n print 'Setting large limit to ', kwargs.get('large')\\n else:\\n largeval=1e10\\n \\n if kwargs.has_key('diag_remove_zero'):\\n sampzero = kwargs.get('diag_remove_zero')\\n print 'Setting diag to reject zero backgrounds '\\n else:\\n sampzero =False\\n \\n if kwargs.has_key('diag_van_median_rate_limit_hi'):\\n vanouthi = kwargs.get('diag_van_median_rate_limit_hi')\\n print 'Setting diag_van_median_rate_limit_hi to ', kwargs.get('diag_van_median_rate_limit_hi')\\n else:\\n vanouthi=100\\n \\n if kwargs.has_key('diag_van_median_rate_limit_lo'):\\n vanoutlo = kwargs.get('diag_van_median_rate_limit_lo')\\n print 'Setting diag_van_median_rate_limit_lo to ', kwargs.get('diag_van_median_rate_limit_lo')\\n else:\\n vanoutlo=0.01\\n \\n if kwargs.has_key('diag_van_median_sigma_lo'):\\n vanlo = kwargs.get('diag_van_median_sigma_lo')\\n print 'Setting diag_van_median_sigma_lo to ', kwargs.get('diag_van_median_sigma_lo')\\n else:\\n vanlo=0.1\\n \\n if kwargs.has_key('diag_van_median_sigma_hi'):\\n vanhi = kwargs.get('diag_van_median_sigma_hi')\\n print 'Setting diag_van_median_sigma_hi to ', kwargs.get('diag_van_median_sigma_hi')\\n else:\\n vanhi=1.5\\n \\n if kwargs.has_key('diag_van_median_sigma'):\\n vansig = kwargs.get('diag_van_median_sigma')\\n print 'Setting diag_van_median_sigma to ', kwargs.get('diag_van_median_sigma')\\n else:\\n vansig=0.0\\n \\n if kwargs.has_key('diag_samp_median_sigma_lo'):\\n samplo = kwargs.get('diag_samp_median_sigma_lo')\\n print 'Setting diag_samp_median_sigma_lo to ', kwargs.get('diag_samp_median_sigma_lo')\\n else:\\n samplo=0.0\\n \\n if kwargs.has_key('diag_samp_median_sigma_hi'):\\n samphi = kwargs.get('diag_samp_median_sigma_hi')\\n print 'Setting diag_samp_median_sigma_hi to ', kwargs.get('diag_samp_median_sigma_hi')\\n else:\\n samphi=2.0\\n \\n if kwargs.has_key('diag_samp_median_sigma'):\\n sampsig = kwargs.get('diag_samp_median_sigma')\\n print 'Setting diag_samp_median_sigma to ', kwargs.get('diag_samp_median_sigma')\\n else:\\n sampsig=3.0\\n \\n if kwargs.has_key('bleed'):\\n bleed_switch = kwargs.get('bleed')\\n print 'Setting bleed ', kwargs.get('bleed')\\n else:\\n print 'bleed set to default'\\n #####diad end########\\n \\n if kwargs.has_key('det_cal_file'):\\n reducer.det_cal_file = kwargs.get('det_cal_file')\\n reducer.relocate_dets = True\\n print 'Setting detector calibration file to ', kwargs.get('det_cal_file')\\n else:\\n print 'Setting detector calibration to detector block info from ', sample_run\\n reducer.det_cal_file =None\\n reducer.relocate_dets = False\\n \\n if mtd.doesExist(str(sample_run))==True and kwargs.has_key('det_cal_file')==False:\\n print 'For data input type: workspace detector calibration must be specified'\\n print 'use Keyword det_cal_file with a valid detctor file or run number'\\n return\\n \\n \\n if kwargs.has_key('one2one'):\\n reducer.map_file =None\\n print 'one2one selected'\\n \\n else:\\n fileName, fileExtension = os.path.splitext(map_file)\\n if (not fileExtension):\\n map_file=map_file+'.map' \\n reducer.map_file = map_file\\n \\n if kwargs.has_key('hardmaskPlus'):\\n HardMaskFile = kwargs.get('hardmaskPlus')\\n print 'Use hardmask from ', HardMaskFile\\n #hardMaskSpec=common.load_mask(HardMaskFile)\\n #MaskDetectors(Workspace='masking',SpectraList=hardMaskSpec)\\n else:\\n HardMaskFile=None\\n \\n reducer.energy_bins = rebin\\n #monovan info\\n fileName, fileExtension = os.path.splitext(monovan_mapfile)\\n if (not fileExtension):\\n monovan_mapfile=monovan_mapfile+'.map'\\n reducer.abs_map_file =monovan_mapfile \\n\\n if kwargs.has_key('abs_units_van_range'):\\n reducer.monovan_integr_range = kwargs.get('abs_units_van_range')\\n print 'Setting absolute units vanadium integratiOn range to ', kwargs.get('abs_units_van_range')\\n else:\\n reducer.monovan_integr_range=[-40,40]\\n \\n #reducer.van_rmm =50.94\\n reducer.van_mass=van_mass\\n #sample info\\n reducer.sample_mass=samp_mass\\n reducer.sample_rmm =samp_rmm\\n \\n print 'output will be normalised to', reducer.normalise_method\\n if (numpy.size(sample_run)) > 1 and kwargs.has_key('sum') and kwargs.get('sum')==True:\\n #this sums the runs together before passing the summed file to the rest of the reduction\\n #this circumvents the inbuilt method of summing which fails to sum the files for diag\\n \\n sumfilename=str(sample_run[0])+'sum'\\n accum=sum_files(sumfilename, sample_run)\\n #the D.E.C. tries to be too clever so we have to fool it into thinking the raw file is already exists as a workpsace\\n RenameWorkspace(InputWorkspace=accum,OutputWorkspace=inst_name+str(sample_run[0])+'.raw')\\n sample_run=sample_run[0]\\n \\n if kwargs.has_key('hardmaskOnly'):\\n hardmask = kwargs.get('hardmaskOnly')\\n print 'Use hardmask from ', hardmask\\n masking=hardmask\\n else:\\n \\n masking = reducer.diagnose(wb_run, \\n sample=mask_run,\\n second_white = None,\\n tiny=tinyval, \\n huge=largeval, \\n van_out_lo=vanoutlo,\\n van_out_hi=vanouthi,\\n van_lo=vanlo,\\n van_hi=vanhi,\\n van_sig=vansig,\\n samp_zero=sampzero,\\n samp_lo=samplo,\\n samp_hi=samphi,\\n samp_sig=sampsig,\\n bkgd_range=background_range, \\n variation=1.1,\\n print_results=True,\\n bleed_test=bleed_switch,\\n bleed_maxrate=rate,\\n bleed_pixels=pixels,\\n hard_mask=HardMaskFile)\\n \\n masking2 = reducer.diagnose(wb_mono, \\n sample=mono_van,\\n second_white = None,\\n tiny=tinyval, \\n huge=largeval, \\n van_out_lo=vanoutlo,\\n van_out_hi=vanouthi,\\n van_lo=vanlo,\\n van_hi=vanhi,\\n van_sig=vansig,\\n samp_zero=sampzero,\\n samp_lo=samplo,\\n samp_hi=samphi,\\n samp_sig=sampsig,\\n bkgd_range=background_range, \\n variation=1.1,\\n print_results=True,\\n bleed_test=bleed_switch,\\n bleed_maxrate=rate,\\n bleed_pixels=pixels,\\n hard_mask=HardMaskFile)\\n \\n total_mask=masking+masking2\\n \\n \\n if kwargs.has_key('use_sam_msk_on_monovan') and kwargs.get('use_sam_msk_on_monovan')==True:\\n print 'applying sample run mask to mono van'\\n reducer.spectra_masks=masking\\n else:\\n reducer.spectra_masks=total_mask\\n \\n fail_list=get_failed_spectra_list('total_mask')\\n \\n \\n print 'Diag found ', len(fail_list),'bad spectra'\\n \\n \\n #Run the conversion\\n deltaE_wkspace = reducer.convert_to_energy(sample_run, ei_guess, wb_run, mono_van,ei_guess,wb_mono)\\n end_time=time.time()\\n results_name=str(sample_run)+'.spe'\\n ei= (deltaE_wkspace.getRun().getLogData(\\\"Ei\\\").value)\\n \\n if mtd.doesExist('_wksp.spe-white')==True:\\n DeleteWorkspace(Workspace='_wksp.spe-white')\\n \\n \\n print 'Incident energy found ',ei,' meV'\\n print 'Elapsed time =',end_time-start_time, 's'\\n #get the name that convert to energy will use\\n \\n if mtd.doesExist(results_name)==False:\\n RenameWorkspace(InputWorkspace=deltaE_wkspace,OutputWorkspace=results_name)\\n RenameWorkspace(InputWorkspace=results_name,OutputWorkspace=wksp_out)\\n \\n return mtd[wksp_out]\",\n \"def plot(self, plottitle, gof_fileroot, indir, outdir,\\n cutoff=0, min_period=0.01, mode=None, colorset=None):\\n\\n # Pick components and labels\\n start_comp = 0\\n\\n if min_period == 0.01:\\n xtick_loc = XTICK_LOC_0_01\\n xtick_label = XTICK_LABEL_0_01\\n elif min_period == 0.1:\\n xtick_loc = XTICK_LOC\\n xtick_label = XTICK_LABEL\\n else:\\n raise bband_utils.ParameterError(\\\"invalid min_period: %f\\\" %\\n (min_period))\\n\\n if mode == \\\"rd50\\\" or mode == \\\"rd50-single\\\":\\n comp_ext = COMP_EXT_RD50\\n comp_title = COMP_TITLE_RD50\\n elif mode == \\\"rd100\\\":\\n comp_ext = COMP_EXT_RD100\\n comp_title = COMP_TITLE_RD100\\n else:\\n raise bband_utils.ParameterError(\\\"plot mode %s unsupported\\\" %\\n (mode))\\n #if mode == \\\"rd50-single\\\" or mode == \\\"rd100\\\":\\n if mode == \\\"rd50-single\\\":\\n # Only plot the last component\\n # rd50 for rd50-single\\n # rd100/rd50 ratio for rd100\\n start_comp = 2\\n\\n # Select colorset\\n if colorset is None:\\n colorset_idx = 0\\n else:\\n colorset_idx = COLORSETS[colorset]\\n\\n # Set plot dims\\n pylab.gcf().set_size_inches(6, 8)\\n pylab.gcf().clf()\\n\\n pylab.subplots_adjust(left=0.125)\\n pylab.subplots_adjust(right=0.9)\\n pylab.subplots_adjust(top=0.85)\\n pylab.subplots_adjust(hspace=0.4)\\n pylab.subplots_adjust(wspace=0.5)\\n\\n period = [[], [], []]\\n bias = [[], [], []]\\n m90 = [[], [], []]\\n p90 = [[], [], []]\\n sigma = [[], [], []]\\n sigma0 = [[], [], []]\\n\\n bias_l = [[], [], []]\\n bias_h = [[], [], []]\\n conf_l = [[], [], []]\\n conf_h = [[], [], []]\\n\\n for compnum in xrange(0, len(comp_ext)):\\n comp = comp_ext[compnum]\\n filenamebase = os.path.join(indir, \\\"%s-%s\\\" % (gof_fileroot, comp))\\n #print(\\\"Reading component files %s.*\\\" % (filenamebase))\\n period[compnum], bias[compnum] = self.read_data(\\\"%s.bias\\\" %\\n (filenamebase),\\n min_period)\\n period[compnum], m90[compnum] = self.read_data(\\\"%s.m90\\\" %\\n (filenamebase),\\n min_period)\\n period[compnum], p90[compnum] = self.read_data(\\\"%s.p90\\\" %\\n (filenamebase),\\n min_period)\\n period[compnum], sigma[compnum] = self.read_data(\\\"%s.sigma\\\" %\\n (filenamebase),\\n min_period)\\n period[compnum], sigma0[compnum] = self.read_data(\\\"%s.sigma0\\\" %\\n (filenamebase),\\n min_period)\\n\\n # Compute bias and conf interval lower/upper bounds\\n for i in xrange(0, len(bias[compnum])):\\n bias_l[compnum].append(bias[compnum][i] - sigma0[compnum][i])\\n bias_h[compnum].append(bias[compnum][i] + sigma0[compnum][i])\\n conf_l[compnum].append(m90[compnum][i])\\n conf_h[compnum].append(p90[compnum][i])\\n\\n # Make sure all components have same number of data points\\n npts = [len(component) for component in period]\\n if npts[1:] != npts[:-1]:\\n print(\\\"Number of data points unequal across components\\\")\\n return\\n\\n # Construct baseline\\n baseline = []\\n for i in xrange(0, len(period[0])):\\n baseline.append(0.0)\\n\\n # Find max, min values\\n min_x = min(period[0])\\n max_x = max(period[0])\\n for comp in period:\\n min_x = min(min_x, min(comp))\\n max_x = max(max_x, max(comp))\\n min_y = MIN_Y_AXIS\\n max_y = MAX_Y_AXIS\\n\\n # Draw each component\\n for compnum in xrange(start_comp, 3):\\n comp = comp_ext[compnum]\\n offset = COMP_OFFSET[compnum]\\n\\n pylab.subplot(offset)\\n pylab.title(comp_title[compnum], size=10)\\n pylab.plot(period[compnum], bias[compnum],\\n color=BIAS_COLORS[colorset_idx],\\n label='_nolegend_')\\n pylab.fill_between(period[compnum], bias_h[compnum],\\n bias_l[compnum],\\n color=BIAS_LH_COLORS[colorset_idx],\\n label='_nolegend_')\\n pylab.fill_between(period[compnum], conf_h[compnum],\\n conf_l[compnum],\\n color=CONF_LH_COLORS[colorset_idx],\\n label='_nolegend_')\\n pylab.plot(period[compnum], baseline, color='grey',\\n label='_nolegend_')\\n pylab.xlim(min_x, max_x)\\n if comp == 'ratio':\\n pylab.ylim(MIN_Y_AXIS_RATIO, MAX_Y_AXIS_RATIO)\\n else:\\n pylab.ylim(min_y, max_y)\\n if compnum == 1:\\n pylab.xlabel(\\\"Period (sec)\\\", size=8)\\n pylab.ylabel(\\\"ln (data/model)\\\", size=8)\\n pylab.xscale('log')\\n pylab.xticks(xtick_loc, xtick_label)\\n pylab.tick_params(labelsize=8)\\n\\n if cutoff == 0:\\n pylab.suptitle('%s' % (plottitle), size=12)\\n else:\\n pylab.suptitle('%s\\\\nR < %d km' % (plottitle, cutoff), size=12)\\n outfile = os.path.join(outdir, \\\"gof-%s.png\\\" % (gof_fileroot))\\n print(\\\"==> Created GoF plot: %s\\\" % (outfile))\\n pylab.savefig(outfile, format=\\\"png\\\",\\n transparent=False, dpi=plot_config.dpi)\\n pylab.close()\",\n \"def plotDistributionWithLimitsOld(lXs, llYs ,out=\\\"out.png\\\", title=\\\"title\\\", xax=\\\"xax\\\", yax=\\\"yax\\\",legend=\\\"\\\"):\\n\\n fig = plt.Figure(figsize=(40,20))\\n fig.suptitle(title, fontsize=32)\\n nbPlots = len(llYs)\\n sqrt = int(math.ceil(math.sqrt(nbPlots)))\\n ymax = 0.0\\n for val in llYs:\\n ymax = max(max(val[0]),ymax)\\n ymaxCurrent = max(max(val[2]),ymax)\\n ymax = ymax*1.05\\n xmax = 147\\n gs = gridspec.GridSpec(1,2) \\n ax = fig.add_subplot(gs[0])\\n gsLimit = gridspec.GridSpecFromSubplotSpec(sqrt,sqrt, subplot_spec=gs[1])\\n for i,val in enumerate(llYs):\\n ax.plot(lXs,val[0],color=Graphics.lColors[i])\\n ax.set_ylim(0,ymax)\\n ax.set_xlim(1,xmax)\\n axCurrent = fig.add_subplot(gsLimit[i]) \\n axCurrent.fill_between(lXs, val[1], val[2], alpha=0.35, edgecolor='black', facecolor=Graphics.lColors[i])\\n for j in val[3:]:\\n axCurrent.plot(lXs,j,color='lightgray')\\n axCurrent.plot(lXs,val[0],color=Graphics.lColors[i])\\n axCurrent.set_ylim(0,ymaxCurrent)\\n axCurrent.set_xlim(1,xmax)\\n# CV = variation(val[0])\\n# axCurrent.text(60, ymaxCurrent*0.7, \\\"CV = {}\\\".format(CV), fontsize=10)\\n axis_font = {'size':'28'}\\n ax.set_xlabel(xax, **axis_font)\\n ax.set_ylabel(yax, **axis_font)\\n ax.tick_params(labelsize=20)\\n if legend:\\n ax.legend(legend)\\n canvas = FigureCanvasAgg(fig)\\n canvas.print_figure(out, dpi=80)\",\n \"def plotSpectrum(inp,xrng=[],yrng=[],xlabel='',ylabel='',xlog=False,ylog=False,grid=False,\\n legend=[],legend_location='upper right',fontscale=1,legend_fontscale=1,title='',\\n color='k',colormap=None,linestyle='-',linewidth=1.5,alpha=1.,\\n show_noise=True,color_noise='k',linestyle_noise='-',linewidth_noise=1.5,alpha_noise=0.5,\\n comparison=None,color_comparison='grey',linestyle_comparison='-',linewidth_comparison=1.5,alpha_comparison=1,\\n residual=False,color_residual='m',linestyle_residual='-',linewidth_residual=1.5,alpha_residual=0.5,\\n telluric=False,color_telluric='grey',linestyle_telluric='-',linewidth_telluric=1.5,alpha_telluric=0.2,\\n features=[],mdwarf=False,ldwarf=False,tdwarf=False,young=False,binary=False,nsamples=100,\\n band=[],band_color='k',band_alpha=0.2,band_label='',band_label_position='bottom',band_width=0.1,\\n show_zero=True,stack=0.,zeropoint=0.,color_zero='k',linestyle_zero=':',linewidth_zero=1.5,alpha_zero=0.3,\\n inset=False,inset_xrange=[],inset_yrange=[],inset_position=[0.65,0.60,0.20,0.20],inset_features=False,\\n output='',multiplot=False,multipage=False,layout=[1,1],figsize=[],tight=True,\\n interactive=False,**kwargs):\\n\\n# keyword parameters (for backward compatability)\\n for k in ['showZero','showzero']: show_zero=kwargs.get(k,show_zero)\\n for k in ['showNoise','noise','uncertainty','shownoise','showuncertainty','show_uncertainty']: show_noise=kwargs.get(k,show_noise)\\n\\n for k in ['line_style','lineStyle','ls','linestyles','line_styles']: linestyle=kwargs.get(k,linestyle)\\n for k in ['line_width','lineWidth','width','lw','linewidths','line_widths']: linewidth=kwargs.get(k,linewidth)\\n for k in ['colors','colour','colours']: color=kwargs.get(k,color)\\n for k in ['colorScheme','color_scheme','colorscheme','colorMap','color_map']: colormap=kwargs.get(k,colormap)\\n\\n for k in ['colornoise','colorNoise','colorUnc','coloruncertainty','color_uncertainty','colorUncertainty']: color_noise=kwargs.get(k,color_noise)\\n for k in ['linestylenoise','line_style_noise','linestyleNoise']: linestyle_noise=kwargs.get(k,linestyle_noise)\\n for k in ['linewidthnoise','linewidthNoise','line_width_noise']: linewidth_noise=kwargs.get(k,linewidth_noise)\\n for k in ['alphanoise','alphaNoise']: alpha_noise=kwargs.get(k,alpha_noise)\\n\\n for k in ['colorzero','colorZero']: color_zero=kwargs.get(k,color_zero)\\n for k in ['linestylezero','line_style_zero','linestyleZero']: linestyle_zero=kwargs.get(k,linestyle_zero)\\n for k in ['linewidthzero','linewidthZero','line_width_zero']: linewidth_zero=kwargs.get(k,linewidth_zero)\\n for k in ['alphazero','alphaZero']: alpha_zero=kwargs.get(k,alpha_zero)\\n\\n for k in ['colorcomparison','colorComparison']: color_comparison=kwargs.get(k,color_comparison)\\n for k in ['linestyleComparison','line_style_comparison','linestylecomparison']: linestyle_comparison=kwargs.get(k,linestyle_comparison)\\n for k in ['linewidthcomparison','linewidthComparison','line_width_comparison']: linewidth_comparison=kwargs.get(k,linewidth_comparison)\\n for k in ['alphacomparison','alphaComparison']: alpha_comparison=kwargs.get(k,alpha_comparison)\\n\\n for k in ['colorresidual','colorResidual']: color_residual=kwargs.get(k,color_residual)\\n for k in ['linestyleresidual','line_style_residual','linestyleResidual']: linestyle_residual=kwargs.get(k,linestyle_residual)\\n for k in ['linewidthresidual','linewidthResidual','line_width_residual']: linewidth_residual=kwargs.get(k,linewidth_residual)\\n for k in ['alpharesidual','alphaResidual']: alpha_residual=kwargs.get(k,alpha_residual)\\n\\n for k in ['bands']: band=kwargs.get(k,band)\\n if len(band) == 2 and isinstance(band[0],list) == False: band = [band]\\n for k in ['bandcolors','bandcolor','band_colors']: band_color=kwargs.get(k,band_color)\\n for k in ['bandalphas','band_alphas','bandalpha']: band_alpha=kwargs.get(k,band_alpha)\\n for k in ['band_labels','bandlabel','bandlabels']: band_label=kwargs.get(k,band_label)\\n for k in ['band_label_positions','bandlabelposition','bandlabelpositions']: band_label_position=kwargs.get(k,band_label_position)\\n for k in ['bandwidth','bandwidths','band_widths']: band_width=kwargs.get(k,band_width)\\n for par in [band_color,band_alpha,band_label,band_label_position,band_width]:\\n if not isinstance(par,list): par = [par]*len(band)\\n if len(par) < len(band): par.extend([par[-1] for x in range(len(band)-len(par))])\\n\\n for k in ['legends','label','labels']: legend=kwargs.get(k,legend)\\n if not isinstance(legend,list): legend = [legend]\\n for k in ['legendfontscale','legendFontscale']: legend_fontscale=kwargs.get(k,legend_fontscale)\\n legend_fontscale=legend_fontscale*fontscale\\n for k in ['legendLocation','legendlocation','labelLocation','labellocation','label_location']: legend_location=kwargs.get(k,legend_location)\\n\\n for k in ['xrange','x_range','wave_range','wrange','wrng']: xrng=kwargs.get(k,xrng)\\n if not isinstance(xrng,list): xrng = [xrng]\\n for k in ['yrange','y_range','flux_range','frange','frng']: yrng=kwargs.get(k,yrng)\\n if not isinstance(yrng,list): yrng = [yrng]\\n\\n for k in ['multilayout','multiLayout','multi_layout']: layout=kwargs.get(k,layout)\\n for k in ['file','filename']: output=kwargs.get(k,output)\\n if not isinstance(output,str): output=''\\n filetype = '.pdf'\\n if output!='': filetype=output.split('.')[-1]\\n\\n if comparison != None and isinstance(comparison,splat.Spectrum) == False and isinstance(comparison,list) == False: \\n print('plotSpectrum() Warning: comparison spectrum should be a splat Spectrum object, you passed {}'.format(comparison))\\n comparison = None\\n\\n# some plotting constants\\n xlabel_default = 'Wavelength'\\n ylabel_deafult = 'Flux'\\n\\n# telluric bands in micron\\n telluric_bands = [[1.1,1.2]*u.micron,[1.3,1.5]*u.micron,[1.75,2.0]*u.micron]\\n\\n# assign features by group\\n if not isinstance(features,list): features = [features]\\n if ldwarf==True or mdwarf==True: features.extend(['k','na','feh','tio','co','h2o','h2'])\\n if tdwarf==True: features.extend(['k','ch4','h2o','h2'])\\n if young==True: features.extend(['vo'])\\n if binary==True: features.extend(['sb'])\\n\\n# clean repeats in features while maintaining order - set does not do this\\n if len(features)>0:\\n fea = []\\n for i in features:\\n if i not in fea: fea.append(i)\\n features = fea\\n\\n\\n# if a list is passed, use this list\\n splist = copy.deepcopy(inp)\\n if isinstance(splist,list) == False: splist = [splist]\\n \\n# set up for multiplot\\n if len(splist) == 1: multiplot = False\\n \\n# array of lists => force multiplot\\n elif len(splist) > 1 and isinstance(splist[0],list) == True: multiplot = True\\n else: pass\\n\\n# reformat array of spectra of multiplot is used (i.e., user forgot to set)\\n if multiplot == True and isinstance(splist[0],splat.Spectrum):\\n splist = [[s] for s in splist]\\n\\n elif multiplot == False and isinstance(splist[0],splat.Spectrum):\\n splist = [splist]\\n \\n# flatten array if multiplot is not set\\n elif multiplot == False and isinstance(splist[0],list) and len(splist) > 1:\\n splist = [[item for sublist in splist for item in sublist]] # flatten\\n else: pass\\n\\n# total number of spectra - use to assign default legends\\n allsps = [item for sublist in splist for item in sublist] # Total number of spectra\\n if len(legend) == 0: legend=[sp.name for sp in allsps]\\n if len(legend) < len(allsps):\\n legend.extend([allsps[i].name for i in range(len(legend),len(allsps)-len(legend))])\\n \\n\\n# now run a loop through the input subarrays\\n plt.close('all')\\n\\n# set up here for multiple file output\\n nplot = 1\\n if multipage == True or multiplot == True:\\n nplot = layout[0]*layout[1]\\n numpages = int(len(splist) / nplot) + 1\\n if (len(splist) % nplot == 0):\\n numpages -= 1\\n fig = []\\n \\n if multipage == True and filetype.lower() == 'pdf':\\n pdf_pages = PdfPages(output)\\n \\n if multipage == False:\\n if len(splist) > 1:\\n filebase = output.replace('.{}'.format(filetype),'')\\n files = [filebase+'{}.'.format(i+1)+filetype for i in numpy.arange(len(splist))]\\n else:\\n files = [output]\\n\\n pg_n = 0 # page counter\\n plt_n = 0 # plot per page counter\\n lg_n = 0 # legend per plot counter\\n\\n for plts,sp in enumerate(splist):\\n# set specific plot parameters\\n if not isinstance(sp[0],splat.Spectrum):\\n raise ValueError('\\\\nInput to plotSpectrum has wrong format:\\\\n\\\\n{}\\\\n\\\\n'.format(sp[0]))\\n\\n# set up plotting defaults for the list of spectra - REPLACE THIS\\n if not isinstance(zeropoint,list): zeropoint = [zeropoint]*len(sp)\\n if len(zeropoint) < len(sp): zeropoint.extend([zeropoint[-1] for x in range(len(sp)-len(zeropoint))])\\n if not isinstance(color,list): color = [color]*len(sp)\\n if len(color) < len(sp): color.extend([color[-1] for x in range(len(sp)-len(color))])\\n if not isinstance(linestyle,list): linestyle = [linestyle]*len(sp)\\n if len(linestyle) < len(sp): linestyle.extend([linestyle[-1] for x in range(len(sp)-len(linestyle))])\\n if not isinstance(linewidth,list): linewidth = [linewidth]*len(sp)\\n if len(linewidth) < len(sp): linewidth.extend([linewidth[-1] for x in range(len(sp)-len(linewidth))])\\n if not isinstance(alpha,list): alpha = [alpha]*len(sp)\\n if len(alpha) < len(sp): alpha.extend([alpha[-1] for x in range(len(sp)-len(alpha))])\\n if not isinstance(color_noise,list): color_noise = [color_noise]*len(sp)\\n if len(color_noise) < len(sp): color_noise.extend([color_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(linestyle_noise,list): linestyle_noise = [linestyle_noise]*len(sp)\\n if len(linestyle_noise) < len(sp): linestyle_noise.extend([linestyle_noise[-1] for x in range(len(sp)-len(linestyle_noise))])\\n if not isinstance(linewidth_noise,list): linewidth_noise = [linewidth_noise]*len(sp)\\n if len(linewidth_noise) < len(sp): linewidth_noise.extend([linewidth_noise[-1] for x in range(len(sp)-len(linewidth_noise))])\\n if not isinstance(alpha_noise,list): alpha_noise = [alpha_noise]*len(sp)\\n if len(alpha_noise) < len(sp): alpha_noise.extend([alpha_noise[-1] for x in range(len(sp)-len(color_noise))])\\n if not isinstance(color_comparison,list): color_comparison = [color_comparison]*len(sp)\\n if len(color_comparison) < len(sp): color_comparison.extend([color_comparison[-1] for x in range(len(sp)-len(color_comparison))])\\n if not isinstance(linestyle_comparison,list): linestyle_comparison = [linestyle_comparison]*len(sp)\\n if len(linestyle_comparison) < len(sp): linestyle_comparison.extend([linestyle_comparison[-1] for x in range(len(sp)-len(linestyle_comparison))])\\n if not isinstance(linewidth_comparison,list): linewidth_comparison = [linewidth_comparison]*len(sp)\\n if len(linewidth_comparison) < len(sp): linewidth_comparison.extend([linewidth_comparison[-1] for x in range(len(sp)-len(linewidth_comparison))])\\n if not isinstance(alpha_comparison,list): alpha_comparison = [alpha_comparison]*len(sp)\\n if len(alpha_comparison) < len(sp): alpha_comparison.extend([alpha_comparison[-1] for x in range(len(sp)-len(alpha_comparison))])\\n\\n# settings that work if the spectrum was read in as legitmate Spectrum object\\n try:\\n xlabel = kwargs.get('xlabel','{} ({})'.format(sp[0].wave_label,sp[0].wave.unit))\\n ylabel = kwargs.get('ylabel','{} ({})'.format(sp[0].flux_label,sp[0].flux.unit))\\n except:\\n xlabel = kwargs.get('xlabel',xlabel_default)\\n ylabel = kwargs.get('ylabel',ylabel_default)\\n# initial plot range\\n bound = [numpy.nanmin(sp[0].wave.value),numpy.nanmax(sp[0].wave.value)]\\n ymax = [numpy.nanquantile(s.flux.value,0.98) for s in sp]\\n bound.extend(numpy.array([-0.02,1.3])*numpy.nanmax(ymax)+\\\\\\n numpy.array([numpy.nanmin(zeropoint),numpy.nanmax(zeropoint)+stack*(len(sp)-1)]))\\n\\n# set colormap if provided\\n if colormap != None:\\n values = numpy.arange(len(sp))\\n color_map = plt.get_cmap(colormap)\\n norm = colmap.Normalize(vmin=0, vmax=1.0*values[-1])\\n scalarMap = cm.ScalarMappable(norm=norm, cmap=color_map)\\n for i in range(len(sp)): color[i] = scalarMap.to_rgba(values[i])\\n\\n# GENERATE PLOTS\\n if multiplot == True or multipage == True:\\n plt_n = plts % nplot\\n if (plt_n == 0):\\n fig.append(plt.figure())\\n pg_n += 1\\n ax = fig[pg_n-1].add_subplot(layout[0], layout[1], plt_n+1)\\n \\n# plotting a single plot with all spectra\\n else:\\n plt.close('all')\\n plt_n = 0\\n fig = []\\n if len(figsize)>0: fig.append(plt.figure(figsize=figsize))\\n else: fig.append(plt.figure())\\n ax = fig[0].add_subplot(111)\\n \\n for ii, a in enumerate(sp):\\n# zeropoint and stack\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n if stack > 0: flx = [f + (len(sp)-ii-1)*stack for f in flx]\\n ax.plot(a.wave.value,flx,color=color[ii],linestyle=linestyle[ii], lw=linewidth[ii], alpha=alpha[ii], zorder = 10, label = legend[lg_n]) \\n\\n# add comparison\\n if comparison != None:\\n# zeropoint and stack\\n cflx = [i+zeropoint[ii] for i in comparison.flux.value]\\n if stack > 0: cflx = [f + (len(sp)-ii-1)*stack for f in cflx]\\n ax.plot(comparison.wave.value,cflx,color=color_comparison[ii],linestyle=linestyle_comparison[ii], lw=linewidth_comparison[ii], alpha=alpha_comparison[ii], zorder = 10)\\n \\n# add residual\\n if residual == True and len(sp) == 2:\\n # Save flux values from first spectrum\\n if ii == 0:\\n flx0 = [f - (len(sp)-ii-1)*stack for f in flx]\\n \\n # Subtract fluxes and plot\\n elif ii == 1:\\n res = [flx0[f_n] - f for f_n, f in enumerate(flx)]\\n ax.plot(a.wave.value, res, alpha = alpha_residual[ii], color = color_residual[ii], linsetyle=linestyle_residual[ii], lw=linewidth_residual[ii])\\n \\n # Fix bound[2] if residual goes below 0\\n if numpy.nanmin(res) < bound[2]:\\n b0 = numpy.argmin(a.wave.value[a.wave.value > bound[0]])\\n b1 = numpy.argmax(a.wave.value[a.wave.value < bound[1]])\\n bound[2] = numpy.nanmin(res[b0:b1])\\n\\n# noise\\n if show_noise == True:\\n ns = [i+zeropoint[ii] for i in a.noise.value]\\n ax.plot(a.wave.value,ns,color=color_noise[ii],linestyle=linestyle_noise[ii],alpha=alpha_noise[ii], lw=linewidth_noise[ii], zorder = 10)\\n\\n# zeropoint\\n if show_zero == True:\\n ze = numpy.ones(len(a.flux))*zeropoint[ii]\\n ax.plot(a.wave.value,ze,color=color[ii],linestyle=linestyle_zero,alpha=alpha_zero,lw=linewidth_zero, zorder = 10)\\n\\n# save maximum flux among all spectra for plotting\\n# THIS IS VERY SLOW AND IT WOULD BE BETTER TO FIND AN ALTERNATE APPROACH\\n if len(features)>0:\\n f = interp1d(a.wave,flx,bounds_error=False,fill_value=0.)\\n if ii == 0: \\n wvmax = numpy.linspace(bound[0],bound[1],nsamples)\\n flxmax = numpy.array(f(wvmax))\\n else: flxmax = numpy.maximum(flxmax,numpy.array(f(wvmax)))\\n\\n# legend counter\\n lg_n = lg_n + 1 # Increment legend\\n\\n\\n# label features\\n# THIS NEEDS TO BE FIXED WITH GRETEL'S STUFF\\n if len(features) > 0:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n fontsize = int((10-numpy.nanmin([(layout[0]*layout[1]-1),6]))*fontscale)\\n for ftr in features:\\n ftr = ftr.lower()\\n if ftr in FEATURE_LABELS:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n# features must be contained in plot range (may change this)\\n if numpy.nanmin(wRng) > bound[0] and numpy.nanmax(wRng) < bound[1]:\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n\\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax.plot(wRng,[y+yoff]*2,color='k',linestyle='-')\\n ax.plot([wRng[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n else:\\n for w in wRng: ax.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax.text(numpy.mean(wRng),y+1.5*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=fontsize)\\n bound[3] = numpy.nanmax([numpy.nanmax(flxmax)+2.*yoff,bound[3]])\\n\\n# add grid\\n if grid == True: ax.grid() \\n\\n# axis labels \\n fontsize = (numpy.round(numpy.max([13./((layout[0]*layout[1])**0.33),5]))) * fontscale\\n legend_fontsize = (13-numpy.min([(layout[0]*layout[1]-1),8])) * legend_fontscale\\n ax.set_xlabel(xlabel, fontsize = fontsize)\\n ax.set_ylabel(ylabel, fontsize = fontsize)\\n ax.tick_params(axis='x', labelsize=fontsize)\\n ax.tick_params(axis='y', labelsize=fontsize)\\n\\n# add title\\n if title!='': ax.set_title(title)\\n\\n# log scale?\\n if kwargs.get('xlog',False): ax.set_xscale('log',nonposx='clip')\\n if kwargs.get('ylog',False): ax.set_yscale('log',nonposy='clip')\\n\\n# place legend\\n if len(legend) > 0:\\n if legend_location == 'outside':\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * 0.15, box.width * 0.7, box.height * 0.7])\\n ax.legend(loc='center left', bbox_to_anchor=(1, 0.5), prop={'size':legend_fontsize})\\n else:\\n ax.legend(loc=legend_location, prop={'size':legend_fontsize})\\n bound[3] = bound[3]+0.1*(bound[3]-bound[2]) # extend axis for in-plot legends\\n\\n# overplot telluric absorption\\n if telluric == True:\\n yoff = 0.02*(bound[3]-bound[2]) # label offset\\n for waveRng in telluric_bands:\\n wR = waveRng.to(sp[0].wave.unit).value\\n rect = patches.Rectangle((wR[0],bound[2]),wR[1]-wR[0],bound[3]-bound[2],facecolor=color_telluric,alpha=alpha_telluric,color=color_telluric)\\n ax.add_patch(rect)\\n ax.text(numpy.mean(wR),bound[2]+3*yoff,r'$\\\\oplus$',horizontalalignment='center',fontsize=fontsize)\\n\\n# overplot color swaths for pre-specified bands\\n if len(band) > 0:\\n for i,b in enumerate(band):\\n if not isinstance(b,list): \\n try: b = [float(b)-0.5*band_width,float(b)+0.5*band_width]\\n except:\\n print('\\\\nWarning: plotSpectrum bands variables should be array of 2-element arrays; you passed {}'.format(band))\\n b = [0.,0.]\\n rect = patches.Rectangle((b[0],bound[2]),b[1]-b[0],bound[3]-bound[2],facecolor=band_color[i],color=band_color[i],alpha=band_alpha[i])\\n ax.add_patch(rect)\\n if band_label_position[i].lower() == 'top':\\n ax.text(numpy.mean(b),bound[3]-3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n elif band_label_position[i].lower() == 'middle':\\n ax.text(numpy.mean(b),0.5*(bound[2]+bound[3]),band_label[i],horizontalalignment='center',fontsize=fontsize)\\n else:\\n ax.text(numpy.mean(b),bound[2]+3*yoff,band_label[i],horizontalalignment='center',fontsize=fontsize)\\n\\n# place inset - RIGHT NOW ONLY SETTING LIMITS WITH FIRST SPECTRUM IN LIST\\n if inset == True and len(inset_xrange) == 2:\\n ax_inset = fig[pg_n-1].add_axes(inset_position) #, axisbg='white')\\n bound2 = inset_xrange\\n if len(inset_yrange) == 0:\\n b0 = numpy.argmax(sp[0].wave.value > bound2[0])\\n b1 = numpy.argmin(sp[0].wave.value < bound2[1])\\n inset_yrange = [numpy.nanmin(sp[0].flux.value[b0:b1]),numpy.nanmax(sp[0].flux.value[b0:b1])]\\n bound2.extend(inset_yrange)\\n db = (bound2[3]-bound2[2])\\n bound2[2] = bound2[2]-0.05*db\\n bound2[3] = bound2[3]+0.05*db\\n ax_inset.axis(bound2)\\n inset_fontsize = fontsize*0.7\\n\\n for ii,a in enumerate(sp):\\n flx = [i+zeropoint[ii] for i in a.flux.value]\\n ax_inset.plot(a.wave.value,flx,color=colors[ii],linestyle=linestyle[ii],linewidth=linewidth[ii],alpha=alpha[ii]) \\n ax_inset.set_xlabel('')\\n ax_inset.set_ylabel('')\\n ax_inset.tick_params(axis='x', labelsize=inset_fontsize)\\n ax_inset.tick_params(axis='y', labelsize=inset_fontsize)\\n# ax_inset.legend()\\n\\n# inset feature labels\\n if len(inset_features) > 0:\\n yoff = 0.05*(bound2[3]-bound2[2])\\n for ftr in inset_features:\\n ftrc = checkDict(ftr,FEATURE_LABELS)\\n if ftrc != False:\\n for ii,waveRng in enumerate(FEATURE_LABELS[ftrc]['wavelengths']):\\n wRng = waveRng.to(sp[0].wave.unit).value\\n if (numpy.min(wRng) > bound2[0] and numpy.max(wRng) < bound2[1]):\\n wfeature = numpy.where(numpy.logical_and(wvmax >= numpy.nanmin(wRng),wvmax <= numpy.nanmax(wRng)))\\n if len(wvmax[wfeature]) == 0: wfeature = numpy.argmax(numpy.absolute(wvmax-numpy.nanmedian(wRng)))\\n y = numpy.nanmax(flxmax[wfeature])+yoff\\n flxmax[wfeature] = flxmax[wfeature]+3.*yoff\\n \\n if FEATURE_LABELS[ftrc]['type'] == 'band':\\n ax_inset.plot(wR,[y+yoff]*2,color='k',linestyle='-')\\n ax_inset.plot([wR[0]]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n else:\\n for w in waveRng:\\n ax_inset.plot([w]*2,[y,y+yoff],color='k',linestyle='-')\\n ax_inset.text(numpy.mean(wR),y+2*yoff,FEATURE_LABELS[ftrc]['label'],horizontalalignment='center',fontsize=inset_fontsize)\\n waveRng = [wR[0]-0.02,wR[1]+0.02] # for overlap\\n \\n# update offset\\n if len(inset_features) > 0: bound2[3] = numpy.nanmax([bound2[3],numpy.nanmax(flxmax)+5.*yoff])\\n ax_inset.axis(bound2)\\n\\n# finalize bounding\\n if len(xrng) > 0: bound[0:2] = xrng\\n if len(yrng) > 0: bound[2:4] = yrng\\n if isUnit(bound[0]): bound = [x.value for x in bound]\\n ax.axis(bound)\\n \\n# save to file or display\\n# ERROR HERE - CHECK WHAT FILES\\n if multipage == False:\\n if files[plts] != '' and (plts % nplot == 3 or plts == len(splist)-1):\\n if kwargs.get('tight',True) == True: \\n plt.savefig(files[plts], bbox_inches='tight')\\n else:\\n plt.savefig(files[plts])\\n if output == '' and not kwargs.get('web',False):\\n plt.show()\\n if (kwargs.get('interactive',False) != False): plt.ion()\\n else: plt.ioff()\\n\\n\\n# save figures in multipage format and write off pdf file\\n if multipage == True: \\n for pg_n in numpy.arange(numpages):\\n# fig[pg_n].text(0.5, 0.04, xlabel, ha = 'center', va = 'center')\\n# fig[pg_n].text(0.06, 0.5, ylabel, ha = 'center', va = 'center', rotation = 'vertical')\\n fig[pg_n].tight_layout\\n fig[pg_n].suptitle(title, fontsize = int(14*fontsize), fontweight = 'bold')\\n pdf_pages.savefig(fig[pg_n])\\n if filetype.lower() == 'pdf':\\n pdf_pages.close()\\n\\n plt.clf()\\n return fig\",\n \"def plot_input_data(data_path,file_name,plots_folder,format_type,lower_matrix,upper_matrix,normalized=False,output_name=None):\\n if output_name is None:\\n aux = ['input_data']\\n else:\\n aux = [output_name,'input_data']\\n if normalized is True:\\n aux.append('normalized')\\n plot_file_name = '-'.join(aux)+'.png'\\n plot_file_name = os.path.join(plots_folder,plot_file_name)\\n\\n M_max, M = check_format_input(data_path,file_name,lower_matrix,upper_matrix,format_type,return_M = True,create_input_file=False)\\n plt.figure()\\n plt.subplot(111,aspect='equal')\\n if(normalized):\\n plt.imshow(M/float(M_max), cmap=plt.cm.Oranges, interpolation=\\\"nearest\\\")\\n plt.colorbar()\\n plt.title('Input data (normalized)')\\n\\n plt.savefig(plot_file_name)\\n print 'Saved input data plot in %s' % plot_file_name\\n else:\\n plt.imshow(M, cmap=plt.cm.Oranges, interpolation=\\\"nearest\\\")\\n plt.colorbar()\\n plt.title('Input data')\\n plt.savefig(plot_file_name)\\n print 'Saved input data plot in %s' % plot_file_name\\n return()\",\n \"def updateParameters(self):\\n\\n if self.params[1].value:\\n if arcpy.Exists(self.params[1].value):\\n try:\\n min_value = arcpy.GetRasterProperties_management(self.params[1].value, \\\"MINIMUM\\\")[0]\\n\\n if str(self.params[8].value) != str(self.params[1].value):\\n self.params[7].value = True\\n self.params[8].value = str(self.params[1].value)\\n else:\\n self.params[7].value = False\\n\\n if str(min_value) == \\\"0\\\":\\n if self.params[7].value == True:\\n self.params[2].value = True\\n self.params[3].enabled = True\\n self.params[7].value = False\\n else:\\n self.params[2].value = False\\n self.params[3].enabled = False\\n\\n except arcpy.ExecuteError:\\n pass\\n\\n if self.params[2].value == True:\\n self.params[3].enabled = True\\n else:\\n self.params[3].enabled = False\",\n \"def spider(inputfiles, names, type=\\\"M1\\\", threshold=0.1, spinwindow=[], Eg_low=0, Eg_high=1e9, Ex_low=0, Ex_high=1e9, scale=2):\\n\\n Nsp = np.ceil(np.sqrt(len(inputfiles))).astype(int)\\n f, ax_list = plt.subplots(Nsp,Nsp,squeeze=False,sharex='col', sharey='row')\\n\\n for i in range(len(inputfiles)):\\n inputfile = inputfiles[i]\\n name = names[i]\\n ax = ax_list[i%Nsp][int((i-i%Nsp)/Nsp)]\\n\\n\\n levels = read_energy_levels(inputfile)\\n Egs = levels[0,0]\\n\\n Ex_high = min(Ex_high, levels[:,0].max()-Egs)\\n Eg_high = min(Eg_high, levels[:,0].max()-Egs)\\n \\n \\n levels_plot_J = []\\n levels_plot_Ex = []\\n for iEx in range(len(levels[:,0])):\\n # print levels[iEx,:]\\n J2 = levels[iEx,1]\\n par = levels[iEx,2]\\n if len(spinwindow) > 0 and not ([J2,par] in spinwindow or [J2-2,par] in spinwindow or [J2+2,par] in spinwindow):\\n continue\\n Ex = levels[iEx,0]-Egs\\n if Ex < Ex_low or Ex > Ex_high:\\n continue\\n \\n levels_plot_J.append(J2/2)\\n levels_plot_Ex.append(Ex)\\n \\n ax.plot(levels_plot_J, levels_plot_Ex, 'o', color='grey', linewidth=0.5)\\n ax.set_xlim([levels[:,1].min()/2-1,levels[:,1].max()/2+1])\\n ax.set_title(name+r'$\\\\,E_\\\\gamma\\\\in[{:.1f},{:.1f}]$'.format(Eg_low,Eg_high))\\n ax.set_ylabel(r'$E_x\\\\,\\\\mathrm{[MeV]}$')\\n ax.set_xlabel(r'$J\\\\,\\\\mathrm{[\\\\hbar]}$')\\n \\n \\n \\n transitions = read_transition_strengths(inputfile, type=type)\\n for iEx in range(len(transitions[:,0])):\\n J2i = int(transitions[iEx,0])\\n pari = int(transitions[iEx,1])\\n if len(spinwindow) > 0 and not [J2i,pari] in spinwindow:\\n continue\\n B = transitions[iEx,7]\\n Eg = transitions[iEx,6]\\n if B < threshold or Eg<Eg_low or Eg>Eg_high:\\n continue\\n Ei = transitions[iEx,2]-Egs\\n if Ei < Ex_low or Ei > Ex_high:\\n continue\\n J2f = int(transitions[iEx,3])\\n parf = int(transitions[iEx,4])\\n Ef = transitions[iEx,5]-Egs\\n ax.plot([J2i/2,J2f/2],[Ei,Ef], color='teal', linewidth=(scale*B))\\n \\n return f, ax_list\",\n \"def minmax ( self , nshoots = 100000 ) :\\n ## try to get minmax directly from pdf/function \\n if self.tricks and hasattr ( self.pdf , 'function' ) :\\n if hasattr ( self.pdf , 'setPars' ) : self.pdf.setPars() \\n f = self.pdf.function()\\n if hasattr ( f , 'minmax' ) :\\n try :\\n mn , mx = f.minmax()\\n if 0<= mn and mn <= mx and 0 < mx : \\n return mn , mx\\n except :\\n pass\\n if hasattr ( f , 'max' ) :\\n try :\\n mx = f.max()\\n if 0 < mx : return 0 , mx\\n except :\\n pass\\n\\n ## check RooAbsReal functionality\\n code = self.pdf.getMaxVal( ROOT.RooArgSet ( self.xvar , self.yvar ) )\\n if 0 < code :\\n mx = self.pdf.maxVal ( code )\\n if 0 < mx : return 0 , mx\\n \\n ## not try to use random\\n \\n mn , mx = -1 , -10\\n if hasattr ( self.pdf , 'min' ) : mn = self.pdf.min()\\n if hasattr ( self.pdf , 'max' ) : mx = self.pdf.max()\\n if 0 <= mn and mn <= mx and 0 < mx : return mn , mx\\n \\n if not self.xminmax() : return ()\\n if not self.yminmax() : return ()\\n \\n mn , mx = -1 , -10\\n xmn , xmx = self.xminmax()\\n ymn , ymx = self.yminmax()\\n for i in range ( nshoots ) : \\n xx = random.uniform ( xmn , xmx )\\n yy = random.uniform ( ymn , ymx )\\n with SETVAR ( self.xvar ) :\\n with SETVAR ( self.yvar ) :\\n self.xvar.setVal ( xx )\\n self.yvar.setVal ( yy )\\n vv = self.pdf.getVal()\\n if mn < 0 or vv < mn : mn = vv\\n if mx < 0 or vv > mx : mx = vv\\n \\n return mn , mx\",\n \"def percentile_plots_ref(plot_var, i_case, plot_var_ref, i_case_ref, plot_settings_abs, plot_settings_rel):\\n column_titles = [\\\"5th percentile\\\", \\\"32nd percentile\\\", \\\"50th percentile\\\"]\\n row_titles = ['Absolute value', 'Relative to reference case']\\n plot_var_suffix = [\\\"_perc5\\\", \\\"_perc32\\\", \\\"_perc50\\\"]\\n\\n # Read data from NetCDF source file.\\n plot_items = [[], []]\\n plot_data_max, plot_data_relative_max = 0, 0\\n for s in plot_var_suffix:\\n d = nc.variables[plot_var+s][i_case, :, :]\\n if plot_var[0] == \\\"p\\\":\\n d *= 1e-3\\n plot_items[0].append({'data': d})\\n if np.amax(d) > plot_data_max:\\n plot_data_max = np.amax(d)\\n\\n d_ref = nc.variables[plot_var_ref+s][i_case_ref, :, :]\\n if plot_var[0] == \\\"p\\\":\\n d_ref *= 1e-3\\n d_relative = d/d_ref\\n plot_items[1].append({'data': d_relative})\\n if np.amax(d_relative) > plot_data_relative_max:\\n plot_data_relative_max = np.amax(d_relative)\\n\\n print(\\\"Max absolute and relative value are respectively {:.2f} and {:.2f}\\\"\\n .format(plot_data_max, plot_data_relative_max))\\n\\n # Mapping plot properties and splitting up into individual and shared properties.\\n plot_handling = plot_settings_abs[\\\"plot_handling\\\"]\\n contour_fill_levels = plot_handling[\\\"contour_fill_levels\\\"]\\n contour_line_levels = plot_handling.get(\\\"contour_line_levels\\\", 3*[contour_fill_levels])\\n colorbar_ticks = plot_handling.get(\\\"colorbar_ticks\\\", contour_fill_levels)\\n\\n contour_fill_levels_rel = plot_settings_rel[\\\"contour_fill_levels\\\"]\\n contour_line_levels_rel = plot_settings_rel.get(\\\"contour_line_levels\\\", 3*[contour_fill_levels_rel])\\n colorbar_ticks_rel = plot_settings_rel.get(\\\"colorbar_ticks\\\", contour_fill_levels_rel)\\n\\n # Write the contour handling to plot_items.\\n for i, plot_item in enumerate(plot_items[0]):\\n plot_item['contour_line_levels'] = contour_line_levels[i]\\n for i, plot_item in enumerate(plot_items[1]):\\n plot_item['contour_line_levels'] = contour_line_levels_rel[i]\\n\\n # Write the row dependent settings to row_items.\\n row_items = []\\n for i in range(2):\\n row_items.append({\\n 'title': row_titles[i],\\n })\\n row_items[0]['colorbar_ticks'] = colorbar_ticks\\n row_items[0]['colorbar_label'] = plot_settings_abs[\\\"color_label\\\"]\\n row_items[0]['contour_fill_levels'] = contour_fill_levels\\n if 'colorbar_tick_fmt' in plot_handling:\\n row_items[0]['colorbar_tick_fmt'] = plot_handling[\\\"colorbar_tick_fmt\\\"]\\n row_items[0]['contour_line_label_fmt'] = '%.1f'\\n\\n row_items[1]['colorbar_ticks'] = colorbar_ticks_rel\\n row_items[1]['colorbar_label'] = \\\"Increase factor [-]\\\"\\n row_items[1]['contour_fill_levels'] = contour_fill_levels_rel\\n if 'colorbar_tick_fmt' in plot_settings_rel:\\n row_items[1]['colorbar_tick_fmt'] = plot_settings_rel[\\\"colorbar_tick_fmt\\\"]\\n row_items[1]['extend'] = plot_settings_rel.get('extend', \\\"neither\\\")\\n\\n plot_panel_2x3(plot_items, column_titles, row_items)\",\n \"def doParametersOfInterest(self):\\n ''' ref : physicsmodel -> rvf\\n self.modelBuilder.out.var(\\\"MH\\\").setRange(float(self.mHRange[0]),float(self.mHRange[1]))\\n self.modelBuilder.out.var(\\\"MH\\\").setConstant(False)\\n '''\\n\\n self.modelBuilder.doVar(\\\"mu[0,0,1000]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doVar(\\\"Fvbf[0,0,1]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doSet(\\\"POI\\\",\\\"mu,Fvbf\\\")\\n self.modelBuilder.doVar(\\\"\\\")\\n self.modelBuilder.factory_('expr::ggH_s_func(\\\"(@0-sqrt(@0))*(1.-@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::ggH_b_func(\\\"(1-sqrt(@0))*(1.-@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\\\"sqrt(@0)*(1.-@1)\\\", mu,Fvbf)')\\n\\n self.modelBuilder.factory_('expr::vbfH_s_func(\\\"(@0-sqrt(@0))*(@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::vbfH_b_func(\\\"(1-sqrt(@0))*(@1)\\\", mu,Fvbf)')\\n self.modelBuilder.factory_( 'expr::vbfH_sbi_func(\\\"sqrt(@0)*(@1)\\\", mu,Fvbf)')\",\n \"def plot_shape_mcnp(self, e_min, e_max, logy=False, norm=False, marker='o', ax_mpl=None, plt_arrow=True):\\n assert self.shape_dict_mcnp is not None\\n if norm:\\n _shape_df = self.shape_df_mcnp_norm\\n _y_label = 'Ratio out of max flux of each energy'\\n else:\\n _shape_df = self.shape_df_mcnp\\n _y_label = 'Flux (n/sterad/pulse)'\\n\\n # Only the energy provided by MCNPX simulation will be filtered\\n _energy_list_dropped = self._form_energy_list_dropped(e_min=e_min, e_max=e_max)\\n if ax_mpl is None:\\n fig, ax_mpl = plt.subplots()\\n ax_mpl.set_prop_cycle(default_cycler)\\n for each in _energy_list_dropped:\\n if logy:\\n ax_mpl.semilogy(_shape_df['t_us'],\\n _shape_df[each],\\n linestyle='-',\\n marker=marker,\\n # fmt=marker,\\n label=str(each) + ' eV (MCNPX)')\\n else:\\n ax_mpl.plot(_shape_df['t_us'],\\n _shape_df[each],\\n linestyle='-',\\n marker=marker,\\n # fmt=marker,\\n label=str(each) + ' eV (MCNPX)')\\n ax_mpl.set_ylabel(_y_label)\\n ax_mpl.set_xlabel(u'Time (\\\\u03BCs)')\\n ax_mpl.grid()\\n if len(_energy_list_dropped) <= 7:\\n ax_mpl.legend()\\n else:\\n if plt_arrow:\\n _plot_ev_arrow_as_legend(ax=ax_mpl, ev_list=_energy_list_dropped)\\n ax_mpl.set_title('Energy dependent neutron pulse shape (MCNPX)')\\n ax_mpl.set_xlim(left=mcnp_plot_lim_dict['x_min'], right=mcnp_plot_lim_dict['x_max'])\\n return ax_mpl\",\n \"def sac_paper_plot(log_dir, det_policy_sublocation,act_0,act_1,act_2,is_tri,actions_to_plot_large=10,\\n actions_to_plot_small = 100,actions_per_log = 6000, custom_colors=None,prot_linewidth=2.7,\\n reward_linewidth = None,plot_file_name = None,small_action_ylim=None,large_action_ylim=None,\\n reward_ylim=None,reward_ylabel=None, reward_plot_extra_args = None,\\n reward_plot_extra_kwargs = None,extra_cycles=None,extra_cycles_linewidth=None,\\n reward_legend_labels=None,action_legend_lines=None,action_legend_text=None,\\n action_legend_location=None):\\n\\n #get location of files\\n running_reward_file, _, actions_file = \\\\\\n sac_logs_file_location(log_dir, is_tri, None,None,None)\\n\\n #font size\\n matplotlib.rcParams.update({'font.size': 14, \\\"text.usetex\\\": True,\\n 'text.latex.preamble' : r'\\\\usepackage{amsmath}\\\\usepackage{physics}'})\\n\\n #create the axis (subplots)\\n fig = plt.figure(constrained_layout=True, figsize=(6,5))\\n gs = gridspec.GridSpec(3, 3, figure=fig, height_ratios = [1,0.7,1])\\n reward_ax = fig.add_subplot(gs[0, :])\\n prot_0_ax = fig.add_subplot(gs[1, 0])\\n prot_1_ax = fig.add_subplot(gs[1, 1],sharey=prot_0_ax)\\n prot_2_ax = fig.add_subplot(gs[1, 2],sharey=prot_0_ax)\\n prot_final_ax = fig.add_subplot(gs[2, :])\\n plt.setp(prot_1_ax.get_yticklabels(), visible=False)\\n plt.setp(prot_2_ax.get_yticklabels(), visible=False) \\n\\n #set the reward axis\\n plot_running_reward_on_axis(running_reward_file, reward_ax, plot_to_file_line = None, linewidth=reward_linewidth,\\n custom_color = \\\"black\\\", lines_to_mark = [nearest_int(act_0/actions_per_log),\\n nearest_int(act_1/actions_per_log),nearest_int(act_2/actions_per_log)],\\n custom_mark_color=\\\"black\\\",ylim=reward_ylim,ylabel=reward_ylabel,\\n plot_extra_args=reward_plot_extra_args, plot_extra_kwargs=reward_plot_extra_kwargs,\\n legend_labels=reward_legend_labels)\\n\\n #set the three actions axis\\n plot_actions_on_axis(actions_file, prot_0_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n actions_ylim=small_action_ylim,plot_to_file_line=act_0,\\n custom_colors=custom_colors,constant_steps=True, linewidth = prot_linewidth,\\n two_xticks=True)\\n plot_actions_on_axis(actions_file, prot_1_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n plot_to_file_line=act_1,ylabel=\\\"\\\",custom_colors=custom_colors,\\n constant_steps=True, linewidth = prot_linewidth,two_xticks=True)\\n plot_actions_on_axis(actions_file, prot_2_ax, is_tri=is_tri, actions_to_plot=actions_to_plot_small,\\n plot_to_file_line=act_2, ylabel=\\\"\\\",custom_colors=custom_colors,\\n constant_steps=True, linewidth = prot_linewidth, two_xticks=True)\\n\\n #set the final protocol axis\\n plot_actions_on_axis(log_dir + det_policy_sublocation, prot_final_ax, is_tri, actions_to_plot=actions_to_plot_large,\\n actions_ylim=large_action_ylim,plot_to_file_line=None,\\n custom_colors=custom_colors, constant_steps=True, k_notation=False, x_count_from_zero=True,\\n linewidth = prot_linewidth, xlabel=\\\"$t[dt]$\\\",extra_cycles=extra_cycles,\\n extra_cycles_linewidth=extra_cycles_linewidth, legend_lines=action_legend_lines,\\n legend_text=action_legend_text, legend_location=action_legend_location)\\n\\n #add the (a) (b) (c) labels\\n reward_ax.text(-0.11,-0.38, r'\\\\textbf{(a)}', transform=reward_ax.transAxes )\\n prot_0_ax.text(-0.4,-0.55, r'\\\\textbf{(b)}', transform=prot_0_ax.transAxes )\\n prot_final_ax.text(-0.11,-0.38, r'\\\\textbf{(c)}', transform=prot_final_ax.transAxes )\\n\\n #save if necessary\\n if plot_file_name is not None:\\n plot_folder = os.path.join(log_dir, PLOT_DIR_NAME)\\n Path(plot_folder).mkdir(parents=True, exist_ok=True)\\n plot_file_name = os.path.join(plot_folder, plot_file_name)\\n plt.savefig(plot_file_name)\\n\\n #show\\n plt.show()\",\n \"def plot_lineratios(modeldata,modeldata2='None',line1='CIV1551',line2='CIII1908',line3='CIV1551',line4='HeII1640',\\n plotname='./TESTPLOT.pdf',Zgas=False,logU=False,xid=0.3,nh=100,COratio=0.38,Mcutoff=100,\\n logx=True,logy=True,logp1=False,logp2=False,fixxrange=False,fixyrange=False,\\n showobs=None,noobserr=False,verbose=True):\\n NFalse = 0\\n freeparam = []\\n inforstr = \\\"\\\"\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n legenddic = {}\\n legenddic['Zgas'] = r'Z$_\\\\textrm{gas}$'\\n legenddic['logUs'] = r'log$_\\\\textrm{10}$(U)'\\n legenddic['xid'] = r'$\\\\xi_\\\\textrm{d}$'\\n legenddic['nh'] = r'n$_\\\\textrm{H}$ / [cm$^3$]'\\n legenddic['COCOsol'] = r'C/O / [C/O]$_\\\\textrm{sun}$'\\n legenddic['mup'] = r'M$_\\\\textrm{cut IMF}$ / [M$_\\\\textrm{sun}]$'\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Zgas:\\n Zgasrange = [0.0,1.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Zgas:vary, '\\n freeparam.append('Zgas')\\n else:\\n Zgasrange = [Zgas-1e-6,Zgas+1e-6]\\n inforstr = inforstr+' '+legenddic['Zgas']+'='+str(Zgas)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not logU:\\n logUrange = [-5.0,0.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' logU:vary, '\\n freeparam.append('logUs')\\n else:\\n logUrange = [logU-0.1,logU+0.1]\\n inforstr = inforstr+' '+legenddic['logUs']+'='+str(logU)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not xid:\\n xidrange = [0.0,0.6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' xid:vary, '\\n freeparam.append('xid')\\n else:\\n xidrange = [xid-0.01,xid+0.01]\\n inforstr = inforstr+' '+legenddic['xid']+'='+str(xid)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not nh:\\n nhrange = [0.0,1.0e6]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' nH:vary, '\\n freeparam.append('nh')\\n else:\\n nhrange = [nh-1.0,nh+1.0]\\n inforstr = inforstr+' '+legenddic['nh']+'='+str(nh)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not COratio:\\n COratiorange = [0.0,2.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' C/O:vary, '\\n freeparam.append('COCOsol')\\n else:\\n COratiorange = [COratio-0.001,COratio+0.001]\\n inforstr = inforstr+' '+legenddic['COCOsol']+'='+str(COratio)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if not Mcutoff:\\n Mcutoffrange = [0.0,400.0]\\n NFalse = NFalse + 1.0\\n #inforstr = inforstr+' Mcutoff:vary, '\\n freeparam.append('mup')\\n else:\\n Mcutoffrange = [Mcutoff-1.0,Mcutoff+1.0]\\n inforstr = inforstr+' '+legenddic['mup']+'='+str(Mcutoff)+', '\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n\\n if NFalse != 2:\\n sys.exit(' Two and only two of the model parameters (Zgas,logU,xid,nh,COratio,Mcutoff) '\\n 'should be set to Flase to define the model grid; however it appears '+str(NFalse)+\\n ' parameters where not set')\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n goodent = np.where( (modeldata['Zgas'] > Zgasrange[0]) & (modeldata['Zgas'] < Zgasrange[1]) &\\n (modeldata['logUs'] > logUrange[0]) & (modeldata['logUs'] < logUrange[1]) &\\n (modeldata['xid'] > xidrange[0]) & (modeldata['xid'] < xidrange[1]) &\\n (modeldata['nh'] > nhrange[0]) & (modeldata['nh'] < nhrange[1]) &\\n (modeldata['COCOsol'] > COratiorange[0]) & (modeldata['COCOsol'] < COratiorange[1]) &\\n (modeldata['mup'] > Mcutoffrange[0]) & (modeldata['mup'] < Mcutoffrange[1]) )\\n\\n Ngoodent = len(goodent[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent)+' data points satisfying (SFR)model selection ')\\n param1_1 = modeldata[freeparam[0]][goodent]\\n if logp1:\\n param1_1 = np.log10(param1_1)\\n\\n param1_2 = modeldata[freeparam[1]][goodent]\\n if logp2:\\n param1_2 = np.log10(param1_2)\\n\\n ratio1_1 = modeldata[line1][goodent]/modeldata[line2][goodent]\\n ratio1_2 = modeldata[line3][goodent]/modeldata[line4][goodent]\\n else:\\n if verbose: print(' WARNING: Less than 2 (SFR)model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - - - - - - - - - - - - - -\\n if modeldata2 != 'None':\\n goodent2 = np.where( (modeldata2['Zgas'] > Zgasrange[0]) & (modeldata2['Zgas'] < Zgasrange[1]) &\\n (modeldata2['logUs'] > logUrange[0]) & (modeldata2['logUs'] < logUrange[1]) &\\n (modeldata2['xid'] > xidrange[0]) & (modeldata2['xid'] < xidrange[1]) &\\n (modeldata2['nh'] > nhrange[0]) & (modeldata2['nh'] < nhrange[1]) )\\n\\n Ngoodent2 = len(goodent2[0])\\n\\n if Ngoodent > 1:\\n if verbose: print(' - Getting data for '+str(Ngoodent2)+' data points satisfying (AGN)model selection ')\\n param2_1 = modeldata2[freeparam[0]][goodent2]\\n if logp1:\\n param2_1 = np.log10(param2_1)\\n\\n param2_2 = modeldata2[freeparam[1]][goodent2]\\n if logp2:\\n param2_2 = np.log10(param2_2)\\n\\n l2s = ['x','x','x','x'] # line names to use for Feltre+16 file\\n for ll, linestr in enumerate([line1,line2,line3,line4]):\\n if '1908' in linestr:\\n l2 = linestr.replace('1908','1907')\\n else:\\n l2 = linestr\\n\\n l2s[ll] = l2\\n\\n ratio2_1 = modeldata2[l2s[0]][goodent2]/modeldata2[l2s[1]][goodent2]\\n ratio2_2 = modeldata2[l2s[2]][goodent2]/modeldata2[l2s[3]][goodent2]\\n else:\\n if verbose: print(' WARNING: Less than 2 (AGN)model grid points to plot; no output generated')\\n return\\n\\n # - - - - - - - - - - - PLOTTING - - - - - - - - - - -\\n if verbose: print(' - Setting up and generating plot')\\n plotname = plotname\\n fig = plt.figure(figsize=(9, 5))\\n fig.subplots_adjust(wspace=0.1, hspace=0.1,left=0.1, right=0.99, bottom=0.10, top=0.95)\\n Fsize = 10\\n lthick = 1\\n marksize = 3\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='serif',size=Fsize)\\n plt.rc('xtick', labelsize=Fsize)\\n plt.rc('ytick', labelsize=Fsize)\\n plt.clf()\\n plt.ioff()\\n plt.title(inforstr[:-2],fontsize=Fsize)\\n\\n margin = 0.1\\n dx = np.abs(np.max(ratio1_1)-np.min(ratio1_1))\\n dy = np.abs(np.max(ratio1_2)-np.min(ratio1_2))\\n\\n\\n if fixxrange:\\n xrange = fixxrange\\n else:\\n if logx:\\n xrange = [np.min(ratio1_1)-np.min(ratio1_1)/2.,np.max(ratio1_1)+np.max(ratio1_1)/2.]\\n else:\\n xrange = [np.min(ratio1_1)-dx*margin,np.max(ratio1_1)+dx*margin]\\n\\n if fixyrange:\\n yrange = fixyrange\\n else:\\n if logy:\\n yrange = [np.min(ratio1_2)-np.min(ratio1_2)/2.,np.max(ratio1_2)+np.max(ratio1_2)/2.]\\n else:\\n yrange = [np.min(ratio1_2)-dy*margin,np.max(ratio1_2)+dy*margin]\\n\\n # ------------ PARAM1 ------------\\n cmap = plt.cm.get_cmap('winter')\\n cmin = np.min(param1_1)\\n cmax = np.max(param1_1)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb1 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr1 = legenddic[freeparam[0]]\\n if logp1:\\n pstr1 = r'log$_\\\\textrm{10}$('+pstr1+')'\\n\\n cb1.set_label(pstr1+' (outer circle) - Fixed: black line')\\n\\n for p1 in np.unique(param1_1):\\n p1col = cmap(colnorm(p1))\\n p1ent = np.where(param1_1 == p1)\\n\\n plt.plot(ratio1_1[p1ent],ratio1_2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(ratio1_1[p1ent],ratio1_2[p1ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n if modeldata2 is not 'None':\\n p1ent = np.where(param2_1 == p1)\\n\\n plt.plot(ratio2_1[p1ent],ratio2_2[p1ent],'-',lw=lthick, color='k',zorder=1)\\n\\n plt.errorbar(ratio2_1[p1ent],ratio2_2[p1ent],xerr=None,yerr=None,\\n marker='D',lw=0, markersize=marksize*3,\\n markerfacecolor=p1col,ecolor=p1col,markeredgecolor = 'k',zorder=10)\\n\\n\\n # ------------ PARAM2 ------------\\n cmap = plt.cm.get_cmap('spring')\\n cmin = np.min(param1_2)\\n cmax = np.max(param1_2)\\n colnorm = matplotlib.colors.Normalize(vmin=cmin,vmax=cmax)\\n cmaparr = np.linspace(cmin, cmax, 30) #cmax-cmin)\\n mm = plt.cm.ScalarMappable(cmap=cmap)\\n mm.set_array(cmaparr)\\n cb2 = plt.colorbar(mm)#shrink=0.25\\n\\n pstr2 = legenddic[freeparam[1]]\\n if logp2:\\n pstr2 = 'log10('+pstr2+')'\\n\\n cb2.set_label(pstr2+' (inner circle) - Fixed: gray line')\\n\\n for p2 in np.unique(param1_2):\\n p2col = cmap(colnorm(p2))\\n p2ent = np.where(param1_2 == p2)\\n\\n plt.plot(ratio1_1[p2ent],ratio1_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(ratio1_1[p2ent],ratio1_2[p2ent],xerr=None,yerr=None,\\n marker='o',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n if modeldata2 is not 'None':\\n p2ent = np.where(param2_2 == p2)\\n\\n plt.plot(ratio2_1[p2ent],ratio2_2[p2ent],'-',lw=lthick, color='gray',zorder=2)\\n\\n plt.errorbar(ratio2_1[p2ent],ratio2_2[p2ent],xerr=None,yerr=None,\\n marker='D',lw=0, markersize=marksize*1.5,\\n markerfacecolor=p2col,ecolor=p2col,markeredgecolor = 'k',zorder=20)\\n\\n\\n if showobs != None:\\n for ii, objid in enumerate(showobs[:,0]):\\n if (showobs[:,7][ii] > xrange[0]) & (showobs[:,7][ii] < xrange[1]) & \\\\\\n (showobs[:,9][ii] > yrange[0]) & (showobs[:,9][ii] < yrange[1]):\\n\\n if noobserr:\\n obsxerr = None\\n obsyerr = None\\n else:\\n obsxerr = showobs[:,8][ii]\\n obsyerr = showobs[:,10][ii]\\n plt.errorbar(showobs[:,7][ii],showobs[:,9][ii],xerr=obsxerr,yerr=obsyerr,\\n marker='*',lw=lthick, markersize=marksize*2,\\n markerfacecolor='k',ecolor='k',markeredgecolor = 'k',zorder=30)\\n\\n plt.xlabel(line1+'/'+line2)\\n plt.ylabel(line3+'/'+line4)\\n\\n plt.xlim(xrange)\\n plt.ylim(yrange)\\n\\n if logx:\\n plt.xscale('log')\\n if logy:\\n plt.yscale('log')\\n\\n #--------- LEGEND ---------\\n # plt.errorbar(-1,-1,xerr=None,yerr=None,fmt='o',lw=lthick,ecolor='white', markersize=marksize*2,\\n # markerfacecolor='white',markeredgecolor = 'k',label='Ground-based spec')\\n #\\n # leg = plt.legend(fancybox=True, loc='upper center',prop={'size':Fsize},ncol=1,numpoints=1)\\n # #bbox_to_anchor=(1.25, 1.03)) # add the legend\\n # leg.get_frame().set_alpha(0.7)\\n #--------------------------\\n\\n if verbose: print(' Saving plot to'+plotname)\\n plt.savefig(plotname)\\n plt.clf()\\n plt.close('all')\",\n \"def relative_range(self):\\n self.calculate_relative_mags()\\n string = '{:.0f}-{:.0f}Hz: {:.5f}'\\n s_ind = self.get_bin(self.s_freq)\\n e_ind = self.get_bin(self.e_freq)\\n lst = self.rel_mags[s_ind:e_ind+1]\\n return sum(lst)/len(lst)\",\n \"def main(config_file, pre_nfiles=None, post_nfiles=None,\\n cutoffs=[12.0, 60.0]):\\n imu_complement_fig = (config_file[:-4] +\\n \\\"_IMU_complementary_spectra.pdf\\\")\\n imu_spectra_fig = (config_file[:-4] + \\\"_IMU_spectra.pdf\\\")\\n nperseg1 = 60 * 5 * 10\\n nperseg2 = 60 * 10\\n fig, axs, leg = check.plot_IMU_euler_angles_spectra(config_file,\\n nperseg=nperseg2,\\n nfiles=pre_nfiles)\\n fig.savefig(imu_complement_fig, bbox_extra_artists=(leg,),\\n bbox_inches=\\\"tight\\\")\\n plt.close(fig)\\n fig_rate, _, fig_acc, _ = check.plot_IMU_spectra(config_file,\\n nperseg=nperseg2,\\n nfiles=pre_nfiles)\\n with PdfPages(imu_spectra_fig) as pdf:\\n pdf.savefig(fig_rate, bbox_inches=\\\"tight\\\")\\n plt.close(fig_rate)\\n pdf.savefig(fig_acc, bbox_inches=\\\"tight\\\")\\n plt.close(fig_acc)\\n\\n # Look at individual periods\\n config = db_flux.parse_config(config_file)\\n input_files = config[\\\"EC Inputs\\\"][\\\"input_files\\\"]\\n if post_nfiles is not None and post_nfiles < len(input_files):\\n input_files = np.random.choice(input_files, post_nfiles,\\n replace=False)\\n imu2anem_pos = config[\\\"EC Motion Correction\\\"][\\\"imu2anemometer_pos\\\"]\\n sample_freq_hz = config[\\\"EC Inputs\\\"][\\\"sample_frequency\\\"]\\n Tcf, Ta = cutoffs\\n for ifile in input_files:\\n file_idx = ifile.index(ifile)\\n ec_prep, _ = db_flux.prepare_period(ifile, config)\\n wind = ec_prep[[\\\"wind_speed_u\\\", \\\"wind_speed_v\\\", \\\"wind_speed_w\\\"]]\\n acceleration = ec_prep[[\\\"acceleration_x\\\",\\n \\\"acceleration_y\\\",\\n \\\"acceleration_z\\\"]]\\n rate = ec_prep[[\\\"rate_x\\\", \\\"rate_y\\\", \\\"rate_z\\\"]]\\n ec_corr = db_flux.wind3D_correct(wind.values, acceleration.values,\\n rate.values,\\n ec_prep.heading.values,\\n ec_prep.speed_over_ground.values,\\n imu2anem_pos, sample_freq_hz,\\n Tcf, Ta)\\n fig, _, leg = check.plot1_IMU_complementary_spectra(config_file,\\n file_idx,\\n Tcf=Tcf,\\n Ta=Ta,\\n nperseg=nperseg1)\\n fig.savefig((ifile[:-4] + \\\"_euler_angle_spectra.pdf\\\"),\\n bbox_extra_artists=(leg,), bbox_inches=\\\"tight\\\")\\n plt.close()\\n fig, axs, leg = check.plot_wind3D_spectra(wind.values,\\n ec_corr.uvw_ship,\\n nperseg=nperseg2)\\n fig.savefig((ifile[:-4] + \\\"_uvw_spectra.pdf\\\"),\\n bbox_extra_artists=(leg,), bbox_inches=\\\"tight\\\")\\n plt.close()\\n # Plot corrected wind cospectra\\n fig, _, leg = check.plot_wind3D_cospectra(wind.values,\\n ec_corr.uvw_ship,\\n nperseg=nperseg2)\\n fig.savefig((ifile[:-4] + \\\"_uvw_cospectra.pdf\\\"),\\n bbox_extra_artists=(leg,), bbox_inches=\\\"tight\\\")\\n plt.close()\",\n \"def growth_curve(userinputs, filter, catalog):\\n logging.info('Running growth curve analysis on {}'.format(catalog))\\n # Load the photometry results from the catalog (that is returned by the phot\\n # function)\\n aper_st, flux_st = np.loadtxt(catalog, unpack=True, usecols=(0,3))\\n\\n #Growth curve is only done on the ref image so we get the filter from userinp.\\n ref_filter = filter\\n\\n ratio_st = np.empty(len(aper_st))\\n\\n #number of apertures\\n naper = 20\\n\\n # Calculate the number of stars, make sure it is an integer\\n nstar = int(len(aper_st)/naper)\\n logging.info('Number of stars used: {}'.format(nstar))\\n aper_ind = naper - 1\\n\\n for k in range(nstar):\\n\\n for i in range(naper):\\n\\n ratio_st[i + k*naper] = flux_st[i + k*naper]/flux_st[aper_ind + k*naper]\\n\\n\\n # Find median ratio at each aperture between all the stars and all the clusters\\n med_st = np.empty(naper)\\n\\n for i in range(naper):\\n\\n med_st[i] = np.median(ratio_st[i::naper])\\n\\n\\n # Plot growth curves\\n logging.info('Creating Growth curve plots')\\n fig = plt.figure(figsize = (7,7))\\n\\n aper_x = np.arange(naper) + 1\\n\\n for i in range(nstar):\\n\\n ratio_y = ratio_st[i*naper:(i + 1)*naper]\\n plt.plot(aper_x, ratio_y, 'y-')\\n plt.annotate(str(i + 1), xy=(8.0, ratio_y[7]),\\n horizontalalignment='left', verticalalignment='top', fontsize=6)\\n\\n\\n plt.plot(aper_x, med_st, 'r-' , linewidth=4.0)\\n plt.hlines(0.5, 0, 20, color='black', linewidth=2, zorder=10)\\n plt.vlines(4, 0, 1.1, color='black', linewidth=2, linestyle='dashed', zorder=10)\\n plt.vlines(5, 0, 1.1, color='black', linewidth=2, linestyle='dashed', zorder=10)\\n plt.vlines(6, 0, 1.1, color='black', linewidth=2, linestyle='dashed', zorder=10)\\n\\n plt.ylabel('Normalized Flux ' + ref_filter.upper())\\n plt.xlabel('Radius (pix)')\\n plt.xlim(1,20)\\n plt.minorticks_on()\\n\\n fig.savefig(userinputs['OUTDIR'] + '/plots/plot_growth_curve_{}.pdf'.format(ref_filter))\",\n \"def calculate_allowable_angles(self, angular_resolution=0.01, visualize=0, optimized=False):\\n #Could be optimized more, if required.\\n \\n if visualize:\\n pylab.ion() #Turns interaction on (?)\\n print \\\"Calculation started\\\"\\n\\n if angular_resolution < self.ANGULAR_RESOLUTION_MIN:\\n warnings.warn(\\\"Requested too small angular resolution. Using %s\\\" % self.ANGULAR_RESOLUTION_MIN)\\n angular_resolution = self.ANGULAR_RESOLUTION_MIN\\n\\n #We do not need to look at more than the motor step size in phi, since the sample rotational\\n # motor does the rest.\\n self.phi_range = 0.99 * (self.sample_motor_step_size / 2)\\n #Arbitrary max ranges here. TODO: User setting?\\n self.chi_range = pi/8\\n self.omega_range = pi/6\\n\\n #Make the lists\\n self.phi_list = array([-self.phi_range, 0, self.phi_range])\\n self.phi_list = np.append(np.arange(-self.phi_range, self.phi_range, angular_resolution), (self.phi_range) )\\n self.chi_list = np.arange(-self.chi_range, self.chi_range, angular_resolution)\\n self.omega_list = np.arange(-self.omega_range, self.omega_range, angular_resolution)\\n\\n #Create the allowed angle map, all false\\n self.allowed = np.zeros( (self.phi_list.size, self.chi_list.size, self.omega_list.size), dtype=np.bool )\\n\\n #Make sure the limits are calculated\\n self.calculate_leg_xy_limits()\\n\\n\\n #Loop through all the angles\\n for i_phi in range(self.phi_list.size):\\n phi = self.phi_list[i_phi]\\n print 'Calculating phi = %s' % phi\\n was_anything_in_line = False\\n for i_chi in range(self.chi_list.size):\\n chi = self.chi_list[i_chi]\\n was_allowed = False\\n for i_omega in range(self.omega_list.size):\\n omega = self.omega_list[i_omega]\\n\\n #Calcualte the leg position from these angles\\n self.getplatepos(phi, chi, omega)\\n #Make sure the legs are not in fault\\n self.check_limits()\\n allowed = not any(self.leg_fault)\\n #Save it\\n self.allowed[i_phi, i_chi, i_omega] = allowed\\n if optimized:\\n #Check that we have reached an unallowed section, to speed calculation\\n if allowed: was_allowed = True\\n if was_allowed and (not allowed):\\n break #All other omega values in this chi will be false. Exit to the next line\\n #(end of omega loop)\\n\\n if optimized:\\n #Is there anything allowed in this chi line?\\n anything_in_line = any(self.allowed[i_phi, i_chi, :])\\n #Once we reach a completely disallowed line, all others after will be too\\n if anything_in_line: was_anything_in_line = True\\n if was_anything_in_line and (not anything_in_line):\\n break #we don't need to look at the remaining lines.\\n #(end of chi loop)\\n #(end of phi loop)\\n\\n print \\\"Done!\\\"\\n \\n if visualize==1:\\n #2D Animated plot\\n for i_phi in range(self.phi_list.size):\\n phi = self.phi_list[i_phi]\\n #Here we are still in the phi loop\\n if visualize:\\n pylab.figure(0)\\n pylab.imshow(self.allowed[i_phi, :, :], interpolation='nearest', extent=(-self.omega_range, self.omega_range, -self.chi_range, self.chi_range))\\n pylab.xlabel(\\\"Omega\\\")\\n pylab.ylabel(\\\"Chi\\\")\\n pylab.title(\\\"Allowable angles for phi=%s\\\" % phi)\\n pylab.draw()\\n time.sleep(0.2)\\n pylab.draw()\\n time.sleep(1)\\n pylab.ion()\\n \\n\\n if visualize==2:\\n #Single 3D plot of allowed angles.\\n mlab.clf() #Clear figure\\n mlab.contour3d(self.allowed.astype(float), contours=[0.5])\\n mlab.xlabel(\\\"Phi\\\")\\n mlab.ylabel(\\\"Chi\\\")\\n mlab.zlabel(\\\"Omega\\\")\\n mlab.axes()\\n mlab.show()\\n\\n #Done calculating\\n return None\",\n \"def describe(name, values):\\n log.info(\\\"Describing %s component.\\\" % name)\\n abs_max_indices = np.unravel_index(np.argmax(np.abs(values), axis=None), values.shape)\\n abs_max_polar = zdi_geometry.centers()[0][abs_max_indices]\\n abs_max_azimuth = zdi_geometry.centers()[1][abs_max_indices]\\n abs_max = np.abs(values[abs_max_indices])\\n\\n abs_mean = np.sum(np.abs(values) * zdi_geometry.areas()) / (4 * np.pi)\\n abs_rms = (np.sum(values**2 * zdi_geometry.areas()) / (4 * np.pi))**.5\\n abs_std = (np.sum((np.abs(values) - abs_mean)**2 * zdi_geometry.areas()) / (4 * np.pi))**.5\\n\\n # This is a statistical identity.\\n assert np.isclose(abs_rms**2, abs_mean**2 + abs_std**2), \\\"RMS does not match mean and std.\\\"\\n\\n dest[f\\\"magnetogram.{name}.abs.max\\\"] = abs_max\\n log.info(f\\\"{name} |B|_max = %4.4g Gauss\\\" % abs_max)\\n log.info(f\\\"{name} |B|_max at az=%2.2f deg, pl=%3.2f deg\\\" % (np.rad2deg(abs_max_azimuth),\\n np.rad2deg(abs_max_polar)))\\n log.info(f\\\"{name} |B|_mean = %4.4g Gauss\\\" % abs_mean)\\n log.info(f\\\"{name} |B|_var = %4.4g Gauss\\\" % abs_std)\\n dest[f\\\"magnetogram.{name}.abs.mean\\\"] = abs_mean\\n dest[f\\\"magnetogram.{name}.abs.rms\\\"] = abs_rms\\n dest[f\\\"magnetogram.{name}.abs.std\\\"] = abs_std\\n\\n return abs_mean\",\n \"def mlmc_massplot():\\n out = parse_output_allg([\\\"t(\\\", \\\"Energy\\\", \\\"Mass\\\", \\\"InFlowRate\\\", \\\"OutFlowRate\\\"])\\n t = out[0]\\n mass = out[2]\\n inflow = out[3]\\n dt_3 = 64\\n ndt = [dt_3, 2 * dt_3, 4 * dt_3]\\n l = [3, 4, 5]\\n nl = [10, 0, 0]\\n n = 0\\n colors = [\\\"darkred\\\", \\\"red\\\", \\\"#ff9966\\\"]\\n mconly = True\\n\\n for i in range(len(l)):\\n fig = plt.figure(i)\\n for j in range(nl[i]):\\n plt.plot(t[n:n + ndt[i] + 1], mass[n:n + ndt[i] + 1], label=\\\"Level \\\" + str(l[i]) + \\\" Sample \\\" + str(j))\\n if (j == -1):\\n plt.plot(t[n:n + ndt[i] + 1], inflow[n:n + ndt[i] + 1], color=\\\"black\\\",\\n label=\\\"Inflow Level \\\" + str(l[i]) + \\\" Sample \\\" + str(j))\\n n += ndt[i] + 1\\n if i > 0 and not mconly:\\n plt.plot(t[n:n + ndt[i - 1] + 1], mass[n:n + ndt[i - 1] + 1],\\n label=\\\"Level \\\" + str(l[i - 1]) + \\\" Sample \\\" + str(j))\\n n += ndt[i - 1] + 1\\n plt.legend()\\n\\n plt.savefig(\\\"MLMCMassPlot.jpg\\\")\",\n \"def plot_q_values(self):\\n\\n sim_freq = self.conf['Simulation']['params']['frequency']\\n sim_wvlgth = 1e9*consts.c / sim_freq\\n leg_str = ''\\n for mat, matpath in self.conf['Materials'].items():\\n n, k = get_nk(matpath, sim_freq)\\n mat_wv = 1e-3*sim_wvlgth / n\\n mat_q = 2*np.pi/mat_wv\\n leg_str += '{}: {:.2f} [rads/$\\\\mu$m]\\\\n'.format(mat, mat_q)\\n leg_str = leg_str[0:-1]\\n for lname, l_obj in self.layers.items():\\n qarr = self.data['{}_qvals'.format(lname)]\\n max_pos_freq = np.amax(qarr.real)\\n max_neg_freq = np.amin(qarr.real)\\n min_pos_wv = 1e3*2*np.pi/max_pos_freq\\n if max_neg_freq == 0:\\n min_neg_wv = 0\\n else:\\n min_neg_wv = 1e3*2*np.pi/max_neg_freq\\n plt.figure()\\n inc_q = 2*np.pi/(1e-3*sim_wvlgth)\\n title = 'Layer: {}, Incident q: {:.2f} [rads/$\\\\mu$m]'.format(lname, inc_q)\\n # title += 'Min Positive $\\\\\\\\lambda$: {:.2f} nm, '\\n # title += 'Min Negative $\\\\\\\\lambda$: {:.2f} nm'\\n # title = title.format(lname, sim_wvlgth, min_pos_wv, min_neg_wv)\\n # title = title.format(lname, sim_wvlgth)\\n plt.title(title)\\n # plt.scatter(1e3*2*np.pi/qarr.real, 1e4*qarr.imag/2*np.pi, c='b', s=.5,\\n # marker='o', label=leg_str)\\n plt.scatter(qarr.real, qarr.imag/(2*np.pi), c='b', s=.75,\\n marker='o', label=leg_str)\\n # pt = (qarr[0].real, qarr[0].imag)\\n # theta = np.linspace(0, 1.48, 200)\\n # plt.plot(pt[0]*np.cos(theta), pt[1]/np.cos(theta), 'r--')\\n plt.legend(loc='best')\\n # plt.annotate(leg_str, xy=(.95,.95), xycoords='axes fraction',\\n # size=14, ha='right', va='top',\\n # bbox=dict(boxstyle='round', fc='w'))\\n plt.xlabel('Re(q) [radians/micron]')\\n plt.ylabel('Im(q) [1/microns]')\\n plot_path = os.path.join(self.dir, '{}_qvals.png'.format(lname))\\n plt.grid(True)\\n plt.savefig(plot_path)\\n plt.close()\",\n \"def cal_mass(self):\\n\\n if not self.check_def(['E','px','py','pz']):\\n sys.exit('Particle error: Quadri impulsion not define (error for mass routine)')\\n\\n\\n \\n if self.E**2-self.px**2-self.py**2-self.pz**2>1e-7: #precision problem\\n self.mass=math.sqrt(self.E**2-self.px**2-self.py**2-self.pz**2)\\n else:\\n self.mass=0\",\n \"def aminusb_ax2( mv1, mv2 ):\\n if hasattr(mv1,'units') and hasattr(mv2,'units') and mv1.units!=mv2.units:\\n print \\\"WARING: aminusb_ax2 is subtracting variables with different units!\\\",mv1,mv1\\n axes1 = allAxes(mv1)\\n axes2 = allAxes(mv2)\\n # TO DO: convert, interpolate, etc. as needed to accomodate differing first axes.\\n # But for now, we'll just check a bit ...\\n ax1=axes1[0]\\n ax2=axes2[0]\\n if ax1.shape!=ax2.shape:\\n print \\\"ERROR aminusb_ax2 requires same axes, but shape differs:\\\",ax1.shape,ax2.shape\\n print \\\"ax1,ax2\\\"\\n return None\\n if hasattr(ax1,'units') and hasattr(ax2,'units') and ax1.units!=ax2.units:\\n if ax1.units=='mb':\\n ax1.units = 'mbar' # udunits uses mb for something else\\n if ax2.units=='mb':\\n ax2.units = 'mbar' # udunits uses mb for something else\\n tmp = udunits(1.0,ax2.units)\\n s,i = tmp.how(ax1.units) # will raise an exception if conversion not possible\\n # crude substitute for a real units library:\\n #if not (ax1.units=='mb' and ax2.units=='millibars') and\\\\\\n # not (ax1.units=='millibars' and ax2.units=='mb'):\\n # print \\\"ERROR aminusb_ax2 requires same axes, but units differ:\\\",ax1.units,ax2,units\\n # print \\\"ax1,ax2\\\"\\n # return None\\n ab_axes = [ax1]\\n if len(axes1[1])<=len(axes2[1]):\\n a = mv1\\n b = interp2( axes1[1], mv2 )\\n ab_axes.append(axes1[1])\\n else:\\n a = interp2( axes2[1], mv1 )\\n b = mv2\\n ab_axes.append(axes2[1])\\n aminusb = a - b\\n aminusb.id = mv1.id\\n aminusb.initDomain( ab_axes )\\n return aminusb\",\n \"def plotDistributionWithLimits(lXs, llYs, lKClassif,out=\\\"out.png\\\", title=\\\"title\\\", xax=\\\"xax\\\", yax=\\\"yax\\\",legend=\\\"\\\"):\\n\\n fig = plt.Figure(figsize=(40,20))\\n fig.suptitle(title, fontsize=32)\\n nbPlots = len(llYs)\\n sqrt = int(math.ceil(math.sqrt(nbPlots)))\\n ymax = 0.0\\n for val in llYs:\\n ymax = max(max(val[0]),ymax)\\n ymaxCurrent = max(max(val[2]),ymax)\\n ymax = ymax*1.05\\n xmax = 147\\n gs = gridspec.GridSpec(1,2) \\n ax = fig.add_subplot(gs[0])\\n gsLimit = gridspec.GridSpecFromSubplotSpec(sqrt,sqrt, subplot_spec=gs[1])\\n for i,val in enumerate(llYs):\\n ax.plot(lXs,val[0],color=Graphics.lColors[i%25])\\n axCurrent = fig.add_subplot(gsLimit[i]) \\n axCurrent.fill_between(lXs, val[1], val[2], alpha=0.35, edgecolor='black', facecolor=Graphics.lColors[i%25])\\n axCurrent.set_title(\\\"Cluster K{}, (position: {})\\\".format(i,lKClassif[i]))\\n axCurrent.fill_between(lXs, val[3], val[4], alpha=0.85, edgecolor='darkgray', facecolor='lightgray')\\n axCurrent.plot(lXs,val[0],color=Graphics.lColors[i%25])\\n axCurrent.set_ylim(0,ymaxCurrent)\\n axCurrent.set_xlim(1,xmax)\\n axCurrent.text(10, ymaxCurrent*0.90, \\\"#nucleosomes: {}\\\".format(legend[i]), fontsize=12)\\n axis_font = {'size':'28'}\\n ax.set_ylim(0,ymax)\\n ax.set_xlim(1,xmax)\\n ax.legend([\\\"K{}\\\".format(x) for x in range(0,nbPlots)])\\n ax.set_title(\\\"all nucleosomes\\\", **axis_font)\\n ax.set_xlabel(xax, **axis_font)\\n ax.set_ylabel(yax, **axis_font)\\n ax.tick_params(labelsize=20)\\n canvas = FigureCanvasAgg(fig)\\n canvas.print_figure(out, dpi=80)\",\n \"def parseArguments():\\n # Create argument parser\\n #parser = argparse.ArgumentParser()\\n parser = ArgumentParser()\\n\\n\\n # Positional mandatory arguments\\n parser.add_argument(\\\"input\\\", nargs='+',help=\\\"Input Image with .fits ending. A folder or multiple Images also work\\\", type=str)\\n parser.add_argument(\\\"-c\\\", \\\"--catalog\\\", help=\\\"Catalog to use for position reference ('PS', '2MASS' or 'GAIA') or name of local file\\\", type=str, default=\\\"PS\\\")\\n\\n parser.add_argument(\\\"-s\\\", \\\"--save_images\\\", help=\\\"Set True to create _image_before.pdf and _image_after.pdf\\\", type=bool, default=False)\\n parser.add_argument(\\\"-p\\\", \\\"--images\\\", help=\\\"Set 0 to not create the plots.\\\", type=int, default=1)\\n\\n parser.add_argument(\\\"-v\\\", \\\"--verbose\\\", help=\\\"More console output about what is happening. Helpfull for debugging.\\\", type=bool, default=False)\\n parser.add_argument(\\\"-silent\\\", \\\"--silent\\\", help=\\\"Almost no console output. Use when running many files. turns verbose off, turns plots off, turns ignore warning on. \\\", type=bool, default=False)\\n\\n\\n\\n parser.add_argument(\\\"-w\\\", \\\"--ignore_warnings\\\", help=\\\"Set False to see all Warnings about the header if there is problems. Default is to ignore most warnings.\\\", type=bool, default=True)\\n\\n parser.add_argument(\\\"-ra\\\", \\\"--ra\\\", help=\\\"Set ra by hand in degrees. Should not be necessary if the info is in the fits header.\\\", type=float, default=None)\\n parser.add_argument(\\\"-dec\\\", \\\"--dec\\\", help=\\\"Set dec by hand in degrees. Should not be necessary if the info is in the fits header.\\\", type=float, default=None)\\n\\n parser.add_argument(\\\"-proj1\\\", \\\"--projection_ra\\\", help=\\\"Set the projection by hand. Should not be necessary if the info is in the fits header. example: -proj1 RA---TAN -proj2 DEC--TAN\\\", type=str, default=None)\\n parser.add_argument(\\\"-proj2\\\", \\\"--projection_dec\\\", help=\\\"Set the projection by hand. Should not be necessary if the info is in the fits header. example: -proj1 RA---TAN -proj2 DEC--TAN\\\", type=str, default=None)\\n\\n\\n parser.add_argument(\\\"-rot_scale\\\", \\\"--rotation_scaling\\\", help=\\\"By default rotation and scaling is determined. If wcs already contains this info and the fit fails you can try deactivating this part by setting it to 0\\\", type=int, default=1)\\n parser.add_argument(\\\"-xy_trafo\\\", \\\"--xy_transformation\\\", help=\\\"By default the x and y offset is determined. If wcs already contains this info and the fit fails you can try deactivating this part by setting it to 0\\\", type=int, default=1)\\n parser.add_argument(\\\"-fine\\\", \\\"--fine_transformation\\\", help=\\\"By default a fine transformation is applied in the end. You can try deactivating this part by setting it to 0\\\", type=int, default=1)\\n\\n parser.add_argument(\\\"-vignette\\\", \\\"--vignette\\\", help=\\\"Do not use corner of the image. Only use the data in a circle around the center with certain radius. Default: not used. Set to 1 for circle that touches the sides. Less to cut off more\\\", type=float, default=3)\\n parser.add_argument(\\\"-vignette_rec\\\", \\\"--vignette_rectangular\\\", help=\\\"Do not use corner of the image. Cutoff 1- <value> on each side of the image. Default: not used. 1 uses the full image, 0.9 cuts 10%% on each side\\\", type=float, default=1.)\\n\\n parser.add_argument(\\\"-cutout\\\", \\\"--cutout\\\", help=\\\"Cutout bad recangle from Image. Specify corners in pixel as -cutout xstart xend ystart yend. You can give multiple cutouts \\\", nargs='+',action=\\\"append\\\", type=int)\\n\\n parser.add_argument(\\\"-ignore_header_rot\\\", \\\"--ignore_header_rot\\\", help=\\\"Set to 0 to ignore rotation information contained in header\\\", type=int, default=0)\\n\\n parser.add_argument(\\\"-r\\\", \\\"--radius\\\", help=\\\"Change the download radius for how many catalog objects should be downloaded in arcmin. \\\", type=float, default=-1)\\n parser.add_argument(\\\"-save_bad_result\\\", \\\"--save_bad_result\\\", help=\\\"Save result even when it is considered bad by setting this to 1. By default bad results will not be saved\\\", type=int, default=0)\\n\\n parser.add_argument(\\\"-sigma_threshold_for_source_detection\\\", \\\"--sigma_threshold_for_source_detection\\\", help=\\\"Sigma threshold for source detection on the image\\\", type=float, default=5)\\n parser.add_argument(\\\"-seeing\\\", \\\"--seeing\\\", help=\\\"Average FWHM of sources. Default 4px\\\", type=float, default=4)\\n\\n parser.add_argument(\\\"-high_res\\\", \\\"--high_resolution\\\", help=\\\"Set true to indicate higher resolution image like HST to allow larger steps for fine transformation. Default False for smaller telescopes\\\", type=bool, default=False)\\n parser.add_argument(\\\"-hdul_idx\\\", \\\"--hdul_idx\\\", help=\\\"Index of the image data in the fits file. Default 0\\\", type=int, default=0)\\n parser.add_argument(\\\"-filename_for_sources\\\", \\\"--filename_for_sources\\\", help=\\\"Save the sky positions of the sources to file to calibrate another image with it. Set to the filename without extension. Default: not used\\\", type=str, default=None)\\n\\n # Print version\\n parser.add_argument(\\\"--version\\\", action=\\\"version\\\", version='%%(prog)s - Version 1.5') #\\n #changelog\\n #version 0.0 proof of concept\\n #version 0.1 alpha version\\n #version 1.0 first public version\\n #version 1.2 included option to not show images\\n #version 1.3 improved support for high resolution images\\n #version 1.4 bugfixes and ability to calibrate based on another image\\n #version 1.5 added compatibility with photutils v1.4\\n\\n # Parse arguments\\n args = parser.parse_args()\\n\\n return args\",\n \"def add_is_approximation(self):\\n \\n if (self.mf_steps == 0 or self.alpha ==0) and (not self.mixture)\\\\\\n and (self.gibbs_steps ==0):\\n print(\\\"Importance distribution is uniform\\\")\\n weight_term = T.log(self.num_samples) + self.num_vars*T.log(0.5)\\n \\n elif (self.mf_steps > 0 and self.alpha > 0) and (not self.mixture)\\\\\\n and (self.gibbs_steps ==0):\\n print(\\\"Importance distribution is not uniform\\\")\\n weight_term = T.log(self.num_samples)+\\\\\\n self.get_importance_evals(T.transpose(self.x_tilda), \\n T.transpose(self.sampler_theta))\\n \\n if self.resample:\\n weight_term = T.reshape(weight_term, \\n [self.batch_size, self.num_samples])\\n \\n elif self.mixture:\\n \\n if self.resample:\\n n_iters = self.num_samples*self.batch_size \\n else:\\n n_iters = self.num_samples \\n \\n weight_term, _ =\\\\\\n theano.scan(lambda j: \\n self.get_mixture_evals(T.transpose(self.x_tilda[j,:])),\\n sequences = [T.arange(n_iters)])\\n \\n if self.resample:\\n weight_term = T.reshape(weight_term, \\n [self.batch_size, self.num_samples]) \\n \\n weight_term = T.log(self.num_samples) + weight_term \\n \\n elif self.gibbs_steps > 0:\\n print(\\\"Importance distribution is gibbs sampler\\\") \\n weight_term = T.log(self.num_samples)+\\\\\\n self.get_importance_evals(T.transpose(self.x_tilda), \\n T.transpose(self.sampler_theta))\\n \\n if self.resample:\\n weight_term = T.reshape(weight_term, \\n [self.batch_size, self.num_samples]) \\n \\n \\n if self.resample and self.num_hidden ==0:\\n \\n approx_Z = -self.compute_energy(self.x_tilda, \\n self.num_samples*self.batch_size)\\n \\n elif (not self.resample) and self.num_hidden ==0:\\n \\n approx_Z = -self.compute_energy(self.x_tilda, \\n self.num_samples)\\n \\n elif self.resample and self.num_hidden > 0:\\n \\n approx_Z = -self.compute_free_energy(self.x_tilda)\\n \\n elif (not self.resample) and self.num_hidden >0:\\n \\n approx_Z = -self.compute_free_energy(self.x_tilda)\\n \\n if self.resample:\\n \\n approx_Z = T.reshape(approx_Z, \\n [self.batch_size, self.num_samples])\\n \\n approx_Z = approx_Z - weight_term\\n \\n return approx_Z\",\n \"def plot(self, plot_limits=None, which_data_rows='all',\\r\\n which_data_ycols='all', which_parts='all', fixed_inputs=[],\\r\\n plot_raw=False,\\r\\n levels=20, samples=0, fignum=None, ax=None, resolution=None):\\r\\n #deal work out which ax to plot on\\r\\n #Need these because we use which_data_rows in this function not just base\\r\\n if which_data_rows == 'all':\\r\\n which_data_rows = slice(None)\\r\\n if which_data_ycols == 'all':\\r\\n which_data_ycols = np.arange(self.output_dim)\\r\\n if ax is None:\\r\\n fig = pb.figure(num=fignum)\\r\\n ax = fig.add_subplot(111)\\r\\n\\r\\n #work out what the inputs are for plotting (1D or 2D)\\r\\n fixed_dims = np.array([i for i,v in fixed_inputs])\\r\\n free_dims = np.setdiff1d(np.arange(self.input_dim),fixed_dims)\\r\\n\\r\\n #call the base plotting\\r\\n GPBase.plot(self, samples=samples, plot_limits=plot_limits,\\r\\n which_data_rows=which_data_rows,\\r\\n which_data_ycols=which_data_ycols, fixed_inputs=fixed_inputs,\\r\\n which_parts=which_parts, resolution=resolution, levels=20,\\r\\n fignum=fignum, ax=ax)\\r\\n\\r\\n if len(free_dims) == 1:\\r\\n #plot errorbars for the uncertain inputs\\r\\n if self.has_uncertain_inputs:\\r\\n Xu = self.X * self._Xscale + self._Xoffset # NOTE self.X are the normalized values now\\r\\n ax.errorbar(Xu[which_data_rows, 0], self.likelihood.data[which_data_rows, 0],\\r\\n xerr=2 * np.sqrt(self.X_variance[which_data_rows, 0]),\\r\\n ecolor='k', fmt=None, elinewidth=.5, alpha=.5)\\r\\n\\r\\n #plot the inducing inputs\\r\\n Zu = self.Z * self._Xscale + self._Xoffset\\r\\n ax.plot(Zu, np.zeros_like(Zu) + ax.get_ylim()[0], 'r|', mew=1.5, markersize=12)\\r\\n\\r\\n elif len(free_dims) == 2:\\r\\n Zu = self.Z * self._Xscale + self._Xoffset\\r\\n ax.plot(Zu[:, 0], Zu[:, 1], 'wo')\\r\\n\\r\\n else:\\r\\n raise NotImplementedError, \\\"Cannot define a frame with more than two input dimensions\\\"\",\n \"def cal_abs_coeff(self, filepath, thickness, sub_filepath,\\n start, end,\\n output_path='/Users/nakayamahidenori/UCSB_data/spectra/abs_coeff',\\n output=True):\\n \\n NM_TO_EV_CONST = 1240. #lambda = 1240/E\\n \\n filename = filepath.split('/')[-1].split('.')[0]\\n \\n from scipy import interpolate\\n\\n \\n def interp(wl, absorbance, start=start, end=end, step=1.): \\n f = interpolate.interp1d(wl, absorbance)\\n new_wl = np.arange(start, end + step, step)\\n new_abs = f(new_wl)\\n \\n return new_wl, new_abs\\n \\n f_abs = Clab_UV().read_file(filepath, absorbance=True)\\n sub_abs = Clab_UV().read_file(sub_filepath, absorbance=True)\\n \\n wl, f_abs_intp = interp(f_abs.ix[:,0], f_abs.ix[:,1])\\n wl, sub_abs_intp = interp(sub_abs.ix[:,0], sub_abs.ix[:,1])\\n abs_coeff_wl = (f_abs_intp - sub_abs_intp)/(thickness*1e-7)\\n \\n ev_converted = NM_TO_EV_CONST/wl\\n ev_start = round(NM_TO_EV_CONST/end + 0.01, 2)\\n ev_end = round(NM_TO_EV_CONST/start - 0.01, 2)\\n \\n\\n ev, abs_coeff_ev = interp(ev_converted, abs_coeff_wl,\\n start=ev_start, end=ev_end, step=.01)\\n\\n \\n if output:\\n df = pd.DataFrame([np.array(wl),\\n np.array(abs_coeff_wl),\\n np.array(ev),\\n np.array(abs_coeff_ev)],\\n index=['wl_[nm]',\\n 'abs_coeff_wl_[cm-1]',\\n 'energy_[eV]',\\n 'abs_coeff_ev_[cm-1]']).T\\n \\n df.to_csv(output_path + '/' + filename + '.csv')\\n\\n return wl, abs_coeff_wl, ev, abs_coeff_ev\",\n \"def main():\\n\\n parser = argparse.ArgumentParser(description=main.__doc__,\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter,\\n epilog=\\\"Homepage: https://github.com/kbat/mc-tools\\\")\\n parser.add_argument('com', type=str, help='plot requests file name', nargs='?', default=\\\"/tmp/foo.c\\\")\\n parser.add_argument('comout', type=str, help='COMOUT file name', nargs='?', default=\\\"zoom\\\")\\n\\n args = parser.parse_args()\\n\\n cmd = {} # dictionary of commands\\n\\n bas = False\\n plane = False\\n \\n with open(args.com) as f:\\n for line in f.readlines():\\n words = line.strip().split()\\n if len(words) is 0:\\n continue\\n\\n for i,w in enumerate(words):\\n if re.search(\\\"^bas\\\", w):\\n cmd['bas'] = list(map(float, words[i+1:i+7]))\\n if plane is False: bas = True # basis was before plane cuts\\n elif re.search(\\\"^or\\\", w):\\n cmd['or'] = list(map(float, words[i+1:i+4]))\\n elif re.search(\\\"^ex\\\", w):\\n try: # both x and y scales are given\\n cmd['ex'] = list(map(float, words[i+1:i+3]))\\n continue\\n except ValueError: # just 1 scale is given\\n cmd['ex'] = list(map(float, words[i+1:i+2]))\\n elif re.search(\\\"^lab\\\", w):\\n cmd['label'] = list(map(int, map(float, words[i+1:i+3]))) #+ [words[i+3]]\\n elif re.search(\\\"^p[xyz]\\\", w):\\n cmd[w] = [float(words[i+1])]\\n if bas is False: plane = True # plane cuts were before basis\\n elif re.search(\\\"^legend\\\", w):\\n cmd[w] = [words[i+1]]\\n elif w == \\\"scale\\\":\\n print(w)\\n if int(words[i+1]): # no need to put 'scale 0'\\n cmd[w] = [words[i+1]]\\n elif w in (\\\"mesh\\\"):\\n if int(words[i+1])==1: # no need to put 'mesh 1'\\n cmd[w] = [words[i+1]]\\n\\n print(bas, plane)\\n\\n if plane: # bas was first\\n keys = ('bas', 'or', 'ex', 'px', 'py', 'pz', 'label', 'mesh', 'legend', 'scale')\\n elif bas:\\n keys = ('or', 'ex', 'px', 'py', 'pz', 'bas', 'label', 'mesh', 'legend', 'scale')\\n else:\\n keys = {'or', 'ex', 'label', 'mesh', 'legend', 'scale'}\\n \\n with open(args.comout, 'w') as f:\\n for key in keys:\\n if key in cmd:\\n # newline required by mcplot:\\n if key in ('mesh', 'legend', 'scale', 'label'):\\n f.write(\\\"\\\\n\\\")\\n f.write(\\\"%s %s \\\" % (key,\\\" \\\".join(str(e) for e in cmd[key]),))\\n f.write(\\\"\\\\n\\\")\",\n \"def plot_shifts(\\n ax: Any,\\n relative_shifts: np.ndarray,\\n) -> None:\\n\\n # Determine the grid size from the shifts array\\n grid_size = relative_shifts.shape[0]\\n\\n # Compute the positions of the centers of the subapertures\\n x, y = get_subaperture_centers(grid_size=grid_size)\\n\\n # Draw the grid of subapertures\\n for z in np.linspace(-1 / np.sqrt(2), 1 / np.sqrt(2), grid_size + 1):\\n ax.plot((z, z), (-1 / np.sqrt(2), 1 / np.sqrt(2)), color=\\\"black\\\")\\n ax.plot((-1 / np.sqrt(2), 1 / np.sqrt(2)), (z, z), color=\\\"black\\\")\\n\\n # Plot the centers of the subapertures\\n ax.plot(x.flatten(), y.flatten(), \\\"x\\\", ms=4, color=\\\"C2\\\", alpha=0.5)\\n\\n # Add a red circle indicating the unit disk\\n ax.add_artist(plt.Circle((0, 0), 1, color=\\\"red\\\", ls=\\\"--\\\", fill=False))\\n\\n # Determine a shrinkage factor to map the relative shifts into the right\\n # reference frame (i.e., scale to the size of a subaperture in the plot)\\n factor = np.sqrt(2) / grid_size / 2\\n\\n # Plot the observed position for each subapertures, which differs from the\\n # center of the subaperture by the given shift vector\\n ax.plot(\\n x.flatten() + factor * relative_shifts[:, :, 0].flatten(),\\n y.flatten() + factor * relative_shifts[:, :, 1].flatten(),\\n \\\".\\\",\\n color=\\\"C0\\\",\\n )\\n\\n # Fix the x- and y-limits of the plot\\n ax.set_xlim(-1.1, 1.1)\\n ax.set_ylim(-1.1, 1.1)\\n\\n # Fix the aspect ratio of the plot\\n ax.set_aspect(\\\"equal\\\")\",\n \"def vis_eval_sysu(distmat, q_pids, g_pids, q_camids, g_camids, max_rank=20,img_paths=[]):\\n num_q, num_g = distmat.shape\\n if num_g < max_rank:\\n max_rank = num_g\\n print(\\\"Note: number of gallery samples is quite small, got {}\\\".format(num_g))\\n indices = np.argsort(distmat, axis=1)\\n pred_label = g_pids[indices]\\n matches = (g_pids[indices] == q_pids[:, np.newaxis]).astype(np.int32)\\n sysumm_save_sample(indices=indices,matches=matches, img_paths=img_paths)\\n # compute cmc curve for each query\\n new_all_cmc = []\\n all_cmc = []\\n all_AP = []\\n num_valid_q = 0. # number of valid query\\n for q_idx in range(num_q):\\n # get query pid and camid\\n q_pid = q_pids[q_idx]\\n q_camid = q_camids[q_idx]\\n\\n # remove gallery samples that have the same pid and camid with query\\n order = indices[q_idx]\\n remove = (q_camid == 3) & (g_camids[order] == 2)\\n keep = np.invert(remove)\\n\\n # compute cmc curve\\n # the cmc calculation is different from standard protocol\\n # we follow the protocol of the author's released code\\n new_cmc = pred_label[q_idx][keep]\\n new_index = np.unique(new_cmc, return_index=True)[1]\\n new_cmc = [new_cmc[index] for index in sorted(new_index)]\\n new_match = (new_cmc == q_pid).astype(np.int32)\\n new_cmc = new_match.cumsum()\\n new_all_cmc.append(new_cmc[:max_rank])\\n\\n orig_cmc = matches[q_idx][keep] # binary vector, positions with value 1 are correct matches\\n if not np.any(orig_cmc):\\n # this condition is true when query identity does not appear in gallery\\n continue\\n\\n cmc = orig_cmc.cumsum()\\n cmc[cmc > 1] = 1\\n\\n all_cmc.append(cmc[:max_rank])\\n num_valid_q += 1.\\n\\n # compute average precision\\n # reference: https://en.wikipedia.org/wiki/Evaluation_measures_(information_retrieval)#Average_precision\\n num_rel = orig_cmc.sum()\\n tmp_cmc = orig_cmc.cumsum()\\n tmp_cmc = [x / (i + 1.) for i, x in enumerate(tmp_cmc)]\\n tmp_cmc = np.asarray(tmp_cmc) * orig_cmc\\n AP = tmp_cmc.sum() / num_rel\\n all_AP.append(AP)\\n\\n assert num_valid_q > 0, \\\"Error: all query identities do not appear in gallery\\\"\\n\\n all_cmc = np.asarray(all_cmc).astype(np.float32)\\n all_cmc = all_cmc.sum(0) / num_valid_q\\n\\n new_all_cmc = np.asarray(new_all_cmc).astype(np.float32)\\n new_all_cmc = new_all_cmc.sum(0) / num_valid_q\\n mAP = np.mean(all_AP)\\n\\n return new_all_cmc, mAP\",\n \"def plotDistributionWithLimitsRefine(lXs, llYs, lKClassif,out=\\\"out.png\\\", title=\\\"title\\\", xax=\\\"xax\\\", yax=\\\"yax\\\",legend=\\\"\\\"):\\n\\n fig = plt.Figure(figsize=(40,20))\\n fig.suptitle(title, fontsize=32)\\n nbPlots = len(llYs)\\n sqrt = int(math.ceil(math.sqrt(nbPlots)))\\n ymax = 0.0\\n for i,val in enumerate(llYs):\\n if lKClassif[i] != \\\"refine\\\":\\n ymax = max(max(val[0]),ymax)\\n ymaxCurrent = max(max(val[2]),ymax)\\n ymax = ymax*1.05\\n xmax = 147\\n gs = gridspec.GridSpec(1,2) \\n ax = fig.add_subplot(gs[0])\\n gsLimit = gridspec.GridSpecFromSubplotSpec(sqrt,sqrt, subplot_spec=gs[1])\\n for i,val in enumerate(llYs):\\n if lKClassif[i] != \\\"refine\\\":\\n ax.plot(lXs,val[0],color=Graphics.lColors[i%25])\\n axCurrent = fig.add_subplot(gsLimit[i]) \\n axCurrent.fill_between(lXs, val[1], val[2], alpha=0.35, edgecolor='black', facecolor=Graphics.lColors[i%25])\\n axCurrent.set_title(\\\"Cluster K{}, (position: {})\\\".format(i,lKClassif[i]))\\n axCurrent.fill_between(lXs, val[3], val[4], alpha=0.85, edgecolor='darkgray', facecolor='lightgray')\\n axCurrent.plot(lXs,val[0],color=Graphics.lColors[i%25])\\n axCurrent.set_ylim(0,ymaxCurrent)\\n axCurrent.set_xlim(1,xmax)\\n axCurrent.text(10, ymaxCurrent*0.90, \\\"#nucleosomes: {}\\\".format(legend[i]), fontsize=12)\\n axis_font = {'size':'28'}\\n ax.set_ylim(0,ymax)\\n ax.set_xlim(1,xmax)\\n ax.legend([\\\"K{}\\\".format(x) for x in range(0,nbPlots)])\\n ax.set_title(\\\"all nucleosomes\\\", **axis_font)\\n ax.set_xlabel(xax, **axis_font)\\n ax.set_ylabel(yax, **axis_font)\\n ax.tick_params(labelsize=20)\\n canvas = FigureCanvasAgg(fig)\\n canvas.print_figure(out, dpi=80)\",\n \"def frac_diff_groups_model(param_dict, proj_dict, plot_opt='mhalo',\\n nlim_min=5, nlim_threshold=False, arr_len=10, bin_statval='left',\\n fig_fmt='pdf', figsize=(10, 8), fig_number=1):\\n file_msg = param_dict['Prog_msg']\\n ## Matplotlib option\\n matplotlib.rcParams['axes.linewidth'] = 2.5\\n matplotlib.rcParams['axes.edgecolor'] = 'black'\\n ##\\n # Constants\\n cm = plt.cm.get_cmap('viridis')\\n plot_dict = param_dict['plot_dict']\\n ham_color = 'red'\\n alpha = 0.6\\n alpha_mass = 0.2\\n zorder_mass = 10\\n zorder_shade = zorder_mass - 1\\n zorder_ml = zorder_mass + 1\\n bin_width = param_dict['ml_args'].mass_bin_width\\n ##\\n ## Figure name\\n fname = os.path.join( proj_dict['figure_dir'],\\n 'Fig_{0}a_{1}_group_mass_comparison.{2}'.format(\\n fig_number,\\n param_dict['catl_str_fig'],\\n fig_fmt))\\n ##\\n ## Paper Figure\\n fname_paper = os.path.join( proj_dict['paper_fig_dir'],\\n 'Figure_01a.{0}'.format(fig_fmt))\\n ##\\n ## Reading in 'master' combined catalogue\\n catl_pd_tot = param_dict['ml_args'].extract_merged_catl_info(\\n opt='combined')\\n ##\\n ## Only selecting groups with `nlim_min` galaxies or larger\\n if nlim_threshold:\\n catl_pd_tot = catl_pd_tot.loc[(catl_pd_tot['GG_ngals'] >= nlim_min)]\\n ##\\n ## Temporarily fixing `GG_mdyn_rproj`\\n # catl_pd_tot.loc[:, 'GG_mdyn_rproj'] /= 0.96\\n ##\\n ## Dropping NaN's\\n catl_pd_tot.dropna(how='any', inplace=True)\\n ##\\n ## Selecting only 'Good' groups\\n good_p_opt = int(1)\\n catl_cols_arr = ['GG_pointing', 'GG_mhalo_point', 'GG_M_group',\\n 'GG_mdyn_rproj', 'groupid']\\n catl_pd_tot_mod = catl_pd_tot.loc[catl_pd_tot['GG_pointing'] == good_p_opt,\\n catl_cols_arr].drop_duplicates().reset_index(drop=True)\\n ##\\n ## Selecting Masses\\n # - HAM Mass -\\n ham_cols = ['GG_M_group', 'GG_mhalo_point']\\n ( ham_pred,\\n ham_true) = catl_pd_tot_mod.loc[:, ham_cols].values.T\\n ham_frac_diff = 100. * (ham_pred - ham_true) / ham_true\\n # - DYN Mass -\\n dyn_cols = ['GG_mdyn_rproj', 'GG_mhalo_point']\\n ( dyn_pred,\\n dyn_true) = catl_pd_tot_mod.loc[\\n catl_pd_tot_mod['GG_mdyn_rproj'] >= 11.0,\\n dyn_cols].values.T\\n dyn_frac_diff = 100. * (dyn_pred - dyn_true) / dyn_true\\n ##\\n ## Choosing which mass to plot\\n if (plot_opt == 'mgroup'):\\n ham_x = ham_pred\\n dyn_x = dyn_pred\\n elif (plot_opt == 'mhalo'):\\n ham_x = ham_true\\n dyn_x = dyn_true\\n ##\\n ## Binning the data\\n ## -- HAM --\\n ( x_stat_ham ,\\n y_stat_ham ,\\n y_std_ham ,\\n y_std_err_ham) = cstats.Stats_one_arr( ham_x,\\n ham_frac_diff,\\n base=bin_width,\\n arr_len=arr_len,\\n bin_statval=bin_statval)\\n y1_ham = y_stat_ham - y_std_ham\\n y2_ham = y_stat_ham + y_std_ham\\n ## -- DYN --\\n ( x_stat_dyn ,\\n y_stat_dyn ,\\n y_std_dyn ,\\n y_std_err_dyn) = cstats.Stats_one_arr( dyn_x,\\n dyn_frac_diff,\\n base=bin_width,\\n arr_len=arr_len,\\n bin_statval=bin_statval)\\n y1_dyn = y_stat_dyn - y_std_dyn\\n y2_dyn = y_stat_dyn + y_std_dyn\\n ## Figure details\\n # Labels\\n # X-label\\n if (plot_opt == 'mgroup'):\\n xlabel = r'\\\\boldmath$\\\\log M_{predicted} \\\\textrm{ - Groups}\\\\left[ h^{-1} M_{\\\\odot}\\\\right]$'\\n elif (plot_opt == 'mhalo'):\\n xlabel = r'\\\\boldmath$\\\\log M_{halo,\\\\textrm{true}} \\\\textrm{ - Groups}\\\\left[ h^{-1} M_{\\\\odot}\\\\right]$'\\n # Y-label\\n ylabel = r'Frac. Difference - Groups \\\\boldmath$[\\\\%]$'\\n ##\\n plt.clf()\\n plt.close()\\n fig = plt.figure(figsize=figsize)\\n ax1 = fig.add_subplot(111, facecolor='white')\\n ## Horizontal line\\n ax1.axhline(y=0, color='black', linestyle='--', zorder=10)\\n ##\\n ## HAM Masses\\n ax1.plot( x_stat_ham,\\n y_stat_ham,\\n color=plot_dict['color_ham'],\\n linestyle='-',\\n marker='o',\\n zorder=zorder_mass)\\n ax1.fill_between( x_stat_ham,\\n y1_ham,\\n y2_ham, \\n color=plot_dict['color_ham'],\\n alpha=alpha_mass,\\n label='HAM',\\n zorder=zorder_shade)\\n ## Dynamical Masses\\n ax1.plot( x_stat_dyn,\\n y_stat_dyn,\\n color=plot_dict['color_dyn'],\\n linestyle='-',\\n marker='o',\\n zorder=zorder_mass)\\n ax1.fill_between( x_stat_dyn,\\n y1_dyn,\\n y2_dyn, \\n color=plot_dict['color_dyn'],\\n alpha=alpha_mass,\\n label='Dynamical',\\n zorder=zorder_shade)\\n ## Legend\\n leg = ax1.legend(loc='upper left', numpoints=1, frameon=False,\\n prop={'size':14})\\n leg.get_frame().set_facecolor('none')\\n ## Ticks\\n # Y-axis\\n xaxis_major_ticker = 1\\n xaxis_minor_ticker = 0.2\\n ax_xaxis_major_loc = ticker.MultipleLocator(xaxis_major_ticker)\\n ax_xaxis_minor_loc = ticker.MultipleLocator(xaxis_minor_ticker)\\n ax1.xaxis.set_major_locator(ax_xaxis_major_loc)\\n ax1.xaxis.set_minor_locator(ax_xaxis_minor_loc)\\n # Y-axis\\n yaxis_major_ticker = 5\\n yaxis_minor_ticker = 2\\n ax_yaxis_major_loc = ticker.MultipleLocator(yaxis_major_ticker)\\n ax_yaxis_minor_loc = ticker.MultipleLocator(yaxis_minor_ticker)\\n ax1.yaxis.set_major_locator(ax_yaxis_major_loc)\\n ax1.yaxis.set_minor_locator(ax_yaxis_minor_loc)\\n ## Labels\\n ax1.set_xlabel(xlabel, fontsize=plot_dict['size_label'])\\n ax1.set_ylabel(ylabel, fontsize=plot_dict['size_label'])\\n ##\\n ## Limits\\n ax1.set_ylim(-10, 10)\\n ##\\n ## Saving figure\\n if fig_fmt=='pdf':\\n plt.savefig(fname, bbox_inches='tight')\\n plt.savefig(fname_paper, bbox_inches='tight')\\n else:\\n plt.savefig(fname, bbox_inches='tight', dpi=400)\\n plt.savefig(fname_paper, bbox_inches='tight', dpi=400)\\n ##\\n ##\\n print('{0} Figure saved as: {1}'.format(file_msg, fname))\\n print('{0} Paper Figure saved as: {1}'.format(file_msg, fname_paper))\\n plt.clf()\\n plt.close()\",\n \"def plot_normalized_density_est(self):\\n # The true density is in self.x_all, num_cells x sim_steps.\\n # the first num_cells row is the density\\n dens = np.flipud(self.est_density[0:self.num_cells, :])\\n\\n # normalize the density [0, rho_max] to [0,1] for all cells\\n rho_max = np.flipud(np.matrix(self.rhomax_cells).reshape((self.num_cells, 1)))\\n\\n norm_dens = dens / rho_max\\n\\n fig = plt.figure(figsize=(10, 10), dpi=100)\\n ax = fig.add_axes([0.1, 0.1, 0.8, 0.8])\\n im = ax.imshow(norm_dens, cmap=plt.get_cmap('jet'),\\n interpolation='nearest',\\n vmin=0, vmax=1)\\n ax.autoscale(False)\\n\\n # ==============================================================\\n # plot the sensors, and on/off ramps\\n # plot onramps\\n onramp_ytick = {}\\n onramp_ytick['tick'] = []\\n onramp_ytick['label'] = []\\n if self.cell_onramp is not None:\\n for cell_id in self.cell_onramp:\\n # the onramp will be drawn as a line in the middle of the cell\\n val = self.num_cells - 1 - cell_id\\n onramp_ytick['tick'].append(val)\\n onramp_ytick['label'].append('Onramp {0}'.format(cell_id))\\n ax.plot([-0.5, self.num_steps - 0.5], [val, val], color='k', linewidth=1)\\n\\n # plot offramps\\n offramp_ytick = {}\\n offramp_ytick['tick'] = []\\n offramp_ytick['label'] = []\\n if self.cell_offramp is not None:\\n for cell_id in self.cell_offramp:\\n # the offramp will be drawn as a line in the middle of the cell\\n val = self.num_cells - 1 - cell_id\\n offramp_ytick['tick'].append(val)\\n offramp_ytick['label'].append('Offramp {0}'.format(cell_id))\\n ax.plot([-0.5, self.num_steps - 0.5], [val, val], color='k', linewidth=1)\\n\\n # plot flow sensors\\n flow_sensor_ytick = {}\\n flow_sensor_ytick['tick'] = []\\n flow_sensor_ytick['label'] = []\\n if len(self.sensors['freeway']) != 0:\\n for s_id in self.sensors['freeway']:\\n # the flow sensor will be drawn as a line in the begining of the cells.\\n cell_id = self.sensors[s_id]['cell']\\n\\n val = self.num_cells - 0.5 - cell_id\\n flow_sensor_ytick['tick'].append(val)\\n flow_sensor_ytick['label'].append('Flow Sensor {0}'.format(cell_id))\\n ax.plot([-0.5, self.num_steps - 0.5], [val, val], color='k', linewidth=1)\\n\\n # set y ticks\\n ax.set_yticks(onramp_ytick['tick'] + offramp_ytick['tick'] + flow_sensor_ytick['tick'])\\n ax.set_yticklabels(onramp_ytick['label'] + offramp_ytick['label'] + flow_sensor_ytick['label'])\\n\\n ax.set_title('Estimated density profile')\\n cax = fig.add_axes([0.95, 0.25, 0.01, 0.5])\\n fig.colorbar(im, cax=cax, orientation='vertical')\\n plt.draw()\",\n \"def check_sizes(self, show=True):\\n # find pixel with common RA \\n comRApix = np.where((self.coords1[0]<=np.max(self.coords2[0]))&\\n (self.coords1[0]>=np.min(self.coords2[0]))\\n )[0]\\n \\n # find pixels with common DEC \\n comDECpix = np.where((self.coords1[1]<=np.max(self.coords2[1]))&\\n (self.coords1[1]>=np.min(self.coords2[1]))\\n )[0]\\n \\n print('Image 1 common pixels size: ({:}, {:})'.format(comRApix.size,\\n comDECpix.size))\\n \\n # Corner coordinates \\n minRA = np.min(self.coords1[0][comRApix])\\n maxRA = np.max(self.coords1[0][comRApix])\\n minDEC = np.min(self.coords1[1][comDECpix])\\n maxDEC = np.max(self.coords1[1][comDECpix])\\n if show:\\n comFrame = plt.Rectangle(xy=(minRA, minDEC), width=maxRA-minRA,\\n height=maxDEC-minDEC, hatch='\\\\\\\\', fill=True,\\n color='g', alpha=.3)\\n fig = plt.figure(figsize=(10,10))\\n ax = fig.add_subplot(111)\\n ax.add_patch(comFrame)\\n ax.add_patch(self.image1.plotframe(color='r'))\\n ax.add_patch(self.image2.plotframe(color='b'))\\n ax.annotate('Image 1', xy=(minRA,maxDEC), color='r')\\n ax.plot() \\n plt.show()\\n \\n self.boundRA = np.array([minRA, maxRA])\\n self.boundDEC = np.array([minDEC, maxDEC]) \\n self.bounds1 = np.array([[comRApix[0], comRApix[-1]], \\n [comDECpix[0], comDECpix[-1]]])\\n \\n if self.image1.get_pix_area() < self.image2.get_pix_area():\\n print('Image 1 have smaller pixels than 2. \\\\n')\\n self.pix_1_smaller = True \\n else:\\n print('Image 2 have smaller pixels than 1. \\\\n')\\n self.pix_1_smaller = False\",\n \"def show_relative_ratio_with_base(base_list, ratio_list, title: str = \\\"\\\", block: bool = True):\\n fig, ax = plt.subplots()\\n ax.plot(base_list, ratio_list)\\n\\n ax.set_xlabel(\\\"Number of Clusters in Batch K-means\\\")\\n ax.set_ylabel(\\\"Relative Ratio\\\")\\n ax.set_title(title)\\n\\n if block:\\n plt.show()\\n\\n return fig, ax\",\n \"def _show_relative_ratio_with_base_all():\\n fig, ax = plt.subplots()\\n base_list = np.linspace(0, 100, num=11).astype(np.int)\\n base_list[0] = 1\\n\\n # MNIST\\n ratio_list = [1.0, 1.16, 1.1949999999999998,\\n 1.1766666666666665, 1.165, 1.1740000000000002, 1.175,\\n 1.1585714285714286, 1.19, 1.18, 1.179]\\n ax.plot(base_list, ratio_list, label=\\\"MNIST\\\")\\n\\n # Fashion MNIST\\n ratio_list = [1.0, 1.1199999999999999, 1.175,\\n 1.1533333333333333, 1.2, 1.15,\\n 1.1866666666666668, 1.1857142857142857, 1.23, 1.2044444444444444, 1.202]\\n ax.plot(base_list, ratio_list, label=\\\"Fashion MNIST\\\")\\n\\n # 20 news groups\\n ratio_list = [1.0, 1.4300000000000002, 1.58, 1.7633333333333332,\\n 1.8275, 1.838, 1.8599999999999999,\\n 1.9428571428571428, 2.05375, 2.148888888888889, 2.135]\\n ax.plot(base_list, ratio_list, label=\\\"Newsgroups\\\")\\n\\n ax.set_xlabel(\\\"Number of Clusters in Batch K-means\\\")\\n ax.set_ylabel(\\\"Relative Ratio\\\")\\n ax.set_title(\\\"Relative Ratio Curve\\\")\\n ax.legend()\\n\\n plt.show()\",\n \"def line_ratio_per_cell(ratio_name,**kwargs):\\n\\n p = copy.copy(params)\\n for key,val in kwargs.items():\\n setattr(p,key,val)\\n\\n # Load sim and cell data\\n gal_ob = gal.galaxy(p.gal_index)\\n cell_data = gal_ob.cell_data.get_dataframe()\\n\\n if ratio_name == 'NII':\\n xlim = [0.2,1.4]\\n line1,line2 = '[NII]122','[NII]205'\\n L_line1 = cell_data['L_'+line1].values\\n L_line2 = cell_data['L_'+line2].values\\n # Get ratio where the two samples overlap:\\n ratio = L_line1 / L_line2\\n if p.weight == 'm': weights = cell_data.m.values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\\n if p.weight == 'light': weights = cell_data['L_'+line2].values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\\n ratio = ratio[(ratio >= xlim[0]) & (ratio <= xlim[1])]\\n label = '%s / %s' % (line1,line2)\\n\\n if ratio_name == 'OICII':\\n xlim = [0,1]\\n line1,line2 = '[OI]63','[CII]'\\n L_line1 = cell_data['L_'+line1].values\\n L_line2 = cell_data['L_'+line2].values\\n # Get ratio where the two samples overlap:\\n ratio = L_line1 / L_line2\\n ratio = ratio[ratio > 1e-2]\\n if p.weight == 'm': weights = cell_data.m.values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\\n if p.weight == 'light': weights = cell_data['L_'+line1].values[(ratio >= xlim[0]) & (ratio <= xlim[1])]\\n ratio = np.log10(ratio[ratio != 0])\\n label = 'log %s / %s' % (line1,line2)\\n\\n if p.add:\\n ax = plt.gca()\\n else:\\n fig,ax = plt.subplots(figsize=(8,6))\\n if p.weight == '':\\n h = ax.hist(ratio,bins=p.bins,color=p.color,alpha=0.6,density=True)\\n ax.set_ylabel('Number of cells',fontsize=15)\\n if p.weight != '':\\n h = ax.hist(ratio,bins=p.bins,color=p.color,alpha=0.6,weights=weights,density=True)\\n if p.weight == 'm':\\n ax.set_title('Mass-weighted distribution',fontsize=15)\\n if p.weight == 'light':\\n ax.set_title('Luminosity-weighted (%s) distribution' % line2,fontsize=15)\\n\\n # Overplot global line ratio\\n GR = glo.global_results()\\n ratio = getattr(GR,'L_'+line1+'_sun')[p.gal_index] / getattr(GR,'L_'+line2+'_sun')[p.gal_index]\\n # print(ratio)\\n # print(np.sum(cell_data['L_'+line1].values)/np.sum(cell_data['L_'+line2].values))\\n ax.plot([ratio,ratio],ax.get_ylim(),'--',c=p.color)\\n\\n # ax.legend()\\n ax.set_xlim(xlim)\\n # ax.set_yscale('log')\\n ax.set_xlabel(label,fontsize=15)\\n ax.set_ylabel('Density of cells',fontsize=15)\\n if not os.path.isdir(p.d_plot + 'luminosity/'): os.mkdir(p.d_plot + 'luminosity/') \\n plt.savefig(p.d_plot + 'luminosity/res_ratio_%s_%s' % (ratio_name,p.weight),dpi=300)\",\n \"def scale_sky_spectrum(wlm, sky_spectrum, spectra, cut_sky=4., fmax=10, fmin=1, valid_wave_min=0, valid_wave_max=0, \\n fibre_list=[100,200,300,400,500,600,700,800,900], plot=True, verbose=True, warnings=True): \\n \\n# # Read sky lines provided by 2dFdr\\n# sky_line_,flux_sky_line_ = read_table(\\\"sky_lines_2dfdr.dat\\\", [\\\"f\\\", \\\"f\\\"] )\\n# # Choose those lines in the range\\n# sky_line=[]\\n# flux_sky_line=[]\\n# valid_wave_min = 6240\\n# valid_wave_max = 7355\\n# for i in range(len(sky_line_)):\\n# if valid_wave_min < sky_line_[i] < valid_wave_max:\\n# sky_line.append(sky_line_[i])\\n# flux_sky_line.append(flux_sky_line_[i])\\n \\n \\n if valid_wave_min == 0: valid_wave_min = wlm[0]\\n if valid_wave_max == 0: valid_wave_max = wlm[-1]\\n \\n if verbose: print(\\\"\\\\n> Identifying sky lines using cut_sky =\\\",cut_sky,\\\", allowed SKY/OBJ values = [\\\",fmin,\\\",\\\",fmax,\\\"]\\\")\\n if verbose: print(\\\" Using fibres = \\\",fibre_list)\\n\\n peaks,peaks_name,peaks_rest,continuum_limits=search_peaks(wlm,sky_spectrum, plot=plot, cut=cut_sky, fmax=fmax, only_id_lines=False, verbose=False) \\n\\n ratio_list=[]\\n valid_peaks=[]\\n \\n if verbose: print(\\\"\\\\n Sky line Gaussian ratio Flux ratio\\\")\\n n_sky_lines_found=0\\n for i in range(len(peaks)):\\n sky_spectrum_data=fluxes(wlm,sky_spectrum, peaks[i], fcal=False, lowlow=50,highhigh=50, plot=False, verbose=False, warnings=False)\\n \\n sky_median_continuum = np.nanmedian(sky_spectrum_data[11])\\n \\n object_spectrum_data_gauss=[]\\n object_spectrum_data_integrated=[] \\n median_list=[]\\n for fibre in fibre_list: \\n object_spectrum_flux=fluxes(wlm, spectra[fibre], peaks[i], fcal=False, lowlow=50,highhigh=50, plot=False, verbose=False, warnings=False)\\n object_spectrum_data_gauss.append(object_spectrum_flux[3]) # Gaussian flux is 3\\n object_spectrum_data_integrated.append(object_spectrum_flux[7]) # integrated flux is 7\\n median_list.append(np.nanmedian(object_spectrum_flux[11]))\\n object_spectrum_data=np.nanmedian(object_spectrum_data_gauss)\\n object_spectrum_data_i=np.nanmedian(object_spectrum_data_integrated)\\n \\n object_median_continuum=np.nanmin(median_list) \\n \\n if fmin < object_spectrum_data/sky_spectrum_data[3] * sky_median_continuum/object_median_continuum < fmax :\\n n_sky_lines_found = n_sky_lines_found + 1\\n valid_peaks.append(peaks[i])\\n ratio_list.append(object_spectrum_data/sky_spectrum_data[3])\\n if verbose: print(\\\"{:3.0f} {:5.3f} {:2.3f} {:2.3f}\\\".format(n_sky_lines_found,peaks[i],object_spectrum_data/sky_spectrum_data[3], object_spectrum_data_i/sky_spectrum_data[7])) \\n\\n\\n #print \\\"ratio_list =\\\", ratio_list\\n #fit = np.polyfit(valid_peaks, ratio_list, 0) # This is the same that doing an average/mean\\n #fit_line = fit[0]+0*wlm\\n fit_line =np.nanmedian(ratio_list) # We just do a median\\n #fit_line = fit[1]+fit[0]*wlm\\n #fit_line = fit[2]+fit[1]*wlm+fit[0]*wlm**2\\n #fit_line = fit[3]+fit[2]*wlm+fit[1]*wlm**2+fit[0]*wlm**3\\n \\n \\n if plot:\\n plt.plot(valid_peaks,ratio_list,\\\"+\\\")\\n #plt.plot(wlm,fit_line)\\n plt.axhline(y=fit_line, color='k', linestyle='--')\\n plt.xlim(valid_wave_min-10, valid_wave_max+10) \\n #if len(ratio_list) > 0:\\n plt.ylim(np.nanmin(ratio_list)-0.2,np.nanmax(ratio_list)+0.2)\\n plt.title(\\\"Scaling sky spectrum to object spectra\\\")\\n plt.xlabel(\\\"Wavelength [$\\\\mathrm{\\\\AA}$]\\\")\\n plt.ylabel(\\\"OBJECT / SKY\\\")\\n plt.minorticks_on()\\n plt.show()\\n plt.close()\\n \\n if verbose: print(\\\" Using this fit to scale sky spectrum to object, the median value is \\\",np.round(fit_line,3),\\\"...\\\") \\n \\n sky_corrected = sky_spectrum * fit_line\\n\\n# plt.plot(wlm,sky_spectrum, \\\"r\\\", alpha=0.3)\\n# plt.plot(wlm,sky_corrected, \\\"g\\\", alpha=0.3)\\n# plt.show()\\n# plt.close()\\n \\n return sky_corrected, np.round(fit_line,3)\",\n \"def plot_instructions_lim_mags(self):\\n return self.__plot_instructions_lim_mags\",\n \"def asses_space(meas):\\n truth = list(meas.spec.central)\\n truth[meas.spec.ipar('syst_s1')] = 1\\n data = meas.spec(truth)\\n meas.spec.set_data(data)\\n\\n lls, xs, rels, prob = minutils.find_minima(meas.spec)\\n\\n print(\\\"Found %d minima with likelihoods:\\\" % len(lls))\\n print(', '.join([\\\"%.3f\\\" % l for l in lls]))\\n\\n print(\\\"Global minimum is found %.3f%% of the time\\\" % (100*prob))\\n\\n l0 = draw_spectrum(meas, truth, True, label='truth', linestyle='--')\\n l1 = draw_spectrum(meas, xs[0], True, label='fit')\\n plt.legend(handles=[l0, l1])\\n plt.savefig('spectrum-ll_0.pdf', format='pdf')\\n plt.clf()\\n\\n for imin in range(1, len(lls)):\\n print(\\\"Local minimum %.3f\\\" % lls[imin])\\n\\n isort = np.argsort(np.fabs(rels[imin]))[::-1]\\n par1 = meas.spec.pars[isort[0]]\\n par2 = meas.spec.pars[isort[1]]\\n print(\\\"Differs in %s, %s\\\" % (par1, par2))\\n\\n print(\\\"%s_0: %.3f, %s_%d: %.3f\\\" % (\\n par1,\\n xs[0][meas.spec.ipar(par1)],\\n par1, imin,\\n xs[imin][meas.spec.ipar(par1)]))\\n\\n print(\\\"%s_0: %.3f, %s_%d: %.3f\\\" % (\\n par2,\\n xs[0][meas.spec.ipar(par2)],\\n par2, imin,\\n xs[imin][meas.spec.ipar(par2)]))\\n\\n draw_spectrum(meas, truth, True, label='truth', linestyle='--')\\n draw_spectrum(meas, xs[imin], True, label='fit')\\n plt.legend(handles=[l0, l1])\\n plt.savefig('spectrum-ll_%d.pdf'%imin, format='pdf')\\n plt.clf()\\n\\n vals = minutils.slice2d(meas.spec, xs[imin], par1, par2)\\n plt.hist2d(\\n vals.T[0], \\n vals.T[1], \\n weights=np.exp(vals.T[2]), \\n bins=len(vals)**0.5,\\n normed=True)\\n \\n plt.xlabel(par1)\\n plt.ylabel(par2)\\n\\n cbar = plt.colorbar()\\n cbar.set_label('Likelihood density')\\n\\n plt.savefig('min_%d.pdf' % imin, format='pdf')\\n plt.clf()\",\n \"def normalize_plot(self):\\n\\n kwargs = dict(stretch = self.stretch,\\n vmin = self.vmin_button.get_value(),\\n vmax = self.vmax_button.get_value())\\n norm = aplpy.normalize.APLpyNormalize(**kwargs)\\n self.parent.aplpy_plot.image.set_norm(norm)\\n self.parent.aplpy_plot.refresh()\",\n \"def perSaccAcrossGroups(addExp2 = True, trim = True, spacing = .5, \\\\\\n\\t\\taddSimulation = True, exclOverlap = True, exclY = True):\\n\\t\\n\\tfig = plt.figure(figsize = (5,10))\\n\\ttitle = \\\"Average towards-handle landings across groups - exclOverlap = %s - exclY = %s\\\" % (exclOverlap, exclY)\\n\\tplt.suptitle(title)\\n\\t\\n\\t# The first experiment has to be treated differently, because\\n\\t# it contains two dependent variables: absolute and corrected\\n\\tdm1 = getDM.getDM(exp = \\\"004A\\\", excludeErrors = True, driftCorr = True)\\n\\tlLandingsAbs = []\\n\\tlLandingsCorr = []\\n\\t\\n\\tfor sacc in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\n\\t\\t\\n\\t\\t# This is the same for corrected landing positions (the saccade\\n\\t\\t# doesn't change; only the reference point does)\\n\\t\\t_dm = dm1.select(\\\"endX%sNorm != ''\\\" % sacc)\\n\\t\\t_dm = _dm.select(\\\"endX%sNorm > -.5\\\" % sacc)\\n\\t\\t_dm = _dm.select(\\\"endX%sNorm < .5\\\" % sacc)\\n\\t\\t\\n\\t\\tif exclY:\\n\\t\\t\\t_dm = _dm.select(\\\"endY%sNorm != ''\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endY%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endY%sNorm < .5\\\" % sacc)\\n\\t\\t\\n\\t\\t\\n\\t\\tif trim:\\n\\t\\t\\t_dmAbs = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sNormToHandle\\\" % sacc)\\n\\t\\t\\t_dmCorr = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sCorrNormToHandle\\\" % sacc)\\n\\t\\t\\n\\t\\t# Determine avg landing position:\\n\\t\\tavgAbs = _dmAbs[\\\"endX%sNormToHandle\\\" % sacc].mean()\\n\\t\\tavgCorr = _dmCorr[\\\"endX%sCorrNormToHandle\\\" % sacc].mean()\\n\\t\\t\\n\\t\\t# TODO: determine error bars:\\n\\n\\t\\tlLandingsAbs.append(avgAbs)\\n\\t\\tlLandingsCorr.append(avgCorr)\\n\\t\\n\\tplt.plot(lLandingsAbs, color = \\\"#f57900\\\", linewidth = 2, marker = \\\"o\\\")\\n\\tplt.plot(lLandingsCorr, color = \\\"#73d216\\\", linewidth = 2, marker = \\\"o\\\")\\n\\t\\n\\t# The other 2 experiments can be treated equally:\\n\\tcolList = [\\\"#ef2929\\\", \\\"#3465a4\\\"]\\n\\n\\tfor exp in [\\\"004B\\\", \\\"004C\\\"]:\\n\\t\\t\\n\\t\\tcontinue\\n\\t\\t\\n\\t\\tif not addExp2:\\n\\t\\t\\tif exp == \\\"004B\\\":\\n\\t\\t\\t\\tcontinue\\n\\t\\tif not addSimulation:\\n\\t\\t\\tif exp == \\\"004C\\\":\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\tdm = getDM.getDM(exp = exp, excludeErrors = True, driftCorr = True)\\n\\t\\t\\n\\t\\tif exp == \\\"004C\\\":\\n\\t\\t\\tprint 'xxx'\\n\\t\\t\\tif exclOverlap:\\n\\t\\t\\t\\tdm = dm.select(\\\"gap == 'zero'\\\")\\n\\n\\t\\tlLandingsAbs = []\\n\\t\\t\\n\\t\\tfor sacc in [\\\"1\\\", \\\"2\\\", \\\"3\\\", '4']:\\n\\t\\t\\t\\n\\t\\t\\t# TODO: how to filter only on-object saccades exp 2??\\n\\t\\t\\t_dm = dm.select(\\\"endX%sNorm != ''\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endX%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endX%sNorm < .5\\\" % sacc)\\n\\t\\t\\t\\n\\t\\t\\tif exclY:\\n\\t\\t\\t\\n\\t\\t\\t\\t_dm = _dm.select(\\\"endY%sNorm != ''\\\" % sacc)\\n\\t\\t\\t\\t_dm = _dm.select(\\\"endY%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t\\t_dm = _dm.select(\\\"endY%sNorm < .5\\\" % sacc)\\n\\n\\t\\t\\tif trim:\\n\\t\\t\\t\\t_dm = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sNormToHandle\\\" % sacc)\\n\\t\\t\\t\\n\\t\\t\\t# Determine avg landing position:\\n\\t\\t\\tavgAbs = _dm[\\\"endX%sNormToHandle\\\" % sacc].mean()\\n\\t\\t\\tlLandingsAbs.append(avgAbs)\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\tcol = colList.pop()\\n\\t\\tplt.plot(lLandingsAbs, color = col, linewidth = 2, marker = \\\"o\\\")\\n\\t\\n\\t# Modify plot:\\n\\tplt.legend([\\\"Exp1 abs\\\", \\\"Exp1 corr\\\", \\\"Exp2\\\", \\\"Sim\\\"])\\n\\t\\t\\n\\tplt.axhline(0, color = \\\"#888a85\\\", linestyle = \\\"--\\\", linewidth = 2)\\n\\txLabels = [\\\"sacc 1\\\", \\\"sacc 2\\\", \\\"sacc 3\\\"]\\n\\txTicks = range(0,3)\\n\\tplt.xticks(xTicks, xLabels, rotation = .5)\\n\\tplt.xlim(min(xTicks)-spacing, max(xTicks)+spacing)\\n\\t\\n\\tplt.ylim([-.5, .5])\\n\\t\\n\\tplt.savefig(\\\"%s.png\\\" % title)\",\n \"def init_plot_force(nb_mus):\\n # --- Curve graph --- #\\n # app = pg.mkQApp(\\\"force\\\")\\n # remote = []\\n # layout = pg.LayoutWidget()\\n # layout.resize(800, 800)\\n # label = QtGui.QLabel()\\n # box = []\\n # rplt = []\\n # row_count = 0\\n # col_span = 4 if nb_mus > 8 else 8\\n # for mus in range(nb_mus):\\n # remote.append(rgv.RemoteGraphicsView())\\n # remote[mus].pg.setConfigOptions(antialias=True)\\n # app.aboutToQuit.connect(remote[mus].close)\\n # box.append(QtGui.QCheckBox(f\\\"muscle_{mus}\\\"))\\n # if mus >= 8:\\n # layout.addWidget(box[mus], row=1, col=mus-8)\\n # layout.addWidget(remote[mus], row=mus - 8 + 2, col=4, colspan=col_span)\\n # else:\\n # layout.addWidget(box[mus], row=0, col=mus)\\n # layout.addWidget(remote[mus], row=mus + 2, col=0, colspan=col_span)\\n # rplt.append(remote[mus].pg.PlotItem())\\n # rplt[mus]._setProxyOptions(deferGetattr=True) ## speeds up access to rplt.plot\\n # remote[mus].setCentralItem(rplt[mus])\\n # layout.addWidget(label)\\n # layout.show()\\n # row_count += 1\\n # return rplt, layout, app , box\\n\\n # --- Progress bar graph --- #\\n # app = pg.mkQApp(\\\"force\\\")\\n # layout = pg.LayoutWidget()\\n # layout.resize(400, 800)\\n # layout.move(0, 0)\\n # box = []\\n # rplt = []\\n # row_count = 0\\n # for mus in range(nb_mus):\\n # rplt.append(QProgressBar())\\n # rplt[mus].setMaximum(1000)\\n # layout.addWidget(rplt[mus], row=mus, col=0)\\n # layout.show()\\n # row_count += 1\\n # return rplt, layout, app\\n\\n # --- Bar graph --- #\\n app = pg.mkQApp()\\n layout = pg.plot()\\n layout.resize(800, 800)\\n rplt = pg.BarGraphItem(x=range(nb_mus), height=np.zeros((nb_mus)), width=0.3, brush=\\\"r\\\")\\n layout.addItem(rplt)\\n return rplt, layout, app\",\n \"def _preprocess_and_checks(self, das, params):\\n das, params = super()._preprocess_and_checks(das, params)\\n\\n # Convert grouping and check if allowed:\\n sim = das[\\\"sim\\\"]\\n ref = das[\\\"ref\\\"]\\n\\n # Check if common coordinates are identical.\\n newsim, newref = xr.broadcast(sim, ref)\\n for dim in set(sim.dims).union(ref.dims):\\n if [sim[dim].size, ref[dim].size] != [newsim[dim].size, newref[dim].size]:\\n raise ValueError(\\n f\\\"Common dimension {dim} has different coordinates between ref and sim.\\\"\\n )\\n\\n units_sim = units2pint(sim)\\n units_ref = units2pint(ref)\\n\\n if units_sim != units_ref:\\n das[\\\"sim\\\"] = convert_units_to(sim, ref)\\n\\n return das, params\",\n \"def coadd_spectra(spec_list_fits, out_name, scale_spectra=True,\\r\\n use_ratios=False, ratio_range=[4200, 4300], \\r\\n one_side=True):\\r\\n\\r\\n spec_list_txt = [f.replace('fits', 'txt') for f in spec_list_fits]\\r\\n\\r\\n # first spectrum in the list is always the reference spectrum\\r\\n hdr = pyfits.getheader(spec_list_fits[0])\\r\\n #mjd = hdr['MJD']\\r\\n #date_obs = hdr['DATE-OBS']\\r\\n #epoch = hdr['EPOCH']\\r\\n #observat = hdr['OBSERVAT']\\r\\n exptime = hdr['EXPTIME']\\r\\n seeing = hdr['FWHM']\\r\\n # save some keywords\\r\\n keys = ['OBJECT', 'OBSERVER', 'DICHROIC', 'APERTURE', 'LAMPS', 'UTSHUT', 'OBSLST', 'RA', 'DEC', 'HOURANG', 'HA', 'TELFOCUS', 'CASSPA', 'PARALLAC', 'CCDTEMP', 'ANGLE', 'GRATING', 'AIRMASS']\\r\\n #mjd_blue = hdr['MJD']\\r\\n exptime_blue = hdr['EXPTIME']\\r\\n hdr_save = {}\\r\\n for key in keys:\\r\\n hdr_save[key] = hdr[key]\\r\\n verr = np.float(hdr['VERR'])**2\\r\\n spec_ref = np.genfromtxt(spec_list_txt[0], names='wave, flux', \\r\\n dtype='f4, f4')\\r\\n err_ref = np.genfromtxt(spec_list_txt[0].replace('spec', 'err'), \\r\\n names='wave, flux', dtype='f4, f4')\\r\\n wave = spec_ref['wave']\\r\\n spec_ref = spec_ref['flux'].view(np.ma.masked_array)\\r\\n err_ref = err_ref['flux'].view(np.ma.masked_array)\\r\\n\\r\\n\\r\\n # err_ref['flux'] = np.where(err_ref['flux'] <= 0, 1, err_ref['flux']) # reset bad error values to 1\\r\\n # boolean array: mask out invalid regions so average excludes zeros\\r\\n bad_err = err_ref <= 0\\r\\n spec_ref[bad_err] = np.ma.masked\\r\\n err_ref[bad_err] = np.ma.masked\\r\\n\\r\\n\\r\\n # spectra and their errors will be stored here\\r\\n spectra = np.ma.zeros((spec_ref.size, len(spec_list_fits)), dtype='f4')\\r\\n spectra_err = np.ma.zeros((spec_ref.size, len(spec_list_fits)), dtype='f4')\\r\\n\\r\\n spectra[:, 0] = spec_ref\\r\\n spectra_err[:, 0] = err_ref\\r\\n\\r\\n ratio = [1]\\r\\n\\r\\n for i, fname in enumerate(spec_list_fits[1:]):\\r\\n fname_txt = spec_list_txt[i+1]\\r\\n hdr = pyfits.getheader(fname)\\r\\n exptime += hdr['EXPTIME']\\r\\n seeing += hdr['FWHM']\\r\\n verr += np.float(hdr['VERR'])**2\\r\\n spec = np.genfromtxt(fname_txt, names='wave, flux', dtype='f4, f4')\\r\\n err = np.genfromtxt(fname_txt.replace('spec', 'err'), \\r\\n names='wave, flux', dtype='f4, f4')\\r\\n spec = spec['flux'].view(np.ma.masked_array)\\r\\n err = err['flux'].view(np.ma.masked_array)\\r\\n # reset bad error values to 1\\r\\n # err['flux'] = np.where(err['flux'] <= 0, 1, err['flux']) \\r\\n bad_err = err <= 0\\r\\n spec[bad_err] = np.ma.masked\\r\\n err[bad_err] = np.ma.masked\\r\\n\\r\\n spectra[:, i+1] = spec\\r\\n spectra_err[:, i+1] = err\\r\\n if scale_spectra:\\r\\n if use_ratios:\\r\\n # use the specified region to determine te ratio of spectra\\r\\n good = np.where((spec > ratio_range[0]) & \\r\\n (spec < ratio_range[1]))\\r\\n ratio.append(np.median(spec_ref[good]/spec[good]))\\r\\n else:\\r\\n spec_good_err = err > 0\\r\\n # identify overlap between sides\\r\\n wgd = (err_ref > 0) & (err > 0)\\r\\n\\r\\n ratio.append(match_spectra_leastsq(spec[wgd], \\r\\n spec_ref[wgd], err[wgd], \\r\\n err_ref[wgd]))\\r\\n\\r\\n \\r\\n\\r\\n spec_avg, sum_weights = np.average(spectra*ratio, weights=1./(spectra_err*ratio)**2, axis=1, returned=True)\\r\\n spec_err = 1./np.sqrt(sum_weights)\\r\\n # output coadded spectra and uncertainties\\r\\n f = open('%s.spec.txt' % out_name, 'w')\\r\\n g = open('%s.err.txt' % out_name, 'w')\\r\\n h = open('%s.snr.txt' % out_name, 'w')\\r\\n # add some header keywords\\r\\n for key in hdr_save.keys():\\r\\n f.write('# %s = %s\\\\n' % (key, hdr_save[key]))\\r\\n if one_side:\\r\\n # exposure time and velocity error are only well-defined for\\r\\n # data combined from a single side\\r\\n f.write('# FWHM = %.2f\\\\n' % float(seeing/len(spec_list_fits)))\\r\\n f.write('# VERR = %.2f\\\\n' % np.sqrt(verr))\\r\\n #f.write('# MJD = %.6f\\\\n' % (mjd + exptime/(2.*60.*60.*24.)))\\r\\n else:\\r\\n # when combining sides, use the MJD and EXPTIME from the combined blue side\\r\\n f.write('# EXPTIME = %.0f\\\\n' % exptime_blue)\\r\\n #f.write('# MJD = %.6f\\\\n' % mjd_blue)\\r\\n\\r\\n for x, y, z in zip(wave, spec_avg, spec_err):\\r\\n f.write('%.3f %.5g\\\\n' % (x, y))\\r\\n g.write('%.3f %.5g\\\\n' % (x, z))\\r\\n h.write('%.3f %.5g\\\\n' % (x, y/z))\\r\\n f.close()\\r\\n g.close()\\r\\n h.close()\\r\\n # save as 1D IRAF FITS files\\r\\n iraf.delete('%s.spec.fits' % out_name, verify=\\\"no\\\")\\r\\n iraf.delete('%s.err.fits' % out_name, verify=\\\"no\\\")\\r\\n iraf.delete('%s.snr.fits' % out_name, verify=\\\"no\\\")\\r\\n iraf.rspectext('%s.spec.txt' % out_name, '%s.spec.fits' % out_name, \\r\\n crval1 = hdr['CRVAL1'], cdelt1 = hdr['CDELT1'])\\r\\n iraf.rspectext('%s.err.txt' % out_name, '%s.err.fits' % out_name, \\r\\n crval1 = hdr['CRVAL1'], cdelt1 = hdr['CDELT1'])\\r\\n iraf.rspectext('%s.snr.txt' % out_name, '%s.snr.fits' % out_name, \\r\\n crval1 = hdr['CRVAL1'], cdelt1 = hdr['CDELT1'])\\r\\n # add keywords\\r\\n f = pyfits.open('%s.spec.fits' % out_name)\\r\\n for key in hdr_save.keys():\\r\\n #f[0].header.update(key, hdr_save[key])\\r\\n f[0].header[key]= hdr_save[key]\\r\\n #f[0].header.update('DATE-OBS', date_obs)\\r\\n #f[0].header.update('OBSERVAT', observat)\\r\\n #f[0].header.update('EPOCH', epoch)\\r\\n #f[0].header['DATE-OBS']= date_obs\\r\\n #f[0].header['OBSERVAT']= observat\\r\\n #f[0].header['EPOCH']= epoch\\r\\n if one_side:\\r\\n # exposure time and velocity error are only well-defined for\\r\\n # data combined from a single side\\r\\n #f[0].header.update('EXPTIME', exptime)\\r\\n #f[0].header.update('FWHM', seeing/len(spec_list_fits))\\r\\n #f[0].header.update('VERR', '%.2f' % np.sqrt(verr), 'Uncertainty in km/s')\\r\\n f[0].header['EXPTIME']= exptime\\r\\n f[0].header['FWHM']= seeing/len(spec_list_fits)\\r\\n f[0].header['VERR']= '%.2f' %np.sqrt(verr)\\r\\n #mjd += exptime/(2.*60.*60.*24.)\\r\\n else:\\r\\n # when combining sides, use the EXPTIME from the combined blue side\\r\\n #f[0].header.update('EXPTIME', exptime_blue)\\r\\n f[0].header['EXPTIME']= exptime_blue\\r\\n #del f[0].header['VERR'] #DaveC\\r\\n #f[0].header.update('MJD', np.round(mjd, decimals=6))\\r\\n #f[0].header['MJD']= np.round(mjd, decimals=6)\\r\\n\\r\\n f.writeto('%s.spec.fits' % out_name, clobber=True)\\r\\n f.close()\",\n \"def variations_plot(S0, K, B, T, N, u, d, q, M, barrier_type, option, \\n MC_runs, price_tree):\\n x_values = []\\n pi_M = []\\n pi_M_RMSE = []\\n for i in range(1,MC_runs,1):\\n Mi=M*i\\n x_values.append([Mi])\\n paths = sample_paths(S0, N, u, d, q, Mi)\\n p_valid, p_invalid, p_counts = split_paths(paths, B, K, \\n barrier_type, option)\\n if option == 'Call':\\n payoffs = np.maximum(0,p_counts[:,-1]-K)*np.exp(-1*r*T)\\n elif option == 'Put':\\n payoffs = np.maximum(0,K-p_counts[:,-1])*np.exp(-1*r*T)\\n payoffs = list(payoffs)\\n while len(payoffs) < Mi:\\n payoffs.append([0])\\n mean_payoff = np.mean(payoffs)[0]\\n pi_M.append(mean_payoff)\\n RMSE = np.sqrt(np.var(payoffs,ddof=1))/np.sqrt(Mi)\\n pi_M_RMSE.append(RMSE[0])\\n \\n # plotting\\n plt.figure(figsize=(8,6))\\n plt.subplot(2, 1, 1)\\n plt.plot(x_values, price_tree-1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, price_tree+1.96*np.array(pi_M_RMSE), '--', c='grey')\\n plt.plot(x_values, pi_M, 'o', label='price via MC')\\n plt.plot(x_values, [price_tree]*len(x_values), '-', lw=3, \\n label='price via tree')\\n plt.legend()\\n plt.title('Monte Carlo price, for increasing number of paths')\\n plt.ylabel('Expected Value')\\n #The following will plot the root mean square error\\n plt.subplot(2, 1, 2)\\n plt.plot(x_values, pi_M_RMSE, '-')\\n plt.xlabel('number of paths')\\n plt.ylabel('Root Mean Square Error')\\n #plt.savefig('MonteCarlo_variation.png', transparent=True)\\n plt.show()\",\n \"def assign_inputs(self):\\n if self.sam_sys_inputs.get(\\\"ui_calculations_only\\\"):\\n msg = ('reV requires model run - cannot set '\\n '\\\"ui_calculations_only\\\" to `True` (1). Automatically '\\n 'setting to `False` (0)!')\\n logger.warning(msg)\\n warn(msg)\\n self.sam_sys_inputs[\\\"ui_calculations_only\\\"] = 0\\n super().assign_inputs()\",\n \"def __init__(self, refstd, fig=None, rect=111, label='_', srange=(0, 1.5)):\\n\\n from matplotlib.projections import PolarAxes\\n import mpl_toolkits.axisartist.floating_axes as FA\\n import mpl_toolkits.axisartist.grid_finder as GF\\n\\n self.refstd = refstd # Reference standard deviation\\n\\n tr = PolarAxes.PolarTransform()\\n\\n # Correlation labels\\n rlocs = NP.concatenate((NP.arange(10)/10., [0.95, 0.99]))\\n tlocs = NP.arccos(rlocs) # Conversion to polar angles\\n gl1 = GF.FixedLocator(tlocs) # Positions\\n tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))\\n\\n # Standard deviation axis extent (in units of reference stddev)\\n self.smin = srange[0]*self.refstd\\n self.smax = srange[1]*self.refstd\\n\\n ghelper = FA.GridHelperCurveLinear(tr,\\n extremes=(0, NP.pi/2, # 1st quadrant\\n self.smin, self.smax),\\n grid_locator1=gl1,\\n tick_formatter1=tf1)\\n\\n if fig is None:\\n fig = PLT.figure()\\n\\n ax = FA.FloatingSubplot(fig, rect, grid_helper=ghelper)\\n fig.add_subplot(ax)\\n\\n # Adjust axes\\n ax.axis[\\\"top\\\"].set_axis_direction(\\\"bottom\\\") # \\\"Angle axis\\\"\\n ax.axis[\\\"top\\\"].toggle(ticklabels=True, label=True)\\n ax.axis[\\\"top\\\"].major_ticklabels.set_axis_direction(\\\"top\\\")\\n ax.axis[\\\"top\\\"].label.set_axis_direction(\\\"top\\\")\\n ax.axis[\\\"top\\\"].label.set_text(\\\"Correlation\\\")\\n\\n ax.axis[\\\"left\\\"].set_axis_direction(\\\"bottom\\\") # \\\"X axis\\\"\\n ax.axis[\\\"left\\\"].label.set_text(\\\"Standard deviation\\\")\\n\\n ax.axis[\\\"right\\\"].set_axis_direction(\\\"top\\\") # \\\"Y axis\\\"\\n ax.axis[\\\"right\\\"].toggle(ticklabels=True)\\n ax.axis[\\\"right\\\"].major_ticklabels.set_axis_direction(\\\"left\\\")\\n #ax.axis[\\\"right\\\"].label.set_text(\\\"Standard deviation\\\")\\n\\n ax.axis[\\\"bottom\\\"].set_visible(False) # Useless\\n\\n self._ax = ax # Graphical axes\\n self.ax = ax.get_aux_axes(tr) # Polar coordinates\\n\\n # Add reference point and stddev contour\\n l, = self.ax.plot([0], self.refstd, 'k*',\\n ls='', ms=10, label=label)\\n t = NP.linspace(0, NP.pi/2)\\n r = NP.zeros_like(t) + self.refstd\\n self.ax.plot(t, r, 'k--', label='_')\\n\\n # Collect sample points for latter use (e.g. legend)\\n self.samplePoints = [l]\",\n \"def __init__(self, refstd, fig=None, rect=111, label='_', srange=(0, 1.5)):\\n\\n from matplotlib.projections import PolarAxes\\n import mpl_toolkits.axisartist.floating_axes as FA\\n import mpl_toolkits.axisartist.grid_finder as GF\\n\\n self.refstd = refstd # Reference standard deviation\\n\\n tr = PolarAxes.PolarTransform()\\n\\n # Correlation labels\\n rlocs = NP.concatenate((NP.arange(10)/10., [0.95, 0.99]))\\n tlocs = NP.arccos(rlocs) # Conversion to polar angles\\n gl1 = GF.FixedLocator(tlocs) # Positions\\n tf1 = GF.DictFormatter(dict(zip(tlocs, map(str, rlocs))))\\n\\n # Standard deviation axis extent (in units of reference stddev)\\n self.smin = srange[0]*self.refstd\\n self.smax = srange[1]*self.refstd\\n\\n ghelper = FA.GridHelperCurveLinear(tr,\\n extremes=(0, NP.pi, # 1st quadrant\\n self.smin, self.smax),\\n grid_locator1=gl1,\\n tick_formatter1=tf1)\\n\\n if fig is None:\\n fig = PLT.figure()\\n\\n ax = FA.FloatingSubplot(fig, rect, grid_helper=ghelper)\\n fig.add_subplot(ax)\\n\\n # Adjust axes\\n ax.axis[\\\"top\\\"].set_axis_direction(\\\"bottom\\\") # \\\"Angle axis\\\"\\n ax.axis[\\\"top\\\"].toggle(ticklabels=True, label=True)\\n ax.axis[\\\"top\\\"].major_ticklabels.set_axis_direction(\\\"top\\\")\\n ax.axis[\\\"top\\\"].label.set_axis_direction(\\\"top\\\")\\n ax.axis[\\\"top\\\"].label.set_text(\\\"Correlation\\\")\\n\\n ax.axis[\\\"left\\\"].set_axis_direction(\\\"bottom\\\") # \\\"X axis\\\"\\n ax.axis[\\\"left\\\"].label.set_text(\\\"Standard deviation\\\")\\n\\n ax.axis[\\\"right\\\"].set_axis_direction(\\\"top\\\") # \\\"Y axis\\\"\\n ax.axis[\\\"right\\\"].toggle(ticklabels=True)\\n ax.axis[\\\"right\\\"].major_ticklabels.set_axis_direction(\\\"left\\\")\\n #ax.axis[\\\"right\\\"].label.set_text(\\\"Standard deviation\\\")\\n\\n ax.axis[\\\"bottom\\\"].set_visible(False) # Useless\\n\\n self._ax = ax # Graphical axes\\n self.ax = ax.get_aux_axes(tr) # Polar coordinates\\n\\n # Add reference point and stddev contour\\n l, = self.ax.plot([0], self.refstd, 'k*',\\n ls='', ms=10, label=label)\\n t = NP.linspace(0, NP.pi/2)\\n r = NP.zeros_like(t) + self.refstd\\n self.ax.plot(t, r, 'k--', label='_')\\n\\n # Collect sample points for latter use (e.g. legend)\\n self.samplePoints = [l]\",\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 doParametersOfInterest(self):\\n self.modelBuilder.doVar(\\\"mu[1,0,100]\\\") ##mu is what we want to return (in string) name[starting_value,min,max] \\n self.modelBuilder.doSet(\\\"POI\\\",\\\"mu\\\")\\n self.modelBuilder.factory_('expr::ggH_s_func(\\\"@0-sqrt(@0)\\\", mu)')\\n self.modelBuilder.factory_( 'expr::ggH_b_func(\\\"1-sqrt(@0)\\\", mu)')\\n self.modelBuilder.factory_( 'expr::ggH_sbi_func(\\\"sqrt(@0)\\\", mu)')\",\n \"def plot_colour_mag_diagram(params,mags, colours, local_mags, local_colours,\\n target, source, blend, RC, blue_filter, red_filter,\\n yaxis_filter, tol, log):\\n\\n def calc_colour_lightcurve(blue_lc, red_lc, y_lc):\\n\\n idx1 = np.where( red_lc['mag_err'] > 0.0 )[0]\\n idx2 = np.where( blue_lc['mag_err'] > 0.0 )[0]\\n idx3 = np.where( y_lc['mag_err'] > 0.0 )[0]\\n idx = set(idx1).intersection(set(idx2))\\n idx = list(idx.intersection(set(idx3)))\\n\\n mags = y_lc['mag'][idx]\\n magerr = y_lc['mag_err'][idx]\\n cols = blue_lc['mag'][idx] - red_lc['mag'][idx]\\n colerr = np.sqrt(blue_lc['mag_err'][idx]**2 + red_lc['mag_err'][idx]**2)\\n\\n return mags, magerr, cols, colerr\\n\\n\\n add_source_trail = False\\n add_target_trail = True\\n add_crosshairs = True\\n add_source = True\\n add_blend = True\\n add_rc_centroid = True\\n add_extinction_vector = True\\n\\n fig = plt.figure(1,(10,10))\\n\\n ax = plt.subplot(111)\\n\\n plt.rcParams.update({'font.size': 18})\\n\\n plt.scatter(colours,mags,\\n c='#E1AE13', marker='.', s=1,\\n label='Stars within ROME field')\\n\\n plt.scatter(local_colours,local_mags,\\n c='#8c6931', marker='*', s=4,\\n label='Stars < '+str(round(tol,1))+'arcmin of target')\\n\\n col_key = blue_filter+red_filter\\n\\n if getattr(source,blue_filter) != None and getattr(source,red_filter) != None\\\\\\n and add_source:\\n\\n plt.errorbar(getattr(source,col_key), getattr(source,yaxis_filter),\\n yerr = getattr(source,'sig_'+yaxis_filter),\\n xerr = getattr(source,'sig_'+col_key), color='m',\\n marker='d',markersize=10, label='Source crosshairs')\\n\\n if add_crosshairs:\\n plot_crosshairs(fig,getattr(source,col_key),getattr(source,yaxis_filter),'m')\\n\\n if add_source_trail:\\n red_lc = source.lightcurves[red_filter]\\n blue_lc = source.lightcurves[blue_filter]\\n y_lc = source.lightcurves[yaxis_filter]\\n\\n (smags, smagerr, scols, scolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\\n\\n plt.errorbar(scols, smags, yerr = smagerr, xerr = scolerr,\\n color='m', marker='d',markersize=10, label='Source')\\n\\n if getattr(blend,blue_filter) != None and getattr(blend,red_filter) != None \\\\\\n and add_blend:\\n\\n plt.errorbar(getattr(blend,col_key), getattr(blend,yaxis_filter),\\n yerr = getattr(blend,'sig_'+yaxis_filter),\\n xerr = getattr(blend,'sig_'+col_key), color='b',\\n marker='v',markersize=10, label='Blend')\\n\\n if getattr(target,blue_filter) != None and getattr(target,red_filter) != None \\\\\\n and add_target_trail:\\n\\n plt.errorbar(getattr(target,col_key), getattr(target,yaxis_filter),\\n yerr = getattr(target,'sig_'+yaxis_filter),\\n xerr = getattr(target,'sig_'+col_key), color='k',\\n marker='x',markersize=10)\\n\\n red_lc = target.lightcurves[red_filter]\\n blue_lc = target.lightcurves[blue_filter]\\n y_lc = target.lightcurves[yaxis_filter]\\n\\n (tmags, tmagerr, tcols, tcolerr) = calc_colour_lightcurve(blue_lc, red_lc, y_lc)\\n\\n plt.errorbar(tcols, tmags, yerr = tmagerr,xerr = tcolerr,\\n color='k', marker='+',markersize=10, alpha=0.4,\\n label='Blended target')\\n\\n if add_rc_centroid:\\n plt.errorbar(getattr(RC,col_key), getattr(RC,yaxis_filter),\\n yerr=getattr(RC,'sig_'+yaxis_filter),\\n xerr=getattr(RC,'sig_'+col_key),\\n color='g', marker='s',markersize=10, label='Red Clump centroid')\\n\\n plt.xlabel('SDSS ('+blue_filter+'-'+red_filter+') [mag]')\\n\\n plt.ylabel('SDSS-'+yaxis_filter+' [mag]')\\n\\n [xmin,xmax,ymin,ymax] = plt.axis()\\n\\n plt.axis([xmin,xmax,ymax,ymin])\\n\\n xticks = np.arange(xmin,xmax,0.1)\\n yticks = np.arange(ymin,ymax,0.2)\\n\\n ax.set_xticks(xticks,minor=True)\\n ax.set_yticks(yticks,minor=True)\\n\\n plot_file = path.join(params['red_dir'],'colour_magnitude_diagram_'+\\\\\\n yaxis_filter+'_vs_'+blue_filter+red_filter\\\\\\n +'.pdf')\\n\\n plt.grid()\\n\\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'i':\\n plt.axis([0.5,2.0,20.2,13.5])\\n\\n if red_filter == 'i' and blue_filter == 'r' and yaxis_filter == 'r':\\n plt.axis([0.0,1.5,21.0,13.5])\\n\\n if red_filter == 'r' and blue_filter == 'g':\\n plt.axis([0.5,3.0,22.0,14.0])\\n\\n if red_filter == 'i' and blue_filter == 'g':\\n plt.axis([0.5,4.4,22.0,14.0])\\n\\n if add_extinction_vector:\\n plot_extinction_vector(fig,params,yaxis_filter)\\n\\n box = ax.get_position()\\n ax.set_position([box.x0, box.y0 + box.height * -0.025,\\n box.width, box.height * 0.95])\\n\\n l = ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.2), ncol=2)\\n\\n l.legendHandles[0]._sizes = [50]\\n l.legendHandles[1]._sizes = [50]\\n\\n plt.rcParams.update({'legend.fontsize':18})\\n plt.rcParams.update({'font.size':18})\\n plt.rc('xtick', labelsize=18)\\n plt.rc('ytick', labelsize=18)\\n\\n plt.savefig(plot_file,bbox_inches='tight')\\n\\n plt.close(1)\\n\\n log.info('Colour-magnitude diagram output to '+plot_file)\",\n \"def plot_multi_abundance(\\n bracken_combined, plot_file, min_percent\\n):\\n\\n nrow, ncol = 1, 2\\n\\n fig, ax = plt.subplots(\\n nrows=nrow, ncols=ncol, figsize=(\\n ncol*14, nrow*14\\n )\\n )\\n\\n data = pandas.read_csv(bracken_combined, sep='\\\\t', index_col='name', header=0)\\n # Use percentage rather than total reads across samples\\n data = data[[c for c in data.columns if 'bracken_frac' in c]]\\n data.columns = [d.replace(\\\".bracken_frac\\\", \\\"\\\") for d in data.columns]\\n\\n if min_percent > 0:\\n keep_idx = []\\n for i, row in data.iterrows():\\n keep_col = [True for v in row if v >= min_percent]\\n if any(keep_col):\\n keep_idx.append(row.name)\\n data = data[data.index.isin(keep_idx)]\\n\\n # Separate viruses\\n viruses = []\\n for name in data.index.tolist():\\n if 'virus' in name.lower():\\n viruses.append(data[data.index == name])\\n viruses = pandas.concat(viruses)\\n data = data.drop(viruses.index.tolist())\\n\\n human = data[data.index == 'Homo sapiens']\\n data = data.drop('Homo sapiens')\\n print(human)\\n\\n REMAINING_PATHOGENS = [p for p in PATHOGENS if p in data.index.tolist()]\\n pathogens = data[data.index.isin(REMAINING_PATHOGENS)].sort_index()\\n data = data.drop(REMAINING_PATHOGENS)\\n\\n REMAINING_CONTAMINATION = [p for p in CONTAM if p in data.index.tolist()]\\n contams = data[data.index.isin(REMAINING_CONTAMINATION)].sort_index()\\n data = data.drop(REMAINING_CONTAMINATION)\\n\\n print(pathogens)\\n print(contams)\\n\\n viruses_collapsed = collapse_taxa(viruses, suffix=\\\"virus\\\")\\n\\n print(viruses_collapsed)\\n\\n other_collapsed = collapse_taxa(data, genus=True)\\n\\n print(other_collapsed)\\n\\n combined = []\\n for name, df in {\\n 'Human': human, 'Pathogens': pathogens, 'Contamination': contams,\\n 'Viruses': viruses_collapsed, 'Microbes': other_collapsed\\n }.items():\\n df['domain'] = [name for _ in range(len(df))]\\n combined.append(df)\\n combined = pandas.concat(combined)\\n\\n print(combined)\\n\\n panel1 = combined[combined['domain'] != 'Microbes']\\n panel2 = combined[combined['domain'] == 'Microbes']\\n\\n panel1.reset_index(level=0, inplace=True)\\n panel2.reset_index(level=0, inplace=True)\\n panel1.rename(columns={'index': 'taxon'}, inplace=True)\\n panel2.rename(columns={'index': 'taxon'}, inplace=True)\\n\\n print(panel1)\\n print(panel2)\\n #\\n panel1_melt = panel1.melt(id_vars=['taxon', 'domain'], value_name=\\\"abundance\\\", var_name=\\\"sample\\\")\\n panel2_melt = panel2.melt(id_vars=['taxon', 'domain'], value_name=\\\"abundance\\\", var_name=\\\"sample\\\")\\n\\n print(panel1_melt)\\n print(panel2_melt)\\n\\n panel1_melt['abundance'] = [None if ab == 0. else ab for ab in panel1_melt['abundance']]\\n panel2_melt['abundance'] = [None if ab == 0. else ab for ab in panel2_melt['abundance']]\\n p1 = sns.scatterplot(\\n data=panel1_melt, x=\\\"sample\\\", y=\\\"taxon\\\", hue=\\\"domain\\\",\\n size=\\\"abundance\\\", legend=False, sizes=(70, 2000), ax=ax[0]\\n )\\n\\n p2 = sns.scatterplot(\\n data=panel2_melt, x=\\\"sample\\\", y=\\\"taxon\\\", hue=\\\"domain\\\", size=\\\"abundance\\\", legend=False, sizes=(50, 2000), ax=ax[1]\\n )\\n\\n # plot grid behind markers\\n # p1.grid(ls=\\\"dotted\\\", zorder=1, linewidth=0.1)\\n # p2.grid(ls=\\\"dotted\\\", zorder=1, linewidth=0.1)\\n # take care of long labels\\n fig.autofmt_xdate()\\n\\n plt.tight_layout()\\n p1.set_ylabel(\\\"\\\")\\n p1.set_ylabel(\\\"\\\")\\n p2.set_ylabel(\\\"\\\")\\n p2.set_ylabel(\\\"\\\")\\n fig.savefig(f'{plot_file}')\",\n \"def _plot(self):\\n # Read results\\n path = self.openmc_dir / f'statepoint.{self._batches}.h5'\\n x1, y1, _ = read_results('openmc', path)\\n if self.code == 'serpent':\\n path = self.other_dir / 'input_det0.m'\\n else:\\n path = self.other_dir / 'outp'\\n x2, y2, sd = read_results(self.code, path)\\n\\n # Convert energies to eV\\n x1 *= 1e6\\n x2 *= 1e6\\n\\n # Normalize the spectra\\n y1 /= np.diff(np.insert(x1, 0, self._min_energy))*sum(y1)\\n y2 /= np.diff(np.insert(x2, 0, self._min_energy))*sum(y2)\\n\\n # Compute the relative error\\n err = np.zeros_like(y2)\\n idx = np.where(y2 > 0)\\n err[idx] = (y1[idx] - y2[idx])/y2[idx]\\n \\n # Set up the figure\\n fig = plt.figure(1, facecolor='w', figsize=(8,8))\\n ax1 = fig.add_subplot(111)\\n \\n # Create a second y-axis that shares the same x-axis, keeping the first\\n # axis in front\\n ax2 = ax1.twinx()\\n ax1.set_zorder(ax2.get_zorder() + 1)\\n ax1.patch.set_visible(False)\\n \\n # Plot the spectra\\n label = 'Serpent' if self.code == 'serpent' else 'MCNP'\\n ax1.loglog(x2, y2, 'r', linewidth=1, label=label)\\n ax1.loglog(x1, y1, 'b', linewidth=1, label='OpenMC', linestyle='--')\\n \\n # Plot the relative error and uncertainties\\n ax2.semilogx(x2, err, color=(0.2, 0.8, 0.0), linewidth=1)\\n ax2.semilogx(x2, 2*sd, color='k', linestyle='--', linewidth=1)\\n ax2.semilogx(x2, -2*sd, color='k', linestyle='--', linewidth=1)\\n \\n # Set grid and tick marks\\n ax1.tick_params(axis='both', which='both', direction='in', length=10)\\n ax1.grid(b=False, axis='both', which='both')\\n ax2.tick_params(axis='y', which='both', right=False)\\n ax2.grid(b=True, which='both', axis='both', alpha=0.5, linestyle='--')\\n \\n # Set axes labels and limits\\n ax1.set_xlim([self._min_energy, self.energy])\\n ax1.set_xlabel('Energy (eV)', size=12)\\n ax1.set_ylabel('Spectrum', size=12)\\n ax1.legend()\\n ax2.set_ylabel(\\\"Relative error\\\", size=12)\\n title = f'{self.nuclide}'\\n if self.thermal is not None:\\n name, suffix = self.thermal.split('.')\\n thermal_name = openmc.data.thermal.get_thermal_name(name)\\n title += f' + {thermal_name}'\\n title += f', {self.energy:.1e} eV Source'\\n plt.title(title)\\n \\n # Save plot\\n os.makedirs('plots', exist_ok=True)\\n if self.name is not None:\\n name = self.name\\n else:\\n name = f'{self.nuclide}'\\n if self.thermal is not None:\\n name += f'-{thermal_name}'\\n name += f'-{self.energy:.1e}eV'\\n if self._temperature is not None:\\n name += f'-{self._temperature:.1f}K'\\n plt.savefig(Path('plots') / f'{name}.png', bbox_inches='tight')\\n plt.close()\",\n \"def plot_source_residuals_comparison(source_truth, source_model_list, name_list, \\n vmin_res=-0.5, vmax_res=-0.5, cmap='cubehelix',\\n fontsize=12):\\n n_model = len(source_model_list)\\n fig, axes = plt.subplots(1+n_model, 2, figsize=(9, (1+n_model)*3.5))\\n axes[0, 1].axis('off')\\n ax = axes[0, 0]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"true source\\\", fontsize=fontsize)\\n im = ax.imshow(source_truth, cmap=cmap, vmin=0)\\n lims = (len(source_truth)/4, 3*len(source_truth)/4) # zoom a bit on the image\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n i = 1\\n for source_model, name in zip(source_model_list, name_list):\\n print(\\\"min/max for source model '{}': {}/{}\\\".format(name, source_model.min(), source_model.max()))\\n\\n residuals_source = source_model - source_truth\\n\\n ax = axes[i, 0]\\n ax.set_title(\\\"model '{}'\\\".format(name), fontsize=fontsize)\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n im = ax.imshow(source_model, cmap=cmap)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n plot_util.nice_colorbar(im, label=\\\"flux\\\", fontsize=fontsize)\\n \\n ax = axes[i, 1]\\n #ax.get_xaxis().set_visible(False)\\n #ax.get_yaxis().set_visible(False)\\n ax.set_title(\\\"difference\\\", fontsize=fontsize)\\n #ax.set_xlim(*lims)\\n #ax.set_ylim(*lims)\\n im = ax.imshow(residuals_source, cmap='RdBu_r', vmin=vmin_res, vmax=vmax_res)\\n plot_util.nice_colorbar_residuals(im, residuals_source, vmin_res, vmax_res,\\n label=r\\\"f${}_{\\\\rm model}$ - f${}_{\\\\rm truth}$\\\", fontsize=fontsize)\\n \\n print(\\\"SDR for model '{}' = {:.3f}\\\".format(name, metrics_util.SDR(source_truth, source_model)))\\n i += 1\\n\\n return fig\",\n \"def calculate_ratio_data(self, z, normalize = True, pos_norm = 2, _SAVING = True):\\n\\n try:\\n z_digits = len((self.z_names[0].replace(self.z_str+'_','')).split('p')[1]) ##counts digits in a key like z_red_0p123456\\n z_request = self.z_str+'_'+'{1:.{0}f}'.format(z_digits, z).replace('.','p')\\n except:\\n z_request = z\\n if z_request not in self.z_names: ## this allows to request numbers not exactly in z_vals if precision is still withing z_digits (usually 6)\\n raise ValueError('Requested redshift'' is not contained in dataframe')\\n\\n\\n\\n ## if ratio mode is not used, the spectra are divided by a reference spectrum\\n if self.ratio_mode == True:\\n reftheo = 1\\n else:\\n reftheo = self.df_ref.loc[(self.data_type, z_request)].values\\n\\n exnoi = self.df_ext.loc[self.data_type, z_request].values / reftheo\\n\\n ## binwise normalization: we shift by the mean and divide by standard devitaion\\n if normalize == True:\\n binwise_mean = exnoi.mean(axis=0)\\n binwise_std = exnoi.std(axis=0)\\n else:\\n binwise_mean = 0\\n binwise_std = 1\\n\\n self.binwise_mean = binwise_mean\\n self.binwise_std = binwise_std\\n \\n ## dictionary with data as keys and array of normalized spectra as values (e.g. {\\\"theo\\\": array([[...],[...],...])})\\n matrix_z = (exnoi - binwise_mean) / binwise_std\\n\\n if _SAVING == True:\\n self.matrix_z = matrix_z\\n self.z_requested = z_request\\n self.multiple_z = False\\n else:\\n return matrix_z\",\n \"def inputToInternal(self, currentInputs):\\n if type(currentInputs) != list:\\n currentInputs = [currentInputs]\\n hasPointSet = False\\n hasHistorySet = False\\n #Check for invalid types\\n for currentInput in currentInputs:\\n inputType = None\\n if hasattr(currentInput, 'type'):\\n inputType = currentInput.type\\n\\n if isinstance(currentInput, Files.File):\\n self.raiseAnError(IOError, \\\"Input type '\\\", inputType, \\\"' can not be accepted\\\")\\n elif isinstance(currentInput, Distributions.Distribution):\\n pass #Allowed type\\n elif inputType == 'HDF5':\\n self.raiseAnError(IOError, \\\"Input type '\\\", inputType, \\\"' can not be accepted\\\")\\n elif inputType == 'PointSet':\\n hasPointSet = True\\n elif inputType == 'HistorySet':\\n hasHistorySet = True\\n if self.multiOutput == 'raw_values':\\n self.dynamic = True\\n if self.pivotParameter not in currentInput.getVars('indexes'):\\n self.raiseAnError(IOError, self, 'Pivot parameter', self.pivotParameter,'has not been found in DataObject', currentInput.name)\\n if not currentInput.checkIndexAlignment(indexesToCheck=self.pivotParameter):\\n self.raiseAnError(IOError, \\\"HistorySet\\\", currentInput.name,\\\" is not syncronized, please use Interfaced PostProcessor HistorySetSync to pre-process it\\\")\\n pivotValues = currentInput.asDataset()[self.pivotParameter].values\\n if len(self.pivotValues) == 0:\\n self.pivotValues = pivotValues\\n elif set(self.pivotValues) != set(pivotValues):\\n self.raiseAnError(IOError, \\\"Pivot values for pivot parameter\\\",self.pivotParameter, \\\"in provided HistorySets are not the same\\\")\\n else:\\n self.raiseAnError(IOError, \\\"Metric cannot process \\\"+inputType+ \\\" of type \\\"+str(type(currentInput)))\\n if self.multiOutput == 'raw_values' and hasPointSet and hasHistorySet:\\n self.multiOutput = 'mean'\\n self.raiseAWarning(\\\"Reset 'multiOutput' to 'mean', since both PointSet and HistorySet are provided as Inputs. Calculation outputs will be aggregated by averaging\\\")\\n\\n measureList = []\\n\\n for cnt in range(len(self.features)):\\n feature = self.features[cnt]\\n target = self.targets[cnt]\\n featureData = self.__getMetricSide(feature, currentInputs)\\n targetData = self.__getMetricSide(target, currentInputs)\\n measureList.append((featureData, targetData))\\n\\n return measureList\",\n \"def plot_alleles(folder):\\n\\n abs_alt,perc_alt = parse_geno_file(folder,False)\\n\\n strain_matcher = re.compile('(.*) \\\\(.*\\\\)') ## regex to get strain name from radio button click\\n strain_matcher2 = re.compile('(.*)-(.*)')\\n \\n fig, ax = plt.subplots()\\n l, = plt.plot(perc_alt['MC'],perc_alt[S],'bs')\\n ax.set_ylabel('Alternate Allele Percentage (MC)')\\n ax.set_xlabel('Alternate Allele Percentage (MC)')\\n \\n rax1 = plt.axes([0.92, 0.1, 0.08, 0.8])\\n radio1 = RadioButtons(rax1, ('MC (Sand)','CL (Sand)','CM (Sand)','CN (Sand)','TI (Sand)','DC (Sand)','MS (Sand)','CV (Sand)','PN (Rock)','AC (Rock)','LF (Rock)','MP (Rock)','MZ (Rock)','Sand-MC','Rock-MC','Sand-MZ','Rock-MZ','Rock-Sand'), active=0)\\n\\n rax2 = plt.axes([0.92, 0.9, 0.08, 0.1])\\n radio2 = RadioButtons(rax2, ('%', 'Abs'), active=0)\\n\\n #for strain in perc_alt.keys():\\n #print strain\\n \\n #ylabel = plt.axes([1,1,0.08,0.08])\\n\\n def update1(strain):\\n if strain not in [\\\"Rock-MZ\\\",\\\"Sand-MC\\\",\\\"Rock-MC\\\",\\\"Sand-MZ\\\",\\\"Rock-Sand\\\"]:\\n match = re.match(strain_matcher,strain)\\n strain = match.group(1)\\n global base\\n base = 'MC'\\n else:\\n match = re.match(strain_matcher2,strain)\\n strain = match.group(1)\\n #global base \\n base = match.group(2)\\n\\n #print D\\n if(D == \\\"%\\\"):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[strain])\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n else:\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[strain])\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(strain))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n\\n ax.relim()\\n ax.autoscale()\\n fig.canvas.draw_idle()\\n global S \\n #print S\\n S = strain\\n\\n\\n def update2(data):\\n if(data == '%'):\\n l.set_xdata(perc_alt[base])\\n l.set_ydata(perc_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Percentage (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Percentage (%s)'%(base))\\n fig.canvas.draw_idle()\\n if(data == 'Abs'):\\n l.set_xdata(abs_alt[base])\\n l.set_ydata(abs_alt[S])\\n ax.relim()\\n ax.autoscale()\\n ax.set_ylabel('Alternate Allele Absolute (%s)'%(S))\\n ax.set_xlabel('Alternate Allele Absolute (%s)'%(base))\\n fig.canvas.draw_idle()\\n \\n global D\\n D = data\\n\\n radio1.on_clicked(update1)\\n radio2.on_clicked(update2)\\n plt.show()\",\n \"def main():\\n # Load properties that will be needed\\n store = [Storage.Storage(2), Storage.Storage(4)] \\n pre_energy = [s.get(\\\"free_energy\\\") for s in store]\\n post_energy = [s.get(\\\"post_energy\\\") for s in store]\\n x_range = store[0].get(\\\"x_range\\\")\\n xlocs = np.arange(x_range[0], x_range[1], x_range[2])\\n y_range = store[0].get(\\\"y_range\\\")\\n ylocs = np.arange(y_range[0], y_range[1], y_range[2])\\n # Calculate step size\\n xb2steps = stepsize(pre_energy[0], post_energy[0], xlocs) \\n xb4steps = stepsize(pre_energy[1], post_energy[1], xlocs) \\n # Set up the figure\\n fig = plt.figure(1, figsize=(7.5,2.5)) \\n axe = (fig.add_subplot(1, 2, 1), fig.add_subplot(1, 2, 2))\\n # Plot the results\\n axe[0].plot(ylocs, xb4steps, color='#FF466F', lw=4)\\n axe[1].plot(ylocs, xb2steps, color='#76D753', lw=4)\\n # Annotate the plots\\n axe[0].set_title(\\\"4sXB step size\\\")\\n axe[0].set_xlabel(\\\"Lattice spacing (nm)\\\") \\n axe[0].set_ylabel(\\\"Step size (nm)\\\")\\n axe[0].set_xlim((25.5, 39))\\n axe[0].set_ylim((1, 8))\\n axe[1].set_title(\\\"2sXB step size\\\")\\n axe[1].set_xlabel(\\\"Lattice spacing (nm)\\\") \\n axe[1].set_ylabel(\\\"Step size (nm)\\\")\\n axe[1].set_xlim((25.5, 39))\\n axe[1].set_ylim((1, 8))\\n # Display the plots\\n fig.subplots_adjust(wspace=0.25, hspace=0.48,\\n left=0.08, right=0.98,\\n top=0.85, bottom=0.21)\\n plt.show()\",\n \"def plot_directory_profiles(path, outname=None, show=True, xscale=1, yscale=1,\\n xval='x', adjustRadial=True):\\n outdirs = np.sort(os.listdir(path))\\n plt.figure()\\n\\n #labels=['homogeneous','1D layering', '3D tomography'] #xscale=1e-3, yscale=1e2\\n for i,outdir in enumerate(outdirs):\\n pointsFile = os.path.join(path, outdir, 'points.h5')\\n #print(pointsFile)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile, output='cyl',adjustRadial=adjustRadial)\\n #x_fem, ur_fem, uz_fem = pu.extract_points(pointsFile)\\n #Load data\\n\\n x,y,z,ux,uy,uz = pu.extract_points(pointsFile)\\n #Y = uz / yscale\\n if xval == 'x':\\n X = x / xscale\\n Y1 = ux / yscale\\n elif xval == 'r':\\n X = np.hypot(x,y) / xscale\\n ur_fem = np.hypot(ux,uy)\\n Y1 = ur_fem / yscale\\n if adjustRadial: #fix sign from hypot square root\\n ur_fem = pu.radial2negative(Y1)\\n\\n x_fem = X #/ xscale #double scaling!\\n ur_fem = Y1 #/ yscale\\n uz_fem = uz / yscale\\n\\n #print(pointsFile)\\n print(ur_fem.min(), ur_fem.max(), uz_fem.min(), uz_fem.max())\\n\\n l, = plt.plot(x_fem,uz_fem,'.-',lw=3,label=outdir)\\n #l, = plt.plot(x_fem,uz_fem,'.-',lw=2,label=labels[i]) #for 3d heterogeneity example\\n plt.plot(x_fem,ur_fem,'.--',lw=3, mfc='w',color=l.get_color()) #mfc='none' transparent\\n\\n # Annotate\\n plt.axhline(color='k',lw=0.5)\\n plt.xlabel('Distance [{}]'.format(get_unit(xscale)))\\n plt.ylabel('Displacement [{}]'.format(get_unit(yscale)))\\n plt.legend()\\n\\n #NOTE: custom annotations for 3d heterogeneity\\n #plt.title('Elastic Heterogeneity Effects')\\n #plt.legend([l1,l2,l3],['homogeneous','1D layering', '3D tomography'])\\n\\n if outname: plt.savefig(outname)\\n if show: plt.show()\",\n \"def checkmaxmin(droi):\\n \\n # Loads data.\\n fd = load_frames('gofparams')\\n rawdata = loadresultsfile('results1.txt', 'Mean1')\\n \\n pardir = cmn.makepardir_data()\\n movie = os.path.basename(os.path.abspath('.'))\\n \\n d = {}\\n rois = droi.keys()\\n \\n # Finds the max and min points using the parameters specified in the list droi.\\n for roi in rois:\\n\\n maxsurr, maxwinlen, maxtrshift, minsurr, minwinlen, mintrshift = droi[roi]\\n \\n dmax, dmin = peaklib.maxminanalysis(rawdata, maxsurr, maxwinlen, maxtrshift, minsurr,\\n minwinlen, mintrshift)\\n \\n d[roi+'_dmax'] = dmax\\n d[roi+'_dmin'] = dmin\\n\\n # Plots the raw traces with the max and min points indicated.\\n for roi in rois:\\n plt.figure(figsize=(14,10))\\n peaklib.plotminmax(d[roi+'_dmax'], d[roi+'_dmin'], 'b', 1, 0)\\n \\n figname = movie+'_'+roi\\n plt.title('{0} \\\\n {1} \\\\n frames = {2}-{3} ({4} total)'.format(figname, fd['condition'], \\n fd['f1'], fd['f_end'], fd['f_end']-fd['f1']))\\n \\n figpath = peaklib.makefilepath(pardir, ANALYSISFOLDPNG, figname)\\n plt.savefig(figpath)\\n plt.close()\\n \\n # Writes the min/max data into a file with the function writei.\\n \\n ifilefold = ANALYSISFOLDTXT + '/' + movie + '/'\\n ipath = peaklib.makesubdir(pardir, ifilefold)\\n peaklib.writei(d, fd, ipath)\",\n \"def sample_pin_position_range():\\n #Create a sample goniometer\\n g = TopazInHouseGoniometer()\\n\\n #Initialize the leg limits\\n g.relative_sample_position = column([0.0, 0.0, 0.0])\\n g.getplatepos(0.0, 0.0, 0.0)\\n g.calculate_leg_xy_limits(visualize=True)\\n\\n# if True:\\n# pylab.show()\\n# return\\n\\n n = 17\\n positions = np.linspace(-8, 8, n) #Range calculated in mm\\n allowed = np.zeros( (n,n,n) )\\n for (ix, x) in enumerate(positions):\\n print \\\"Calculating x\\\", x\\n for (iy, y) in enumerate(positions):\\n for (iz, z) in enumerate(positions):\\n #Set up\\n g.relative_sample_position = column([x, y, z])\\n allowed[ix,iy,iz] = g.are_angles_allowed([0., 0., 0.], return_reason=False)\\n\\n #Do a plot\\n\\n pylab.figure(1, figsize=[15,15])\\n pylab.title(\\\"Allowable XZ sample positions\\\")\\n for (iy, y) in enumerate(positions):\\n print \\\"At y of\\\", y, \\\", # of points = \\\", np.sum( allowed[:, iy,:])\\n if iy < 16:\\n pylab.subplot(4,4,iy+1)\\n pylab.pcolor(positions, positions, allowed[:, iy, :].transpose(), norm=pylab.Normalize(0, 1))\\n pylab.xlabel(\\\"x\\\")\\n pylab.ylabel(\\\"z\\\")\\n pylab.title(\\\"y = %.3f mm\\\" % y)\\n pylab.draw()\\n pylab.axis('equal')\\n pylab.show()\\n #pylab.\",\n \"def do_plot_abs(the_input):\\n pressurefield = None\\n\\n if the_input is None:\\n raise Exception(\\\"You must supply a pressurefield or world:cueBeamCore2.CueBeamWorld\\\")\\n\\n if (type(the_input) is CueBeamWorld):\\n world = the_input\\n pressurefield = world.rxPlane.pressurefield\\n\\n if (type(the_input) is numpy.ndarray):\\n world = CueBeamWorld() # create new, default world\\n pressurefield = the_input\\n\\n if pressurefield is None:\\n raise Exception(\\\"Something wrong: pressurefield is still None\\\")\\n\\n hfig = plt.figure(num=1, figsize=(8, 6), dpi=90, facecolor='white', edgecolor='black')\\n\\n imgplot = plt.imshow(\\n X=numpy.real(pressurefield),\\n extent=(\\n world.rxPlane.z0, world.rxPlane.z0 + world.rxPlane.nz * world.rxPlane.dz,\\n world.rxPlane.y0, world.rxPlane.y0 + world.rxPlane.ny * world.rxPlane.dy\\n ),\\n # interpolation=\\\"spline36\\\",\\n interpolation=\\\"nearest\\\",\\n clim=(0, 8.0),\\n origin=\\\"lower\\\")\\n # end imshow\\n plt.set_cmap(\\\"plasma\\\") # black-to-yellow color map\\n plt.xlabel(\\\"z-axis[m]\\\")\\n plt.ylabel(\\\"y-axis[m]\\\")\\n plt.show()\",\n \"def plot_lognormal_relative_likelihoods(tmin, tmax, min_shape, max_shape, step_shape,\\n min_scale, max_scale, step_scale, label_as_confidence=False,\\n ax=None):\\n dist_fun = lognorm\\n ax = _plot_shape_scale_confidence_regions(tmin, tmax, min_shape, max_shape, step_shape,\\n min_scale, max_scale, step_scale, dist_fun,\\n label_as_confidence, ax=ax)\\n plt.xlabel(r'$m$')\\n plt.ylabel(r'$\\\\sigma$')\\n\\n return ax\",\n \"def fraction():\\n global correct_fraction\\n S1,S2,S3 = {\\\"molar_mass\\\":1.008, \\\"name\\\":\\\"A\\\"},{\\\"molar_mass\\\":16.00, \\\"name\\\":\\\"B\\\"},{\\\"molar_mass\\\":44.01, \\\"name\\\":\\\"C\\\"}\\n M1,M2,M3 = randint(1,50),randint(1,20),randint(1,20) # Really really shitty but I'm lazy rn\\n total_mass = S1[\\\"molar_mass\\\"]*M1 + S2[\\\"molar_mass\\\"]*M2 + S3[\\\"molar_mass\\\"]*M3\\n\\n print(\\\"\\\\n\\\\nThis is a mass and molar fractions question.\\\\n\\\")\\n print(\\\"\\\\nFor a substance made out of '{}' with a molar mass of '{}'\\\".format(S1[\\\"name\\\"], S1[\\\"molar_mass\\\"]))\\n print(\\\"'{}' with a molar mass of '{}'\\\".format(S2[\\\"name\\\"], S2[\\\"molar_mass\\\"]))\\n print(\\\"and '{}' with a molar mass of '{}'\\\".format(S3[\\\"name\\\"], S3[\\\"molar_mass\\\"]))\\n\\n # Chance at being molar or mass fraction\\n if choice([True, False]):\\n print(\\\"If there are {} moles of {} what is the mass fraction of a substance weighing {:0.2f}g ?\\\\n\\\".format(M1, S1[\\\"name\\\"],total_mass))\\n guess = get_user_input(float)\\n answer = (M1*S1[\\\"molar_mass\\\"])/(total_mass)*100\\n else:\\n print(\\\"If the mass of {} is {} and {} is {} what is the molar fraction of {} \\\\nin a substance weighing {:0.2f}g ?\\\\n\\\".format(S1[\\\"name\\\"], M1*S1[\\\"molar_mass\\\"], S2[\\\"name\\\"], M2*S2[\\\"molar_mass\\\"], S3[\\\"name\\\"], total_mass))\\n guess = get_user_input(float)\\n answer = M1/(M1+M2+M3)*100\\n\\n if check_answer(guess,answer,0.3):\\n print(\\\"correct\\\")\\n correct_fraction += 1\\n else:\\n print(\\\"false the answer is {:0.2f}\\\".format(answer))\",\n \"def awGrid(vis,HA,uvw,image_params,obs_params,Mterms,Mterms_ij):\\t\\n\\tStokes = image_params['Stokes']\\n\\t\\n\\n\\n\\tprint '--------------Gridding X pol--------------------'\\n\\txgrid_wt, xgrid_uv = gridOnePolAWproj(vis[0],HA,uvw,image_params,obs_params,Mterms[0],Mterms_ij[0])\\n\\tprint '--------------Gridding Y pol--------------------'\\n\\tygrid_wt, ygrid_uv = gridOnePolAWproj(vis[1],HA,uvw,image_params,obs_params,Mterms[1],Mterms_ij[1])\\n\\n\\tN = np.shape(xgrid_wt)[0]\\n\\tgrid_uv = np.zeros([N, N], dtype=complex)\\n\\tgrid_wt = np.zeros([N, N], dtype=complex)\\n\\t\\n\\tif Stokes == 'I':\\n\\t\\t#combine X and Y gridded vis to create the I pol gridded vis\\n\\t\\t# I = (XX+YY)/2\\n\\t\\tgrid_uv.real = (ygrid_uv.real + xgrid_uv.real)/2\\n\\t\\tgrid_uv.imag = (ygrid_uv.imag + xgrid_uv.imag)/2\\n\\n\\t\\t#combine X and Y gridded wt to create the I pol gridded wt\\n\\t\\tgrid_wt.real = (ygrid_wt.real + xgrid_wt.real)/2\\n\\t\\tgrid_wt.imag = (ygrid_wt.imag + xgrid_wt.imag)/2\\n\\n\\telif Stokes == 'Q':\\n\\t\\t#combine X and Y gridded vis to create the I pol gridded vis\\n\\t\\t# Q = (XX-YY)/2\\n\\t\\tgrid_uv.real = (ygrid_uv.real - xgrid_uv.real)/2\\n\\t\\tgrid_uv.imag = (ygrid_uv.imag - xgrid_uv.imag)/2\\n\\n\\t\\t#combine X and Y gridded wt to create the I pol gridded wt\\n\\t\\tgrid_wt.real = (ygrid_wt.real - xgrid_wt.real)/2\\n\\t\\tgrid_wt.imag = (ygrid_wt.imag - xgrid_wt.imag)/2\\n\\n\\n\\tdty_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_uv)))\\n\\tpsf_image=np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(grid_wt)))\\n\\n\\treturn dty_image, psf_image\",\n \"def perSaccPerGroup(addExp2 = True, trim = True, spacing = .5, addSimulation = True, \\\\\\n\\t\\texclOverlap = True):\\n\\n\\tfig = plt.figure(figsize = (10,10))\\n\\ttitle = \\\"Average towards-handle landings per group - exclOverlap = %s\\\" % exclOverlap\\n\\tplt.title(title)\\n\\t\\n\\t\\n\\t# Exp 1:\\n\\tdm1 = getDM.getDM(exp = \\\"004A\\\", excludeErrors = True, driftCorr = True)\\n\\t\\n\\t\\n\\tsubPlot = 1\\n\\t\\n\\tfor group in dm1.unique(\\\"corrDirection\\\"):\\n\\n\\t\\t# New subplot:\\n\\t\\tplt.subplot(1,2,subPlot)\\n\\t\\tplt.title(group)\\n\\t\\t_dm1 = dm1.select(\\\"corrDirection == '%s'\\\" % group)\\n\\n\\t\\tlLandingsAbs = []\\n\\t\\tlLandingsCorr = []\\n\\t\\t\\n\\t\\tfor sacc in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\n\\t\\t\\t\\n\\t\\t\\t# This is the same for corrected landing positions (the saccade\\n\\t\\t\\t# doesn't change; only the reference point does)\\n\\t\\t\\t_dm = _dm1.select(\\\"endX%sNorm != ''\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endX%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t_dm = _dm.select(\\\"endX%sNorm < .5\\\" % sacc)\\n\\t\\t\\t\\n\\t\\t\\tif trim:\\n\\t\\t\\t\\t_dmAbs = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sNormToHandle\\\" % sacc)\\n\\t\\t\\t\\t_dmCorr = _dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sCorrNormToHandle\\\" % sacc)\\n\\t\\t\\t\\n\\t\\t\\t# Determine avg landing position:\\n\\t\\t\\tavgAbs = _dmAbs[\\\"endX%sNormToHandle\\\" % sacc].mean()\\n\\t\\t\\tavgCorr = _dmCorr[\\\"endX%sCorrNormToHandle\\\" % sacc].mean()\\n\\t\\t\\t\\n\\t\\t\\t# TODO: determine error bars:\\n\\t\\t\\t\\n\\t\\t\\t\\n\\t\\t\\tlLandingsAbs.append(avgAbs)\\n\\t\\t\\tlLandingsCorr.append(avgCorr)\\n\\t\\t\\n\\t\\tplt.plot(lLandingsAbs, color = \\\"#f57900\\\", linewidth = 2, marker = \\\"o\\\")\\n\\t\\tplt.plot(lLandingsCorr, color = \\\"#73d216\\\", linewidth = 2, marker = \\\"o\\\")\\n\\t\\t\\n\\t\\t# The other 2 experiments can be treated equally:\\n\\t\\tcolList = [\\\"#ef2929\\\", \\\"#3465a4\\\"]\\n\\t\\t\\n\\t\\tfor exp in [\\\"004B\\\", \\\"004C\\\"]:\\n\\t\\t\\t\\n\\t\\t\\tif not addExp2:\\n\\t\\t\\t\\tif exp == \\\"004B\\\":\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\tif not addSimulation:\\n\\t\\t\\t\\tif exp == \\\"004C\\\":\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\tdm = getDM.getDM(exp = exp, excludeErrors = True, driftCorr = True)\\n\\t\\t\\t_dm = dm.select(\\\"corrDirection == '%s'\\\" % group)\\n\\n\\t\\t\\tif exp == \\\"004C\\\":\\n\\t\\t\\t\\tif exclOverlap:\\n\\t\\t\\t\\t\\t_dm = _dm.select(\\\"gap == 'zero'\\\")\\n\\n\\t\\t\\t\\n\\t\\t\\tlLandingsAbs = []\\n\\t\\t\\t\\n\\t\\t\\tfor sacc in [\\\"1\\\", \\\"2\\\", \\\"3\\\"]:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# TODO: how to filter only on-object saccades exp 2??\\n\\t\\t\\t\\tsacc_dm = _dm.select(\\\"endX%sNorm != ''\\\" % sacc)\\n\\t\\t\\t\\tsacc_dm = sacc_dm.select(\\\"endX%sNorm > -.5\\\" % sacc)\\n\\t\\t\\t\\tsacc_dm = sacc_dm.select(\\\"endX%sNorm < .5\\\" % sacc)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tif trim:\\n\\t\\t\\t\\t\\tsacc_dm = sacc_dm.selectByStdDev(keys = [\\\"file\\\"], dv = \\\"endX%sNormToHandle\\\" % sacc)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Determine avg landing position:\\n\\t\\t\\t\\tavgAbs = sacc_dm[\\\"endX%sNormToHandle\\\" % sacc].mean()\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# TODO: determine error bars:\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tlLandingsAbs.append(avgAbs)\\n\\t\\t\\tcol = colList.pop()\\n\\t\\t\\tplt.plot(lLandingsAbs, color = col, linewidth = 2, marker = \\\"o\\\")\\n\\t\\t\\t\\n\\t\\t# Modify plot:\\n\\t\\tplt.legend([\\\"Exp1 abs\\\", \\\"Exp1 corr\\\", \\\"Exp2\\\", \\\"Sim\\\"])\\n\\t\\t\\t\\n\\t\\tplt.axhline(0, color = \\\"#888a85\\\", linestyle = \\\"--\\\", linewidth = 2)\\n\\t\\txLabels = [\\\"sacc 1\\\", \\\"sacc 2\\\", \\\"sacc 3\\\"]\\n\\t\\txTicks = range(0,3)\\n\\t\\tplt.xticks(xTicks, xLabels, rotation = .5)\\n\\t\\tplt.ylim([-.5, .5])\\n\\t\\tplt.xlim(min(xTicks)-spacing, max(xTicks)+spacing)\\n\\t\\t\\n\\t\\tsubPlot +=1\\n\\t\\t\\n\\tplt.savefig(\\\"%s.png\\\" % title)\",\n \"def _adjust_data_range_using_min_ratio(c_min, c_max, c_axis_range, *, min_ratio=0.01):\\n c_range = c_max - c_min\\n if c_range < c_axis_range * min_ratio:\\n c_center = (c_max + c_min) / 2\\n c_new_range = c_axis_range * min_ratio\\n c_min = c_center - c_new_range / 2\\n c_max = c_center + c_new_range / 2\\n return c_min, c_max\",\n \"def normalizeMinRes(resolution, lbcs, modeNames):\\n\\n nModes = len(modeNames)\\n\\n volPtsIn = getVolumePoints(32, 64, \\\"in\\\")\\n volPtsOut = getVolumePoints(32, 64, \\\"out\\\")\\n print \\\"Total number of volume points for minimizing L2 error: \\\", len(volPtsIn) + len(volPtsOut)\\n\\n # get mx fields from simulation\\n # calculate analytic fields at points if data does not already exist in simulation directory\\n mxVolFieldsIn = []\\n mxVolFieldsOut = []\\n anVolFieldsIn = []\\n anVolFieldsOut = []\\n for mode in modeNames:\\n print \\\" Mode \\\" + mode + \\\":\\\"\\n print \\\" calculating simulation volume field values...\\\"\\n mxVolFieldsIn.append(mxFieldValuesAtPoints(resolution, lbcs, 'E', mode, volPtsIn, \\\"volume_in\\\").ravel())\\n mxVolFieldsOut.append(mxFieldValuesAtPoints(resolution, lbcs, 'E', mode, volPtsOut, \\\"volume_out\\\").ravel())\\n print \\\" calculating analytic volume field values...\\\"\\n anVolFieldsIn.append(analyticFieldValuesAtPoints(\\\"./analytic/\\\", mode, volPtsIn, \\\"volume_in\\\").ravel())\\n anVolFieldsOut.append(analyticFieldValuesAtPoints(\\\"./analytic/\\\", mode, volPtsOut, \\\"volume_out\\\").ravel())\\n mxVolFieldsIn = numpy.asarray(mxVolFieldsIn)\\n mxVolFieldsOut = numpy.asarray(mxVolFieldsOut)\\n anVolFieldsIn = numpy.asarray(anVolFieldsIn)\\n anVolFieldsOut = numpy.asarray(anVolFieldsOut)\\n\\n # dot product matrix of degenerate mx fields\\n dotProds = eps * numpy.dot(mxVolFieldsIn, mxVolFieldsIn.T)\\n dotProds += numpy.dot(mxVolFieldsOut, mxVolFieldsOut.T)\\n invDotProds = numpy.linalg.inv(dotProds)\\n\\n rhs = eps * numpy.dot(mxVolFieldsIn, anVolFieldsIn.T)\\n rhs += numpy.dot(mxVolFieldsOut, anVolFieldsOut.T)\\n return numpy.dot(invDotProds, rhs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5534918","0.515236","0.51322854","0.49179512","0.48812607","0.48483542","0.4839429","0.47949347","0.47881106","0.47665024","0.47452495","0.4722007","0.47154492","0.46393847","0.462126","0.46191898","0.460472","0.46012208","0.4596538","0.4591982","0.45806232","0.45663953","0.45578176","0.45439526","0.45347401","0.45295703","0.4526022","0.452533","0.45225394","0.45221642","0.4521058","0.4508857","0.45044515","0.44919547","0.44892722","0.44887167","0.44811618","0.4472393","0.44560164","0.44542512","0.4435457","0.44342643","0.44317713","0.44231525","0.44204026","0.44170457","0.4388443","0.43803102","0.4355809","0.4352363","0.43494985","0.4346918","0.43464428","0.43431005","0.43416598","0.43416527","0.43382895","0.43342796","0.4334209","0.433322","0.4332268","0.43228212","0.43225646","0.4312251","0.43111548","0.43108094","0.4309943","0.43078002","0.43050015","0.42988434","0.42939174","0.42930835","0.4285235","0.428451","0.4283439","0.42816886","0.4272437","0.42720583","0.42646015","0.42628866","0.42608052","0.4259286","0.42569464","0.42540354","0.424603","0.4244177","0.42411304","0.42408475","0.4238172","0.42354456","0.42350322","0.42332226","0.42323202","0.42306408","0.42257807","0.4222535","0.4219349","0.42160037","0.42119837","0.4211309"],"string":"[\n \"0.5534918\",\n \"0.515236\",\n \"0.51322854\",\n \"0.49179512\",\n \"0.48812607\",\n \"0.48483542\",\n \"0.4839429\",\n \"0.47949347\",\n \"0.47881106\",\n \"0.47665024\",\n \"0.47452495\",\n \"0.4722007\",\n \"0.47154492\",\n \"0.46393847\",\n \"0.462126\",\n \"0.46191898\",\n \"0.460472\",\n \"0.46012208\",\n \"0.4596538\",\n \"0.4591982\",\n \"0.45806232\",\n \"0.45663953\",\n \"0.45578176\",\n \"0.45439526\",\n \"0.45347401\",\n \"0.45295703\",\n \"0.4526022\",\n \"0.452533\",\n \"0.45225394\",\n \"0.45221642\",\n \"0.4521058\",\n \"0.4508857\",\n \"0.45044515\",\n \"0.44919547\",\n \"0.44892722\",\n \"0.44887167\",\n \"0.44811618\",\n \"0.4472393\",\n \"0.44560164\",\n \"0.44542512\",\n \"0.4435457\",\n \"0.44342643\",\n \"0.44317713\",\n \"0.44231525\",\n \"0.44204026\",\n \"0.44170457\",\n \"0.4388443\",\n \"0.43803102\",\n \"0.4355809\",\n \"0.4352363\",\n \"0.43494985\",\n \"0.4346918\",\n \"0.43464428\",\n \"0.43431005\",\n \"0.43416598\",\n \"0.43416527\",\n \"0.43382895\",\n \"0.43342796\",\n \"0.4334209\",\n \"0.433322\",\n \"0.4332268\",\n \"0.43228212\",\n \"0.43225646\",\n \"0.4312251\",\n \"0.43111548\",\n \"0.43108094\",\n \"0.4309943\",\n \"0.43078002\",\n \"0.43050015\",\n \"0.42988434\",\n \"0.42939174\",\n \"0.42930835\",\n \"0.4285235\",\n \"0.428451\",\n \"0.4283439\",\n \"0.42816886\",\n \"0.4272437\",\n \"0.42720583\",\n \"0.42646015\",\n \"0.42628866\",\n \"0.42608052\",\n \"0.4259286\",\n \"0.42569464\",\n \"0.42540354\",\n \"0.424603\",\n \"0.4244177\",\n \"0.42411304\",\n \"0.42408475\",\n \"0.4238172\",\n \"0.42354456\",\n \"0.42350322\",\n \"0.42332226\",\n \"0.42323202\",\n \"0.42306408\",\n \"0.42257807\",\n \"0.4222535\",\n \"0.4219349\",\n \"0.42160037\",\n \"0.42119837\",\n \"0.4211309\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.60177034"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88372,"cells":{"query":{"kind":"string","value":"Generates a string of chuncks from an initial chunk."},"document":{"kind":"string","value":"def chunk_seq(f, text, order=3, length=50):\n next_chunk = text[-1]\n chunklist = next_chunk.split()\n\n while len(text) * order < length:\n candidates = gather_next_chunks(f, chunklist, order) #1\n candidates_edited = edit_chunks(candidates)\n #print candidates_edited\n next_chunk = pick_next_chunk(candidates_edited, next_chunk)\n text.append(next_chunk)\n\n markov = ' '.join(text)\n return markov"},"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 chunkify(msg):\n return [\"%s %s\" % (i, msg[i*158 : (i+1)*158]) for i in range(len(msg)/158 + 1)]","def getChunks():","def full_chromosomes(reader):\n for line in reader.header.get_lines(\"contig\"):\n if line.id in CHROMS:\n name = line.id\n length = line.length or 1_000_000_000\n yield \"{}:{}-{}\".format(name, 1, length)","def chunk_base_name(path_name, out_dir, chunk_i = None, tag= \"\"):\n bn = os.path.join(out_dir, \"{}-chunk\".format(path_name))\n if chunk_i is not None:\n bn += \"-{}\".format(chunk_i)\n return \"{}{}\".format(bn, tag)","def generateSubSequences(k, ch):\n seq = [\"\".join(c) for c in itertools.product(ch, repeat = k)]\n# discussion about the best way to do this:\n# https://stackoverflow.com/questions/7074051/what-is-the-best-way-to-generate-all-possible-three-letter-strings\n return seq","def _make_data(self, approximate_length):\n fragments = []\n so_far = 0\n while so_far < approximate_length:\n fragment = ('%d:' % so_far).encode('utf-8')\n so_far += len(fragment)\n fragments.append(fragment)\n return six.b('').join(fragments)","def test_gen_raw_ch():\n raw = _generate_raw(duration=1, n_chan=1)\n\n assert_sequence_equal(raw.ch_names, ['0', 'STI 014'])\n\n raw = _generate_raw(duration=1, n_chan=1, ch_names=['bob'])\n\n assert_sequence_equal(raw.ch_names, ['bob', 'STI 014'])\n\n raw = _generate_raw(duration=1, n_chan=1, ch_names='standard_1020')\n montage = make_standard_montage('standard_1020')\n raw = raw.pick_types(eeg=True)\n assert_true(np.all([ch in montage.ch_names for ch in raw.ch_names]))","def create_string(start_index):\n return [NOTES_SHARP[(x + start_index) % 12] for x in range(0, 12)]","def get_chunks(sequence, ck_size):\n \n list_chunk = []\n i=1\n l = len(sequence)\n if l < 4*ck_size:\n raise ValueError(\"Chunk size should be of 4 at least \")\n for i in range(1, l):\n if i*ck_size < l:\n list_chunk.append(sequence[i*ck_size-ck_size:i*ck_size])\n #while(i*ck_size < l):\n #list_chunk.append(sequence[i*ck_size-ck_size:i*ck_size])\n #i += 1\n return list_chunk","def _write_start():\n from ._common import header\n\n out = \"{:5}{}\\n\".format(\"----*\", header)\n return [out[:11] + \"MOP: 123456789*123456789*1234\" + out[40:]]","def chunked(sentence):\n # For example, to construct a training vector with the head of previous chunks as a feature.\n # Doing this with Sentence.chunks would discard the punctuation marks and conjunctions\n # (Sentence.chunks only yields Chunk objects), which amy be useful features.\n chunks = []\n for word in sentence:\n if word.chunk is not None:\n if len(chunks) == 0 or chunks[-1] != word.chunk:\n chunks.append(word.chunk)\n else:\n ch = Chink(sentence)\n ch.append(word.copy(ch))\n chunks.append(ch)\n return chunks","def get_cards_as_string(self):\n return '' \\\n ' {}\\n' \\\n ' {}\\n' \\\n ' {}\\n' \\\n ' {}\\n' \\\n ' {}\\n'.format(*self.get_cards_high_to_low())","def say_chunk(num):\n output_string_list = []\n num_string = str(num)\n\n units = ['zero', 'one', 'two', 'three', 'four', 'five',\n 'six', 'seven', 'eight', 'nine']\n teens = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',\n 'sixteen', 'seventeen', 'eighteen', 'nineteen']\n tens = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']\n\n # singles\n if num < 10:\n output_string_list.append(units[num])\n\n # teens\n elif 10 <= num <= 19:\n output_string_list.append(teens[int(num) % 10])\n\n # tens\n elif 20 <= num <= 99:\n num_str = str(num)\n modifier = int(num_str[0])\n if int(num_str[1]):\n output_string_list.append(\"{}-{}\".format(tens[modifier - 2], units[int(num) % 10]))\n else:\n output_string_list.append(tens[modifier - 2])\n\n # hundreds\n elif 100 <= num <= 999:\n output_string_list.append(units[int(num_string[0])])\n output_string_list.append('hundred')\n\n num = int(num_string[1:])\n if num:\n output_string_list.append('and')\n num_string = str(num)\n modifier = int(num_string[0])\n\n if int(num_string[1]):\n output_string_list.append(\"{}-{}\".format(tens[modifier - 2], units[int(num_string[1:]) % 10]))\n else:\n output_string_list.append(tens[modifier - 2])\n\n return ' '.join(output_string_list)","def get_full_composition(chrom, kmer_len, species):\n seq = refseq(species, chrom, 1, -1)\n return Counter(kmers_generator(seq, kmer_len))","def generate_sent(self):\n # WORK HERE!!\n n = self._n\n # Add (n-1) opening tags to start the generation\n sent = [\"<s>\"] * (n - 1)\n\n while \"</s>\" not in sent:\n\n sent += [self.generate_token(tuple(sent[-n + 1:]))]\n\n # Delete (n-1) opening tags and closing tag previously added\n return sent[n-1:-1]","def generate_strings(char_list, length):\n if length <= 0:\n yield []\n elif length == 1:\n for char in char_list:\n yield [char]\n else:\n for char in char_list:\n for l in generate_strings(char_list, length-1):\n yield [char] + l","def gen_chars(length, character):\n return ''.join([character for i in range(length)])","def chunks(cipher, size):\n\treturn [cipher[i*size:(i+1)*size] for i in range(int(math.ceil(len(cipher)*1.0/size)))]","def output(self):\n return \" \".join(self.pieces)","def piece_factory(total_length, piece_length, hashes):\n num_pieces = (total_length // piece_length) + 1\n for i in range(num_pieces - 1):\n yield Piece(i, piece_length, hashes[i])\n yield Piece(num_pieces - 1, total_length % piece_length, hashes[num_pieces - 1])","def as_string(self) -> str:\n return self._chunk_str","def chunks_of_five(self, text):\r\n\r\n # Gets a random index in the length of the string and adds a random\r\n # garbage character at that index\r\n while len(text) % 5 != 0:\r\n rand_index = random.randint(0, len(text)-1)\r\n garb_char = random.choice(self.GARBAGE)\r\n text = text[:rand_index] + garb_char + text[rand_index:]\r\n\r\n # Generate list of indeces where the 5 chars should start\r\n # then get all 5 chars and join with a space\r\n text = ' '.join([text[i:i+5] for i in range(0, len(text), 5)])\r\n return text","def send_chunk(chnk, sock):\n length = len(chnk)\n data = str(length).zfill(MAX_CHUNK_SIZE).encode() + chnk\n sock.send(data)","def create(cls, raw_data, chunk_dir, prefix='chunk'):\n other_names = [f for f in os.listdir(chunk_dir) if \\\n f.startswith(prefix)]\n other_names.sort()\n last_digit = 0\n if other_names:\n last_digit = int(other_names[-1].split('_')[-1])\n filename = '%s_%s' % (prefix, str(last_digit + 1).zfill(9))\n logger.debug('creating chunk %s' % filename)\n file_path = os.path.join(chunk_dir, filename)\n f = open(file_path, 'wb')\n f.write(raw_data)\n f.close()\n append_checksum(file_path)\n return ClientChunk(file_path)","def _chunkify(sequence, num_chunks):\n quo, rem = divmod(len(sequence), num_chunks)\n return (sequence[i * quo + min(i, rem):(i + 1) * quo + min(i + 1, rem)] for i in range(num_chunks))","def makeChrom(length):\n output = []\n for i in range(length):\n output.append(randrange(14))\n return output","def create_random_string(total_character):\n feed=string.printable\n words=\"\"\n i=0\n while i < total_character:\n words += feed[random.randrange(0,len(feed)-1)]\n i+=1\n return words","def repeatstring(stingy, no):\n packup = ''\n for i in range(no):\n packup += stingy\n return packup","def channel_string(self, pre=\"\", full=False):\n\n return \" \".join(pre+c.get_chanstr(full=full) for c in self.channels)","def __str__(self):\r\n result = \"\"\r\n for s in self.__deck:\r\n result = result + str(s) + '\\n'\r\n return result","def __next_chunk_pattern(self, chunk_sectors:int):\n\t\tcurr_pat = next(self.pat_it, None)\t\t\t\n\n\t\tif (curr_pat is None):\n\t\t\tself.__reset_pat()\n\t\t\tcurr_pat = next(self.pat_it, None)\n\t\t\t\t\t\n\t\treturn bytearray(curr_pat[0:chunk_sectors * 512])","def _get_chunk(token: spacy.tokens.Token) -> str:\n\n if token is None:\n return \"\"\n\n def token_filter(tok):\n \"\"\"True for various modifiers of tok and compound tokens, which include tok\"\"\"\n return tok is token or \\\n tok.dep_.endswith(\"mod\") or \\\n tok.dep_ == \"compound\"\n\n tree = SpacyEventExtractor._get_tree(root=token, depth=2, token_filter=token_filter)\n return \" \".join(map(str, tree))","def wc(substring):\n n = 0\n try:\n while True:\n n += (yield)\n except GeneratorExit:\n print(substring, n, flush=True)","def chunk_name(s):\n\n # See https://www.w3.org/TR/2003/REC-PNG-20031110/#table51\n valid = len(s) == 4 and set(s) <= set(string.ascii_letters)\n if not valid:\n raise ValueError(\"Chunk name must be 4 ASCII letters\")\n return s.encode(\"ascii\")","def hexlify(self: str, verbose=False):\n nbytes = len(_chunk_bs(self))\n buf = b''\n strlen = ''\n for b in to_bytes(_chunk_bs(self)):\n buf+=b\n# for s in _from_list(_chunk_bs(self)):\n# strlen+=f'{ _bit_length(s): 02d}'\n if verbose:\n for n in range(nbytes):\n strlen += f'{_bit_length(_from_list(_chunk_bs(self))[n])} @[{n}] '\n print(strlen)\n return buf","def make_chopper(\n frequency: sc.Variable,\n position: sc.Variable,\n phase: sc.Variable = None,\n cutout_angles_center: sc.Variable = None,\n cutout_angles_width: sc.Variable = None,\n cutout_angles_begin: sc.Variable = None,\n cutout_angles_end: sc.Variable = None,\n kind: str = None,\n) -> sc.Dataset:\n data = {\"frequency\": frequency, \"position\": position}\n if phase is not None:\n data[\"phase\"] = phase\n if cutout_angles_center is not None:\n data[\"cutout_angles_center\"] = cutout_angles_center\n if cutout_angles_width is not None:\n data[\"cutout_angles_width\"] = cutout_angles_width\n if cutout_angles_begin is not None:\n data[\"cutout_angles_begin\"] = cutout_angles_begin\n if cutout_angles_end is not None:\n data[\"cutout_angles_end\"] = cutout_angles_end\n if kind is not None:\n data[\"kind\"] = kind\n chopper = sc.Dataset(data=data)\n\n # Sanitize input parameters\n if (None not in [cutout_angles_begin, cutout_angles_end]) or (\n None not in [cutout_angles_center, cutout_angles_width]\n ):\n widths = utils.cutout_angles_width(chopper)\n if (sc.min(widths) < sc.scalar(0.0, unit=widths.unit)).value:\n raise ValueError(\"Negative window width found in chopper cutout angles.\")\n if not sc.allsorted(utils.cutout_angles_begin(chopper), dim=widths.dim):\n raise ValueError(\"Chopper begin cutout angles are not monotonic.\")\n if not sc.allsorted(utils.cutout_angles_end(chopper), dim=widths.dim):\n raise ValueError(\"Chopper end cutout angles are not monotonic.\")\n\n return chopper","def scramble(word_chunk, results):\n letters_displaced = word_chunk[0:letter_displacement]\n temp_word = word_chunk[letter_displacement:]\n temp2_word = temp_word + letters_displaced\n add_on = get_add_on()\n results.append(temp2_word + add_on)\n temp = 0\n for i in results:\n temp += len(i)","def output(self):\n\t\treturn \"\".join(self.pieces)","def get_pieces(pkg_root_dir, files, piece_length):\n s = b''\n for f in files:\n file_path = os.path.join(pkg_root_dir, os.sep.join(f['path']))\n with open(file_path, 'rb') as fd:\n buf = fd.read(piece_length)\n while len(buf) != 0:\n s += buf\n if len(s) >= piece_length:\n h = hashlib.sha1()\n h.update(s[:piece_length])\n yield h.digest()\n s = s[piece_length:]\n buf = fd.read(piece_length)\n h = hashlib.sha1()\n h.update(s[:piece_length])\n yield h.digest()","def generate_starting_point() -> str:\n starter = ''\n for i in range(len(wf.ANSWER) // wf.SECTION_LENGTH):\n section = list(wf.ANSWER[wf.SECTION_LENGTH * i:wf.SECTION_LENGTH * (i + 1)])\n random.shuffle(section)\n starter = starter + ''.join(section)\n return starter","def generate_chunk(self, filename):\n\n # open resource file in binary\n with open(filename, 'rb') as resource:\n\n # instantiate chunk start byte and trailing line string\n p = 0\n overlap = ''\n\n while p <= self.file_size:\n\n try:\n if self.file_size - p < self.chunk_size:\n buffer = overlap + resource.read(self.file_size - p).decode(\"UTF-8\")\n else:\n buffer = overlap + resource.read(self.chunk_size).decode(\"UTF-8\")\n except:\n p += self.chunk_size\n continue\n\n # remove and store trailing sentence\n buffer, overlap = buffer.rsplit('\\n', maxsplit=1)\n\n yield buffer\n\n p += self.chunk_size","def chunks(sequence, chunk_size):\r\n\r\n # YOUR CODE HERE\r","def makeSetup(self):\n startingRanks = [FLAG, SPY, SCOUT, SCOUT, MINER, MINER, GENERAL, MARSHALL, BOMB, BOMB]\n startingSpots = random.sample(self.getStartSpots(), len(startingRanks))\n pieces = []\n for i in range(len(startingRanks)):\n pieces += [Piece(startingRanks[i], startingSpots[i], self.index)]\n # print [(str(p), p.position) for p in pieces]\n return pieces","def _build_from_chunks(self, data_node):\n result = ''\n\n if not data_node:\n return ''\n\n master_data = data_node[0]\n result = \"{}{}\".format(result, self._decode(master_data['value']))\n # if data is not in chunks, then return the first node's value\n if 'tags' not in master_data or 'chunks' not in master_data['tags']:\n return result\n\n # join the values in chunks\n last_chunk = int(master_data['tags']['chunks'])\n for chunk_id in range(1, last_chunk):\n slave_data = data_node[chunk_id]\n result = \"{}{}\".format(result, self._decode(slave_data['value']))\n return result","def _chunker(self, seq, size):\n return (seq[pos:pos + size] for pos in range(0, len(seq), size))","def generator(size=6, chars=string.ascii_uppercase + string.digits):\n return ''.join(random.choice(chars) for _ in range(size))","def get_first(self):\n return \"%s%s\" % (\n weighted_choice([(\"\", 39), (\"We put our faith in \", 1)]),\n choice(self.first_chunks).title()\n )","def chunk_up(base64str, num_chunks):\n chunk_size = int(len(base64str)/num_chunks)\n chunks = []\n for i in range(num_chunks-1):\n low = i*chunk_size\n upper = (i+1)*chunk_size\n chunks.append(base64str[low:upper])\n chunks.append(base64str[(num_chunks-1)*chunk_size:])\n return chunks","def _create_initial_chunks(self, by_dir):\n\n class Chunk(object):\n def __init__(self, paths, index):\n \"\"\"List of PathData objects that together form a single chunk of\n tests\"\"\"\n self.paths = deque(paths)\n self.time = sum(item.time for item in paths)\n self.index = index\n\n def appendleft(self, path):\n \"\"\"Add a PathData object to the start of the chunk\"\"\"\n self.paths.appendleft(path)\n self.time += path.time\n\n def append(self, path):\n \"\"\"Add a PathData object to the end of the chunk\"\"\"\n self.paths.append(path)\n self.time += path.time\n\n def pop(self):\n \"\"\"Remove PathData object from the end of the chunk\"\"\"\n assert len(self.paths) > 1\n self.time -= self.paths[-1].time\n return self.paths.pop()\n\n def popleft(self):\n \"\"\"Remove PathData object from the start of the chunk\"\"\"\n assert len(self.paths) > 1\n self.time -= self.paths[0].time\n return self.paths.popleft()\n\n @property\n def badness(self_):\n \"\"\"Badness metric for this chunk\"\"\"\n return self._badness(self_.time)\n\n initial_size = len(by_dir) / self.total_chunks\n chunk_boundaries = [initial_size * i\n for i in xrange(self.total_chunks)] + [len(by_dir)]\n\n chunks = OrderedDict()\n for i, lower in enumerate(chunk_boundaries[:-1]):\n upper = chunk_boundaries[i + 1]\n paths = by_dir.values()[lower:upper]\n chunks[i] = Chunk(paths, i)\n\n assert self._all_tests(by_dir) == self._chunked_tests(chunks)\n\n return chunks","def genCharGroup(self):\n alphabet = list('abcdefghijklmnopqrstuvwxyz') #Creates a list of all the alphabet characters\n group = []\n count = 0\n while count != 3: #While the loop total does not equal 3\n i = random.choice(alphabet) #Make a random choice\n alphabet.remove(i) #Remove it from the alphabet\n group.append(i) #And add it to the group array\n count += 1 #Add one to the loop total\n return str(''.join(group)) #Return the string of 3 characters to the user","def generate_characters(g, checkpoint, num_chars, reader, prompt='A', pick_top_chars=None):\n char_id, id_char = reader.to_ids()\n with tf.Session() as sess:\n sess.run(tf.initialize_all_variables())\n g['saver'].restore(sess, checkpoint)\n\n state = None\n current_char = char_id[prompt]\n chars = [current_char]\n\n for i in range(num_chars):\n if state is not None:\n feed_dict = {g['x']: [[current_char]], g['init_state']: state}\n else:\n feed_dict = {g['x']: [[current_char]]}\n\n preds, state = sess.run([g['preds'], g['final_state']], feed_dict)\n\n if pick_top_chars is not None:\n p = np.squeeze(preds)\n p[np.argsort(p)[:-pick_top_chars]] = 0\n p = p / np.sum(p)\n current_char = np.random.choice(reader.len, 1, p=p)[0]\n else:\n current_char = np.random.choice(reader.len, 1, p=np.squeeze(preds))[0]\n\n chars.append(current_char)\n\n chars = [id_char[c] for c in chars]\n print(\"\".join(chars))\n return (\"\".join(chars))","def part_1():\n input_ = parse_input()\n cups = turn_input_into_cups(input_)\n cups = solve(cups, first_cup=cups[input_[0]], turns=100)\n\n answer = []\n current_cup = cups[1].next\n while current_cup != cups[1]:\n answer.append(str(current_cup.number))\n current_cup = current_cup.next\n\n return \"\".join(answer)","def gen():\r\n\r\n output = \"\"\r\n frame = 12\r\n prior = 0\r\n second = 0\r\n\r\n while frame > 0:\r\n frame -= .5\r\n roll = randrange(11 - prior)\r\n\r\n # If strike is rolled:\r\n if roll == 10:\r\n output += \"X\"\r\n frame -= .5\r\n prior = 0\r\n second = 0\r\n\r\n # If spare is rolled:\r\n elif second == 1 and roll + prior == 10:\r\n output += \"/\"\r\n prior = 0\r\n second = 0\r\n\r\n # If not strike or spare:\r\n else:\r\n output += str(roll)\r\n prior = roll\r\n second = 1 - second\r\n\r\n # Deliminate frames:\r\n if second == 0:\r\n output += \"-\"\r\n\r\n return output[:-1]","def chunked(size, source):\n for i in range(0, len(source), size):\n yield source[i : i + size]","def gluechops(string, key, n, funcref):\n\n messageparts = []\n chops = decode64chops(string) #Decode base64 strings into integer chops\n \n for chop in chops:\n value = funcref(chop, key, n) #Decrypt each chop\n block = transform.int2bytes(value)\n messageparts.append(block)\n\n # Combine decrypted strings into a msg\n return ''.join(messageparts)","def make_unicode():\r\n for num in range(300, 320):\r\n yield unichr(num)","def chunker(seq, size):\n\n return (seq[pos : pos + size] for pos in range(0, len(seq), size))","def _get_arbitrary_chunk(post: Post) -> str:\n instance_template = Template(config.PLAN_POSTS_INSTANCE_CHUNK)\n instance_chunk = instance_template.render(Context({\"post\": post}))\n return instance_chunk","def create_cue_sheet(tracks):\n for track_index, (track_time, name, performer) in enumerate(tracks):\n minutes = int(track_time.total_seconds() / 60)\n seconds = int(track_time.total_seconds() % 60)\n\n cue_sheet_entry = ''' TRACK {:02} AUDIO\n TITLE {}\n PERFORMER {}\n INDEX 01 {:02d}:{:02d}:00'''.format(track_index, name, performer, minutes,\n seconds)\n yield cue_sheet_entry","def make_chunks(self, audio_segment, chunk_length):\r\n\t\tnumber_of_chunks = math.ceil(len(audio_segment) / float(chunk_length))\r\n\t\treturn [audio_segment[i * chunk_length:(i + 1) * chunk_length]\r\n\t\t\t\tfor i in range(int(number_of_chunks))]","def test_chunks(year, day, part_number):\n chunks = []\n chunk_index = -1\n data_file_lines(part_number).each do |line|\n if line[0] == '#'\n chunk_index += 1\n chunks[chunk_index] = [line[1..-1].strip, []]\n elsif chunk_index >= 0\n chunks[chunk_index][1] << line\n end\n end\n chunks","def gen_beat_output(e):\n return [playback_char(e,t) for t in range(70000)]","def sample_data():\n global _cached_sample_data\n if _cached_sample_data is None:\n data = StringIO()\n chars = \"\".join(chr(i) for i in xrange(256))\n for count in xrange(6):\n cc = chr(count)\n for _ in xrange(2 * 1024):\n # each iteration adds 1MB\n # each 1MB chunk is made up of an alternation of the block's index (zero based)\n # and an incrementing counter (overflows to 0 several times)\n # the first block will be: 00 00 00 01 00 02 ... 00 ff 00 00 ... 00 ff\n data.write(\n \"\".join(cc+chars[i] for i in xrange(256))\n )\n print \"wrote {} MB\" .format(data.tell() / 1024.0 / 1024.0)\n # give the test a read-only file to avoid accidentally modifying the data between tests\n _cached_sample_data = ReadOnlyFile(data)\n _cached_sample_data.seek(0)\n return _cached_sample_data","def ninja_chirp(total_chirp):\n return \"chirp\" + (\"-chirp\" * (total_chirp - 1))","async def chord(ctx, root:str,length=3,):\n if length < 2:\n length = 2\n elif length > 5:\n length = 5\n chord = Tempo.generateChordProgression(root)\n await ctx.send(chord)","def get_chunks(indivs, k):\r\n\tpair_chunk_collection=[]\r\n\tfor i in xrange(0, len(indivs[0])-k+1, k):\r\n\t\tchunks=[]\r\n\t\tfor x in indivs:\r\n\t\t\tchunks.append(x[i:i+k])\r\n\t\tpartial_phase_pairs=tune_em(chunks, 5)[1]\r\n\t\tprint partial_phase_pairs\r\n\t\tpair_chunk_collection.append(partial_phase_pairs)\r\n\treturn pair_chunk_collection","def fuzzChunk(chunkData):\n\tfname = tempfile.mktemp(dir=\"/tmp/samples/\")\n\tprint(fname)\n\tx = open(fname, \"wb\")\n\tx.write(chunkData)\n\tx.close()\n\tsubprocess.run(\"{} {} -o {}\".format(radamsa,fname,fname), shell=True)\n\tx = open(fname, \"rb\")\n\tx = x.read()\n\tx = \"\".join(\"{:02x}\".format(_) for _ in x)\n\treturn x","def new_deck(cla):\r\n\treturn [cla(i) for i in range(52)]","def break_to_chunks(self, text,\n chunk_size=TWITTER_MAX_CHARS,\n suffix = TWITTER_HAS_NEXT_SUFFIX,\n prefix = TWITTER_HAS_PREV_PREFIX):\n\n res = []\n current_prefix = \"\" # first chunk has no prefix\n while text:\n if len(current_prefix + text) <= chunk_size:\n res.append(current_prefix + text)\n return res\n else: # break a chunk\n c = text[:chunk_size - len(current_prefix) - len(suffix)]\n i = c.rfind(\" \")\n if i > 0: # got a blank\n c = c[:i]\n text = text[len(c):].lstrip()\n res.append((current_prefix + c.rstrip() + suffix))\n current_prefix = prefix # from now on, we want a prefix","def gen_14BQ_OH():\r\n q_smiles_base = {}\r\n q_smiles_mid = {}\r\n q_smiles_base['1,4-BQ,2-OH'] = '[H]OC1=C([H])C(=O)C([H])=C([H])C1=O'\r\n q_smiles_base['1,4-BQ,Full-OH'] = 'OC1=C(O)C(=O)C(O)=C(O)C1=O'\r\n q_smiles_base['1,4-BQ'] = 'O=C1C=CC(=O)C=C1'\r\n\r\n q_smiles_mid['1,4-BQ'] = 'O=C1C=CC(=O)C=C1'\r\n q_smiles_mid['1,4-BQ,2-OH'] = 'OC1=CC(=O)C=CC1=O'\r\n q_smiles_mid['1,4-BQ,2,3-OH'] = 'OC1=C(O)C(=O)C=CC1=O'\r\n q_smiles_mid['1,4-BQ,2,3,5-OH'] = 'OC1=CC(=O)C(O)=C(O)C1=O'\r\n q_smiles_mid['1,4-BQ,Full-OH'] = 'OC1=C(O)C(=O)C(O)=C(O)C1=O' \r\n\r\n return q_smiles_base, q_smiles_mid","def chunks(parts, n):\n for i in range(0, len(parts), n):\n yield parts[i:i+n]","def rand_kmer(rng, k_low, k_high=None):\n if k_high is None:\n k_high = k_low\n k_len = rng.randint(k_low, k_high + 1)\n return ''.join([NUCLEOTIDES[x] for x in rng.randint(4, size=k_len)])","def randomString(stringLength=10):\n letters = string.ascii_letters+string.digits\n rand_int = random.randint(3,11)\n string_random = [random.choice(letters) for i in range(stringLength)]\n chunk_array = []\n for chunk in chunks(string_random,rand_int):\n chunk_array.append(\"\".join(chunk))\n return chunk_array","def generateAll(self):\n\n dsource = DataSource.DataSource('summer533moon')\n data = dsource.getKeyList()\n replacements = {}\n\n # Generates the champion list to be displayed.\n result = '<p class=\"champ-display\">'\n line_break_counter = 0\n for champ in data:\n if line_break_counter % 10 == 0 and line_break_counter != 0:\n result += '<br />'\n result += '<a href=\"index.py?champ_name=%s\"><img src=\"http://ddra\\\ngon.leagueoflegends.com/cdn/5.7.2/img/champion/%s.png\"></a>' %\\\n (champ, champ)\n line_break_counter += 1\n result += '</p>'\n\n replacements['champ_display'] = result\n self.content = self.content.format(**replacements)","def gc_blocks(seq, block_size):\n\n # Make all capital\n seq = seq.upper()\n iterations = len(seq) // block_size\n\n # Iterate through finding the GC content\n gc = []\n for i in range(iterations):\n block = seq[i*block_size:(i+1)*block_size]\n gc.append((block.count('G') + block.count('C')) / block_size)\n return tuple(gc)","def creatCharList(start, end, increment):\r\n\r\n start = int(start)\r\n end = int(end)\r\n increment = int(increment)\r\n characters = []\r\n i = start\r\n\r\n for i in range(start, end, increment):\r\n print(f\"Loop: {i}.\")\r\n characters.append(chr(i))\r\n\r\n print(\"Characters:\\n{}\".format(characters))\r\n\r\n print(f\"At the bottom i is {i}\\n\")\r\n\r\n return characters","def generate_basic(self, time):\n output_text = ''\n try:\n output_text = 'for x=1 to ' + str(int(time)//4) + ':\\n'\n except:\n return\n for i, layer in enumerate(self.c_layers):\n c = ['0'] * 8\n b = ['0'] * 8\n d = ['0'] * 8\n\n c[self.num_sides - i - 1] = '1'\n for point in layer:\n if not point.on:\n continue\n\n index = 7 - int(point.toplevel[1])\n if point.toplevel[0] == \"b\":\n b[index] = '1'\n else:\n d[index] = '1'\n\n output_text += f' portb = %{\"\".join(b)}\\n'\n output_text += f' portd = %{\"\".join(d)}\\n'\n output_text += f' portc = %{\"\".join(c)}\\n'\n output_text += ' pause 1\\n'\n output_text += '\\n'\n\n output_text += ' next x\\n'\n return output_text","def draw(self):\n labels = \" a.b.c.d.e.f.g.h.\"\n\n grid = ''\n i = 0\n for row_of_pieces in chunks(self.pieces, 8):\n row = ''\n for p in row_of_pieces:\n row += p.draw()\n\n grid += '{0} {1}{0}\\n'.format(str(i + 1), row)\n\n i += 1\n\n output = '{0}\\n{1}{0}'.format(labels, grid)\n return output","def startOfChunk(prevTag, tag, prevType, type_):\r\n chunkStart = ((prevTag == \"B\" and tag == \"B\") or\r\n (prevTag == \"B\" and tag == \"B\") or\r\n (prevTag == \"I\" and tag == \"B\") or\r\n (prevTag == \"O\" and tag == \"B\") or\r\n (prevTag == \"O\" and tag == \"I\") or\r\n\r\n (prevTag == \"E\" and tag == \"E\") or\r\n (prevTag == \"E\" and tag == \"I\") or\r\n (prevTag == \"O\" and tag == \"E\") or\r\n (prevTag == \"O\" and tag == \"I\") or\r\n\r\n (tag != \"O\" and tag != \".\" and prevType != type_) or\r\n (tag == \"]\" or tag == \"[\"))\r\n # corrected 1998-12-22: these chunks are assumed to have length 1\r\n\r\n #print(\"startOfChunk?\", prevTag, tag, prevType, type)\r\n #print(chunkStart)\r\n return chunkStart","def writeChunk(chunk):","def more(self):\n buffer = []\n i = 1\n for x in xrange(self.loops):\n try:\n next = self.iterator.next()\n file_format = next.split('file-')\n if len(file_format) > 1:\n buffer.append(str(i) + ': ' + file_format[-1])\n i += 1\n except StopIteration:\n break\n return ''.join(buffer)[:-1]","def test_create_chunks():\n items = list(range(0, 100))\n size = 3\n\n chunks = create_chunks(items, size)\n\n current = next(chunks)\n assert len(current) == size\n assert current == [0, 1, 2]\n\n current = next(chunks)\n assert current == [3, 4, 5]","def letters_generator():\n def multiletters(seq):\n for n in itertools.count(1):\n for s in itertools.product(seq, repeat=n):\n yield \"\".join(s)\n letters = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"\n return multiletters(letters)","def solution(self) -> str:\n\n # \"Starting after the cup labeled 1, collect the other cups' labels clockwise into a single string with no\n # extra characters.\"\n\n self.current = 1\n eight_cups = self.pick_up_cups(8) # 9 cups in the circle, so all cups except '1' is 8 cups.\n\n answer = ''\n for cup in eight_cups:\n answer += str(cup)\n return answer","def generate_sent(self):\n n = self._n\n\n sent = []\n prev_tokens = ['<s>'] * (n - 1)\n token = self.generate_token(tuple(prev_tokens))\n while token != '</s>':\n # WORK HERE!!\n sent += list((token,))\n prev_tokens += list((token,))\n prev_tokens = prev_tokens[1:]\n token = self.generate_token(tuple(prev_tokens))\n\n return sent","def make_chunk(size, seed=0):\n rng = random.Random(seed)\n cubes = set([Cube()])\n while len(cubes) < size:\n c = rng.choice(list(cubes))\n n = rng.choice(list(c.neighbors()))\n cubes.add(n)\n return cubes","def construct_cards(tokens: List[Tuple[Token, str]]) -> List[str]:\n md = Render()\n headers: Tuple[str, str, str] = (\"\", \"\", \"\")\n cards: List[str] = []\n\n for token in tokens:\n if token[0] == Token.HEADER_1:\n headers = (token[1], \"\", \"\")\n elif token[0] == Token.HEADER_2:\n headers = (headers[0], token[1], \"\")\n elif token[0] == Token.HEADER_3:\n headers = (headers[0], headers[1], token[1])\n elif token[0] == Token.CARD:\n constructed_headers = Template.assemble_headers(headers)\n body = add_cloze(md.render(token[1]))\n\n if constructed_headers is None:\n cards.append(\n f'{Template.OPEN_CARD}' \n f'{body}'\n f'{Template.CLOSE_CARD}'\n )\n else:\n cards.append(\n f'{Template.OPEN_CARD}' \n f'{constructed_headers}'\n f'<hr>'\n f'{body}'\n f'{Template.CLOSE_CARD}'\n )\n\n return cards","def generate_scaffold(smiles: str, include_chirality: bool = False) -> str:\n if type(smiles) == str:\n mol = Chem.MolFromSmiles(smiles)\n else:\n mol = smiles\n engine = ScaffoldGenerator(include_chirality=include_chirality)\n scaffold = engine.get_scaffold(mol)\n\n return scaffold","def part1(nums, steps=100):\n for _ in range(steps):\n nums = _one_pass(nums)\n return \"\".join(str(d) for d in nums[:8])","def get_scaffold(self, mol: Chem.rdchem.Mol) -> str:\n return MurckoScaffold.MurckoScaffoldSmiles(mol=mol, includeChirality=self.include_chirality)","def generate_text(model, prev_chars, length):\n history = \"~\" * prev_chars\n chars = []\n for _ in range(length):\n new_char = generate_char(model, history, prev_chars)\n history = history[-prev_chars:] + new_char\n chars.append(new_char)\n return ''.join(chars)","def __str__(self):\n string = \"Deck contains \"\n\n for i in range(len(self.deck)):\n string += str(self.deck[i].get_suit()) + str(self.deck[i].get_rank()) + \" \"\n return string","def generate_data(q, maxlen=2, minlen=1):\n alphabet = 'ab'\n alphabet = printable\n for l in range(minlen, maxlen+1):\n for s in product(alphabet, repeat=l):\n q.put( ''.join(s) )","def chopstring(message, key, n, int_op):\n\n\n nbytes = block_size(n)\n\n msglen = len(message)\n blocks = msglen // nbytes\n\n if msglen % nbytes > 0:\n blocks += 1\n\n cypher = []\n \n for bindex in range(blocks):\n offset = bindex * nbytes\n block = message[offset:offset + nbytes]\n\n value = transform.bytes2int(block)\n to_store = int_op(value, key, n)\n\n cypher.append(to_store)\n\n return encode64chops(cypher) #Encode encrypted ints to base64 strings","def output(self):\n\n return \"\".join(self.pieces)","def GetNamesOfPieces(self):\n assert self.RecoveredEnoughPieces()\n result = []\n base = self.fileName + dibs_constants.fileSeparator \n for p in self.piecesRecovered.keys():\n result.append(base + p)\n return result","def compileIntro(self):\n out = audio.AudioQuantumList()\n intro = audio.AudioData(self.sample_path + self.template['intro'], sampleRate=44100, numChannels=2, verbose=False)\n \n # First 4 bars of song\n custom_bars = []\n\n if not self.beats or len(self.beats) < 16:\n # Song is not long or identifiable enough\n # Take our best shot at making something\n self.tempo = 60.0 * 16.0 / self.original.duration\n for i in xrange(0, 4):\n bar = []\n for j in xrange(0, 4):\n length = self.original.duration / 16.0\n start = ((i * 4) + j) * length\n bar.append(audio.AudioQuantum(start, length, None, 0, self.original.source))\n custom_bars.append(bar)\n else:\n for i in xrange(0, 4):\n custom_bars.append(self.beats[i*4:(i*4)+4])\n out.extend([x for bar in custom_bars for x in bar])\n\n # First beat of first bar x 4\n for i in xrange(0, 4):\n out.append(custom_bars[0][0])\n \n # First beat of second bar x 4\n for i in xrange(0, 4):\n out.append(custom_bars[1][0])\n\n beatone = custom_bars[2][0]\n beattwo = custom_bars[3][0]\n beatthree = custom_bars[3][2]\n \n # First beat of third bar x 8\n for x in xrange(0, 8):\n out.append(audio.AudioQuantum(beatone.start, beatone.duration/2, None, beatone.confidence, beatone.source))\n\n # First beat of fourth bar x 8\n for x in xrange(0, 8):\n out.append(audio.AudioQuantum(beattwo.start, beattwo.duration/4, None, beattwo.confidence, beattwo.source))\n\n # Third beat of fourth bar x 8\n for x in xrange(0, 8):\n out.append(audio.AudioQuantum(beatthree.start, beatthree.duration/4, None, beatthree.confidence, beatthree.source))\n \n if self.original.analysis.time_signature == 4:\n shifted = self.st.shiftTempo(audio.getpieces(self.original, out), self.template['tempo']/self.tempo)\n else:\n shifted1 = audio.getpieces(self.original, out)\n shifted = self.st.shiftTempo(shifted1, len(shifted1) / ((44100 * 16 * 2 * 60.0)/self.template['tempo']))\n shifted1.unload()\n if shifted.numChannels == 1: \n shifted = self.mono_to_stereo(shifted)\n return self.truncatemix(intro, shifted, self.mixfactor(out))","def lettergen():\n for repeat in range(1, 10):\n for item in itertools.product(ascii_uppercase, repeat=repeat):\n yield \"\".join(item)","def gen_str(self):\n min_edge_val = self[0][0]\n start_ix = 0\n\n for i in range(1, self.n):\n next_edge_val = self[i][0]\n if next_edge_val < min_edge_val:\n min_edge_val = next_edge_val\n start_ix = i\n\n return ''.join(str(x) for x in chain.from_iterable(\n self[(i + start_ix) % self.n] for i in range(self.n)))","def convert_deck_to_deck_str(deck: Deck):\n main, side = deck\n deck_str = []\n\n for card_name in main:\n for _ in range(main[card_name]):\n deck_str.append(card_name.lower().split(\"(\")[0].strip())\n for card_name in side:\n for _ in range(side[card_name]):\n deck_str.append(\"SB:\" + card_name.lower().split(\"(\")[0].strip())\n\n deck_str.sort()\n return \";\".join(deck_str)","def cards_per_hand(self):\n s = \"\"\n for id in self.player_id_list:\n name = self.players[id].name\n cards = len(self.players[id])\n s += \"{} has {} cards.\\n\".format(name, cards)\n return s[:-1]"],"string":"[\n \"def chunkify(msg):\\n return [\\\"%s %s\\\" % (i, msg[i*158 : (i+1)*158]) for i in range(len(msg)/158 + 1)]\",\n \"def getChunks():\",\n \"def full_chromosomes(reader):\\n for line in reader.header.get_lines(\\\"contig\\\"):\\n if line.id in CHROMS:\\n name = line.id\\n length = line.length or 1_000_000_000\\n yield \\\"{}:{}-{}\\\".format(name, 1, length)\",\n \"def chunk_base_name(path_name, out_dir, chunk_i = None, tag= \\\"\\\"):\\n bn = os.path.join(out_dir, \\\"{}-chunk\\\".format(path_name))\\n if chunk_i is not None:\\n bn += \\\"-{}\\\".format(chunk_i)\\n return \\\"{}{}\\\".format(bn, tag)\",\n \"def generateSubSequences(k, ch):\\n seq = [\\\"\\\".join(c) for c in itertools.product(ch, repeat = k)]\\n# discussion about the best way to do this:\\n# https://stackoverflow.com/questions/7074051/what-is-the-best-way-to-generate-all-possible-three-letter-strings\\n return seq\",\n \"def _make_data(self, approximate_length):\\n fragments = []\\n so_far = 0\\n while so_far < approximate_length:\\n fragment = ('%d:' % so_far).encode('utf-8')\\n so_far += len(fragment)\\n fragments.append(fragment)\\n return six.b('').join(fragments)\",\n \"def test_gen_raw_ch():\\n raw = _generate_raw(duration=1, n_chan=1)\\n\\n assert_sequence_equal(raw.ch_names, ['0', 'STI 014'])\\n\\n raw = _generate_raw(duration=1, n_chan=1, ch_names=['bob'])\\n\\n assert_sequence_equal(raw.ch_names, ['bob', 'STI 014'])\\n\\n raw = _generate_raw(duration=1, n_chan=1, ch_names='standard_1020')\\n montage = make_standard_montage('standard_1020')\\n raw = raw.pick_types(eeg=True)\\n assert_true(np.all([ch in montage.ch_names for ch in raw.ch_names]))\",\n \"def create_string(start_index):\\n return [NOTES_SHARP[(x + start_index) % 12] for x in range(0, 12)]\",\n \"def get_chunks(sequence, ck_size):\\n \\n list_chunk = []\\n i=1\\n l = len(sequence)\\n if l < 4*ck_size:\\n raise ValueError(\\\"Chunk size should be of 4 at least \\\")\\n for i in range(1, l):\\n if i*ck_size < l:\\n list_chunk.append(sequence[i*ck_size-ck_size:i*ck_size])\\n #while(i*ck_size < l):\\n #list_chunk.append(sequence[i*ck_size-ck_size:i*ck_size])\\n #i += 1\\n return list_chunk\",\n \"def _write_start():\\n from ._common import header\\n\\n out = \\\"{:5}{}\\\\n\\\".format(\\\"----*\\\", header)\\n return [out[:11] + \\\"MOP: 123456789*123456789*1234\\\" + out[40:]]\",\n \"def chunked(sentence):\\n # For example, to construct a training vector with the head of previous chunks as a feature.\\n # Doing this with Sentence.chunks would discard the punctuation marks and conjunctions\\n # (Sentence.chunks only yields Chunk objects), which amy be useful features.\\n chunks = []\\n for word in sentence:\\n if word.chunk is not None:\\n if len(chunks) == 0 or chunks[-1] != word.chunk:\\n chunks.append(word.chunk)\\n else:\\n ch = Chink(sentence)\\n ch.append(word.copy(ch))\\n chunks.append(ch)\\n return chunks\",\n \"def get_cards_as_string(self):\\n return '' \\\\\\n ' {}\\\\n' \\\\\\n ' {}\\\\n' \\\\\\n ' {}\\\\n' \\\\\\n ' {}\\\\n' \\\\\\n ' {}\\\\n'.format(*self.get_cards_high_to_low())\",\n \"def say_chunk(num):\\n output_string_list = []\\n num_string = str(num)\\n\\n units = ['zero', 'one', 'two', 'three', 'four', 'five',\\n 'six', 'seven', 'eight', 'nine']\\n teens = ['ten', 'eleven', 'twelve', 'thirteen', 'fourteen', 'fifteen',\\n 'sixteen', 'seventeen', 'eighteen', 'nineteen']\\n tens = ['twenty', 'thirty', 'forty', 'fifty', 'sixty', 'seventy', 'eighty', 'ninety']\\n\\n # singles\\n if num < 10:\\n output_string_list.append(units[num])\\n\\n # teens\\n elif 10 <= num <= 19:\\n output_string_list.append(teens[int(num) % 10])\\n\\n # tens\\n elif 20 <= num <= 99:\\n num_str = str(num)\\n modifier = int(num_str[0])\\n if int(num_str[1]):\\n output_string_list.append(\\\"{}-{}\\\".format(tens[modifier - 2], units[int(num) % 10]))\\n else:\\n output_string_list.append(tens[modifier - 2])\\n\\n # hundreds\\n elif 100 <= num <= 999:\\n output_string_list.append(units[int(num_string[0])])\\n output_string_list.append('hundred')\\n\\n num = int(num_string[1:])\\n if num:\\n output_string_list.append('and')\\n num_string = str(num)\\n modifier = int(num_string[0])\\n\\n if int(num_string[1]):\\n output_string_list.append(\\\"{}-{}\\\".format(tens[modifier - 2], units[int(num_string[1:]) % 10]))\\n else:\\n output_string_list.append(tens[modifier - 2])\\n\\n return ' '.join(output_string_list)\",\n \"def get_full_composition(chrom, kmer_len, species):\\n seq = refseq(species, chrom, 1, -1)\\n return Counter(kmers_generator(seq, kmer_len))\",\n \"def generate_sent(self):\\n # WORK HERE!!\\n n = self._n\\n # Add (n-1) opening tags to start the generation\\n sent = [\\\"<s>\\\"] * (n - 1)\\n\\n while \\\"</s>\\\" not in sent:\\n\\n sent += [self.generate_token(tuple(sent[-n + 1:]))]\\n\\n # Delete (n-1) opening tags and closing tag previously added\\n return sent[n-1:-1]\",\n \"def generate_strings(char_list, length):\\n if length <= 0:\\n yield []\\n elif length == 1:\\n for char in char_list:\\n yield [char]\\n else:\\n for char in char_list:\\n for l in generate_strings(char_list, length-1):\\n yield [char] + l\",\n \"def gen_chars(length, character):\\n return ''.join([character for i in range(length)])\",\n \"def chunks(cipher, size):\\n\\treturn [cipher[i*size:(i+1)*size] for i in range(int(math.ceil(len(cipher)*1.0/size)))]\",\n \"def output(self):\\n return \\\" \\\".join(self.pieces)\",\n \"def piece_factory(total_length, piece_length, hashes):\\n num_pieces = (total_length // piece_length) + 1\\n for i in range(num_pieces - 1):\\n yield Piece(i, piece_length, hashes[i])\\n yield Piece(num_pieces - 1, total_length % piece_length, hashes[num_pieces - 1])\",\n \"def as_string(self) -> str:\\n return self._chunk_str\",\n \"def chunks_of_five(self, text):\\r\\n\\r\\n # Gets a random index in the length of the string and adds a random\\r\\n # garbage character at that index\\r\\n while len(text) % 5 != 0:\\r\\n rand_index = random.randint(0, len(text)-1)\\r\\n garb_char = random.choice(self.GARBAGE)\\r\\n text = text[:rand_index] + garb_char + text[rand_index:]\\r\\n\\r\\n # Generate list of indeces where the 5 chars should start\\r\\n # then get all 5 chars and join with a space\\r\\n text = ' '.join([text[i:i+5] for i in range(0, len(text), 5)])\\r\\n return text\",\n \"def send_chunk(chnk, sock):\\n length = len(chnk)\\n data = str(length).zfill(MAX_CHUNK_SIZE).encode() + chnk\\n sock.send(data)\",\n \"def create(cls, raw_data, chunk_dir, prefix='chunk'):\\n other_names = [f for f in os.listdir(chunk_dir) if \\\\\\n f.startswith(prefix)]\\n other_names.sort()\\n last_digit = 0\\n if other_names:\\n last_digit = int(other_names[-1].split('_')[-1])\\n filename = '%s_%s' % (prefix, str(last_digit + 1).zfill(9))\\n logger.debug('creating chunk %s' % filename)\\n file_path = os.path.join(chunk_dir, filename)\\n f = open(file_path, 'wb')\\n f.write(raw_data)\\n f.close()\\n append_checksum(file_path)\\n return ClientChunk(file_path)\",\n \"def _chunkify(sequence, num_chunks):\\n quo, rem = divmod(len(sequence), num_chunks)\\n return (sequence[i * quo + min(i, rem):(i + 1) * quo + min(i + 1, rem)] for i in range(num_chunks))\",\n \"def makeChrom(length):\\n output = []\\n for i in range(length):\\n output.append(randrange(14))\\n return output\",\n \"def create_random_string(total_character):\\n feed=string.printable\\n words=\\\"\\\"\\n i=0\\n while i < total_character:\\n words += feed[random.randrange(0,len(feed)-1)]\\n i+=1\\n return words\",\n \"def repeatstring(stingy, no):\\n packup = ''\\n for i in range(no):\\n packup += stingy\\n return packup\",\n \"def channel_string(self, pre=\\\"\\\", full=False):\\n\\n return \\\" \\\".join(pre+c.get_chanstr(full=full) for c in self.channels)\",\n \"def __str__(self):\\r\\n result = \\\"\\\"\\r\\n for s in self.__deck:\\r\\n result = result + str(s) + '\\\\n'\\r\\n return result\",\n \"def __next_chunk_pattern(self, chunk_sectors:int):\\n\\t\\tcurr_pat = next(self.pat_it, None)\\t\\t\\t\\n\\n\\t\\tif (curr_pat is None):\\n\\t\\t\\tself.__reset_pat()\\n\\t\\t\\tcurr_pat = next(self.pat_it, None)\\n\\t\\t\\t\\t\\t\\n\\t\\treturn bytearray(curr_pat[0:chunk_sectors * 512])\",\n \"def _get_chunk(token: spacy.tokens.Token) -> str:\\n\\n if token is None:\\n return \\\"\\\"\\n\\n def token_filter(tok):\\n \\\"\\\"\\\"True for various modifiers of tok and compound tokens, which include tok\\\"\\\"\\\"\\n return tok is token or \\\\\\n tok.dep_.endswith(\\\"mod\\\") or \\\\\\n tok.dep_ == \\\"compound\\\"\\n\\n tree = SpacyEventExtractor._get_tree(root=token, depth=2, token_filter=token_filter)\\n return \\\" \\\".join(map(str, tree))\",\n \"def wc(substring):\\n n = 0\\n try:\\n while True:\\n n += (yield)\\n except GeneratorExit:\\n print(substring, n, flush=True)\",\n \"def chunk_name(s):\\n\\n # See https://www.w3.org/TR/2003/REC-PNG-20031110/#table51\\n valid = len(s) == 4 and set(s) <= set(string.ascii_letters)\\n if not valid:\\n raise ValueError(\\\"Chunk name must be 4 ASCII letters\\\")\\n return s.encode(\\\"ascii\\\")\",\n \"def hexlify(self: str, verbose=False):\\n nbytes = len(_chunk_bs(self))\\n buf = b''\\n strlen = ''\\n for b in to_bytes(_chunk_bs(self)):\\n buf+=b\\n# for s in _from_list(_chunk_bs(self)):\\n# strlen+=f'{ _bit_length(s): 02d}'\\n if verbose:\\n for n in range(nbytes):\\n strlen += f'{_bit_length(_from_list(_chunk_bs(self))[n])} @[{n}] '\\n print(strlen)\\n return buf\",\n \"def make_chopper(\\n frequency: sc.Variable,\\n position: sc.Variable,\\n phase: sc.Variable = None,\\n cutout_angles_center: sc.Variable = None,\\n cutout_angles_width: sc.Variable = None,\\n cutout_angles_begin: sc.Variable = None,\\n cutout_angles_end: sc.Variable = None,\\n kind: str = None,\\n) -> sc.Dataset:\\n data = {\\\"frequency\\\": frequency, \\\"position\\\": position}\\n if phase is not None:\\n data[\\\"phase\\\"] = phase\\n if cutout_angles_center is not None:\\n data[\\\"cutout_angles_center\\\"] = cutout_angles_center\\n if cutout_angles_width is not None:\\n data[\\\"cutout_angles_width\\\"] = cutout_angles_width\\n if cutout_angles_begin is not None:\\n data[\\\"cutout_angles_begin\\\"] = cutout_angles_begin\\n if cutout_angles_end is not None:\\n data[\\\"cutout_angles_end\\\"] = cutout_angles_end\\n if kind is not None:\\n data[\\\"kind\\\"] = kind\\n chopper = sc.Dataset(data=data)\\n\\n # Sanitize input parameters\\n if (None not in [cutout_angles_begin, cutout_angles_end]) or (\\n None not in [cutout_angles_center, cutout_angles_width]\\n ):\\n widths = utils.cutout_angles_width(chopper)\\n if (sc.min(widths) < sc.scalar(0.0, unit=widths.unit)).value:\\n raise ValueError(\\\"Negative window width found in chopper cutout angles.\\\")\\n if not sc.allsorted(utils.cutout_angles_begin(chopper), dim=widths.dim):\\n raise ValueError(\\\"Chopper begin cutout angles are not monotonic.\\\")\\n if not sc.allsorted(utils.cutout_angles_end(chopper), dim=widths.dim):\\n raise ValueError(\\\"Chopper end cutout angles are not monotonic.\\\")\\n\\n return chopper\",\n \"def scramble(word_chunk, results):\\n letters_displaced = word_chunk[0:letter_displacement]\\n temp_word = word_chunk[letter_displacement:]\\n temp2_word = temp_word + letters_displaced\\n add_on = get_add_on()\\n results.append(temp2_word + add_on)\\n temp = 0\\n for i in results:\\n temp += len(i)\",\n \"def output(self):\\n\\t\\treturn \\\"\\\".join(self.pieces)\",\n \"def get_pieces(pkg_root_dir, files, piece_length):\\n s = b''\\n for f in files:\\n file_path = os.path.join(pkg_root_dir, os.sep.join(f['path']))\\n with open(file_path, 'rb') as fd:\\n buf = fd.read(piece_length)\\n while len(buf) != 0:\\n s += buf\\n if len(s) >= piece_length:\\n h = hashlib.sha1()\\n h.update(s[:piece_length])\\n yield h.digest()\\n s = s[piece_length:]\\n buf = fd.read(piece_length)\\n h = hashlib.sha1()\\n h.update(s[:piece_length])\\n yield h.digest()\",\n \"def generate_starting_point() -> str:\\n starter = ''\\n for i in range(len(wf.ANSWER) // wf.SECTION_LENGTH):\\n section = list(wf.ANSWER[wf.SECTION_LENGTH * i:wf.SECTION_LENGTH * (i + 1)])\\n random.shuffle(section)\\n starter = starter + ''.join(section)\\n return starter\",\n \"def generate_chunk(self, filename):\\n\\n # open resource file in binary\\n with open(filename, 'rb') as resource:\\n\\n # instantiate chunk start byte and trailing line string\\n p = 0\\n overlap = ''\\n\\n while p <= self.file_size:\\n\\n try:\\n if self.file_size - p < self.chunk_size:\\n buffer = overlap + resource.read(self.file_size - p).decode(\\\"UTF-8\\\")\\n else:\\n buffer = overlap + resource.read(self.chunk_size).decode(\\\"UTF-8\\\")\\n except:\\n p += self.chunk_size\\n continue\\n\\n # remove and store trailing sentence\\n buffer, overlap = buffer.rsplit('\\\\n', maxsplit=1)\\n\\n yield buffer\\n\\n p += self.chunk_size\",\n \"def chunks(sequence, chunk_size):\\r\\n\\r\\n # YOUR CODE HERE\\r\",\n \"def makeSetup(self):\\n startingRanks = [FLAG, SPY, SCOUT, SCOUT, MINER, MINER, GENERAL, MARSHALL, BOMB, BOMB]\\n startingSpots = random.sample(self.getStartSpots(), len(startingRanks))\\n pieces = []\\n for i in range(len(startingRanks)):\\n pieces += [Piece(startingRanks[i], startingSpots[i], self.index)]\\n # print [(str(p), p.position) for p in pieces]\\n return pieces\",\n \"def _build_from_chunks(self, data_node):\\n result = ''\\n\\n if not data_node:\\n return ''\\n\\n master_data = data_node[0]\\n result = \\\"{}{}\\\".format(result, self._decode(master_data['value']))\\n # if data is not in chunks, then return the first node's value\\n if 'tags' not in master_data or 'chunks' not in master_data['tags']:\\n return result\\n\\n # join the values in chunks\\n last_chunk = int(master_data['tags']['chunks'])\\n for chunk_id in range(1, last_chunk):\\n slave_data = data_node[chunk_id]\\n result = \\\"{}{}\\\".format(result, self._decode(slave_data['value']))\\n return result\",\n \"def _chunker(self, seq, size):\\n return (seq[pos:pos + size] for pos in range(0, len(seq), size))\",\n \"def generator(size=6, chars=string.ascii_uppercase + string.digits):\\n return ''.join(random.choice(chars) for _ in range(size))\",\n \"def get_first(self):\\n return \\\"%s%s\\\" % (\\n weighted_choice([(\\\"\\\", 39), (\\\"We put our faith in \\\", 1)]),\\n choice(self.first_chunks).title()\\n )\",\n \"def chunk_up(base64str, num_chunks):\\n chunk_size = int(len(base64str)/num_chunks)\\n chunks = []\\n for i in range(num_chunks-1):\\n low = i*chunk_size\\n upper = (i+1)*chunk_size\\n chunks.append(base64str[low:upper])\\n chunks.append(base64str[(num_chunks-1)*chunk_size:])\\n return chunks\",\n \"def _create_initial_chunks(self, by_dir):\\n\\n class Chunk(object):\\n def __init__(self, paths, index):\\n \\\"\\\"\\\"List of PathData objects that together form a single chunk of\\n tests\\\"\\\"\\\"\\n self.paths = deque(paths)\\n self.time = sum(item.time for item in paths)\\n self.index = index\\n\\n def appendleft(self, path):\\n \\\"\\\"\\\"Add a PathData object to the start of the chunk\\\"\\\"\\\"\\n self.paths.appendleft(path)\\n self.time += path.time\\n\\n def append(self, path):\\n \\\"\\\"\\\"Add a PathData object to the end of the chunk\\\"\\\"\\\"\\n self.paths.append(path)\\n self.time += path.time\\n\\n def pop(self):\\n \\\"\\\"\\\"Remove PathData object from the end of the chunk\\\"\\\"\\\"\\n assert len(self.paths) > 1\\n self.time -= self.paths[-1].time\\n return self.paths.pop()\\n\\n def popleft(self):\\n \\\"\\\"\\\"Remove PathData object from the start of the chunk\\\"\\\"\\\"\\n assert len(self.paths) > 1\\n self.time -= self.paths[0].time\\n return self.paths.popleft()\\n\\n @property\\n def badness(self_):\\n \\\"\\\"\\\"Badness metric for this chunk\\\"\\\"\\\"\\n return self._badness(self_.time)\\n\\n initial_size = len(by_dir) / self.total_chunks\\n chunk_boundaries = [initial_size * i\\n for i in xrange(self.total_chunks)] + [len(by_dir)]\\n\\n chunks = OrderedDict()\\n for i, lower in enumerate(chunk_boundaries[:-1]):\\n upper = chunk_boundaries[i + 1]\\n paths = by_dir.values()[lower:upper]\\n chunks[i] = Chunk(paths, i)\\n\\n assert self._all_tests(by_dir) == self._chunked_tests(chunks)\\n\\n return chunks\",\n \"def genCharGroup(self):\\n alphabet = list('abcdefghijklmnopqrstuvwxyz') #Creates a list of all the alphabet characters\\n group = []\\n count = 0\\n while count != 3: #While the loop total does not equal 3\\n i = random.choice(alphabet) #Make a random choice\\n alphabet.remove(i) #Remove it from the alphabet\\n group.append(i) #And add it to the group array\\n count += 1 #Add one to the loop total\\n return str(''.join(group)) #Return the string of 3 characters to the user\",\n \"def generate_characters(g, checkpoint, num_chars, reader, prompt='A', pick_top_chars=None):\\n char_id, id_char = reader.to_ids()\\n with tf.Session() as sess:\\n sess.run(tf.initialize_all_variables())\\n g['saver'].restore(sess, checkpoint)\\n\\n state = None\\n current_char = char_id[prompt]\\n chars = [current_char]\\n\\n for i in range(num_chars):\\n if state is not None:\\n feed_dict = {g['x']: [[current_char]], g['init_state']: state}\\n else:\\n feed_dict = {g['x']: [[current_char]]}\\n\\n preds, state = sess.run([g['preds'], g['final_state']], feed_dict)\\n\\n if pick_top_chars is not None:\\n p = np.squeeze(preds)\\n p[np.argsort(p)[:-pick_top_chars]] = 0\\n p = p / np.sum(p)\\n current_char = np.random.choice(reader.len, 1, p=p)[0]\\n else:\\n current_char = np.random.choice(reader.len, 1, p=np.squeeze(preds))[0]\\n\\n chars.append(current_char)\\n\\n chars = [id_char[c] for c in chars]\\n print(\\\"\\\".join(chars))\\n return (\\\"\\\".join(chars))\",\n \"def part_1():\\n input_ = parse_input()\\n cups = turn_input_into_cups(input_)\\n cups = solve(cups, first_cup=cups[input_[0]], turns=100)\\n\\n answer = []\\n current_cup = cups[1].next\\n while current_cup != cups[1]:\\n answer.append(str(current_cup.number))\\n current_cup = current_cup.next\\n\\n return \\\"\\\".join(answer)\",\n \"def gen():\\r\\n\\r\\n output = \\\"\\\"\\r\\n frame = 12\\r\\n prior = 0\\r\\n second = 0\\r\\n\\r\\n while frame > 0:\\r\\n frame -= .5\\r\\n roll = randrange(11 - prior)\\r\\n\\r\\n # If strike is rolled:\\r\\n if roll == 10:\\r\\n output += \\\"X\\\"\\r\\n frame -= .5\\r\\n prior = 0\\r\\n second = 0\\r\\n\\r\\n # If spare is rolled:\\r\\n elif second == 1 and roll + prior == 10:\\r\\n output += \\\"/\\\"\\r\\n prior = 0\\r\\n second = 0\\r\\n\\r\\n # If not strike or spare:\\r\\n else:\\r\\n output += str(roll)\\r\\n prior = roll\\r\\n second = 1 - second\\r\\n\\r\\n # Deliminate frames:\\r\\n if second == 0:\\r\\n output += \\\"-\\\"\\r\\n\\r\\n return output[:-1]\",\n \"def chunked(size, source):\\n for i in range(0, len(source), size):\\n yield source[i : i + size]\",\n \"def gluechops(string, key, n, funcref):\\n\\n messageparts = []\\n chops = decode64chops(string) #Decode base64 strings into integer chops\\n \\n for chop in chops:\\n value = funcref(chop, key, n) #Decrypt each chop\\n block = transform.int2bytes(value)\\n messageparts.append(block)\\n\\n # Combine decrypted strings into a msg\\n return ''.join(messageparts)\",\n \"def make_unicode():\\r\\n for num in range(300, 320):\\r\\n yield unichr(num)\",\n \"def chunker(seq, size):\\n\\n return (seq[pos : pos + size] for pos in range(0, len(seq), size))\",\n \"def _get_arbitrary_chunk(post: Post) -> str:\\n instance_template = Template(config.PLAN_POSTS_INSTANCE_CHUNK)\\n instance_chunk = instance_template.render(Context({\\\"post\\\": post}))\\n return instance_chunk\",\n \"def create_cue_sheet(tracks):\\n for track_index, (track_time, name, performer) in enumerate(tracks):\\n minutes = int(track_time.total_seconds() / 60)\\n seconds = int(track_time.total_seconds() % 60)\\n\\n cue_sheet_entry = ''' TRACK {:02} AUDIO\\n TITLE {}\\n PERFORMER {}\\n INDEX 01 {:02d}:{:02d}:00'''.format(track_index, name, performer, minutes,\\n seconds)\\n yield cue_sheet_entry\",\n \"def make_chunks(self, audio_segment, chunk_length):\\r\\n\\t\\tnumber_of_chunks = math.ceil(len(audio_segment) / float(chunk_length))\\r\\n\\t\\treturn [audio_segment[i * chunk_length:(i + 1) * chunk_length]\\r\\n\\t\\t\\t\\tfor i in range(int(number_of_chunks))]\",\n \"def test_chunks(year, day, part_number):\\n chunks = []\\n chunk_index = -1\\n data_file_lines(part_number).each do |line|\\n if line[0] == '#'\\n chunk_index += 1\\n chunks[chunk_index] = [line[1..-1].strip, []]\\n elsif chunk_index >= 0\\n chunks[chunk_index][1] << line\\n end\\n end\\n chunks\",\n \"def gen_beat_output(e):\\n return [playback_char(e,t) for t in range(70000)]\",\n \"def sample_data():\\n global _cached_sample_data\\n if _cached_sample_data is None:\\n data = StringIO()\\n chars = \\\"\\\".join(chr(i) for i in xrange(256))\\n for count in xrange(6):\\n cc = chr(count)\\n for _ in xrange(2 * 1024):\\n # each iteration adds 1MB\\n # each 1MB chunk is made up of an alternation of the block's index (zero based)\\n # and an incrementing counter (overflows to 0 several times)\\n # the first block will be: 00 00 00 01 00 02 ... 00 ff 00 00 ... 00 ff\\n data.write(\\n \\\"\\\".join(cc+chars[i] for i in xrange(256))\\n )\\n print \\\"wrote {} MB\\\" .format(data.tell() / 1024.0 / 1024.0)\\n # give the test a read-only file to avoid accidentally modifying the data between tests\\n _cached_sample_data = ReadOnlyFile(data)\\n _cached_sample_data.seek(0)\\n return _cached_sample_data\",\n \"def ninja_chirp(total_chirp):\\n return \\\"chirp\\\" + (\\\"-chirp\\\" * (total_chirp - 1))\",\n \"async def chord(ctx, root:str,length=3,):\\n if length < 2:\\n length = 2\\n elif length > 5:\\n length = 5\\n chord = Tempo.generateChordProgression(root)\\n await ctx.send(chord)\",\n \"def get_chunks(indivs, k):\\r\\n\\tpair_chunk_collection=[]\\r\\n\\tfor i in xrange(0, len(indivs[0])-k+1, k):\\r\\n\\t\\tchunks=[]\\r\\n\\t\\tfor x in indivs:\\r\\n\\t\\t\\tchunks.append(x[i:i+k])\\r\\n\\t\\tpartial_phase_pairs=tune_em(chunks, 5)[1]\\r\\n\\t\\tprint partial_phase_pairs\\r\\n\\t\\tpair_chunk_collection.append(partial_phase_pairs)\\r\\n\\treturn pair_chunk_collection\",\n \"def fuzzChunk(chunkData):\\n\\tfname = tempfile.mktemp(dir=\\\"/tmp/samples/\\\")\\n\\tprint(fname)\\n\\tx = open(fname, \\\"wb\\\")\\n\\tx.write(chunkData)\\n\\tx.close()\\n\\tsubprocess.run(\\\"{} {} -o {}\\\".format(radamsa,fname,fname), shell=True)\\n\\tx = open(fname, \\\"rb\\\")\\n\\tx = x.read()\\n\\tx = \\\"\\\".join(\\\"{:02x}\\\".format(_) for _ in x)\\n\\treturn x\",\n \"def new_deck(cla):\\r\\n\\treturn [cla(i) for i in range(52)]\",\n \"def break_to_chunks(self, text,\\n chunk_size=TWITTER_MAX_CHARS,\\n suffix = TWITTER_HAS_NEXT_SUFFIX,\\n prefix = TWITTER_HAS_PREV_PREFIX):\\n\\n res = []\\n current_prefix = \\\"\\\" # first chunk has no prefix\\n while text:\\n if len(current_prefix + text) <= chunk_size:\\n res.append(current_prefix + text)\\n return res\\n else: # break a chunk\\n c = text[:chunk_size - len(current_prefix) - len(suffix)]\\n i = c.rfind(\\\" \\\")\\n if i > 0: # got a blank\\n c = c[:i]\\n text = text[len(c):].lstrip()\\n res.append((current_prefix + c.rstrip() + suffix))\\n current_prefix = prefix # from now on, we want a prefix\",\n \"def gen_14BQ_OH():\\r\\n q_smiles_base = {}\\r\\n q_smiles_mid = {}\\r\\n q_smiles_base['1,4-BQ,2-OH'] = '[H]OC1=C([H])C(=O)C([H])=C([H])C1=O'\\r\\n q_smiles_base['1,4-BQ,Full-OH'] = 'OC1=C(O)C(=O)C(O)=C(O)C1=O'\\r\\n q_smiles_base['1,4-BQ'] = 'O=C1C=CC(=O)C=C1'\\r\\n\\r\\n q_smiles_mid['1,4-BQ'] = 'O=C1C=CC(=O)C=C1'\\r\\n q_smiles_mid['1,4-BQ,2-OH'] = 'OC1=CC(=O)C=CC1=O'\\r\\n q_smiles_mid['1,4-BQ,2,3-OH'] = 'OC1=C(O)C(=O)C=CC1=O'\\r\\n q_smiles_mid['1,4-BQ,2,3,5-OH'] = 'OC1=CC(=O)C(O)=C(O)C1=O'\\r\\n q_smiles_mid['1,4-BQ,Full-OH'] = 'OC1=C(O)C(=O)C(O)=C(O)C1=O' \\r\\n\\r\\n return q_smiles_base, q_smiles_mid\",\n \"def chunks(parts, n):\\n for i in range(0, len(parts), n):\\n yield parts[i:i+n]\",\n \"def rand_kmer(rng, k_low, k_high=None):\\n if k_high is None:\\n k_high = k_low\\n k_len = rng.randint(k_low, k_high + 1)\\n return ''.join([NUCLEOTIDES[x] for x in rng.randint(4, size=k_len)])\",\n \"def randomString(stringLength=10):\\n letters = string.ascii_letters+string.digits\\n rand_int = random.randint(3,11)\\n string_random = [random.choice(letters) for i in range(stringLength)]\\n chunk_array = []\\n for chunk in chunks(string_random,rand_int):\\n chunk_array.append(\\\"\\\".join(chunk))\\n return chunk_array\",\n \"def generateAll(self):\\n\\n dsource = DataSource.DataSource('summer533moon')\\n data = dsource.getKeyList()\\n replacements = {}\\n\\n # Generates the champion list to be displayed.\\n result = '<p class=\\\"champ-display\\\">'\\n line_break_counter = 0\\n for champ in data:\\n if line_break_counter % 10 == 0 and line_break_counter != 0:\\n result += '<br />'\\n result += '<a href=\\\"index.py?champ_name=%s\\\"><img src=\\\"http://ddra\\\\\\ngon.leagueoflegends.com/cdn/5.7.2/img/champion/%s.png\\\"></a>' %\\\\\\n (champ, champ)\\n line_break_counter += 1\\n result += '</p>'\\n\\n replacements['champ_display'] = result\\n self.content = self.content.format(**replacements)\",\n \"def gc_blocks(seq, block_size):\\n\\n # Make all capital\\n seq = seq.upper()\\n iterations = len(seq) // block_size\\n\\n # Iterate through finding the GC content\\n gc = []\\n for i in range(iterations):\\n block = seq[i*block_size:(i+1)*block_size]\\n gc.append((block.count('G') + block.count('C')) / block_size)\\n return tuple(gc)\",\n \"def creatCharList(start, end, increment):\\r\\n\\r\\n start = int(start)\\r\\n end = int(end)\\r\\n increment = int(increment)\\r\\n characters = []\\r\\n i = start\\r\\n\\r\\n for i in range(start, end, increment):\\r\\n print(f\\\"Loop: {i}.\\\")\\r\\n characters.append(chr(i))\\r\\n\\r\\n print(\\\"Characters:\\\\n{}\\\".format(characters))\\r\\n\\r\\n print(f\\\"At the bottom i is {i}\\\\n\\\")\\r\\n\\r\\n return characters\",\n \"def generate_basic(self, time):\\n output_text = ''\\n try:\\n output_text = 'for x=1 to ' + str(int(time)//4) + ':\\\\n'\\n except:\\n return\\n for i, layer in enumerate(self.c_layers):\\n c = ['0'] * 8\\n b = ['0'] * 8\\n d = ['0'] * 8\\n\\n c[self.num_sides - i - 1] = '1'\\n for point in layer:\\n if not point.on:\\n continue\\n\\n index = 7 - int(point.toplevel[1])\\n if point.toplevel[0] == \\\"b\\\":\\n b[index] = '1'\\n else:\\n d[index] = '1'\\n\\n output_text += f' portb = %{\\\"\\\".join(b)}\\\\n'\\n output_text += f' portd = %{\\\"\\\".join(d)}\\\\n'\\n output_text += f' portc = %{\\\"\\\".join(c)}\\\\n'\\n output_text += ' pause 1\\\\n'\\n output_text += '\\\\n'\\n\\n output_text += ' next x\\\\n'\\n return output_text\",\n \"def draw(self):\\n labels = \\\" a.b.c.d.e.f.g.h.\\\"\\n\\n grid = ''\\n i = 0\\n for row_of_pieces in chunks(self.pieces, 8):\\n row = ''\\n for p in row_of_pieces:\\n row += p.draw()\\n\\n grid += '{0} {1}{0}\\\\n'.format(str(i + 1), row)\\n\\n i += 1\\n\\n output = '{0}\\\\n{1}{0}'.format(labels, grid)\\n return output\",\n \"def startOfChunk(prevTag, tag, prevType, type_):\\r\\n chunkStart = ((prevTag == \\\"B\\\" and tag == \\\"B\\\") or\\r\\n (prevTag == \\\"B\\\" and tag == \\\"B\\\") or\\r\\n (prevTag == \\\"I\\\" and tag == \\\"B\\\") or\\r\\n (prevTag == \\\"O\\\" and tag == \\\"B\\\") or\\r\\n (prevTag == \\\"O\\\" and tag == \\\"I\\\") or\\r\\n\\r\\n (prevTag == \\\"E\\\" and tag == \\\"E\\\") or\\r\\n (prevTag == \\\"E\\\" and tag == \\\"I\\\") or\\r\\n (prevTag == \\\"O\\\" and tag == \\\"E\\\") or\\r\\n (prevTag == \\\"O\\\" and tag == \\\"I\\\") or\\r\\n\\r\\n (tag != \\\"O\\\" and tag != \\\".\\\" and prevType != type_) or\\r\\n (tag == \\\"]\\\" or tag == \\\"[\\\"))\\r\\n # corrected 1998-12-22: these chunks are assumed to have length 1\\r\\n\\r\\n #print(\\\"startOfChunk?\\\", prevTag, tag, prevType, type)\\r\\n #print(chunkStart)\\r\\n return chunkStart\",\n \"def writeChunk(chunk):\",\n \"def more(self):\\n buffer = []\\n i = 1\\n for x in xrange(self.loops):\\n try:\\n next = self.iterator.next()\\n file_format = next.split('file-')\\n if len(file_format) > 1:\\n buffer.append(str(i) + ': ' + file_format[-1])\\n i += 1\\n except StopIteration:\\n break\\n return ''.join(buffer)[:-1]\",\n \"def test_create_chunks():\\n items = list(range(0, 100))\\n size = 3\\n\\n chunks = create_chunks(items, size)\\n\\n current = next(chunks)\\n assert len(current) == size\\n assert current == [0, 1, 2]\\n\\n current = next(chunks)\\n assert current == [3, 4, 5]\",\n \"def letters_generator():\\n def multiletters(seq):\\n for n in itertools.count(1):\\n for s in itertools.product(seq, repeat=n):\\n yield \\\"\\\".join(s)\\n letters = \\\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\\\"\\n return multiletters(letters)\",\n \"def solution(self) -> str:\\n\\n # \\\"Starting after the cup labeled 1, collect the other cups' labels clockwise into a single string with no\\n # extra characters.\\\"\\n\\n self.current = 1\\n eight_cups = self.pick_up_cups(8) # 9 cups in the circle, so all cups except '1' is 8 cups.\\n\\n answer = ''\\n for cup in eight_cups:\\n answer += str(cup)\\n return answer\",\n \"def generate_sent(self):\\n n = self._n\\n\\n sent = []\\n prev_tokens = ['<s>'] * (n - 1)\\n token = self.generate_token(tuple(prev_tokens))\\n while token != '</s>':\\n # WORK HERE!!\\n sent += list((token,))\\n prev_tokens += list((token,))\\n prev_tokens = prev_tokens[1:]\\n token = self.generate_token(tuple(prev_tokens))\\n\\n return sent\",\n \"def make_chunk(size, seed=0):\\n rng = random.Random(seed)\\n cubes = set([Cube()])\\n while len(cubes) < size:\\n c = rng.choice(list(cubes))\\n n = rng.choice(list(c.neighbors()))\\n cubes.add(n)\\n return cubes\",\n \"def construct_cards(tokens: List[Tuple[Token, str]]) -> List[str]:\\n md = Render()\\n headers: Tuple[str, str, str] = (\\\"\\\", \\\"\\\", \\\"\\\")\\n cards: List[str] = []\\n\\n for token in tokens:\\n if token[0] == Token.HEADER_1:\\n headers = (token[1], \\\"\\\", \\\"\\\")\\n elif token[0] == Token.HEADER_2:\\n headers = (headers[0], token[1], \\\"\\\")\\n elif token[0] == Token.HEADER_3:\\n headers = (headers[0], headers[1], token[1])\\n elif token[0] == Token.CARD:\\n constructed_headers = Template.assemble_headers(headers)\\n body = add_cloze(md.render(token[1]))\\n\\n if constructed_headers is None:\\n cards.append(\\n f'{Template.OPEN_CARD}' \\n f'{body}'\\n f'{Template.CLOSE_CARD}'\\n )\\n else:\\n cards.append(\\n f'{Template.OPEN_CARD}' \\n f'{constructed_headers}'\\n f'<hr>'\\n f'{body}'\\n f'{Template.CLOSE_CARD}'\\n )\\n\\n return cards\",\n \"def generate_scaffold(smiles: str, include_chirality: bool = False) -> str:\\n if type(smiles) == str:\\n mol = Chem.MolFromSmiles(smiles)\\n else:\\n mol = smiles\\n engine = ScaffoldGenerator(include_chirality=include_chirality)\\n scaffold = engine.get_scaffold(mol)\\n\\n return scaffold\",\n \"def part1(nums, steps=100):\\n for _ in range(steps):\\n nums = _one_pass(nums)\\n return \\\"\\\".join(str(d) for d in nums[:8])\",\n \"def get_scaffold(self, mol: Chem.rdchem.Mol) -> str:\\n return MurckoScaffold.MurckoScaffoldSmiles(mol=mol, includeChirality=self.include_chirality)\",\n \"def generate_text(model, prev_chars, length):\\n history = \\\"~\\\" * prev_chars\\n chars = []\\n for _ in range(length):\\n new_char = generate_char(model, history, prev_chars)\\n history = history[-prev_chars:] + new_char\\n chars.append(new_char)\\n return ''.join(chars)\",\n \"def __str__(self):\\n string = \\\"Deck contains \\\"\\n\\n for i in range(len(self.deck)):\\n string += str(self.deck[i].get_suit()) + str(self.deck[i].get_rank()) + \\\" \\\"\\n return string\",\n \"def generate_data(q, maxlen=2, minlen=1):\\n alphabet = 'ab'\\n alphabet = printable\\n for l in range(minlen, maxlen+1):\\n for s in product(alphabet, repeat=l):\\n q.put( ''.join(s) )\",\n \"def chopstring(message, key, n, int_op):\\n\\n\\n nbytes = block_size(n)\\n\\n msglen = len(message)\\n blocks = msglen // nbytes\\n\\n if msglen % nbytes > 0:\\n blocks += 1\\n\\n cypher = []\\n \\n for bindex in range(blocks):\\n offset = bindex * nbytes\\n block = message[offset:offset + nbytes]\\n\\n value = transform.bytes2int(block)\\n to_store = int_op(value, key, n)\\n\\n cypher.append(to_store)\\n\\n return encode64chops(cypher) #Encode encrypted ints to base64 strings\",\n \"def output(self):\\n\\n return \\\"\\\".join(self.pieces)\",\n \"def GetNamesOfPieces(self):\\n assert self.RecoveredEnoughPieces()\\n result = []\\n base = self.fileName + dibs_constants.fileSeparator \\n for p in self.piecesRecovered.keys():\\n result.append(base + p)\\n return result\",\n \"def compileIntro(self):\\n out = audio.AudioQuantumList()\\n intro = audio.AudioData(self.sample_path + self.template['intro'], sampleRate=44100, numChannels=2, verbose=False)\\n \\n # First 4 bars of song\\n custom_bars = []\\n\\n if not self.beats or len(self.beats) < 16:\\n # Song is not long or identifiable enough\\n # Take our best shot at making something\\n self.tempo = 60.0 * 16.0 / self.original.duration\\n for i in xrange(0, 4):\\n bar = []\\n for j in xrange(0, 4):\\n length = self.original.duration / 16.0\\n start = ((i * 4) + j) * length\\n bar.append(audio.AudioQuantum(start, length, None, 0, self.original.source))\\n custom_bars.append(bar)\\n else:\\n for i in xrange(0, 4):\\n custom_bars.append(self.beats[i*4:(i*4)+4])\\n out.extend([x for bar in custom_bars for x in bar])\\n\\n # First beat of first bar x 4\\n for i in xrange(0, 4):\\n out.append(custom_bars[0][0])\\n \\n # First beat of second bar x 4\\n for i in xrange(0, 4):\\n out.append(custom_bars[1][0])\\n\\n beatone = custom_bars[2][0]\\n beattwo = custom_bars[3][0]\\n beatthree = custom_bars[3][2]\\n \\n # First beat of third bar x 8\\n for x in xrange(0, 8):\\n out.append(audio.AudioQuantum(beatone.start, beatone.duration/2, None, beatone.confidence, beatone.source))\\n\\n # First beat of fourth bar x 8\\n for x in xrange(0, 8):\\n out.append(audio.AudioQuantum(beattwo.start, beattwo.duration/4, None, beattwo.confidence, beattwo.source))\\n\\n # Third beat of fourth bar x 8\\n for x in xrange(0, 8):\\n out.append(audio.AudioQuantum(beatthree.start, beatthree.duration/4, None, beatthree.confidence, beatthree.source))\\n \\n if self.original.analysis.time_signature == 4:\\n shifted = self.st.shiftTempo(audio.getpieces(self.original, out), self.template['tempo']/self.tempo)\\n else:\\n shifted1 = audio.getpieces(self.original, out)\\n shifted = self.st.shiftTempo(shifted1, len(shifted1) / ((44100 * 16 * 2 * 60.0)/self.template['tempo']))\\n shifted1.unload()\\n if shifted.numChannels == 1: \\n shifted = self.mono_to_stereo(shifted)\\n return self.truncatemix(intro, shifted, self.mixfactor(out))\",\n \"def lettergen():\\n for repeat in range(1, 10):\\n for item in itertools.product(ascii_uppercase, repeat=repeat):\\n yield \\\"\\\".join(item)\",\n \"def gen_str(self):\\n min_edge_val = self[0][0]\\n start_ix = 0\\n\\n for i in range(1, self.n):\\n next_edge_val = self[i][0]\\n if next_edge_val < min_edge_val:\\n min_edge_val = next_edge_val\\n start_ix = i\\n\\n return ''.join(str(x) for x in chain.from_iterable(\\n self[(i + start_ix) % self.n] for i in range(self.n)))\",\n \"def convert_deck_to_deck_str(deck: Deck):\\n main, side = deck\\n deck_str = []\\n\\n for card_name in main:\\n for _ in range(main[card_name]):\\n deck_str.append(card_name.lower().split(\\\"(\\\")[0].strip())\\n for card_name in side:\\n for _ in range(side[card_name]):\\n deck_str.append(\\\"SB:\\\" + card_name.lower().split(\\\"(\\\")[0].strip())\\n\\n deck_str.sort()\\n return \\\";\\\".join(deck_str)\",\n \"def cards_per_hand(self):\\n s = \\\"\\\"\\n for id in self.player_id_list:\\n name = self.players[id].name\\n cards = len(self.players[id])\\n s += \\\"{} has {} cards.\\\\n\\\".format(name, cards)\\n return s[:-1]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.54023075","0.5305364","0.5266323","0.52563137","0.5210865","0.51348937","0.5116953","0.50660634","0.5042289","0.50343066","0.5030568","0.5028163","0.50268525","0.5004204","0.49979058","0.4997518","0.49932313","0.49587467","0.4947032","0.49435583","0.49176735","0.49116042","0.4885316","0.48727393","0.48518956","0.48411527","0.484039","0.4832","0.4828256","0.48241654","0.48095292","0.48069677","0.48037586","0.47990897","0.47606727","0.47456932","0.47405025","0.47372767","0.47329292","0.47326156","0.47284126","0.4719247","0.47191584","0.4706105","0.47045118","0.46963036","0.46924606","0.46761954","0.4674608","0.4673043","0.46713632","0.4671063","0.4670424","0.46698767","0.4666307","0.46572742","0.4649927","0.46466488","0.4632306","0.46306512","0.46268883","0.46193802","0.46167928","0.4613598","0.46108475","0.46056306","0.46050853","0.45955124","0.458932","0.45817515","0.45775005","0.45716894","0.45661807","0.45654598","0.4565078","0.45605308","0.4560072","0.45534968","0.45516974","0.45503333","0.45425054","0.4540415","0.45378312","0.45353973","0.4533731","0.45316532","0.45283076","0.4521878","0.4521289","0.45208874","0.4519881","0.4519139","0.4519123","0.45051146","0.4504646","0.449005","0.4486645","0.44848445","0.44812173","0.44803238","0.4474338"],"string":"[\n \"0.54023075\",\n \"0.5305364\",\n \"0.5266323\",\n \"0.52563137\",\n \"0.5210865\",\n \"0.51348937\",\n \"0.5116953\",\n \"0.50660634\",\n \"0.5042289\",\n \"0.50343066\",\n \"0.5030568\",\n \"0.5028163\",\n \"0.50268525\",\n \"0.5004204\",\n \"0.49979058\",\n \"0.4997518\",\n \"0.49932313\",\n \"0.49587467\",\n \"0.4947032\",\n \"0.49435583\",\n \"0.49176735\",\n \"0.49116042\",\n \"0.4885316\",\n \"0.48727393\",\n \"0.48518956\",\n \"0.48411527\",\n \"0.484039\",\n \"0.4832\",\n \"0.4828256\",\n \"0.48241654\",\n \"0.48095292\",\n \"0.48069677\",\n \"0.48037586\",\n \"0.47990897\",\n \"0.47606727\",\n \"0.47456932\",\n \"0.47405025\",\n \"0.47372767\",\n \"0.47329292\",\n \"0.47326156\",\n \"0.47284126\",\n \"0.4719247\",\n \"0.47191584\",\n \"0.4706105\",\n \"0.47045118\",\n \"0.46963036\",\n \"0.46924606\",\n \"0.46761954\",\n \"0.4674608\",\n \"0.4673043\",\n \"0.46713632\",\n \"0.4671063\",\n \"0.4670424\",\n \"0.46698767\",\n \"0.4666307\",\n \"0.46572742\",\n \"0.4649927\",\n \"0.46466488\",\n \"0.4632306\",\n \"0.46306512\",\n \"0.46268883\",\n \"0.46193802\",\n \"0.46167928\",\n \"0.4613598\",\n \"0.46108475\",\n \"0.46056306\",\n \"0.46050853\",\n \"0.45955124\",\n \"0.458932\",\n \"0.45817515\",\n \"0.45775005\",\n \"0.45716894\",\n \"0.45661807\",\n \"0.45654598\",\n \"0.4565078\",\n \"0.45605308\",\n \"0.4560072\",\n \"0.45534968\",\n \"0.45516974\",\n \"0.45503333\",\n \"0.45425054\",\n \"0.4540415\",\n \"0.45378312\",\n \"0.45353973\",\n \"0.4533731\",\n \"0.45316532\",\n \"0.45283076\",\n \"0.4521878\",\n \"0.4521289\",\n \"0.45208874\",\n \"0.4519881\",\n \"0.4519139\",\n \"0.4519123\",\n \"0.45051146\",\n \"0.4504646\",\n \"0.449005\",\n \"0.4486645\",\n \"0.44848445\",\n \"0.44812173\",\n \"0.44803238\",\n \"0.4474338\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88373,"cells":{"query":{"kind":"string","value":"Test the CommandList class"},"document":{"kind":"string","value":"def test_CommandList():\n from paradrop.confd.command import CommandList\n\n clist = CommandList()\n clist.append(20, \"b\")\n clist.append(20, \"c\")\n clist.append(10, \"a\")\n\n commands = list(clist.commands())\n assert commands == [\"a\", \"b\", \"c\"]"},"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 test_arg_parser_list(self):\n args = self.parser.parse_args(['list'])\n self.assertEqual(args.command, 'list')","def test_listCommand(self):\n acli = ArmiCLI()\n\n origout = sys.stdout\n try:\n out = io.StringIO()\n sys.stdout = out\n acli.listCommands()\n finally:\n sys.stdout = origout\n\n self.assertIn(\"run-suite\", out.getvalue())","def test_listCommand(self):\n from armi import cli\n\n cli = cli.ArmiCLI()\n\n origout = sys.stdout\n try:\n out = io.StringIO()\n sys.stdout = out\n cli.listCommands()\n finally:\n sys.stdout = origout\n self.assertIn(\"run-suite\", out.getvalue())","def test_list(self):\n pass","def test_list(self):\n pass","def test_device_command_list(self):\n actual_device_commands = set(self.sim_device.get_command_list()) - {\"Init\"}\n expected_command_list = set(\n self.sim_file_parser.get_device_command_metadata().keys()\n )\n self.assertEquals(\n actual_device_commands,\n expected_command_list,\n \"The commands specified are not present in the device\",\n )","def test_device_command_list(self):\n default_cmds = helper_module.DEFAULT_TANGO_DEVICE_COMMANDS\n actual_device_cmds = set(self.sim_device.get_command_list()) - default_cmds\n expected_cmd_list = self.sim_file_parser.get_device_command_metadata().keys()\n self.assertEquals(\n actual_device_cmds,\n set(expected_cmd_list),\n \"The commands specified in the json file are not present in\" \" the device\",\n )","def test_device_command_list(self):\n actual_device_cmds = self.sim_device.get_command_list()\n expected_cmd_list = self.sim_file_parser.get_device_command_metadata().keys()\n self.assertEquals(\n set(actual_device_cmds),\n set(expected_cmd_list),\n \"The commands specified in the fgo file are not present in\" \" the device\",\n )","def list_command(ctx: Any) -> None:\n pass","def test_list(self):\n parser = parse_args(['-g', '10', '-s', 'bubble', '-l'])\n self.assertTrue(parser.list)\n self.assertEqual(True, parser.list)\n\n parser = parse_args(['-g', '10', '-s', 'bubble'])\n self.assertEqual(False, parser.list)","def test_list_options(self):\n pass","def cmd_list(args):","def do_command(self, args):\n testops = dbops.Tests()\n listing = testops.list(args)\n ordering = ['test_name', 'os_type_name',\n 'test_command', 'runtime', 'timeout']\n do_list(listing, ordering)","def __init__(self, command_list, ):\n self.command_list = [] # all addition via function below\n self.add_command( command_list )","def test_status_command(self):\n # make sure STATUS is a valid command\n command = Command('STATUS')\n self.assertTrue(type(command) == Command)","def test_lg_commands(self): # noqa\n # list objects - before creating anything\n for obj in [command['obj'] for command in self.commands]:\n out = StringIO()\n args = ('list', obj)\n call_command('lg', *args, stdout=out)\n expect = \"No {} configured\".format(obj)\n assert expect in out.getvalue()\n # add objects\n for command in self.commands:\n out = StringIO()\n args = ('add', command['obj'])\n opts = command['opts']\n call_command('lg', *args, stdout=out, **opts)\n expect = \"index: 1\"\n assert expect in out.getvalue()\n # list objects\n for obj in [command['obj'] for command in self.commands]:\n out = StringIO()\n args = ('list', obj)\n call_command('lg', *args, stdout=out)\n expect = \"Configured {}\".format(obj.capitalize())\n assert expect in out.getvalue()\n # modify objects\n for command in self.commands:\n args = ('modify', command['obj'])\n for opt in command['opts']:\n out = StringIO()\n opts = {\"index\": 1, opt: command['opts'][opt]}\n call_command('lg', *args, stdout=out, **opts)\n expect = \"index: 1\"\n assert expect in out.getvalue()\n # show created objects\n for command in self.commands:\n out = StringIO()\n args = ('show', command['obj'])\n call_command('lg', *args, index=1, stdout=out)\n expect = \"index: 1\"\n assert expect in out.getvalue()\n # delete objects\n for obj in [command['obj'] for command in self.commands]:\n out = StringIO()\n args = ('delete', obj)\n call_command('lg', *args, index=1, stdout=out)\n # show deleted objects\n for command in self.commands:\n out = StringIO()\n args = ('show', command['obj'])\n try:\n call_command('lg', *args, index=1, stdout=out)\n except Exception as e:\n assert isinstance(e, CommandError)","def test_multiple_commands_at_same_time(self):","def test_get_commands(self):\n self.installer.os = \"amazonLinux\"\n commands = self.installer._get_commands()\n assert len(commands) > 0\n self.installer.os = \"ubuntu\"\n commands = self.installer._get_commands()\n assert len(commands) > 0\n self.installer.os = \"does_not_exist\"\n commands = self.installer._get_commands()\n self.assertEqual(len(commands), 1)","def testList(self):\n def _check(results):\n self.assertEqual(results[0], [b'testDirectory', b'testRemoveFile',\n b'testRenameFile', b'testfile1'])\n self.assertEqual(results[1], [b'testDirectory', b'testRemoveFile',\n b'testRenameFile', b'testfile1'])\n self.assertEqual(results[2], [b'testRemoveFile', b'testRenameFile'])\n self.assertEqual(results[3], [b'.testHiddenFile', b'testRemoveFile',\n b'testRenameFile'])\n self.assertEqual(results[4], [b''])\n d = self.runScript('ls', 'ls ../' + self.testDir.basename(),\n 'ls *File', 'ls -a *File', 'ls -l testDirectory')\n d.addCallback(lambda xs: [x.split(b'\\n') for x in xs])\n return d.addCallback(_check)","def test_command_finds_commands(self):\r\n COMMANDLIST['!toread'] = lambda bmark: bmark\r\n\r\n bm = BmarkMock()\r\n bm.tags['!toread'] = True\r\n commander = Commander(bm)\r\n commander.build_commands()\r\n\r\n self.assertTrue(\r\n '!toread' in commander.commands,\r\n \"Our commander should find !toread command to run\")","def test_importtleCommandExists(self):\n self.assertIn('importtle', get_commands())","def check_commands(self):\n pass","def test_cell_list_success(self, mock_list):\n self.shell('cell-list -r 1')\n self.assertTrue(mock_list.called)","def test_list_runs(self):\n pass","def test_get_list(self):\n pass","def test_pre_cli_list(run):\n out, err = run(dork.cli.the_predork_cli, [], *(\"\", \"-l\"))\n assert \"test.yml\" in out, \\\n \"Failed run the dork.cli.the_predork_cli method: {err}\"\\\n .format(err=err)","def test_command_list(self):\n from pystarlab.starlab import Story\n commands = [\"makeking -w 1.5 -s 1454677882 -n 5 -i\",\n \"makemass -i -l 0.1 -u 20 -s 1454677882\"]\n\n mass_output = \"mass.out\"\n\n mass_path = os.path.join(DATA_DIR, mass_output)\n with open(mass_path, 'r') as f:\n mass_str = f.read()\n\n mass_story = Story.from_command_list(commands)\n for line in zip(mass_str.splitlines(),\n str(mass_story).splitlines()):\n string_with_date = re.match(\"^ ===>\",line[0])\n if not string_with_date:\n self.assertEquals(line[0], line[1])","def test_stratis_list_default(self):\n for subcommand in [[\"pool\"], [\"filesystem\"], [\"blockdev\"]]:\n for prefix in [[], [\"--propagate\"]]:\n self.assertEqual(RUNNER(prefix + subcommand), 0)","def getCommands(self):","def processCommandList():\n\n try:\n # Assume that maya.cmds.about and maya.cmds.internalVar are already registered\n #\n commandListPath = os.path.realpath( os.environ[ 'MAYA_LOCATION' ] )\n platform = maya.cmds.about( os=True )\n commandListPath = os.path.join( commandListPath, commandListLocations[platform], 'commandList' )\n\n file = open( commandListPath, 'r' )\n for line in file:\n commandName, library = line.split()\n if not commandName in maya.cmds.__dict__:\n maya.cmds.__dict__[commandName] = __makeStubFunc( commandName, library )\n except:\n sys.stderr.write(\"Unable to process commandList %s\" % commandListPath)\n raise","def test_features(self):\n assert list(parser.generate_commands(yaml.load(\n '- my_command: {name: my_name}'))) == [('my_command', {'name': 'my_name'})]","def test_run_command(self):\n self.build()\n self.data_formatter_commands()","def test_command_method_exists(self):\n motor_shield = MotorShield(self.options, self.connection)\n\n for command in motor_shield.commands:\n self.assertIn(command, dir(motor_shield))","def test_cell_list_parse_param_success(self, mock_list):\n self.shell('cell-list -r 1 --limit 0')\n self.assertTrue(mock_list.called)","def test_get_operations_list_with_correct_data(self):\n ops = self.client.get_operations_list(self.agent_id)\n self.assertIsInstance(ops, list)","def test_list(self):\n output, _err = self.executor.prepare('chat', 'mention', person=['emett', 'lucy']).batch()\n self.assertEqual(output, 'mentioning folks')","async def test_commands(aresponses):\n aresponses.add(\n MATCH_HOST,\n \"/api/command\",\n \"GET\",\n aresponses.Response(\n status=200,\n headers={\"Content-Type\": \"application/json\"},\n text=load_fixture(\"command.json\"),\n ),\n )\n\n async with ClientSession() as session:\n client = Sonarr(HOST, API_KEY, session=session)\n response = await client.commands()\n\n assert response\n assert isinstance(response, List)\n\n assert response[0]\n assert isinstance(response[0], models.CommandItem)","def commands():","def create_command_list(device):\n command = XmlApiObject({})\n command.name = \"test\"\n device.commands[command.name] = command","def test_cell_list_detail_success(self, mock_list):\n self.shell('cell-list -r 1 --detail')\n mock_list.assert_called_once_with(detail=True)","def test_message_list():","def process_commands(self, commands: List[str]):","def run(self, commands: list[str]):\n ...","def cmd(self):","async def list(self, *args, **kwargs):\n return f\"Command list: {', '.join(self.get_commands())}\"","def test_command(self):\n\n expected = \"PyFunceble has been written by Fun Ilrys.\"\n actual = Command(\"echo '%s'\" % expected).execute()\n\n self.assertEqual(expected + \"\\n\", actual)","def test_handle_multiple_subcommands(self):\r\n ret, code = self.testcommand.handle(\"project list edit\", user)\r\n self.assertEqual(ret, self.testcommand.get_help())\r\n self.assertEqual(code, 200)","def main_list(args):\n return list_commands(args.directory)","def _commands(self) -> Dict[str, List[str]]:\r\n pass","def test_handle_multiple_subcommands(self):\n ret, code = self.testcommand.handle(\"team list edit\", user)\n self.assertEqual(ret, self.testcommand.get_help())\n self.assertEqual(code, 200)","def test_explicitListHelp(self):\n self.assertSuccessStatus(self._makeConfig(None), [\"list\", \"--help\"])\n self.assertSpacelessEqual(self._listHelpText, sys.stdout.getvalue())","def test_by_order(self):\n # addon_executor = AddonExecutor(execute_order, stop_order)\n # self.assertEqual(expected, addon_executor.execute_with_order(addon, execute_order, stop_order))\n self.run_mgr.by_order(self.cli_inst, ['execute', 'start'], ['stop'])\n output = self._get_lines_as_list(sys.stdout)\n\n self.assertTrue(output[0].startswith('Execute'))\n self.assertTrue(output[1].startswith('Start'))\n self.assertTrue(output[2].startswith('Stop'))","def test_get_help(self):\r\n subcommands = list(self.testcommand.subparser.choices.keys())\r\n help_message = self.testcommand.get_help()\r\n self.assertEqual(len(subcommands), help_message.count(\"usage\"))","def test_build_command(self):\n actual_result = IperfServerCommandBuilder().build_server_command()\n self.assertListEqual(actual_result, ['iperf', '-s'])","def __init__(self, command_list: list = None) -> None:\n if command_list is None:\n command_list = implemented_commands\n for command in command_list:\n setattr(self, command.get(\"name\").replace(\" \", \"_\"), self._SingleCommand(command))","def do_list_commands(self):\n result = \"\\n\".join(self.commands.keys())\n return result, True","def test_ssh_cmd(self):\n self.assertEqual(general.ssh_command('user','example.com',('ls','-l')).command_line,\n ['ssh','user@example.com','ls','-l'])","def test_get_help(self):\n subcommands = list(self.testcommand.subparser.choices.keys())\n help_message = self.testcommand.get_help()\n self.assertEqual(len(subcommands), help_message.count(\"usage\"))","def test_cell_list_sort_dir_desc_success(self, mock_list):\n self.shell('cell-list -r 1 --sort-key name --sort-dir desc')\n mock_list.assert_called_once_with(sort_key='name',\n sort_dir='desc')","def commands():\n pass","def commands():\n pass","def commands():\n pass","def commands():\n pass","def test_all(self):\n _help = \"[Usage: all <class name>]or [Usage: all] or \"\\\n \"[Usage: <class name>.all()]\\n\"\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"help all\")\n self.assertEqual(f.getvalue(), _help)","def test_by_config(self):\n # addon_executor = AddonExecutor(execute_order, stop_order)\n # self.assertEqual(expected, addon_executor.execute_with_config(addon))\n\n self.run_mgr.by_default(self.cli_inst)\n output = self._get_lines_as_list(sys.stdout)\n\n self.assertTrue(output[0].startswith('Start'))\n self.assertTrue(output[1].startswith('Execute'))\n self.assertTrue(output[2].startswith('Stop'))","def command_list(self, command):\n\n # See if the list exists and return results\n if len(command.args) > 0 and command.args[0] in LISTS:\n resp = []\n\n\n # Print out our available machines\n if command.args[0] == \"machines\":\n # Loop over controllers\n for c in self.config_list:\n\n # Get updated list of machiens\n self.config_list[c].get_machines()\n\n # Print output\n machines_tmp = self.config_list[c].machines\n\n resp.append(\"--- %s\" % c)\n for x in machines_tmp:\n name = machines_tmp[x].config.name\n m_type = machines_tmp[x].type\n profile = machines_tmp[x].config.volatility_profile\n resp.append(\" [%s] Type: %s, Profile: %s\" % (\n name, m_type, profile))\n resp.append(\"--- %s\" % c)\n\n # Print out our LO-PHI configs\n if command.args[0] == \"controllers\":\n\n if len(self.config_list) == 0:\n resp.append(\"No controllers are configured.\")\n else:\n resp.append(\"--- Available Controllers\")\n for x in self.config_list:\n resp.append(str(self.config_list[x]))\n resp.append(\"--- Available Controllers\")\n\n # Print out our running analyses\n if command.args[0] == \"analysis\":\n\n # Ensure our list\n self.update_analysis()\n\n # Loop over controllers\n for c in self.analysis_list:\n analysis, filename = self.analysis_list[c]\n\n resp.append(\"\\n[%s] %s\" % (c, filename))\n\n if len(resp) == 0:\n resp.append(\n \"No analysis scripts found in %s.\" % self.analysis_directory)\n\n return '\\n'.join(resp)\n\n else:\n return self.RESP_HEADER + \"ERROR: No such list.\\n Available lists are: %s\\n\" % LISTS","def test_commands_initialization(bot):\n plugin = Commands(bot)\n assert isinstance(plugin, Commands)\n assert plugin.bot == bot","def test_all(self):\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create User\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create State\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create City\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create Amenity\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create Place\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create Review\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"all\")\n self.assertTrue(\"[User]\" in f.getvalue().strip())\n self.assertTrue(\"[State]\" in f.getvalue().strip())\n self.assertTrue(\"[City]\" in f.getvalue().strip())\n self.assertTrue(\"[Amenity]\" in f.getvalue().strip())\n self.assertTrue(\"[Place]\" in f.getvalue().strip())\n self.assertTrue(\"[Review]\" in f.getvalue().strip())\n self.assertTrue(\"created_at\" in f.getvalue().strip())\n self.assertTrue(\"updated_at\" in f.getvalue().strip())\n self.assertTrue(\"id\" in f.getvalue().strip())","def run_command_check(self):\n pass","def test_list_group(self):\n pass","def setUp(self):\r\n self.saved_commandlist = COMMANDLIST\r\n for key in COMMANDLIST.keys():\r\n del(COMMANDLIST[key])","def test_command():\n\n dispatcher = ntelebot.dispatch.Dispatcher()\n dispatcher.add_command('command', lambda ctx: 'DISPATCHED')\n ctx = MockContext()\n ctx.type = 'message'\n ctx.command = None\n assert dispatcher(ctx) is False\n ctx.command = 'command'\n assert dispatcher(ctx) == 'DISPATCHED'\n ctx.type = 'callback_query'\n assert dispatcher(ctx) == 'DISPATCHED'\n ctx.type = 'inline_query'\n assert dispatcher(ctx) is False","def test_module(client: Client, args: Dict[str, Any]) -> str:\n client.get_lists()\n return 'ok'","def test_client_list(self):\n pass","def command_list(arguments):\n global current_mode\n current_mode = Mode.list\n #current_entity.addlink(arguments[0], arguments[1])\n return 'Now listing all entities'","def test_fixture_list_runs(tmp_sample_project):\n config_dir = tmp_sample_project\n output = subprocess.run([\"smif\", \"list\", \"-d\", config_dir], stdout=subprocess.PIPE)\n assert \"energy_water_cp_cr\" in str(output.stdout)\n assert \"energy_central\" in str(output.stdout)\n\n # Run energy_central and re-check output with optional flag for completed results\n subprocess.run([\"smif\", \"run\", \"energy_central\", \"-d\", config_dir], stdout=subprocess.PIPE)\n output = subprocess.run([\"smif\", \"list\", \"-c\", \"-d\", config_dir], stdout=subprocess.PIPE)\n assert \"energy_central *\" in str(output.stdout)","def testCmdFilterCompleter(self):\n\n self.inv.ATTRIBUTES = ['apple', 'pear']\n self.assertEqual(self.inv.ATTRIBUTES[0],\n self.inv._CmdFilterCompleter([''], 0))\n self.assertEqual(self.inv.ATTRIBUTES[1],\n self.inv._CmdFilterCompleter([''], 1))\n self.assertEqual(\n None, self.inv._CmdFilterCompleter([''], len(self.inv.ATTRIBUTES)))\n self.assertEqual('pear', self.inv._CmdFilterCompleter(['p'], 0))\n self.assertEqual(None, self.inv._CmdFilterCompleter(['p', 'bogus'], 0))","async def list_command(ctx, cmd:str=False):\n if cmd == False: # for quick list of commands\n ls = await get_quick_list(ctx)\n await ctx.send(embed=ls)\n if cmd == \"all\" or cmd == \"commands\":\n ls = await get_list(ctx.message.author, 1)\n sent_list = await ctx.send(embed=ls)\n await sent_list.add_reaction(EMOJI_FAST_REVERSE)\n await sent_list.add_reaction(EMOJI_LEFT_ARROW)\n await sent_list.add_reaction(EMOJI_RIGHT_ARROW)\n await sent_list.add_reaction(EMOJI_FAST_FORWARD)\n elif cmd == \"states\":\n states_list = await get_state_list()\n list = assemble_embed(\n title=\"List of all states\",\n desc=\"\\n\".join([f\"`{state}`\" for state in states_list])\n )\n await ctx.send(embed=list)\n elif cmd == \"events\":\n events_list = [r['eventName'] for r in EVENT_INFO]\n list = assemble_embed(\n title=\"List of all events\",\n desc=\"\\n\".join([f\"`{name}`\" for name in events_list])\n )\n await ctx.send(embed=list)","def get_commands(bot):\n new_commands = []\n\n new_commands.append(Command(\n 'mycommand', subcommands=[\n SubCommand(\n Opt('myoption'),\n doc='This is a simple command with a single required option.'),\n SubCommand(\n Opt('custom', optional=True),\n Opt('attached', optional=True, attached='attached argument'),\n doc='This has two different optional options, one without an attached '\n 'parameter, and the other requiring an attached parameter.'),\n SubCommand(\n Opt('trailing'),\n Arg('arg 1'),\n Arg('arg 2'),\n Arg('arg 3', argtype=ArgTypes.SPLIT, additional='more args'),\n doc='This command requires a lot of trailing arguments.'),\n SubCommand(\n Opt('grouped'),\n Arg('grouped arguments', argtype=ArgTypes.MERGED),\n doc='This will group all given arguments as a single string.'),\n SubCommand(\n Opt('complex', attached='attached'),\n Opt('other', optional=True, attached='also required'),\n Arg('arg 1'),\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL, additional='more args'),\n doc='The complex option has a required attached parameter, and the '\n '\\'other\\' option also has a required attached parameter if '\n '\\'other\\' is included. Additionally, there will be a requirement '\n 'of at least 1 trailing argument.'),\n SubCommand(\n Opt('marquee'),\n Arg('text', argtype=ArgTypes.MERGED,\n check=lambda b, m, v, *a: len(v) <= 100,\n check_error=\"Marquee message must be less than 100 characters long.\"),\n doc='Creates a marquee that loops 3 times.')],\n shortcuts=[\n Shortcut(\n 'complex', 'complex {attached} other {other} {arg 1} {arg 2}',\n Arg('attached'), Arg('other'), Arg('arg 1'),\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL)),\n Shortcut(\n 'marquee', 'marquee {text}', Arg('text', argtype=ArgTypes.MERGED))],\n description='Your command description here.',\n other='This text is optional - it just shows up after everything '\n 'else. Quick note, all of the commands here can only be used by '\n 'bot moderators or above, as indicated by elevated_level. A '\n 'level of 2 would mean only server owners or above can use the '\n 'command, and a level of 3 would restrict the command to only '\n 'the bot owners.',\n elevated_level=1, category='demo'))\n\n new_commands.append(Command(\n 'myothercommand', subcommands=[\n SubCommand(\n Arg('text', argtype=ArgTypes.MERGED_OPTIONAL),\n doc='This traps all further commands from being executed.'),\n SubCommand(\n Opt('order'), Opt('matters'),\n doc='It is impossible to access this command because the first '\n 'subcommand will always be satisfied first. Order of the '\n 'subcommand matters!'),\n SubCommand(\n Opt('sample'), Opt('foo'), Opt('bar'),\n doc='Also impossible to access. This subcommand just adds some '\n 'keywords to the command.')],\n description='Only bot owners can see this text!',\n other='Note that no shortcuts were defined. They, too, are optional. '\n 'Also, this command is hidden, which means that only the bot '\n 'owners can see this command listed from the help command. '\n 'However, unless the command is configured with an elevated '\n 'permissions level, any user can still execute the command. '\n 'Users still will not be able to see the specific help for this '\n 'command, though. Lastly, this command is disabled in DMs.',\n hidden=True, allow_direct=False, category='demo'))\n\n new_commands.append(Command(\n 'notify', subcommands=[\n SubCommand(\n Arg('text', argtype=ArgTypes.MERGED),\n doc='Notify the owners with some text!')],\n other='This command uses a custom function. It is called with the '\n 'same arguments as get_response. The command will show up to '\n 'all users in the help command, but can only be used by server '\n 'owners, as it is disallowed in direct messages.',\n elevated_level=2, allow_direct=False, function=custom_notify,\n category='demo'))\n\n new_commands.append(Command(\n 'wait', other='Use this command to demo the wait_for functionality', category='demo'))\n\n return new_commands","def commands(self) -> List[Command]:\n return []","def test_pos_operate_with_list_remove_operations(self, list, bin, expected):\n key = (\"test\", \"demo\", \"list_key\")\n\n self.as_connection.operate(key, list)\n\n key, _, bins = self.as_connection.get(key)\n\n assert bins[bin] == expected","def test_list_composition_status(self):\n pass","def _run_commands(self, command_list):\n for cmd in command_list:\n print(cmd)\n if not self.dry_run:\n run(cmd)","def test_handle_list(self, mock_uuid):\r\n mock_uuid.uuid4.return_value = \"1\"\r\n project1 = Project(\"GTID1\", [\"a\", \"b\"])\r\n project1.display_name = \"project1\"\r\n project2 = Project(\"GTID2\", [\"c\", \"d\"])\r\n project2.display_name = \"project2\"\r\n self.mock_facade.query.return_value = [project1, project2]\r\n with self.app.app_context():\r\n resp, code = self.testcommand.handle(\"project list\", user)\r\n expect = \\\r\n \"*PROJECT ID : GITHUB TEAM ID : PROJECT NAME*\\n\" \\\r\n \"1 : GTID1 : project1\\n\" \\\r\n \"1 : GTID2 : project2\\n\"\r\n self.assertEqual(resp, expect)\r\n self.assertEqual(code, 200)\r\n self.mock_facade.query.assert_called_once_with(Project)","def test_cell_list_sort_dir_not_passed_without_sort_key(self, mock_list):\n self.shell('cell-list -r 1 --sort-dir desc')\n mock_list.assert_called_once_with()","def test_list_field():","def test_list_user(self):\n pass","def test_command(self):\n output, _error = self.executor.command(['echo', 'hello']).batch()\n self.assertEqual(output, 'hello\\n')","def test_create(self):\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create\")\n self.assertEqual(f.getvalue().strip(), \"** class name missing **\")\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create hello\")\n self.assertEqual(f.getvalue().strip(), \"** class doesn't exist **\")\n for _class in self.clis:\n with patch('sys.stdout', new=StringIO()) as f:\n command = \"create\" + \" \" + _class\n HBNBCommand().onecmd(command)\n _id = f.getvalue().strip()\n key = _class + \".\" + _id\n self.assertTrue(key in storage.all().keys())","async def test_command(self, parser_mock):\n test_cases = (\n (),\n (15, ),\n (MockTextChannel(),),\n (MockTextChannel(), 15),\n )\n\n ctx = MockContext()\n parser_mock.return_value = (ctx.channel, 10)\n\n for case in test_cases:\n with self.subTest(\"Test command converters\", args=case):\n await self.cog.silence.callback(self.cog, ctx, *case)\n\n try:\n first_arg = case[0]\n except IndexError:\n # Default value when the first argument is not passed\n first_arg = None\n\n try:\n second_arg = case[1]\n except IndexError:\n # Default value when the second argument is not passed\n second_arg = 10\n\n parser_mock.assert_called_with(ctx, first_arg, second_arg)","def test_pos_operate_with_list_operations_different_datatypes(self, list, result, bin, expected):\n key = (\"test\", \"demo\", \"list_key\")\n\n key, _, bins = self.as_connection.operate(key, list)\n\n assert bins == result\n\n key, _, bins = self.as_connection.get(key)\n\n assert bins[bin] == expected","def test_help_messsages(mock_db):\n database = sqlite3.connect(mock_db)\n shell = MiniProjectShell(database)\n\n shell.help_book_member()\n shell.help_cancel_booking()\n shell.help_delete_request()\n shell.help_search_requests_lcode()\n shell.help_search_requests_city()\n shell.help_search_rides()\n shell.help_select_request()\n shell.help_post_request()\n shell.help_offer_ride()\n shell.help_list_bookings()\n shell.help_list_requests()\n shell.help_logout()","def test_urllist_command(self):\n # TODO: Write tests for when there is no superuser.\n # This seemed to not work when using this command on PythonAnywhere the first time\n pass","def test_cell_list_sort_dir_asc_success(self, mock_list):\n self.shell('cell-list -r 1 --sort-key name --sort-dir asc')\n mock_list.assert_called_once_with(sort_key='name',\n sort_dir='asc')","def test_process_host_commands(self):\n\n command = [\"df\", \"-h\"]\n output = run(verification.process_host_commands(command))\n self.assertTrue(\"```\\nThat command is not available.```\" not in output)\n\n command = [\"ls\", \"-la\"]\n output = run(verification.process_host_commands(command))\n self.assertEqual(\"```\\nThat command is not available.```\", output)","def list(ctx):\n handler = ValidateCommandHandler(ctx.obj['qa_dir'])\n if handler.validate():\n handler = ListCommandHandler(ctx.obj['qa_dir'])\n handler.show_test_case_tree()\n else:\n exit(1)","def _verifyCommand(self):\n for i in range(3):\n rc = self.subdevice.command_test() # Verify command is correct\n if rc is None:\n break","def test_list(self):\n self.userbase('create', 'alice', 'localhost', SECRET)\n self.userbase('create', 'bob', 'localhost', SECRET)\n output = self.userbase('list')\n self.assertEqual(output, ['alice@localhost', 'bob@localhost'])","def test_pos_operate_with_list_addition_operations(self, list, result, bin, expected):\n key = (\"test\", \"demo\", \"list_key\")\n\n key, _, bins = self.as_connection.operate(key, list)\n\n assert bins == result\n\n key, _, bins = self.as_connection.get(key)\n\n assert bins[bin] == expected","def test_command(self):\n out = io.StringIO()\n management.call_command('import_data', stdout=out)\n self.assertIn(\"Successfully imported\", out.getvalue())"],"string":"[\n \"def test_arg_parser_list(self):\\n args = self.parser.parse_args(['list'])\\n self.assertEqual(args.command, 'list')\",\n \"def test_listCommand(self):\\n acli = ArmiCLI()\\n\\n origout = sys.stdout\\n try:\\n out = io.StringIO()\\n sys.stdout = out\\n acli.listCommands()\\n finally:\\n sys.stdout = origout\\n\\n self.assertIn(\\\"run-suite\\\", out.getvalue())\",\n \"def test_listCommand(self):\\n from armi import cli\\n\\n cli = cli.ArmiCLI()\\n\\n origout = sys.stdout\\n try:\\n out = io.StringIO()\\n sys.stdout = out\\n cli.listCommands()\\n finally:\\n sys.stdout = origout\\n self.assertIn(\\\"run-suite\\\", out.getvalue())\",\n \"def test_list(self):\\n pass\",\n \"def test_list(self):\\n pass\",\n \"def test_device_command_list(self):\\n actual_device_commands = set(self.sim_device.get_command_list()) - {\\\"Init\\\"}\\n expected_command_list = set(\\n self.sim_file_parser.get_device_command_metadata().keys()\\n )\\n self.assertEquals(\\n actual_device_commands,\\n expected_command_list,\\n \\\"The commands specified are not present in the device\\\",\\n )\",\n \"def test_device_command_list(self):\\n default_cmds = helper_module.DEFAULT_TANGO_DEVICE_COMMANDS\\n actual_device_cmds = set(self.sim_device.get_command_list()) - default_cmds\\n expected_cmd_list = self.sim_file_parser.get_device_command_metadata().keys()\\n self.assertEquals(\\n actual_device_cmds,\\n set(expected_cmd_list),\\n \\\"The commands specified in the json file are not present in\\\" \\\" the device\\\",\\n )\",\n \"def test_device_command_list(self):\\n actual_device_cmds = self.sim_device.get_command_list()\\n expected_cmd_list = self.sim_file_parser.get_device_command_metadata().keys()\\n self.assertEquals(\\n set(actual_device_cmds),\\n set(expected_cmd_list),\\n \\\"The commands specified in the fgo file are not present in\\\" \\\" the device\\\",\\n )\",\n \"def list_command(ctx: Any) -> None:\\n pass\",\n \"def test_list(self):\\n parser = parse_args(['-g', '10', '-s', 'bubble', '-l'])\\n self.assertTrue(parser.list)\\n self.assertEqual(True, parser.list)\\n\\n parser = parse_args(['-g', '10', '-s', 'bubble'])\\n self.assertEqual(False, parser.list)\",\n \"def test_list_options(self):\\n pass\",\n \"def cmd_list(args):\",\n \"def do_command(self, args):\\n testops = dbops.Tests()\\n listing = testops.list(args)\\n ordering = ['test_name', 'os_type_name',\\n 'test_command', 'runtime', 'timeout']\\n do_list(listing, ordering)\",\n \"def __init__(self, command_list, ):\\n self.command_list = [] # all addition via function below\\n self.add_command( command_list )\",\n \"def test_status_command(self):\\n # make sure STATUS is a valid command\\n command = Command('STATUS')\\n self.assertTrue(type(command) == Command)\",\n \"def test_lg_commands(self): # noqa\\n # list objects - before creating anything\\n for obj in [command['obj'] for command in self.commands]:\\n out = StringIO()\\n args = ('list', obj)\\n call_command('lg', *args, stdout=out)\\n expect = \\\"No {} configured\\\".format(obj)\\n assert expect in out.getvalue()\\n # add objects\\n for command in self.commands:\\n out = StringIO()\\n args = ('add', command['obj'])\\n opts = command['opts']\\n call_command('lg', *args, stdout=out, **opts)\\n expect = \\\"index: 1\\\"\\n assert expect in out.getvalue()\\n # list objects\\n for obj in [command['obj'] for command in self.commands]:\\n out = StringIO()\\n args = ('list', obj)\\n call_command('lg', *args, stdout=out)\\n expect = \\\"Configured {}\\\".format(obj.capitalize())\\n assert expect in out.getvalue()\\n # modify objects\\n for command in self.commands:\\n args = ('modify', command['obj'])\\n for opt in command['opts']:\\n out = StringIO()\\n opts = {\\\"index\\\": 1, opt: command['opts'][opt]}\\n call_command('lg', *args, stdout=out, **opts)\\n expect = \\\"index: 1\\\"\\n assert expect in out.getvalue()\\n # show created objects\\n for command in self.commands:\\n out = StringIO()\\n args = ('show', command['obj'])\\n call_command('lg', *args, index=1, stdout=out)\\n expect = \\\"index: 1\\\"\\n assert expect in out.getvalue()\\n # delete objects\\n for obj in [command['obj'] for command in self.commands]:\\n out = StringIO()\\n args = ('delete', obj)\\n call_command('lg', *args, index=1, stdout=out)\\n # show deleted objects\\n for command in self.commands:\\n out = StringIO()\\n args = ('show', command['obj'])\\n try:\\n call_command('lg', *args, index=1, stdout=out)\\n except Exception as e:\\n assert isinstance(e, CommandError)\",\n \"def test_multiple_commands_at_same_time(self):\",\n \"def test_get_commands(self):\\n self.installer.os = \\\"amazonLinux\\\"\\n commands = self.installer._get_commands()\\n assert len(commands) > 0\\n self.installer.os = \\\"ubuntu\\\"\\n commands = self.installer._get_commands()\\n assert len(commands) > 0\\n self.installer.os = \\\"does_not_exist\\\"\\n commands = self.installer._get_commands()\\n self.assertEqual(len(commands), 1)\",\n \"def testList(self):\\n def _check(results):\\n self.assertEqual(results[0], [b'testDirectory', b'testRemoveFile',\\n b'testRenameFile', b'testfile1'])\\n self.assertEqual(results[1], [b'testDirectory', b'testRemoveFile',\\n b'testRenameFile', b'testfile1'])\\n self.assertEqual(results[2], [b'testRemoveFile', b'testRenameFile'])\\n self.assertEqual(results[3], [b'.testHiddenFile', b'testRemoveFile',\\n b'testRenameFile'])\\n self.assertEqual(results[4], [b''])\\n d = self.runScript('ls', 'ls ../' + self.testDir.basename(),\\n 'ls *File', 'ls -a *File', 'ls -l testDirectory')\\n d.addCallback(lambda xs: [x.split(b'\\\\n') for x in xs])\\n return d.addCallback(_check)\",\n \"def test_command_finds_commands(self):\\r\\n COMMANDLIST['!toread'] = lambda bmark: bmark\\r\\n\\r\\n bm = BmarkMock()\\r\\n bm.tags['!toread'] = True\\r\\n commander = Commander(bm)\\r\\n commander.build_commands()\\r\\n\\r\\n self.assertTrue(\\r\\n '!toread' in commander.commands,\\r\\n \\\"Our commander should find !toread command to run\\\")\",\n \"def test_importtleCommandExists(self):\\n self.assertIn('importtle', get_commands())\",\n \"def check_commands(self):\\n pass\",\n \"def test_cell_list_success(self, mock_list):\\n self.shell('cell-list -r 1')\\n self.assertTrue(mock_list.called)\",\n \"def test_list_runs(self):\\n pass\",\n \"def test_get_list(self):\\n pass\",\n \"def test_pre_cli_list(run):\\n out, err = run(dork.cli.the_predork_cli, [], *(\\\"\\\", \\\"-l\\\"))\\n assert \\\"test.yml\\\" in out, \\\\\\n \\\"Failed run the dork.cli.the_predork_cli method: {err}\\\"\\\\\\n .format(err=err)\",\n \"def test_command_list(self):\\n from pystarlab.starlab import Story\\n commands = [\\\"makeking -w 1.5 -s 1454677882 -n 5 -i\\\",\\n \\\"makemass -i -l 0.1 -u 20 -s 1454677882\\\"]\\n\\n mass_output = \\\"mass.out\\\"\\n\\n mass_path = os.path.join(DATA_DIR, mass_output)\\n with open(mass_path, 'r') as f:\\n mass_str = f.read()\\n\\n mass_story = Story.from_command_list(commands)\\n for line in zip(mass_str.splitlines(),\\n str(mass_story).splitlines()):\\n string_with_date = re.match(\\\"^ ===>\\\",line[0])\\n if not string_with_date:\\n self.assertEquals(line[0], line[1])\",\n \"def test_stratis_list_default(self):\\n for subcommand in [[\\\"pool\\\"], [\\\"filesystem\\\"], [\\\"blockdev\\\"]]:\\n for prefix in [[], [\\\"--propagate\\\"]]:\\n self.assertEqual(RUNNER(prefix + subcommand), 0)\",\n \"def getCommands(self):\",\n \"def processCommandList():\\n\\n try:\\n # Assume that maya.cmds.about and maya.cmds.internalVar are already registered\\n #\\n commandListPath = os.path.realpath( os.environ[ 'MAYA_LOCATION' ] )\\n platform = maya.cmds.about( os=True )\\n commandListPath = os.path.join( commandListPath, commandListLocations[platform], 'commandList' )\\n\\n file = open( commandListPath, 'r' )\\n for line in file:\\n commandName, library = line.split()\\n if not commandName in maya.cmds.__dict__:\\n maya.cmds.__dict__[commandName] = __makeStubFunc( commandName, library )\\n except:\\n sys.stderr.write(\\\"Unable to process commandList %s\\\" % commandListPath)\\n raise\",\n \"def test_features(self):\\n assert list(parser.generate_commands(yaml.load(\\n '- my_command: {name: my_name}'))) == [('my_command', {'name': 'my_name'})]\",\n \"def test_run_command(self):\\n self.build()\\n self.data_formatter_commands()\",\n \"def test_command_method_exists(self):\\n motor_shield = MotorShield(self.options, self.connection)\\n\\n for command in motor_shield.commands:\\n self.assertIn(command, dir(motor_shield))\",\n \"def test_cell_list_parse_param_success(self, mock_list):\\n self.shell('cell-list -r 1 --limit 0')\\n self.assertTrue(mock_list.called)\",\n \"def test_get_operations_list_with_correct_data(self):\\n ops = self.client.get_operations_list(self.agent_id)\\n self.assertIsInstance(ops, list)\",\n \"def test_list(self):\\n output, _err = self.executor.prepare('chat', 'mention', person=['emett', 'lucy']).batch()\\n self.assertEqual(output, 'mentioning folks')\",\n \"async def test_commands(aresponses):\\n aresponses.add(\\n MATCH_HOST,\\n \\\"/api/command\\\",\\n \\\"GET\\\",\\n aresponses.Response(\\n status=200,\\n headers={\\\"Content-Type\\\": \\\"application/json\\\"},\\n text=load_fixture(\\\"command.json\\\"),\\n ),\\n )\\n\\n async with ClientSession() as session:\\n client = Sonarr(HOST, API_KEY, session=session)\\n response = await client.commands()\\n\\n assert response\\n assert isinstance(response, List)\\n\\n assert response[0]\\n assert isinstance(response[0], models.CommandItem)\",\n \"def commands():\",\n \"def create_command_list(device):\\n command = XmlApiObject({})\\n command.name = \\\"test\\\"\\n device.commands[command.name] = command\",\n \"def test_cell_list_detail_success(self, mock_list):\\n self.shell('cell-list -r 1 --detail')\\n mock_list.assert_called_once_with(detail=True)\",\n \"def test_message_list():\",\n \"def process_commands(self, commands: List[str]):\",\n \"def run(self, commands: list[str]):\\n ...\",\n \"def cmd(self):\",\n \"async def list(self, *args, **kwargs):\\n return f\\\"Command list: {', '.join(self.get_commands())}\\\"\",\n \"def test_command(self):\\n\\n expected = \\\"PyFunceble has been written by Fun Ilrys.\\\"\\n actual = Command(\\\"echo '%s'\\\" % expected).execute()\\n\\n self.assertEqual(expected + \\\"\\\\n\\\", actual)\",\n \"def test_handle_multiple_subcommands(self):\\r\\n ret, code = self.testcommand.handle(\\\"project list edit\\\", user)\\r\\n self.assertEqual(ret, self.testcommand.get_help())\\r\\n self.assertEqual(code, 200)\",\n \"def main_list(args):\\n return list_commands(args.directory)\",\n \"def _commands(self) -> Dict[str, List[str]]:\\r\\n pass\",\n \"def test_handle_multiple_subcommands(self):\\n ret, code = self.testcommand.handle(\\\"team list edit\\\", user)\\n self.assertEqual(ret, self.testcommand.get_help())\\n self.assertEqual(code, 200)\",\n \"def test_explicitListHelp(self):\\n self.assertSuccessStatus(self._makeConfig(None), [\\\"list\\\", \\\"--help\\\"])\\n self.assertSpacelessEqual(self._listHelpText, sys.stdout.getvalue())\",\n \"def test_by_order(self):\\n # addon_executor = AddonExecutor(execute_order, stop_order)\\n # self.assertEqual(expected, addon_executor.execute_with_order(addon, execute_order, stop_order))\\n self.run_mgr.by_order(self.cli_inst, ['execute', 'start'], ['stop'])\\n output = self._get_lines_as_list(sys.stdout)\\n\\n self.assertTrue(output[0].startswith('Execute'))\\n self.assertTrue(output[1].startswith('Start'))\\n self.assertTrue(output[2].startswith('Stop'))\",\n \"def test_get_help(self):\\r\\n subcommands = list(self.testcommand.subparser.choices.keys())\\r\\n help_message = self.testcommand.get_help()\\r\\n self.assertEqual(len(subcommands), help_message.count(\\\"usage\\\"))\",\n \"def test_build_command(self):\\n actual_result = IperfServerCommandBuilder().build_server_command()\\n self.assertListEqual(actual_result, ['iperf', '-s'])\",\n \"def __init__(self, command_list: list = None) -> None:\\n if command_list is None:\\n command_list = implemented_commands\\n for command in command_list:\\n setattr(self, command.get(\\\"name\\\").replace(\\\" \\\", \\\"_\\\"), self._SingleCommand(command))\",\n \"def do_list_commands(self):\\n result = \\\"\\\\n\\\".join(self.commands.keys())\\n return result, True\",\n \"def test_ssh_cmd(self):\\n self.assertEqual(general.ssh_command('user','example.com',('ls','-l')).command_line,\\n ['ssh','user@example.com','ls','-l'])\",\n \"def test_get_help(self):\\n subcommands = list(self.testcommand.subparser.choices.keys())\\n help_message = self.testcommand.get_help()\\n self.assertEqual(len(subcommands), help_message.count(\\\"usage\\\"))\",\n \"def test_cell_list_sort_dir_desc_success(self, mock_list):\\n self.shell('cell-list -r 1 --sort-key name --sort-dir desc')\\n mock_list.assert_called_once_with(sort_key='name',\\n sort_dir='desc')\",\n \"def commands():\\n pass\",\n \"def commands():\\n pass\",\n \"def commands():\\n pass\",\n \"def commands():\\n pass\",\n \"def test_all(self):\\n _help = \\\"[Usage: all <class name>]or [Usage: all] or \\\"\\\\\\n \\\"[Usage: <class name>.all()]\\\\n\\\"\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"help all\\\")\\n self.assertEqual(f.getvalue(), _help)\",\n \"def test_by_config(self):\\n # addon_executor = AddonExecutor(execute_order, stop_order)\\n # self.assertEqual(expected, addon_executor.execute_with_config(addon))\\n\\n self.run_mgr.by_default(self.cli_inst)\\n output = self._get_lines_as_list(sys.stdout)\\n\\n self.assertTrue(output[0].startswith('Start'))\\n self.assertTrue(output[1].startswith('Execute'))\\n self.assertTrue(output[2].startswith('Stop'))\",\n \"def command_list(self, command):\\n\\n # See if the list exists and return results\\n if len(command.args) > 0 and command.args[0] in LISTS:\\n resp = []\\n\\n\\n # Print out our available machines\\n if command.args[0] == \\\"machines\\\":\\n # Loop over controllers\\n for c in self.config_list:\\n\\n # Get updated list of machiens\\n self.config_list[c].get_machines()\\n\\n # Print output\\n machines_tmp = self.config_list[c].machines\\n\\n resp.append(\\\"--- %s\\\" % c)\\n for x in machines_tmp:\\n name = machines_tmp[x].config.name\\n m_type = machines_tmp[x].type\\n profile = machines_tmp[x].config.volatility_profile\\n resp.append(\\\" [%s] Type: %s, Profile: %s\\\" % (\\n name, m_type, profile))\\n resp.append(\\\"--- %s\\\" % c)\\n\\n # Print out our LO-PHI configs\\n if command.args[0] == \\\"controllers\\\":\\n\\n if len(self.config_list) == 0:\\n resp.append(\\\"No controllers are configured.\\\")\\n else:\\n resp.append(\\\"--- Available Controllers\\\")\\n for x in self.config_list:\\n resp.append(str(self.config_list[x]))\\n resp.append(\\\"--- Available Controllers\\\")\\n\\n # Print out our running analyses\\n if command.args[0] == \\\"analysis\\\":\\n\\n # Ensure our list\\n self.update_analysis()\\n\\n # Loop over controllers\\n for c in self.analysis_list:\\n analysis, filename = self.analysis_list[c]\\n\\n resp.append(\\\"\\\\n[%s] %s\\\" % (c, filename))\\n\\n if len(resp) == 0:\\n resp.append(\\n \\\"No analysis scripts found in %s.\\\" % self.analysis_directory)\\n\\n return '\\\\n'.join(resp)\\n\\n else:\\n return self.RESP_HEADER + \\\"ERROR: No such list.\\\\n Available lists are: %s\\\\n\\\" % LISTS\",\n \"def test_commands_initialization(bot):\\n plugin = Commands(bot)\\n assert isinstance(plugin, Commands)\\n assert plugin.bot == bot\",\n \"def test_all(self):\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create User\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create State\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create City\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create Amenity\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create Place\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create Review\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"all\\\")\\n self.assertTrue(\\\"[User]\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"[State]\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"[City]\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"[Amenity]\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"[Place]\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"[Review]\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"created_at\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"updated_at\\\" in f.getvalue().strip())\\n self.assertTrue(\\\"id\\\" in f.getvalue().strip())\",\n \"def run_command_check(self):\\n pass\",\n \"def test_list_group(self):\\n pass\",\n \"def setUp(self):\\r\\n self.saved_commandlist = COMMANDLIST\\r\\n for key in COMMANDLIST.keys():\\r\\n del(COMMANDLIST[key])\",\n \"def test_command():\\n\\n dispatcher = ntelebot.dispatch.Dispatcher()\\n dispatcher.add_command('command', lambda ctx: 'DISPATCHED')\\n ctx = MockContext()\\n ctx.type = 'message'\\n ctx.command = None\\n assert dispatcher(ctx) is False\\n ctx.command = 'command'\\n assert dispatcher(ctx) == 'DISPATCHED'\\n ctx.type = 'callback_query'\\n assert dispatcher(ctx) == 'DISPATCHED'\\n ctx.type = 'inline_query'\\n assert dispatcher(ctx) is False\",\n \"def test_module(client: Client, args: Dict[str, Any]) -> str:\\n client.get_lists()\\n return 'ok'\",\n \"def test_client_list(self):\\n pass\",\n \"def command_list(arguments):\\n global current_mode\\n current_mode = Mode.list\\n #current_entity.addlink(arguments[0], arguments[1])\\n return 'Now listing all entities'\",\n \"def test_fixture_list_runs(tmp_sample_project):\\n config_dir = tmp_sample_project\\n output = subprocess.run([\\\"smif\\\", \\\"list\\\", \\\"-d\\\", config_dir], stdout=subprocess.PIPE)\\n assert \\\"energy_water_cp_cr\\\" in str(output.stdout)\\n assert \\\"energy_central\\\" in str(output.stdout)\\n\\n # Run energy_central and re-check output with optional flag for completed results\\n subprocess.run([\\\"smif\\\", \\\"run\\\", \\\"energy_central\\\", \\\"-d\\\", config_dir], stdout=subprocess.PIPE)\\n output = subprocess.run([\\\"smif\\\", \\\"list\\\", \\\"-c\\\", \\\"-d\\\", config_dir], stdout=subprocess.PIPE)\\n assert \\\"energy_central *\\\" in str(output.stdout)\",\n \"def testCmdFilterCompleter(self):\\n\\n self.inv.ATTRIBUTES = ['apple', 'pear']\\n self.assertEqual(self.inv.ATTRIBUTES[0],\\n self.inv._CmdFilterCompleter([''], 0))\\n self.assertEqual(self.inv.ATTRIBUTES[1],\\n self.inv._CmdFilterCompleter([''], 1))\\n self.assertEqual(\\n None, self.inv._CmdFilterCompleter([''], len(self.inv.ATTRIBUTES)))\\n self.assertEqual('pear', self.inv._CmdFilterCompleter(['p'], 0))\\n self.assertEqual(None, self.inv._CmdFilterCompleter(['p', 'bogus'], 0))\",\n \"async def list_command(ctx, cmd:str=False):\\n if cmd == False: # for quick list of commands\\n ls = await get_quick_list(ctx)\\n await ctx.send(embed=ls)\\n if cmd == \\\"all\\\" or cmd == \\\"commands\\\":\\n ls = await get_list(ctx.message.author, 1)\\n sent_list = await ctx.send(embed=ls)\\n await sent_list.add_reaction(EMOJI_FAST_REVERSE)\\n await sent_list.add_reaction(EMOJI_LEFT_ARROW)\\n await sent_list.add_reaction(EMOJI_RIGHT_ARROW)\\n await sent_list.add_reaction(EMOJI_FAST_FORWARD)\\n elif cmd == \\\"states\\\":\\n states_list = await get_state_list()\\n list = assemble_embed(\\n title=\\\"List of all states\\\",\\n desc=\\\"\\\\n\\\".join([f\\\"`{state}`\\\" for state in states_list])\\n )\\n await ctx.send(embed=list)\\n elif cmd == \\\"events\\\":\\n events_list = [r['eventName'] for r in EVENT_INFO]\\n list = assemble_embed(\\n title=\\\"List of all events\\\",\\n desc=\\\"\\\\n\\\".join([f\\\"`{name}`\\\" for name in events_list])\\n )\\n await ctx.send(embed=list)\",\n \"def get_commands(bot):\\n new_commands = []\\n\\n new_commands.append(Command(\\n 'mycommand', subcommands=[\\n SubCommand(\\n Opt('myoption'),\\n doc='This is a simple command with a single required option.'),\\n SubCommand(\\n Opt('custom', optional=True),\\n Opt('attached', optional=True, attached='attached argument'),\\n doc='This has two different optional options, one without an attached '\\n 'parameter, and the other requiring an attached parameter.'),\\n SubCommand(\\n Opt('trailing'),\\n Arg('arg 1'),\\n Arg('arg 2'),\\n Arg('arg 3', argtype=ArgTypes.SPLIT, additional='more args'),\\n doc='This command requires a lot of trailing arguments.'),\\n SubCommand(\\n Opt('grouped'),\\n Arg('grouped arguments', argtype=ArgTypes.MERGED),\\n doc='This will group all given arguments as a single string.'),\\n SubCommand(\\n Opt('complex', attached='attached'),\\n Opt('other', optional=True, attached='also required'),\\n Arg('arg 1'),\\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL, additional='more args'),\\n doc='The complex option has a required attached parameter, and the '\\n '\\\\'other\\\\' option also has a required attached parameter if '\\n '\\\\'other\\\\' is included. Additionally, there will be a requirement '\\n 'of at least 1 trailing argument.'),\\n SubCommand(\\n Opt('marquee'),\\n Arg('text', argtype=ArgTypes.MERGED,\\n check=lambda b, m, v, *a: len(v) <= 100,\\n check_error=\\\"Marquee message must be less than 100 characters long.\\\"),\\n doc='Creates a marquee that loops 3 times.')],\\n shortcuts=[\\n Shortcut(\\n 'complex', 'complex {attached} other {other} {arg 1} {arg 2}',\\n Arg('attached'), Arg('other'), Arg('arg 1'),\\n Arg('arg 2', argtype=ArgTypes.SPLIT_OPTIONAL)),\\n Shortcut(\\n 'marquee', 'marquee {text}', Arg('text', argtype=ArgTypes.MERGED))],\\n description='Your command description here.',\\n other='This text is optional - it just shows up after everything '\\n 'else. Quick note, all of the commands here can only be used by '\\n 'bot moderators or above, as indicated by elevated_level. A '\\n 'level of 2 would mean only server owners or above can use the '\\n 'command, and a level of 3 would restrict the command to only '\\n 'the bot owners.',\\n elevated_level=1, category='demo'))\\n\\n new_commands.append(Command(\\n 'myothercommand', subcommands=[\\n SubCommand(\\n Arg('text', argtype=ArgTypes.MERGED_OPTIONAL),\\n doc='This traps all further commands from being executed.'),\\n SubCommand(\\n Opt('order'), Opt('matters'),\\n doc='It is impossible to access this command because the first '\\n 'subcommand will always be satisfied first. Order of the '\\n 'subcommand matters!'),\\n SubCommand(\\n Opt('sample'), Opt('foo'), Opt('bar'),\\n doc='Also impossible to access. This subcommand just adds some '\\n 'keywords to the command.')],\\n description='Only bot owners can see this text!',\\n other='Note that no shortcuts were defined. They, too, are optional. '\\n 'Also, this command is hidden, which means that only the bot '\\n 'owners can see this command listed from the help command. '\\n 'However, unless the command is configured with an elevated '\\n 'permissions level, any user can still execute the command. '\\n 'Users still will not be able to see the specific help for this '\\n 'command, though. Lastly, this command is disabled in DMs.',\\n hidden=True, allow_direct=False, category='demo'))\\n\\n new_commands.append(Command(\\n 'notify', subcommands=[\\n SubCommand(\\n Arg('text', argtype=ArgTypes.MERGED),\\n doc='Notify the owners with some text!')],\\n other='This command uses a custom function. It is called with the '\\n 'same arguments as get_response. The command will show up to '\\n 'all users in the help command, but can only be used by server '\\n 'owners, as it is disallowed in direct messages.',\\n elevated_level=2, allow_direct=False, function=custom_notify,\\n category='demo'))\\n\\n new_commands.append(Command(\\n 'wait', other='Use this command to demo the wait_for functionality', category='demo'))\\n\\n return new_commands\",\n \"def commands(self) -> List[Command]:\\n return []\",\n \"def test_pos_operate_with_list_remove_operations(self, list, bin, expected):\\n key = (\\\"test\\\", \\\"demo\\\", \\\"list_key\\\")\\n\\n self.as_connection.operate(key, list)\\n\\n key, _, bins = self.as_connection.get(key)\\n\\n assert bins[bin] == expected\",\n \"def test_list_composition_status(self):\\n pass\",\n \"def _run_commands(self, command_list):\\n for cmd in command_list:\\n print(cmd)\\n if not self.dry_run:\\n run(cmd)\",\n \"def test_handle_list(self, mock_uuid):\\r\\n mock_uuid.uuid4.return_value = \\\"1\\\"\\r\\n project1 = Project(\\\"GTID1\\\", [\\\"a\\\", \\\"b\\\"])\\r\\n project1.display_name = \\\"project1\\\"\\r\\n project2 = Project(\\\"GTID2\\\", [\\\"c\\\", \\\"d\\\"])\\r\\n project2.display_name = \\\"project2\\\"\\r\\n self.mock_facade.query.return_value = [project1, project2]\\r\\n with self.app.app_context():\\r\\n resp, code = self.testcommand.handle(\\\"project list\\\", user)\\r\\n expect = \\\\\\r\\n \\\"*PROJECT ID : GITHUB TEAM ID : PROJECT NAME*\\\\n\\\" \\\\\\r\\n \\\"1 : GTID1 : project1\\\\n\\\" \\\\\\r\\n \\\"1 : GTID2 : project2\\\\n\\\"\\r\\n self.assertEqual(resp, expect)\\r\\n self.assertEqual(code, 200)\\r\\n self.mock_facade.query.assert_called_once_with(Project)\",\n \"def test_cell_list_sort_dir_not_passed_without_sort_key(self, mock_list):\\n self.shell('cell-list -r 1 --sort-dir desc')\\n mock_list.assert_called_once_with()\",\n \"def test_list_field():\",\n \"def test_list_user(self):\\n pass\",\n \"def test_command(self):\\n output, _error = self.executor.command(['echo', 'hello']).batch()\\n self.assertEqual(output, 'hello\\\\n')\",\n \"def test_create(self):\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create\\\")\\n self.assertEqual(f.getvalue().strip(), \\\"** class name missing **\\\")\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create hello\\\")\\n self.assertEqual(f.getvalue().strip(), \\\"** class doesn't exist **\\\")\\n for _class in self.clis:\\n with patch('sys.stdout', new=StringIO()) as f:\\n command = \\\"create\\\" + \\\" \\\" + _class\\n HBNBCommand().onecmd(command)\\n _id = f.getvalue().strip()\\n key = _class + \\\".\\\" + _id\\n self.assertTrue(key in storage.all().keys())\",\n \"async def test_command(self, parser_mock):\\n test_cases = (\\n (),\\n (15, ),\\n (MockTextChannel(),),\\n (MockTextChannel(), 15),\\n )\\n\\n ctx = MockContext()\\n parser_mock.return_value = (ctx.channel, 10)\\n\\n for case in test_cases:\\n with self.subTest(\\\"Test command converters\\\", args=case):\\n await self.cog.silence.callback(self.cog, ctx, *case)\\n\\n try:\\n first_arg = case[0]\\n except IndexError:\\n # Default value when the first argument is not passed\\n first_arg = None\\n\\n try:\\n second_arg = case[1]\\n except IndexError:\\n # Default value when the second argument is not passed\\n second_arg = 10\\n\\n parser_mock.assert_called_with(ctx, first_arg, second_arg)\",\n \"def test_pos_operate_with_list_operations_different_datatypes(self, list, result, bin, expected):\\n key = (\\\"test\\\", \\\"demo\\\", \\\"list_key\\\")\\n\\n key, _, bins = self.as_connection.operate(key, list)\\n\\n assert bins == result\\n\\n key, _, bins = self.as_connection.get(key)\\n\\n assert bins[bin] == expected\",\n \"def test_help_messsages(mock_db):\\n database = sqlite3.connect(mock_db)\\n shell = MiniProjectShell(database)\\n\\n shell.help_book_member()\\n shell.help_cancel_booking()\\n shell.help_delete_request()\\n shell.help_search_requests_lcode()\\n shell.help_search_requests_city()\\n shell.help_search_rides()\\n shell.help_select_request()\\n shell.help_post_request()\\n shell.help_offer_ride()\\n shell.help_list_bookings()\\n shell.help_list_requests()\\n shell.help_logout()\",\n \"def test_urllist_command(self):\\n # TODO: Write tests for when there is no superuser.\\n # This seemed to not work when using this command on PythonAnywhere the first time\\n pass\",\n \"def test_cell_list_sort_dir_asc_success(self, mock_list):\\n self.shell('cell-list -r 1 --sort-key name --sort-dir asc')\\n mock_list.assert_called_once_with(sort_key='name',\\n sort_dir='asc')\",\n \"def test_process_host_commands(self):\\n\\n command = [\\\"df\\\", \\\"-h\\\"]\\n output = run(verification.process_host_commands(command))\\n self.assertTrue(\\\"```\\\\nThat command is not available.```\\\" not in output)\\n\\n command = [\\\"ls\\\", \\\"-la\\\"]\\n output = run(verification.process_host_commands(command))\\n self.assertEqual(\\\"```\\\\nThat command is not available.```\\\", output)\",\n \"def list(ctx):\\n handler = ValidateCommandHandler(ctx.obj['qa_dir'])\\n if handler.validate():\\n handler = ListCommandHandler(ctx.obj['qa_dir'])\\n handler.show_test_case_tree()\\n else:\\n exit(1)\",\n \"def _verifyCommand(self):\\n for i in range(3):\\n rc = self.subdevice.command_test() # Verify command is correct\\n if rc is None:\\n break\",\n \"def test_list(self):\\n self.userbase('create', 'alice', 'localhost', SECRET)\\n self.userbase('create', 'bob', 'localhost', SECRET)\\n output = self.userbase('list')\\n self.assertEqual(output, ['alice@localhost', 'bob@localhost'])\",\n \"def test_pos_operate_with_list_addition_operations(self, list, result, bin, expected):\\n key = (\\\"test\\\", \\\"demo\\\", \\\"list_key\\\")\\n\\n key, _, bins = self.as_connection.operate(key, list)\\n\\n assert bins == result\\n\\n key, _, bins = self.as_connection.get(key)\\n\\n assert bins[bin] == expected\",\n \"def test_command(self):\\n out = io.StringIO()\\n management.call_command('import_data', stdout=out)\\n self.assertIn(\\\"Successfully imported\\\", out.getvalue())\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7797336","0.7349881","0.72588724","0.72235614","0.72235614","0.7143625","0.71298486","0.70965886","0.68910056","0.68389577","0.68290025","0.6811658","0.67939836","0.6771567","0.6757199","0.6725292","0.669489","0.6669298","0.65990645","0.6597851","0.65958035","0.6583955","0.65660274","0.65395635","0.6505553","0.65003735","0.6419058","0.6402709","0.64012617","0.63994175","0.63962257","0.6392748","0.6364211","0.634117","0.63106096","0.62942815","0.6291537","0.6274508","0.62677115","0.6254878","0.6234891","0.6227068","0.6207709","0.62004614","0.61977094","0.6175494","0.6150312","0.6150147","0.6149139","0.61479616","0.6139432","0.6128833","0.61262965","0.61197233","0.61174405","0.61156577","0.6112326","0.60984534","0.60870653","0.6066461","0.6066461","0.6066461","0.6066461","0.6053175","0.6046221","0.60416365","0.60383177","0.6034744","0.6019508","0.60174733","0.6015298","0.6013549","0.59997135","0.59965855","0.59920824","0.5973555","0.5973297","0.5971835","0.5970176","0.59680456","0.5955228","0.59523284","0.5949346","0.5944837","0.59411436","0.59341717","0.5929362","0.59245265","0.59167993","0.59137124","0.5912473","0.59112436","0.5909285","0.59014714","0.58988047","0.5895717","0.58887064","0.58846915","0.58796275","0.5876413"],"string":"[\n \"0.7797336\",\n \"0.7349881\",\n \"0.72588724\",\n \"0.72235614\",\n \"0.72235614\",\n \"0.7143625\",\n \"0.71298486\",\n \"0.70965886\",\n \"0.68910056\",\n \"0.68389577\",\n \"0.68290025\",\n \"0.6811658\",\n \"0.67939836\",\n \"0.6771567\",\n \"0.6757199\",\n \"0.6725292\",\n \"0.669489\",\n \"0.6669298\",\n \"0.65990645\",\n \"0.6597851\",\n \"0.65958035\",\n \"0.6583955\",\n \"0.65660274\",\n \"0.65395635\",\n \"0.6505553\",\n \"0.65003735\",\n \"0.6419058\",\n \"0.6402709\",\n \"0.64012617\",\n \"0.63994175\",\n \"0.63962257\",\n \"0.6392748\",\n \"0.6364211\",\n \"0.634117\",\n \"0.63106096\",\n \"0.62942815\",\n \"0.6291537\",\n \"0.6274508\",\n \"0.62677115\",\n \"0.6254878\",\n \"0.6234891\",\n \"0.6227068\",\n \"0.6207709\",\n \"0.62004614\",\n \"0.61977094\",\n \"0.6175494\",\n \"0.6150312\",\n \"0.6150147\",\n \"0.6149139\",\n \"0.61479616\",\n \"0.6139432\",\n \"0.6128833\",\n \"0.61262965\",\n \"0.61197233\",\n \"0.61174405\",\n \"0.61156577\",\n \"0.6112326\",\n \"0.60984534\",\n \"0.60870653\",\n \"0.6066461\",\n \"0.6066461\",\n \"0.6066461\",\n \"0.6066461\",\n \"0.6053175\",\n \"0.6046221\",\n \"0.60416365\",\n \"0.60383177\",\n \"0.6034744\",\n \"0.6019508\",\n \"0.60174733\",\n \"0.6015298\",\n \"0.6013549\",\n \"0.59997135\",\n \"0.59965855\",\n \"0.59920824\",\n \"0.5973555\",\n \"0.5973297\",\n \"0.5971835\",\n \"0.5970176\",\n \"0.59680456\",\n \"0.5955228\",\n \"0.59523284\",\n \"0.5949346\",\n \"0.5944837\",\n \"0.59411436\",\n \"0.59341717\",\n \"0.5929362\",\n \"0.59245265\",\n \"0.59167993\",\n \"0.59137124\",\n \"0.5912473\",\n \"0.59112436\",\n \"0.5909285\",\n \"0.59014714\",\n \"0.58988047\",\n \"0.5895717\",\n \"0.58887064\",\n \"0.58846915\",\n \"0.58796275\",\n \"0.5876413\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81857985"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88374,"cells":{"query":{"kind":"string","value":"Test the Command.execute method"},"document":{"kind":"string","value":"def test_Command_execute(Popen, out):\n from paradrop.confd.command import Command\n\n proc = MagicMock()\n proc.stdout = [\"output\"]\n proc.stderr = [\"error\"]\n Popen.return_value = proc\n\n command = Command([\"callme\"])\n command.parent = MagicMock()\n\n command.execute()\n assert out.verbose.called_once_with(\"callme: output\")\n assert out.verbose.called_once_with(\"callme: error\")\n assert command.parent.executed.append.called\n\n Popen.side_effect = Exception(\"Boom!\")\n command.execute()\n assert out.info.called"},"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 execute():\n pass","def test_command(self):\n output, _error = self.executor.command(['echo', 'hello']).batch()\n self.assertEqual(output, 'hello\\n')","def execute_command(self):\n raise Exception(\"Not implemented\")","def test_command(self):\n\n expected = \"PyFunceble has been written by Fun Ilrys.\"\n actual = Command(\"echo '%s'\" % expected).execute()\n\n self.assertEqual(expected + \"\\n\", actual)","def execute():","def execute(self):\n pass","def execute(self):\n pass","def execute(self):\n pass","def execute(self):\n pass","def execute(self):\n pass","def execute(self):\n pass","def execute(self):\r\n pass","def execute(self):\n\t\tpass","def execute(cmd_string):\n pass","def test_execute(self):\n with patch('command_executor.subprocess.Popen') as mock_subproc_popen:\n communicate_mock = Mock()\n attrs = {'communicate.return_value': (OUTPUT_RESULT,\n OK_MESSAGE),\n 'returncode': OK_RETURN_CODE}\n communicate_mock.configure_mock(**attrs)\n mock_subproc_popen.return_value = communicate_mock\n actual_result = BaseCommandExecutor(COMMAND).to_execute()\n self.assertIs(actual_result.error, OK_MESSAGE)\n self.assertIs(actual_result.exit_code, OK_RETURN_CODE)\n self.assertMultiLineEqual(actual_result.output,\n EXECUTE_EXPECTED_RESULT)","def execute(self):\n\n pass","def execute(self):\n\n pass","def execute(self):\n\n pass","def execute(self):\n\n pass","def execute_command(self, command):\n raise NotImplementedError","def execute(arg):\n print('Invalid command!!!')\n return","def execute(self, args):","def execute_test(self):\n try:\n self._execute()\n except Exception as ex:\n self._fail(exception=ex)\n raise","def _execute_test_cmd(self):\n\n self.log.info('-' * 80)\n self.log.info('Execute test command line')\n\n code, out = cmd_exec(self._cmd, shell=False, log=self.log)\n if code:\n self.log.error(out)\n return False\n\n self.log.info(out)\n return True","def _execute(self, _):\r\n pass","def execute(self):","def execute(self):","def execute(self):","def execute(self):","def Execute(self):\n return True","def execute(self, args):\r\n pass","def test_command(self):\n out = io.StringIO()\n management.call_command('import_data', stdout=out)\n self.assertIn(\"Successfully imported\", out.getvalue())","def execute(self):\n raise NotImplementedError","def execute(self):\n raise NotImplementedError","def execute(self, *args, **kwargs):","def execute(self, *args, **kwargs):","def execute(self, *args, **kwargs):\n pass","def execute(cls):\n pass","def execute(self):\n raise NotImplementedError('execute')","def test_execute(self):\n with patch('command_executor.subprocess.Popen') as mock_subproc_popen:\n communicate_mock = Mock()\n attrs = {'communicate.return_value': (OUTPUT_RESULT,\n OK_MESSAGE),\n 'returncode': OK_RETURN_CODE}\n communicate_mock.configure_mock(**attrs)\n mock_subproc_popen.return_value = communicate_mock\n actual_result = IperfCommandExecutor(COMMAND).to_execute()\n self.assertIs(actual_result.error, OK_MESSAGE)\n self.assertIs(actual_result.exit_code, OK_RETURN_CODE)\n self.assertDictEqual(actual_result.output,\n IPERF_PARSER_EXPECTED_RESULT)","def test_execute(self):\n context = dict()\n cmd = pycell.python_cell(\n source='print(2+2)',\n validate=True\n )\n controller = FakeWorkflowController()\n self.backend.execute_async(\n task=TaskHandle(\n task_id='000',\n project_id=self.PROJECT_ID,\n controller=controller\n ),\n command=cmd,\n artifacts=context\n )\n time.sleep(3)\n self.assertEqual(controller.task_id, '000')\n self.assertEqual(controller.state, 'SUCCESS')\n self.assertEqual(controller.outputs.stdout[0].value, '4')","def test_execute_with_context(self):\n pass","def test_sendCommand(self):\n self.p.sendCommand(\"CMD\", (\"param1\", \"param2\"))\n self.check(\"CMD param1 param2\\r\\n\")","def execute_command(self):\n return ''","def test_multiple_commands_at_same_time(self):","def run_command_check(self):\n pass","def _execute_command(self, cmd):\n LOG.info(\"Executing: %s\" % cmd)\n status, stdout, stderr = self.client.execute(cmd)\n if status:\n raise RuntimeError(\"Failed executing command: \",\n cmd, stderr)\n return stdout","def _execute_impl(self, commands):\n raise NotImplementedError(\"abstract method\")","def execute(self) -> None:\n raise NotImplementedError","def test_run_command(self):\n self.build()\n self.data_formatter_commands()","def execute(self) :\n \n raise NotImplementedError()","def test_valid_python_execute(self):\n\n data_file = testutils.DataFile(\"integration_module_valid_mod\")\n\n rtn = self.run_cmd(\"pm install --force --single module --install_name test_execute --name %s --auto\" % str(data_file))\n assert(rtn.return_code == 0)\n\n rtn = self.run_cmd(\"test_execute\")\n\n assert(rtn.return_code == 0)","def test_status_command(self):\n # make sure STATUS is a valid command\n command = Command('STATUS')\n self.assertTrue(type(command) == Command)","def test_exec(self):\n self.database.addUser(\n getpass.getuser(), 'secret', os.getuid(), 1234, 'foo', 'bar',\n sys.executable)\n\n d = self.client._dispatchCommand(\"exec print(1 + 2)\")\n d.addCallback(self.assertEqual, b\"3\\n\")\n return d","def runCommand(command):\n None","def _execute(self, cmd):\r\n stdout, stderr, return_code = self._remote_client.run_remote_cmd(cmd)\r\n if return_code:\r\n raise exceptions.ArgusError(\r\n \"Command {command!r} failed with \"\r\n \"return code {return_code!r}\"\r\n .format(command=cmd,\r\n return_code=return_code))\r\n return stdout, stderr","def execute(self):\n raise NotImplementedError('You must implement the execute() method '\n 'yourself!')","def execute(*args):","def _execute_command(\n cls,\n connection_info: misc_utils.ConnectionInfo,\n search_info: misc_utils.SearchInfo,\n command_name: str,\n arguments: List[str],\n ):\n dictionary, ip_address, port = tuple(connection_info)\n is_printing_list, ids, components, search, json = tuple(search_info)\n\n search_filter = cls._get_search_filter(ids, components, search, json)\n if is_printing_list:\n cls._log(cls._list_all_possible_items(dictionary, search_filter, json))\n return\n\n # ======================================================================\n pipeline, api = test_api_utils.initialize_test_api(\n dictionary, server_ip=ip_address, server_port=port\n )\n # ======================================================================\n\n try:\n api.send_command(command_name, arguments)\n except KeyError:\n cls._log(\"'%s' is not a known command\" % (command_name))\n close_matches = CommandSendCommand.get_closest_commands(\n pipeline.dictionaries, command_name\n )\n if close_matches:\n cls._log(\"Similar known commands: {}\".format(close_matches))\n except NotInitializedException:\n temp = CommandSendCommand.get_command_template(\n pipeline.dictionaries, command_name\n )\n cls._log(\n \"'%s' requires %d arguments (%d given)\"\n % (command_name, len(temp.get_args()), len(arguments))\n )\n cls._log(cls.get_command_help_message(pipeline.dictionaries, command_name))\n except CommandArgumentsException as err:\n cls._log(\"Invalid arguments given; %s\" % (str(err)))\n cls._log(cls.get_command_help_message(pipeline.dictionaries, command_name))\n\n # ======================================================================\n pipeline.disconnect()\n api.teardown()\n # ======================================================================","def runCommand(self): \\\n # pylint: disable=no-self-use","def test_execute_queries(self):\n # Setup params\n n_slots = 5\n query_regnums_by_color = \"registration_numbers_for_cars_with_colour\"\n query_slotids_by_color = \"slot_number_for_registration_number\"\n query_slotid_by_regnum = \"slot_numbers_for_cars_with_colour\"\n commands = [\n (query_regnums_by_color, \"Color-2\"),\n (query_slotids_by_color, \"Color-1\"),\n (query_slotid_by_regnum, \"Renum-5\")\n ]\n\n # Verify command is able to execute without errors\n for query, arg in commands:\n self.controller.execute(query, *(arg,))","def test_example(self, _, cmd):\n out = subprocess.run(cmd, shell=True)\n self.assertFalse(out.returncode)","async def _run_command(self, command, *args, **kwargs):\n pass","def test_execution(self):\n self.assertTrue(True)","def test_basic_execution(self):","def to_execute(self):\r\n return True","def execute(self, *args, **options):\r\n context = {\r\n 'command': self.prog_name,\r\n }\r\n COMMAND_CONTEXT_NAME = 'edx.mgmt.command'\r\n with tracker.get_tracker().context(COMMAND_CONTEXT_NAME, context):\r\n super(TrackedCommand, self).execute(*args, **options)","def execute(self) -> None:\n pass # Implement in Executors","def test_execute_status(self):\n # Setup params\n n_slots = 3\n status_cmd = \"status\"\n\n # Prepare n number of empty slots\n self.prepare_cars(n_slots)\n\n # Verify command is able to execute without errors\n self.controller.execute(status_cmd)","def execute(self, rc):\n pass","def test_send_command(fprime_test_api):\n fprime_test_api.send_and_assert_command(\"cmdDisp.CMD_NO_OP\", max_delay=0.1)\n assert fprime_test_api.get_command_test_history().size() == 1\n fprime_test_api.send_and_assert_command(\"cmdDisp.CMD_NO_OP\", max_delay=0.1)\n assert fprime_test_api.get_command_test_history().size() == 2","def test_ssh_cmd(self):\n self.assertEqual(general.ssh_command('user','example.com',('ls','-l')).command_line,\n ['ssh','user@example.com','ls','-l'])","def test_process_host_commands(self):\n\n command = [\"df\", \"-h\"]\n output = run(verification.process_host_commands(command))\n self.assertTrue(\"```\\nThat command is not available.```\" not in output)\n\n command = [\"ls\", \"-la\"]\n output = run(verification.process_host_commands(command))\n self.assertEqual(\"```\\nThat command is not available.```\", output)","def test_command_integrity(self):\n out = io.StringIO()\n management.call_command('import_data', stdout=out)\n positions = Position.objects.count()\n management.call_command('import_data', stdout=out)\n self.assertEqual(Position.objects.count(), positions)","def execute(self):\n raise NotImplementedError(\"Subclasses should override this method.\")","def _execute_command(self):\n try:\n self.dw.execute_sql_command(self.query)\n except Exception as e:\n raise e","def test_execute_or_bail_ok(self):\n with self.assertLogs(level=\"INFO\") as cm:\n with etl.commands.execute_or_bail(\"unittest\"):\n pass\n self.assertEqual(len(cm.output), 1)\n self.assertTrue(\"finished successfully\" in cm.output[0])","def do_command(self, args):\n pass","def test_command(self):\r\n with self.assertRaises(SystemExit) as ex:\r\n with self.assertRaisesRegexp(CommandError, 'This script requires.*'):\r\n call_command('git_export', 'blah', 'blah', 'blah',\r\n stderr=StringIO.StringIO())\r\n self.assertEqual(ex.exception.code, 1)\r\n\r\n with self.assertRaises(SystemExit) as ex:\r\n with self.assertRaisesRegexp(CommandError, 'This script requires.*'):\r\n call_command('git_export', stderr=StringIO.StringIO())\r\n self.assertEqual(ex.exception.code, 1)\r\n\r\n # Send bad url to get course not exported\r\n with self.assertRaises(SystemExit) as ex:\r\n with self.assertRaisesRegexp(CommandError, GitExportError.URL_BAD):\r\n call_command('git_export', 'foo/bar/baz', 'silly',\r\n stderr=StringIO.StringIO())\r\n self.assertEqual(ex.exception.code, 1)\r\n # Send bad course_id to get course not exported\r\n with self.assertRaises(SystemExit) as ex:\r\n with self.assertRaisesRegexp(CommandError, GitExportError.BAD_COURSE):\r\n call_command('git_export', 'foo/bar:baz', 'silly',\r\n stderr=StringIO.StringIO())\r\n self.assertEqual(ex.exception.code, 1)","def test_execute_nothing(self):\n code, out, err = self.t.runError(\"--execute ''\")\n self.assertIn(\"A non-trivial path must be specified.\", out)","def execute(self, command: LoadCommand):\n command.execute()","def _verifyCommand(self):\n for i in range(3):\n rc = self.subdevice.command_test() # Verify command is correct\n if rc is None:\n break","def test_run_and_check_result(self):\n # Run a successful command.\n result = build_cmake_project.run_and_check_result('echo hello world')\n self.assertTrue(result)\n\n # Run a failure command.\n try:\n result = build_cmake_project.run_and_check_result('unexistent --command')\n except subprocess.CalledProcessError:\n self.fail('Exception thrown when running unexistent command.')\n self.assertFalse(result)","def test_main_succeeds(app_tester: ApplicationTester) -> None:\n assert app_tester.execute(\"\") == 0","def test_run_command(self, mock_paramiko):\n _mock = Mock()\n self.installer.SSH_client.exec_command.return_value = [_mock, \"output123\", \"error\"]\n stdout, stderr = self.installer._run_command(\"description\", \"command\")\n self.assertEqual(\"output123\", stdout)\n self.installer.SSH_client.exec_command.side_effect = SSHException\n with self.assertRaises(SSHException):\n self.installer._run_command(\"description\", \"command\")","def execute(self, *args, **options):\n raise NotImplementedError","def run_test_tool(self, cmd, expected_status=0 ):\n\n status, output = self.target.run(cmd)\n self.assertEqual(status, expected_status, msg='\\n'.join([cmd, output]))","def test_execute(self):\n rset = self.connection.execute(self.rql, export_type=\"json\")\n self.assertTrue(len(rset) > 0)","def _fake_execute(self, *cmd, **kwargs):\n cmdlist = list(cmd)\n exe = cmdlist.pop(0)\n if exe == 'vgc-cluster':\n exe = cmdlist.pop(0)\n if exe == \"request-cancel\":\n self._request_cancel = True\n if self._return_blocked > 0:\n return 'Request cancelled', ''\n else:\n raise processutils.ProcessExecutionError(exit_code=1)\n elif self._fail_vgc_cluster:\n raise processutils.ProcessExecutionError(exit_code=1)\n elif exe == \"--version\":\n return \"HGST Solutions V2.5.0.0.x.x.x.x.x\", ''\n elif exe == \"space-list\":\n return self._parse_space_list(cmdlist)\n elif exe == \"space-create\":\n self._parse_space_create(cmdlist)\n if self._return_blocked > 0:\n self._return_blocked = self._return_blocked - 1\n out = \"VGC_CREATE_000002\\nBLOCKED\\n\"\n raise processutils.ProcessExecutionError(stdout=out,\n exit_code=1)\n return '', ''\n elif exe == \"space-delete\":\n return self._parse_space_delete(cmdlist)\n elif exe == \"space-extend\":\n return self._parse_space_extend(cmdlist)\n elif exe == \"host-storage\":\n if self._fail_host_storage:\n raise processutils.ProcessExecutionError(exit_code=1)\n return HGST_HOST_STORAGE, ''\n elif exe == \"domain-list\":\n return self._parse_domain_list()\n elif exe == \"network-list\":\n return self._parse_network_list()\n elif exe == \"space-set-apphosts\":\n if self._fail_set_apphosts:\n raise processutils.ProcessExecutionError(exit_code=1)\n return '', ''\n else:\n raise NotImplementedError\n elif exe == 'ip':\n if self._fail_ip:\n raise processutils.ProcessExecutionError(exit_code=1)\n else:\n return IP_OUTPUT, ''\n elif exe == 'dd':\n self.dd_count = -1\n for p in cmdlist:\n if 'count=' in p:\n self.dd_count = int(p[6:])\n elif 'bs=' in p:\n self.bs = p[3:]\n return DD_OUTPUT, ''\n else:\n return '', ''","def _execute(self, db):\n raise NotImplementedError","def test_void_command(self):\n # make sure VOID is a valid command\n command = Command('VOID')\n self.assertTrue(type(command) == Command)","def execute(self, command, user_context=None):\n return self.parse(command, user_context).execute()","async def execute(self, client, message, arg):\n\t\treturn","async def _execute(self):","def test_do_custom():\n config = ReadConfig.get_all_settings()\n output_file_name = \"gau-test_do_custom.txt\"\n try:\n # Design\n command = \"{}\".format(config[\"GAU_CUSTOM_COMMAND\"])\n config[\"LOGGER\"].info(\"'{}' is executed!\".format(command))\n # Execution and dumping\n FileOperation.dump_all(output_file_name, OSOperations.execute_shell_command(command))\n config[\"LOGGER\"].info(\"Result dumped into '{}'\".format(output_file_name))\n assert True\n except Exception as e:\n config[\"LOGGER\"].error(\"gau-test_do_custom -> {}\".format(str(e)))\n assert False","def test_replace_command(command, expected):\n assert replace_command(command) == expected","def test_execWithoutShell(self):\n self.database.addUser(\n getpass.getuser(), 'secret', os.getuid(), 1234, 'foo', 'bar', '')\n\n d = self.client._dispatchCommand(\"exec echo hello\")\n d.addCallback(self.assertEqual, b\"hello\\n\")\n return d","def execute(self) -> None:\n self.command(self.target)","def test_translate_command(command, expected):\n assert translate_command(command) == expected","def executor(command, *args, **kwargs):\n command = command(*args, **kwargs)\n command.execute()\n command.reply()"],"string":"[\n \"def execute():\\n pass\",\n \"def test_command(self):\\n output, _error = self.executor.command(['echo', 'hello']).batch()\\n self.assertEqual(output, 'hello\\\\n')\",\n \"def execute_command(self):\\n raise Exception(\\\"Not implemented\\\")\",\n \"def test_command(self):\\n\\n expected = \\\"PyFunceble has been written by Fun Ilrys.\\\"\\n actual = Command(\\\"echo '%s'\\\" % expected).execute()\\n\\n self.assertEqual(expected + \\\"\\\\n\\\", actual)\",\n \"def execute():\",\n \"def execute(self):\\n pass\",\n \"def execute(self):\\n pass\",\n \"def execute(self):\\n pass\",\n \"def execute(self):\\n pass\",\n \"def execute(self):\\n pass\",\n \"def execute(self):\\n pass\",\n \"def execute(self):\\r\\n pass\",\n \"def execute(self):\\n\\t\\tpass\",\n \"def execute(cmd_string):\\n pass\",\n \"def test_execute(self):\\n with patch('command_executor.subprocess.Popen') as mock_subproc_popen:\\n communicate_mock = Mock()\\n attrs = {'communicate.return_value': (OUTPUT_RESULT,\\n OK_MESSAGE),\\n 'returncode': OK_RETURN_CODE}\\n communicate_mock.configure_mock(**attrs)\\n mock_subproc_popen.return_value = communicate_mock\\n actual_result = BaseCommandExecutor(COMMAND).to_execute()\\n self.assertIs(actual_result.error, OK_MESSAGE)\\n self.assertIs(actual_result.exit_code, OK_RETURN_CODE)\\n self.assertMultiLineEqual(actual_result.output,\\n EXECUTE_EXPECTED_RESULT)\",\n \"def execute(self):\\n\\n pass\",\n \"def execute(self):\\n\\n pass\",\n \"def execute(self):\\n\\n pass\",\n \"def execute(self):\\n\\n pass\",\n \"def execute_command(self, command):\\n raise NotImplementedError\",\n \"def execute(arg):\\n print('Invalid command!!!')\\n return\",\n \"def execute(self, args):\",\n \"def execute_test(self):\\n try:\\n self._execute()\\n except Exception as ex:\\n self._fail(exception=ex)\\n raise\",\n \"def _execute_test_cmd(self):\\n\\n self.log.info('-' * 80)\\n self.log.info('Execute test command line')\\n\\n code, out = cmd_exec(self._cmd, shell=False, log=self.log)\\n if code:\\n self.log.error(out)\\n return False\\n\\n self.log.info(out)\\n return True\",\n \"def _execute(self, _):\\r\\n pass\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def execute(self):\",\n \"def Execute(self):\\n return True\",\n \"def execute(self, args):\\r\\n pass\",\n \"def test_command(self):\\n out = io.StringIO()\\n management.call_command('import_data', stdout=out)\\n self.assertIn(\\\"Successfully imported\\\", out.getvalue())\",\n \"def execute(self):\\n raise NotImplementedError\",\n \"def execute(self):\\n raise NotImplementedError\",\n \"def execute(self, *args, **kwargs):\",\n \"def execute(self, *args, **kwargs):\",\n \"def execute(self, *args, **kwargs):\\n pass\",\n \"def execute(cls):\\n pass\",\n \"def execute(self):\\n raise NotImplementedError('execute')\",\n \"def test_execute(self):\\n with patch('command_executor.subprocess.Popen') as mock_subproc_popen:\\n communicate_mock = Mock()\\n attrs = {'communicate.return_value': (OUTPUT_RESULT,\\n OK_MESSAGE),\\n 'returncode': OK_RETURN_CODE}\\n communicate_mock.configure_mock(**attrs)\\n mock_subproc_popen.return_value = communicate_mock\\n actual_result = IperfCommandExecutor(COMMAND).to_execute()\\n self.assertIs(actual_result.error, OK_MESSAGE)\\n self.assertIs(actual_result.exit_code, OK_RETURN_CODE)\\n self.assertDictEqual(actual_result.output,\\n IPERF_PARSER_EXPECTED_RESULT)\",\n \"def test_execute(self):\\n context = dict()\\n cmd = pycell.python_cell(\\n source='print(2+2)',\\n validate=True\\n )\\n controller = FakeWorkflowController()\\n self.backend.execute_async(\\n task=TaskHandle(\\n task_id='000',\\n project_id=self.PROJECT_ID,\\n controller=controller\\n ),\\n command=cmd,\\n artifacts=context\\n )\\n time.sleep(3)\\n self.assertEqual(controller.task_id, '000')\\n self.assertEqual(controller.state, 'SUCCESS')\\n self.assertEqual(controller.outputs.stdout[0].value, '4')\",\n \"def test_execute_with_context(self):\\n pass\",\n \"def test_sendCommand(self):\\n self.p.sendCommand(\\\"CMD\\\", (\\\"param1\\\", \\\"param2\\\"))\\n self.check(\\\"CMD param1 param2\\\\r\\\\n\\\")\",\n \"def execute_command(self):\\n return ''\",\n \"def test_multiple_commands_at_same_time(self):\",\n \"def run_command_check(self):\\n pass\",\n \"def _execute_command(self, cmd):\\n LOG.info(\\\"Executing: %s\\\" % cmd)\\n status, stdout, stderr = self.client.execute(cmd)\\n if status:\\n raise RuntimeError(\\\"Failed executing command: \\\",\\n cmd, stderr)\\n return stdout\",\n \"def _execute_impl(self, commands):\\n raise NotImplementedError(\\\"abstract method\\\")\",\n \"def execute(self) -> None:\\n raise NotImplementedError\",\n \"def test_run_command(self):\\n self.build()\\n self.data_formatter_commands()\",\n \"def execute(self) :\\n \\n raise NotImplementedError()\",\n \"def test_valid_python_execute(self):\\n\\n data_file = testutils.DataFile(\\\"integration_module_valid_mod\\\")\\n\\n rtn = self.run_cmd(\\\"pm install --force --single module --install_name test_execute --name %s --auto\\\" % str(data_file))\\n assert(rtn.return_code == 0)\\n\\n rtn = self.run_cmd(\\\"test_execute\\\")\\n\\n assert(rtn.return_code == 0)\",\n \"def test_status_command(self):\\n # make sure STATUS is a valid command\\n command = Command('STATUS')\\n self.assertTrue(type(command) == Command)\",\n \"def test_exec(self):\\n self.database.addUser(\\n getpass.getuser(), 'secret', os.getuid(), 1234, 'foo', 'bar',\\n sys.executable)\\n\\n d = self.client._dispatchCommand(\\\"exec print(1 + 2)\\\")\\n d.addCallback(self.assertEqual, b\\\"3\\\\n\\\")\\n return d\",\n \"def runCommand(command):\\n None\",\n \"def _execute(self, cmd):\\r\\n stdout, stderr, return_code = self._remote_client.run_remote_cmd(cmd)\\r\\n if return_code:\\r\\n raise exceptions.ArgusError(\\r\\n \\\"Command {command!r} failed with \\\"\\r\\n \\\"return code {return_code!r}\\\"\\r\\n .format(command=cmd,\\r\\n return_code=return_code))\\r\\n return stdout, stderr\",\n \"def execute(self):\\n raise NotImplementedError('You must implement the execute() method '\\n 'yourself!')\",\n \"def execute(*args):\",\n \"def _execute_command(\\n cls,\\n connection_info: misc_utils.ConnectionInfo,\\n search_info: misc_utils.SearchInfo,\\n command_name: str,\\n arguments: List[str],\\n ):\\n dictionary, ip_address, port = tuple(connection_info)\\n is_printing_list, ids, components, search, json = tuple(search_info)\\n\\n search_filter = cls._get_search_filter(ids, components, search, json)\\n if is_printing_list:\\n cls._log(cls._list_all_possible_items(dictionary, search_filter, json))\\n return\\n\\n # ======================================================================\\n pipeline, api = test_api_utils.initialize_test_api(\\n dictionary, server_ip=ip_address, server_port=port\\n )\\n # ======================================================================\\n\\n try:\\n api.send_command(command_name, arguments)\\n except KeyError:\\n cls._log(\\\"'%s' is not a known command\\\" % (command_name))\\n close_matches = CommandSendCommand.get_closest_commands(\\n pipeline.dictionaries, command_name\\n )\\n if close_matches:\\n cls._log(\\\"Similar known commands: {}\\\".format(close_matches))\\n except NotInitializedException:\\n temp = CommandSendCommand.get_command_template(\\n pipeline.dictionaries, command_name\\n )\\n cls._log(\\n \\\"'%s' requires %d arguments (%d given)\\\"\\n % (command_name, len(temp.get_args()), len(arguments))\\n )\\n cls._log(cls.get_command_help_message(pipeline.dictionaries, command_name))\\n except CommandArgumentsException as err:\\n cls._log(\\\"Invalid arguments given; %s\\\" % (str(err)))\\n cls._log(cls.get_command_help_message(pipeline.dictionaries, command_name))\\n\\n # ======================================================================\\n pipeline.disconnect()\\n api.teardown()\\n # ======================================================================\",\n \"def runCommand(self): \\\\\\n # pylint: disable=no-self-use\",\n \"def test_execute_queries(self):\\n # Setup params\\n n_slots = 5\\n query_regnums_by_color = \\\"registration_numbers_for_cars_with_colour\\\"\\n query_slotids_by_color = \\\"slot_number_for_registration_number\\\"\\n query_slotid_by_regnum = \\\"slot_numbers_for_cars_with_colour\\\"\\n commands = [\\n (query_regnums_by_color, \\\"Color-2\\\"),\\n (query_slotids_by_color, \\\"Color-1\\\"),\\n (query_slotid_by_regnum, \\\"Renum-5\\\")\\n ]\\n\\n # Verify command is able to execute without errors\\n for query, arg in commands:\\n self.controller.execute(query, *(arg,))\",\n \"def test_example(self, _, cmd):\\n out = subprocess.run(cmd, shell=True)\\n self.assertFalse(out.returncode)\",\n \"async def _run_command(self, command, *args, **kwargs):\\n pass\",\n \"def test_execution(self):\\n self.assertTrue(True)\",\n \"def test_basic_execution(self):\",\n \"def to_execute(self):\\r\\n return True\",\n \"def execute(self, *args, **options):\\r\\n context = {\\r\\n 'command': self.prog_name,\\r\\n }\\r\\n COMMAND_CONTEXT_NAME = 'edx.mgmt.command'\\r\\n with tracker.get_tracker().context(COMMAND_CONTEXT_NAME, context):\\r\\n super(TrackedCommand, self).execute(*args, **options)\",\n \"def execute(self) -> None:\\n pass # Implement in Executors\",\n \"def test_execute_status(self):\\n # Setup params\\n n_slots = 3\\n status_cmd = \\\"status\\\"\\n\\n # Prepare n number of empty slots\\n self.prepare_cars(n_slots)\\n\\n # Verify command is able to execute without errors\\n self.controller.execute(status_cmd)\",\n \"def execute(self, rc):\\n pass\",\n \"def test_send_command(fprime_test_api):\\n fprime_test_api.send_and_assert_command(\\\"cmdDisp.CMD_NO_OP\\\", max_delay=0.1)\\n assert fprime_test_api.get_command_test_history().size() == 1\\n fprime_test_api.send_and_assert_command(\\\"cmdDisp.CMD_NO_OP\\\", max_delay=0.1)\\n assert fprime_test_api.get_command_test_history().size() == 2\",\n \"def test_ssh_cmd(self):\\n self.assertEqual(general.ssh_command('user','example.com',('ls','-l')).command_line,\\n ['ssh','user@example.com','ls','-l'])\",\n \"def test_process_host_commands(self):\\n\\n command = [\\\"df\\\", \\\"-h\\\"]\\n output = run(verification.process_host_commands(command))\\n self.assertTrue(\\\"```\\\\nThat command is not available.```\\\" not in output)\\n\\n command = [\\\"ls\\\", \\\"-la\\\"]\\n output = run(verification.process_host_commands(command))\\n self.assertEqual(\\\"```\\\\nThat command is not available.```\\\", output)\",\n \"def test_command_integrity(self):\\n out = io.StringIO()\\n management.call_command('import_data', stdout=out)\\n positions = Position.objects.count()\\n management.call_command('import_data', stdout=out)\\n self.assertEqual(Position.objects.count(), positions)\",\n \"def execute(self):\\n raise NotImplementedError(\\\"Subclasses should override this method.\\\")\",\n \"def _execute_command(self):\\n try:\\n self.dw.execute_sql_command(self.query)\\n except Exception as e:\\n raise e\",\n \"def test_execute_or_bail_ok(self):\\n with self.assertLogs(level=\\\"INFO\\\") as cm:\\n with etl.commands.execute_or_bail(\\\"unittest\\\"):\\n pass\\n self.assertEqual(len(cm.output), 1)\\n self.assertTrue(\\\"finished successfully\\\" in cm.output[0])\",\n \"def do_command(self, args):\\n pass\",\n \"def test_command(self):\\r\\n with self.assertRaises(SystemExit) as ex:\\r\\n with self.assertRaisesRegexp(CommandError, 'This script requires.*'):\\r\\n call_command('git_export', 'blah', 'blah', 'blah',\\r\\n stderr=StringIO.StringIO())\\r\\n self.assertEqual(ex.exception.code, 1)\\r\\n\\r\\n with self.assertRaises(SystemExit) as ex:\\r\\n with self.assertRaisesRegexp(CommandError, 'This script requires.*'):\\r\\n call_command('git_export', stderr=StringIO.StringIO())\\r\\n self.assertEqual(ex.exception.code, 1)\\r\\n\\r\\n # Send bad url to get course not exported\\r\\n with self.assertRaises(SystemExit) as ex:\\r\\n with self.assertRaisesRegexp(CommandError, GitExportError.URL_BAD):\\r\\n call_command('git_export', 'foo/bar/baz', 'silly',\\r\\n stderr=StringIO.StringIO())\\r\\n self.assertEqual(ex.exception.code, 1)\\r\\n # Send bad course_id to get course not exported\\r\\n with self.assertRaises(SystemExit) as ex:\\r\\n with self.assertRaisesRegexp(CommandError, GitExportError.BAD_COURSE):\\r\\n call_command('git_export', 'foo/bar:baz', 'silly',\\r\\n stderr=StringIO.StringIO())\\r\\n self.assertEqual(ex.exception.code, 1)\",\n \"def test_execute_nothing(self):\\n code, out, err = self.t.runError(\\\"--execute ''\\\")\\n self.assertIn(\\\"A non-trivial path must be specified.\\\", out)\",\n \"def execute(self, command: LoadCommand):\\n command.execute()\",\n \"def _verifyCommand(self):\\n for i in range(3):\\n rc = self.subdevice.command_test() # Verify command is correct\\n if rc is None:\\n break\",\n \"def test_run_and_check_result(self):\\n # Run a successful command.\\n result = build_cmake_project.run_and_check_result('echo hello world')\\n self.assertTrue(result)\\n\\n # Run a failure command.\\n try:\\n result = build_cmake_project.run_and_check_result('unexistent --command')\\n except subprocess.CalledProcessError:\\n self.fail('Exception thrown when running unexistent command.')\\n self.assertFalse(result)\",\n \"def test_main_succeeds(app_tester: ApplicationTester) -> None:\\n assert app_tester.execute(\\\"\\\") == 0\",\n \"def test_run_command(self, mock_paramiko):\\n _mock = Mock()\\n self.installer.SSH_client.exec_command.return_value = [_mock, \\\"output123\\\", \\\"error\\\"]\\n stdout, stderr = self.installer._run_command(\\\"description\\\", \\\"command\\\")\\n self.assertEqual(\\\"output123\\\", stdout)\\n self.installer.SSH_client.exec_command.side_effect = SSHException\\n with self.assertRaises(SSHException):\\n self.installer._run_command(\\\"description\\\", \\\"command\\\")\",\n \"def execute(self, *args, **options):\\n raise NotImplementedError\",\n \"def run_test_tool(self, cmd, expected_status=0 ):\\n\\n status, output = self.target.run(cmd)\\n self.assertEqual(status, expected_status, msg='\\\\n'.join([cmd, output]))\",\n \"def test_execute(self):\\n rset = self.connection.execute(self.rql, export_type=\\\"json\\\")\\n self.assertTrue(len(rset) > 0)\",\n \"def _fake_execute(self, *cmd, **kwargs):\\n cmdlist = list(cmd)\\n exe = cmdlist.pop(0)\\n if exe == 'vgc-cluster':\\n exe = cmdlist.pop(0)\\n if exe == \\\"request-cancel\\\":\\n self._request_cancel = True\\n if self._return_blocked > 0:\\n return 'Request cancelled', ''\\n else:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n elif self._fail_vgc_cluster:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n elif exe == \\\"--version\\\":\\n return \\\"HGST Solutions V2.5.0.0.x.x.x.x.x\\\", ''\\n elif exe == \\\"space-list\\\":\\n return self._parse_space_list(cmdlist)\\n elif exe == \\\"space-create\\\":\\n self._parse_space_create(cmdlist)\\n if self._return_blocked > 0:\\n self._return_blocked = self._return_blocked - 1\\n out = \\\"VGC_CREATE_000002\\\\nBLOCKED\\\\n\\\"\\n raise processutils.ProcessExecutionError(stdout=out,\\n exit_code=1)\\n return '', ''\\n elif exe == \\\"space-delete\\\":\\n return self._parse_space_delete(cmdlist)\\n elif exe == \\\"space-extend\\\":\\n return self._parse_space_extend(cmdlist)\\n elif exe == \\\"host-storage\\\":\\n if self._fail_host_storage:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n return HGST_HOST_STORAGE, ''\\n elif exe == \\\"domain-list\\\":\\n return self._parse_domain_list()\\n elif exe == \\\"network-list\\\":\\n return self._parse_network_list()\\n elif exe == \\\"space-set-apphosts\\\":\\n if self._fail_set_apphosts:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n return '', ''\\n else:\\n raise NotImplementedError\\n elif exe == 'ip':\\n if self._fail_ip:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n else:\\n return IP_OUTPUT, ''\\n elif exe == 'dd':\\n self.dd_count = -1\\n for p in cmdlist:\\n if 'count=' in p:\\n self.dd_count = int(p[6:])\\n elif 'bs=' in p:\\n self.bs = p[3:]\\n return DD_OUTPUT, ''\\n else:\\n return '', ''\",\n \"def _execute(self, db):\\n raise NotImplementedError\",\n \"def test_void_command(self):\\n # make sure VOID is a valid command\\n command = Command('VOID')\\n self.assertTrue(type(command) == Command)\",\n \"def execute(self, command, user_context=None):\\n return self.parse(command, user_context).execute()\",\n \"async def execute(self, client, message, arg):\\n\\t\\treturn\",\n \"async def _execute(self):\",\n \"def test_do_custom():\\n config = ReadConfig.get_all_settings()\\n output_file_name = \\\"gau-test_do_custom.txt\\\"\\n try:\\n # Design\\n command = \\\"{}\\\".format(config[\\\"GAU_CUSTOM_COMMAND\\\"])\\n config[\\\"LOGGER\\\"].info(\\\"'{}' is executed!\\\".format(command))\\n # Execution and dumping\\n FileOperation.dump_all(output_file_name, OSOperations.execute_shell_command(command))\\n config[\\\"LOGGER\\\"].info(\\\"Result dumped into '{}'\\\".format(output_file_name))\\n assert True\\n except Exception as e:\\n config[\\\"LOGGER\\\"].error(\\\"gau-test_do_custom -> {}\\\".format(str(e)))\\n assert False\",\n \"def test_replace_command(command, expected):\\n assert replace_command(command) == expected\",\n \"def test_execWithoutShell(self):\\n self.database.addUser(\\n getpass.getuser(), 'secret', os.getuid(), 1234, 'foo', 'bar', '')\\n\\n d = self.client._dispatchCommand(\\\"exec echo hello\\\")\\n d.addCallback(self.assertEqual, b\\\"hello\\\\n\\\")\\n return d\",\n \"def execute(self) -> None:\\n self.command(self.target)\",\n \"def test_translate_command(command, expected):\\n assert translate_command(command) == expected\",\n \"def executor(command, *args, **kwargs):\\n command = command(*args, **kwargs)\\n command.execute()\\n command.reply()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76571196","0.76401484","0.76354915","0.7635409","0.75945634","0.73478067","0.73478067","0.73478067","0.73478067","0.73478067","0.73478067","0.73469025","0.7315164","0.7250304","0.7222985","0.72060025","0.72060025","0.72060025","0.72060025","0.72033477","0.7158366","0.71549636","0.7150866","0.7148375","0.7140153","0.71378946","0.71378946","0.71378946","0.71378946","0.7090484","0.70762134","0.70719963","0.7037551","0.7037551","0.7035148","0.7035148","0.7029567","0.7001491","0.6992584","0.6987732","0.6977602","0.69719535","0.6964609","0.6926162","0.6920025","0.6919565","0.6918478","0.6877084","0.683743","0.6832556","0.6826173","0.67888325","0.67779195","0.67744076","0.6773375","0.67575055","0.6740359","0.6726768","0.6719147","0.6711343","0.6692678","0.66723615","0.66597575","0.6634126","0.6628527","0.6626682","0.66238064","0.6620959","0.65963674","0.6542096","0.65342647","0.65279984","0.651755","0.6514245","0.6502103","0.6492788","0.6492119","0.6484812","0.6466625","0.64608264","0.64592236","0.64448756","0.64439666","0.64436066","0.64419943","0.6441877","0.6440211","0.64395624","0.64209265","0.6415063","0.6395186","0.6383492","0.6383407","0.6372375","0.6371543","0.636925","0.636195","0.635949","0.63478714","0.63406664"],"string":"[\n \"0.76571196\",\n \"0.76401484\",\n \"0.76354915\",\n \"0.7635409\",\n \"0.75945634\",\n \"0.73478067\",\n \"0.73478067\",\n \"0.73478067\",\n \"0.73478067\",\n \"0.73478067\",\n \"0.73478067\",\n \"0.73469025\",\n \"0.7315164\",\n \"0.7250304\",\n \"0.7222985\",\n \"0.72060025\",\n \"0.72060025\",\n \"0.72060025\",\n \"0.72060025\",\n \"0.72033477\",\n \"0.7158366\",\n \"0.71549636\",\n \"0.7150866\",\n \"0.7148375\",\n \"0.7140153\",\n \"0.71378946\",\n \"0.71378946\",\n \"0.71378946\",\n \"0.71378946\",\n \"0.7090484\",\n \"0.70762134\",\n \"0.70719963\",\n \"0.7037551\",\n \"0.7037551\",\n \"0.7035148\",\n \"0.7035148\",\n \"0.7029567\",\n \"0.7001491\",\n \"0.6992584\",\n \"0.6987732\",\n \"0.6977602\",\n \"0.69719535\",\n \"0.6964609\",\n \"0.6926162\",\n \"0.6920025\",\n \"0.6919565\",\n \"0.6918478\",\n \"0.6877084\",\n \"0.683743\",\n \"0.6832556\",\n \"0.6826173\",\n \"0.67888325\",\n \"0.67779195\",\n \"0.67744076\",\n \"0.6773375\",\n \"0.67575055\",\n \"0.6740359\",\n \"0.6726768\",\n \"0.6719147\",\n \"0.6711343\",\n \"0.6692678\",\n \"0.66723615\",\n \"0.66597575\",\n \"0.6634126\",\n \"0.6628527\",\n \"0.6626682\",\n \"0.66238064\",\n \"0.6620959\",\n \"0.65963674\",\n \"0.6542096\",\n \"0.65342647\",\n \"0.65279984\",\n \"0.651755\",\n \"0.6514245\",\n \"0.6502103\",\n \"0.6492788\",\n \"0.6492119\",\n \"0.6484812\",\n \"0.6466625\",\n \"0.64608264\",\n \"0.64592236\",\n \"0.64448756\",\n \"0.64439666\",\n \"0.64436066\",\n \"0.64419943\",\n \"0.6441877\",\n \"0.6440211\",\n \"0.64395624\",\n \"0.64209265\",\n \"0.6415063\",\n \"0.6395186\",\n \"0.6383492\",\n \"0.6383407\",\n \"0.6372375\",\n \"0.6371543\",\n \"0.636925\",\n \"0.636195\",\n \"0.635949\",\n \"0.63478714\",\n \"0.63406664\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6589691"},"document_rank":{"kind":"string","value":"69"}}},{"rowIdx":88375,"cells":{"query":{"kind":"string","value":"Test the KillCommand class"},"document":{"kind":"string","value":"def test_KillCommand(execute):\n from paradrop.confd.command import KillCommand\n\n # Test with a numeric pid.\n command = KillCommand(12345)\n assert command.getPid() == 12345\n\n expected = [\"kill\", \"12345\"]\n command.execute()\n assert execute.called_once_with(expected)\n\n execute.reset_mock()\n\n pidFile = tempfile.NamedTemporaryFile(delete=True)\n pidFile.write(\"54321\")\n pidFile.flush()\n\n # Test with a pid file.\n command = KillCommand(pidFile.name)\n assert command.getPid() == 54321\n\n expected = [\"kill\", \"54321\"]\n command.execute()\n assert execute.called_once_with(expected)\n \n execute.reset_mock()\n\n # Test with a non-existent pid file.\n command = KillCommand(\"\")\n assert command.getPid() is None\n \n command.execute()\n assert not execute.called"},"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 test_kill(self):\n A = ConwayAgent(23, True)\n self.assertTrue(A.status() == 1)\n A.kill()\n self.assertTrue(A.status() == 0)","def remote_kill():","def test_build_kill_command(self):\n actual_result = IperfKillCommandBuilder(SERVER_USER)\\\n .set_ip_address(SERVER_IP)\\\n .set_password(SERVER_PASSWORD)\\\n .to_build()\n self.assertListEqual(actual_result,\n ['sshpass', '-p', 'QWERTY', 'ssh',\n 'root@192.168.1.1', 'pkill', '-9',\n 'iperf', ';echo', '$?'])","def test_destroy(self):\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"destroy\")\n self.assertEqual(f.getvalue().strip(),\n \"** class name missing **\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"destroy Manga\")\n self.assertEqual(f.getvalue().strip(),\n \"** class doesn't exist **\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"destroy BaseModel\")\n self.assertEqual(f.getvalue().strip(),\n \"** instance id missing **\")\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"create BaseModel\")\n id = f.getvalue().strip()\n\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"destroy BaseModel \" + str(id))\n self.assertEqual(f.getvalue().strip(), \"\")","def test_shutdown_command(self):\n # make sure SHUTDOWN is a valid command\n command = Command('SHUTDOWN')\n self.assertTrue(type(command) == Command)","def test_terminate_run(self):\n pass","def test_generic(self):\n ring = KillRing()\n self.assertTrue(ring.yank() is None)\n self.assertTrue(ring.rotate() is None)\n\n ring.kill('foo')\n self.assertEqual(ring.yank(), 'foo')\n self.assertTrue(ring.rotate() is None)\n self.assertEqual(ring.yank(), 'foo')\n\n ring.kill('bar')\n self.assertEqual(ring.yank(), 'bar')\n self.assertEqual(ring.rotate(), 'foo')\n\n ring.clear()\n self.assertTrue(ring.yank() is None)\n self.assertTrue(ring.rotate() is None)","def test_destroy(self):\n _help = \"[Usage: destroy <class name> <id>] or \"\\\n \"[Usage: <class name>.destroy(<id>)]\\n\"\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"help destroy\")\n self.assertEqual(f.getvalue(), _help)","def test_kill(self):\n self.dut._poll_processes = MagicMock()\n self.dut._kill_all()\n self.assertTrue(self.dut._poll_processes.call_count, 1)","def killExperiment(self, **kwargs):\n if kwargs['kill']=='YES':\n killRobot.sshKill()","def test_clean(self):\n\n arg_parser = arguments.get_parser()\n\n args = arg_parser.parse_args([\n 'run',\n '-H', 'this',\n 'clean_test'\n ])\n run_cmd = commands.get_command(args.command_name)\n run_cmd.silence()\n run_cmd.run(self.pav_cfg, args)\n\n for test in run_cmd.last_tests:\n test.wait(timeout=10)\n\n args = arg_parser.parse_args([\n 'clean'\n ])\n\n clean_cmd = commands.get_command(args.command_name)\n clean_cmd.silence()\n\n self.assertEqual(clean_cmd.run(self.pav_cfg, args), 0)","def GET_kill(self):\n sys.exit(0)","def kill(self, id):","def kill(self, id):","def test_clean_wait(self):\n\n arg_parser = arguments.get_parser()\n\n args = arg_parser.parse_args([\n 'run',\n '-H', 'this',\n 'clean_test'\n ])\n run_cmd = commands.get_command(args.command_name)\n run_cmd.silence()\n run_cmd.run(self.pav_cfg, args)\n\n time.sleep(1)\n\n args = arg_parser.parse_args([\n 'clean'\n ])\n\n clean_cmd = commands.get_command(args.command_name)\n clean_cmd.silence()\n\n self.assertEqual(clean_cmd.run(self.pav_cfg, args), 0)","def test_quit(self):\n _help = 'Quit method to exit form cmd '\n _help += 'program (Usage: quit)\\n'\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"help quit\")\n self.assertEqual(f.getvalue(), _help)","def test_delete_device(self):\n pass","def test_delete_device(self):\n pass","def test_correct_connection(self, mock_execute, mock_parse):\n mock_parse.return_value = ARGS_INPUT\n result = CONNECTION_KILL\n mock_execute.return_value = result\n actual_result = connection_to_server_to_kill_iperf()\n self.assertIs(actual_result.exit_code, 0)\n self.assertIs(actual_result.error, '')\n self.assertIs(actual_result.exit_code_execution, '')\n self.assertIs(actual_result.output, 0)","def test_delete_simulator_by_udid(self, subprocess_mock, _, _2):\n iossim_util.delete_simulator_by_udid('UDID')\n self.assertEqual(['xcrun', 'simctl', 'delete', 'UDID'],\n subprocess_mock.call_args[0][0])","def test_stopProcessForcedKill(self):\r\n self.pm.startService()\r\n self.pm.addProcess(\"foo\", [\"foo\"])\r\n self.assertIn(\"foo\", self.pm.protocols)\r\n self.reactor.advance(self.pm.threshold)\r\n proc = self.pm.protocols[\"foo\"].transport\r\n # Arrange for the fake process to live longer than the killTime\r\n proc._terminationDelay = self.pm.killTime + 1\r\n self.pm.stopProcess(\"foo\")\r\n # If process doesn't die before the killTime, procmon should\r\n # terminate it\r\n self.reactor.advance(self.pm.killTime - 1)\r\n self.assertEqual(0.0, self.pm.timeStarted[\"foo\"])\r\n\r\n self.reactor.advance(1)\r\n # We expect it to be immediately restarted\r\n self.assertEqual(self.reactor.seconds(), self.pm.timeStarted[\"foo\"])","def test_quit_game(run):\n out, _ = run(dork.cli.quit_game)\n assert \"Thank you\" in out","def test_delete_run(self):\n pass","def test_quit(self):\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"quit\")\n out = f.getvalue()\n self.assertTrue(len(out) == 0)\n self.assertEqual(\"\", out)\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"quit fake\")\n msj = f.getvalue()\n self.assertTrue(len(msj) == 0)\n self.assertEqual(\"\", msj)","def test_clean(self, check_docker, volumes, q):\n\n volume1 = MagicMock()\n volume1.name = \"some-name-tmpvol\"\n volumes.list.return_value = [volume1]\n\n question = MagicMock(name=\"pop-the-question\")\n question.ask.return_value = True\n q.confirm.return_value = question\n\n runner = CliRunner()\n result = runner.invoke(cli_node_clean)\n\n # check exit code\n self.assertEqual(result.exit_code, 0)","def do_command(self, args):\n testops = dbops.Tests()\n testops.delete(args)","def kill(self):\n self.error_code = 'KILLED'\n self.running = False","def test_send_command(fprime_test_api):\n fprime_test_api.send_and_assert_command(\"cmdDisp.CMD_NO_OP\", max_delay=0.1)\n assert fprime_test_api.get_command_test_history().size() == 1\n fprime_test_api.send_and_assert_command(\"cmdDisp.CMD_NO_OP\", max_delay=0.1)\n assert fprime_test_api.get_command_test_history().size() == 2","def __del__(self):\n if self.child_pid:\n self.host.Kill(self.child_pid, IperfClient.KILL_STRING)","def test_kill(self):\n s = 'hello world'\n n = 5\n self.widget.buffer = s\n self.widget.cursor = n\n self.widget.keystrokeReceived('\\x0b', None) # C-k\n self.assertEqual(self.widget.buffer, s[:n])\n self.assertEqual(self.widget.killRing, [s[n:]])","def kill(targets, controller=False):","def test_do_quit(self):\n for string in self.random_strings:\n self.assertTrue(self.CommandParser.do_quit(string))","def testBogusCommand(self):\n self.client_connect()\n self.client_send('bogus\\r\\n')\n self.client_recv('.*ERROR.*\\r\\n')\n self.assertTrue(self.mock_quiet())","def __del__(self):\n if self.child_pid:\n self.host.Kill(self.child_pid, IperfServer.KILL_STRING)","def test_destroy_exit_code(destroy_result: Result) -> None:\n assert destroy_result.exit_code == 0","def watchdogReset(unitTestUtil, utilType, logger, cmd_bmc, hostname, headnode=None):\n if utilType.daemonProcessesKill is None:\n raise Exception(\"no daemon process kill commands listed\")\n # Login and run WatchdogProcess\n logger.debug(\"starting watchdog process from this test\")\n cmd_run_wdp = \"python /tmp/tests/common/watchdogProcess.py\"\n wdSubProcess = subprocess.Popen(cmd_bmc + cmd_run_wdp,\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n\n # Login and kill daemon processes\n logger.debug(\"killing all daemon processes\")\n killcmds = utilType.daemonProcessesKill\n for cmd in killcmds:\n killSubProcess = subprocess.Popen(cmd_bmc + cmd,\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n output = killSubProcess.communicate()\n # kill process that just started from this script\n logger.debug(\"killing watchdog process started from this test\")\n psSubProcess = subprocess.Popen(cmd_bmc + \"ps\",\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n output = psSubProcess.communicate()[0]\n #info = output.split('\\n')\n info = output.decode('utf-8').split('\\n')\n for line in info:\n if \"watchdogProcess\" in line:\n line = line.split(' ')\n for word in line:\n if word != '':\n killprocess = subprocess.Popen(cmd_bmc + 'kill ' + word,\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n output = killprocess.communicate()\n break\n\n # check that host is pingable -> not pingable -> pingable\n pingcmd = \"\"\n if headnode is None or utilType.ConnectionTestPath is None:\n pingcmd = 'python {0}tests/common/connectionTest.py {1} 6'.format(testPath, hostname)\n #pingcmd = ['python', testPath + 'common/connectionTest.py', hostname, '6']\n else:\n pingcmd = 'python {0}{1} {2} {3} 6'.format(testPath, utilType.ConnectionTestPath, headnode, hostname)\n logger.debug(\"checking that ping connection to host succeeds before reboot is triggered\")\n f = subprocess.Popen(pingcmd,\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n out, err = f.communicate()\n if len(err) != 0:\n raise Exception(err)\n if b'PASSED' not in out:\n print(\"watchdog Reset Test [FAILED]\")\n sys.exit(1)\n logger.debug(\"waiting 30 seconds\")\n time.sleep(30)\n logger.debug(\"checking that ping connection to host fails because rebooting is occurring\")\n f = subprocess.Popen(pingcmd,\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n out, err = f.communicate()\n if len(err) != 0:\n raise Exception(err)\n if b'PASSED' in out:\n print(\"No reset from watchdog [FAILED]\")\n sys.exit(1)\n logger.debug(\"waiting 900 seconds\")\n time.sleep(900)\n logger.debug(\"checking that ping connection to host succeeds, reboot should have completed\")\n f = subprocess.Popen(pingcmd,\n shell=True, stdin=None,\n stdout=subprocess.PIPE,\n stderr=subprocess.PIPE)\n out, err = f.communicate()\n if len(err) != 0:\n print(\"checking not connected: err\")\n print(err)\n raise Exception(err)\n if b'PASSED' not in out:\n print(\"Watchdog Reset Test [FAILED]\")\n sys.exit(1)\n else:\n print(\"Watchdog Reset Test [PASSED]\")\n sys.exit(0)","def testBasicQuit(self):\n self.client_connect()\n self.client_send(\"get keyNotThere\\r\\n\")\n self.mock_recv('get keyNotThere\\r\\n')\n self.mock_send('END\\r\\n')\n self.client_recv(\"END\\r\\n\")\n\n self.client_send(\"quit\\r\\n\")\n self.assertTrue(self.mock_quiet())","def test_void_command(self):\n # make sure VOID is a valid command\n command = Command('VOID')\n self.assertTrue(type(command) == Command)","def kill(self):\n if self.process is not None:\n LOGGER.info('Killing command...')\n self.process.kill()\n self.process = None","def test_issue_delete_stop_watch(self):\n pass","def Deletetest(self):\n # Test delete()\n result = self.runner.invoke(\n yoda.cli,\n [\"setup\", \"delete\"],\n input=\"n\\n\"\n )\n self.assertEqual(result.exit_code, 0)\n self.assertIn(\"Operation cancelled\", result.output)\n\n result = self.runner.invoke(\n yoda.cli,\n [\"setup\", \"delete\"],\n input=\"y\\n\"\n )\n self.assertEqual(result.exit_code, 0)\n self.assertIn(\"Configuration file deleted\", result.output)","def cmd_quit(args):","def phone_kill(self) -> None:","def kill(self):\n self.status = Modem.Status.KILL","def stopTest(self, test):","def test_delete():\n mock_ret = MagicMock(return_value=0)\n mock_group = {\"passwd\": \"*\", \"gid\": 0, \"name\": \"test\", \"members\": [\"root\"]}\n with patch.dict(mac_group.__salt__, {\"cmd.retcode\": mock_ret}), patch(\n \"salt.modules.mac_group.info\", MagicMock(return_value=mock_group)\n ):\n assert mac_group.delete(\"test\")","def _check_stop(self, guest_obj, stop_cmd):\n # call method and verify if it executed cmd in ssh shell\n guest_obj.stop()\n self._mock_ssh_shell.run.assert_called_with(stop_cmd)","def _kill_kernel(self):","def test_emptyKill(self):\n s = 'hello world'\n self.widget.buffer = s\n self.widget.cursor = len(s)\n self.widget.keystrokeReceived('\\x0b', None) # C-k\n self.assertEqual(self.widget.buffer, s)\n self.assertEqual(self.widget.killRing, [])","def test_stopService(self):\r\n self.pm.addProcess(\"foo\", [\"foo\"])\r\n self.pm.addProcess(\"bar\", [\"bar\"])\r\n # Schedule the process to start\r\n self.pm.startService()\r\n # advance the reactor to start the processes\r\n self.reactor.advance(self.pm.threshold)\r\n self.assertIn(\"foo\", self.pm.protocols)\r\n self.assertIn(\"bar\", self.pm.protocols)\r\n\r\n self.reactor.advance(1)\r\n\r\n self.pm.stopService()\r\n # Advance to beyond the killTime - all monitored processes\r\n # should have exited\r\n self.reactor.advance(self.pm.killTime + 1)\r\n # The processes shouldn't be restarted\r\n self.assertEqual({}, self.pm.protocols)","def _kill():\n\n messagebox.showerror(\n title=const.TSSD_ERROR_TITLE,\n message=const.TSSD_ERROR_MSG\n )\n\n sys.exit(3)","def test_delete__volume(self):\n arglist = [\n '--volume',\n self.projects[0].id,\n ]\n verifylist = [\n ('service', 'volume'),\n ('project', self.projects[0].id),\n ]\n\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\n\n result = self.cmd.take_action(parsed_args)\n\n self.assertIsNone(result)\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\n self.compute_quotas_mock.delete.assert_not_called()\n self.volume_quotas_mock.delete.assert_called_once_with(\n self.projects[0].id,\n )\n self.network_mock.delete_quota.assert_not_called()","def kill(self):\n\n self.proc.kill()","def test_status_command(self):\n # make sure STATUS is a valid command\n command = Command('STATUS')\n self.assertTrue(type(command) == Command)","def test_delete_sms_message(self):\n pass","def kill(self):\n if self.transport.pid is not None:\n self.transport.signalProcess('KILL')","def script_kill(self):\n return self._execute([b'SCRIPT', b'KILL'], b'OK')","def _kill(self) -> None:\n if not hasattr(self, \"proc\"):\n raise FuzzFrontendError(\"Attempted to kill non-running PID.\")\n\n self.proc.terminate()\n try:\n self.proc.wait(timeout=0.5)\n L.info(\"Fuzzer subprocess exited with `%d`\", self.proc.returncode)\n except subprocess.TimeoutExpired:\n raise FuzzFrontendError(\"Subprocess could not terminate in time\")\n\n self._on = False","def test_delete_destroy(self):\n domain = mock.Mock()\n logger = mock.Mock()\n domain.isActive.return_value = True\n lxc.domain_delete(domain, logger, None)\n self.assertTrue(domain.destroy.called)","def stopTestRun(self):","def test_uninstall(self):\n pass","def __init__(self,cmd,logger,killsig=-1,killtime=0):\n self.cmd = cmd\n self.log = logger\n self.killsig = killsig\n self.killtime = killtime\n self.exception = None\n self.exit = None\n self.stdout = None\n self.stderr = None\n self.status = None","def test_delete(self):\n\n value = self.instance.delete()\n self.client.delete_instance.assert_called_once_with('nginx')\n self.assertEqual(value, self.client.delete_instance.return_value)","def test_node_stop(self, m_docker_client, m_client):\n # Call method under test\n node.node_stop(True)\n\n # Assert\n m_client.remove_host.assert_called_once_with(node.hostname)\n m_docker_client.stop.assert_called_once_with('calico-node')","def test_parser_destroy(parser):\n parser.parse_args(['--destroy'])","def test_users_remove(mocker):\r\n mocker.patch('subprocess.call')\r\n users.remove(user_dict)\r\n subprocess.call.assert_called_with([\r\n 'userdel',\r\n '-r',\r\n 'kevin',\r\n ])","def test_command_tags_removed(self):\r\n\r\n COMMANDLIST['!toread'] = CommandMock\r\n\r\n bm = BmarkMock()\r\n bm.tags['!toread'] = True\r\n commander = Commander(bm)\r\n updated = commander.process()\r\n\r\n self.assertTrue(\r\n '!toread' not in updated.tags,\r\n \"Our commander should find !toread command to run\")","def test_node_graceful_shutdown(self, proc_info, controller_node):\n launch_testing.asserts.assertExitCodes(proc_info, process=controller_node)","def test_removeProcess(self):\r\n self.pm.startService()\r\n self.pm.addProcess(\"foo\", [\"foo\"])\r\n self.assertEqual(len(self.pm.processes), 1)\r\n self.pm.removeProcess(\"foo\")\r\n self.assertEqual(len(self.pm.processes), 0)","def test_do_delete(delete_resource: MagicMock, response: execution.ResponseInfo):\n delete_resource.return_value = response\n bundle = MagicMock()\n bundle.resources.matching.return_value = [MagicMock(), MagicMock()]\n action = interface.CommandAction(MagicMock(), [], bundle)\n interface.do_delete(action)\n assert delete_resource.call_count == 2","def test_delete_destroy_error(self):\n domain = mock.Mock()\n logger = mock.Mock()\n domain.isActive.return_value = True\n domain.destroy.side_effect = libvirt.libvirtError(\"BOOM\")\n lxc.domain_delete(domain, logger, None)\n self.assertTrue(domain.undefine.called)","def test_users_remove(mocker):\n mocker.patch('subprocess.call')\n users.remove(user_dict)\n subprocess.call.assert_called_with([\n 'userdel',\n '-r',\n 'kevin',\n ])","def do_destroy(self, arg):\n arg_list = arg.split(\" \") if type(arg) == str else arg\n if not arg:\n print(\"** class name missing **\")\n return\n if arg_list[0] not in HBNBCommand.class_list:\n print(\"** class doesn't exist **\")\n return\n if len(arg_list) < 2:\n print(\"** instance id missing **\")\n return\n key = arg_list[0] + \".\" + arg_list[1]\n if key in storage.all():\n del storage.all()[key]\n storage.save()\n return\n print(\"** no instance found **\")","def test_delete(self):\n self.request.access.allow_delete = [\"everyone\"]\n pkg = make_package()\n key = self.db.redis_key(pkg.filename)\n self.redis[key] = \"foobar\"\n self.db.delete(pkg)\n val = self.redis.get(key)\n self.assertIsNone(val)\n count = self.redis.scard(self.db.redis_set)\n self.assertEqual(count, 0)\n self.storage.delete.assert_called_with(pkg)","def test_stopProcessUnknownKeyError(self):\r\n self.assertRaises(KeyError, self.pm.stopProcess, \"foo\")","def tearDown(self):\n self.popen_patcher.stop()","def tearDown(self):\n self.popen_patcher.stop()","def test_multiple_commands_at_same_time(self):","def test_delete_device_by_id(self):\n pass","def test_deletion(self):\n\n # Set the current pipe to the 'orig' data pipe.\n name = 'orig'\n pipes.switch(name)\n\n # Delete the 'orig' data pipe.\n pipes.delete(name)\n\n # Test that the data pipe no longer exists.\n self.assert_(name not in ds)\n\n # Test that the current pipe is None (as the current pipe was deleted).\n self.assertEqual(pipes.cdp_name(), None)","def test_delete(self):\n pass","def kill(coro):\n return KillEvent(coro)","def kill(self):\n\n #Kill relevant process names\n if self.driver_type != 'firefox_wdm':\n os.system('pkill -f chrome')\n os.system('pkill -f Chrome')\n os.system('pkill -f chromedriver')\n else:\n os.system('pkill -f FireFox')\n #TODO: confirm this -> os.system('pkill -f geckodriver')","def test_delete_bios_policy(self):\n pass","def kill(self):\n self.send_signal(signal.SIGKILL)","def test_ctrl_c(u_boot_console):\n\n u_boot_console.kill(signal.SIGINT)\n assert(u_boot_console.validate_exited())","async def kill(self, restart: bool = False) -> None:\n pass","def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\n resources._domain = mock.Mock()\n resources._network = mock.Mock()\n resources._hypervisor = mock.Mock()\n resources.cleanup()\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\n network_delete_mock.assert_called_with(resources.network)\n self.assertTrue(resources._hypervisor.close.called)","def test_destroy_container_privilege(self):\n pass","async def module_command_quit(self, ctx, parsed):\n if parsed.invoker != ctx.owner:\n return\n reason = \" \".join(parsed.args[\"msg\"] or []) or \"Shutting down\"\n self.quit(reason)","def do_kill(self, args):\n if (len(args.split()) < 1):\n self.__bad_arguments(\"kill\")\n else:\n print \"Killed \" + args + \".\"\n player_killed = args.split()[0]\n AssassinsManager.remove_assassin(self.assassins_manager, player_killed)","def test_unkown_command(self):\n with patch('sys.stdout', new=StringIO()) as f:\n HBNBCommand().onecmd(\"something\")\n self.assertEqual(f.getvalue().strip(),\n \"*** Unknown syntax: something\")","def test_destroy_nas_share(self):\n pass","def test_delete_boat(self):\n pass","def test_004_delete(self):\n ret = svcmgr.main(argv=[\"delete\", \"-s\", SVCNAME, \"--local\"])\n assert ret == 0","def test_execute_process_killed():\n port = port_for.select_random()\n passing_check = check_tcp(port)\n\n def failing_check_for_testing_purposes():\n return False\n\n with pytest.raises(PostChecksFailed) as checks_failed:\n execute([SERVICE, 'tcp', '--port', str(port)], [passing_check, failing_check_for_testing_purposes], timeout=1)\n\n assert 'function failing_check_for_testing_purposes' in str(checks_failed.value)\n\n # The process will be killed and nothing will be listening on that port.\n wait_until(lambda: passing_check() is False)","def test_delete_underscore():\n pytest.raises(SaltInvocationError, mac_group.delete, \"_Test\")","def test_delete_case(self):\n pass","def test_destroy_container(self):\n pass","def test_cmd(host, cmd, timeout=None):\n ps = host.popen(cmd)\n rs = monitor_ps(ps, timeout)\n if rs is None:\n ps.kill()\n return False\n return rs == 0"],"string":"[\n \"def test_kill(self):\\n A = ConwayAgent(23, True)\\n self.assertTrue(A.status() == 1)\\n A.kill()\\n self.assertTrue(A.status() == 0)\",\n \"def remote_kill():\",\n \"def test_build_kill_command(self):\\n actual_result = IperfKillCommandBuilder(SERVER_USER)\\\\\\n .set_ip_address(SERVER_IP)\\\\\\n .set_password(SERVER_PASSWORD)\\\\\\n .to_build()\\n self.assertListEqual(actual_result,\\n ['sshpass', '-p', 'QWERTY', 'ssh',\\n 'root@192.168.1.1', 'pkill', '-9',\\n 'iperf', ';echo', '$?'])\",\n \"def test_destroy(self):\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"destroy\\\")\\n self.assertEqual(f.getvalue().strip(),\\n \\\"** class name missing **\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"destroy Manga\\\")\\n self.assertEqual(f.getvalue().strip(),\\n \\\"** class doesn't exist **\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"destroy BaseModel\\\")\\n self.assertEqual(f.getvalue().strip(),\\n \\\"** instance id missing **\\\")\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"create BaseModel\\\")\\n id = f.getvalue().strip()\\n\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"destroy BaseModel \\\" + str(id))\\n self.assertEqual(f.getvalue().strip(), \\\"\\\")\",\n \"def test_shutdown_command(self):\\n # make sure SHUTDOWN is a valid command\\n command = Command('SHUTDOWN')\\n self.assertTrue(type(command) == Command)\",\n \"def test_terminate_run(self):\\n pass\",\n \"def test_generic(self):\\n ring = KillRing()\\n self.assertTrue(ring.yank() is None)\\n self.assertTrue(ring.rotate() is None)\\n\\n ring.kill('foo')\\n self.assertEqual(ring.yank(), 'foo')\\n self.assertTrue(ring.rotate() is None)\\n self.assertEqual(ring.yank(), 'foo')\\n\\n ring.kill('bar')\\n self.assertEqual(ring.yank(), 'bar')\\n self.assertEqual(ring.rotate(), 'foo')\\n\\n ring.clear()\\n self.assertTrue(ring.yank() is None)\\n self.assertTrue(ring.rotate() is None)\",\n \"def test_destroy(self):\\n _help = \\\"[Usage: destroy <class name> <id>] or \\\"\\\\\\n \\\"[Usage: <class name>.destroy(<id>)]\\\\n\\\"\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"help destroy\\\")\\n self.assertEqual(f.getvalue(), _help)\",\n \"def test_kill(self):\\n self.dut._poll_processes = MagicMock()\\n self.dut._kill_all()\\n self.assertTrue(self.dut._poll_processes.call_count, 1)\",\n \"def killExperiment(self, **kwargs):\\n if kwargs['kill']=='YES':\\n killRobot.sshKill()\",\n \"def test_clean(self):\\n\\n arg_parser = arguments.get_parser()\\n\\n args = arg_parser.parse_args([\\n 'run',\\n '-H', 'this',\\n 'clean_test'\\n ])\\n run_cmd = commands.get_command(args.command_name)\\n run_cmd.silence()\\n run_cmd.run(self.pav_cfg, args)\\n\\n for test in run_cmd.last_tests:\\n test.wait(timeout=10)\\n\\n args = arg_parser.parse_args([\\n 'clean'\\n ])\\n\\n clean_cmd = commands.get_command(args.command_name)\\n clean_cmd.silence()\\n\\n self.assertEqual(clean_cmd.run(self.pav_cfg, args), 0)\",\n \"def GET_kill(self):\\n sys.exit(0)\",\n \"def kill(self, id):\",\n \"def kill(self, id):\",\n \"def test_clean_wait(self):\\n\\n arg_parser = arguments.get_parser()\\n\\n args = arg_parser.parse_args([\\n 'run',\\n '-H', 'this',\\n 'clean_test'\\n ])\\n run_cmd = commands.get_command(args.command_name)\\n run_cmd.silence()\\n run_cmd.run(self.pav_cfg, args)\\n\\n time.sleep(1)\\n\\n args = arg_parser.parse_args([\\n 'clean'\\n ])\\n\\n clean_cmd = commands.get_command(args.command_name)\\n clean_cmd.silence()\\n\\n self.assertEqual(clean_cmd.run(self.pav_cfg, args), 0)\",\n \"def test_quit(self):\\n _help = 'Quit method to exit form cmd '\\n _help += 'program (Usage: quit)\\\\n'\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"help quit\\\")\\n self.assertEqual(f.getvalue(), _help)\",\n \"def test_delete_device(self):\\n pass\",\n \"def test_delete_device(self):\\n pass\",\n \"def test_correct_connection(self, mock_execute, mock_parse):\\n mock_parse.return_value = ARGS_INPUT\\n result = CONNECTION_KILL\\n mock_execute.return_value = result\\n actual_result = connection_to_server_to_kill_iperf()\\n self.assertIs(actual_result.exit_code, 0)\\n self.assertIs(actual_result.error, '')\\n self.assertIs(actual_result.exit_code_execution, '')\\n self.assertIs(actual_result.output, 0)\",\n \"def test_delete_simulator_by_udid(self, subprocess_mock, _, _2):\\n iossim_util.delete_simulator_by_udid('UDID')\\n self.assertEqual(['xcrun', 'simctl', 'delete', 'UDID'],\\n subprocess_mock.call_args[0][0])\",\n \"def test_stopProcessForcedKill(self):\\r\\n self.pm.startService()\\r\\n self.pm.addProcess(\\\"foo\\\", [\\\"foo\\\"])\\r\\n self.assertIn(\\\"foo\\\", self.pm.protocols)\\r\\n self.reactor.advance(self.pm.threshold)\\r\\n proc = self.pm.protocols[\\\"foo\\\"].transport\\r\\n # Arrange for the fake process to live longer than the killTime\\r\\n proc._terminationDelay = self.pm.killTime + 1\\r\\n self.pm.stopProcess(\\\"foo\\\")\\r\\n # If process doesn't die before the killTime, procmon should\\r\\n # terminate it\\r\\n self.reactor.advance(self.pm.killTime - 1)\\r\\n self.assertEqual(0.0, self.pm.timeStarted[\\\"foo\\\"])\\r\\n\\r\\n self.reactor.advance(1)\\r\\n # We expect it to be immediately restarted\\r\\n self.assertEqual(self.reactor.seconds(), self.pm.timeStarted[\\\"foo\\\"])\",\n \"def test_quit_game(run):\\n out, _ = run(dork.cli.quit_game)\\n assert \\\"Thank you\\\" in out\",\n \"def test_delete_run(self):\\n pass\",\n \"def test_quit(self):\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"quit\\\")\\n out = f.getvalue()\\n self.assertTrue(len(out) == 0)\\n self.assertEqual(\\\"\\\", out)\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"quit fake\\\")\\n msj = f.getvalue()\\n self.assertTrue(len(msj) == 0)\\n self.assertEqual(\\\"\\\", msj)\",\n \"def test_clean(self, check_docker, volumes, q):\\n\\n volume1 = MagicMock()\\n volume1.name = \\\"some-name-tmpvol\\\"\\n volumes.list.return_value = [volume1]\\n\\n question = MagicMock(name=\\\"pop-the-question\\\")\\n question.ask.return_value = True\\n q.confirm.return_value = question\\n\\n runner = CliRunner()\\n result = runner.invoke(cli_node_clean)\\n\\n # check exit code\\n self.assertEqual(result.exit_code, 0)\",\n \"def do_command(self, args):\\n testops = dbops.Tests()\\n testops.delete(args)\",\n \"def kill(self):\\n self.error_code = 'KILLED'\\n self.running = False\",\n \"def test_send_command(fprime_test_api):\\n fprime_test_api.send_and_assert_command(\\\"cmdDisp.CMD_NO_OP\\\", max_delay=0.1)\\n assert fprime_test_api.get_command_test_history().size() == 1\\n fprime_test_api.send_and_assert_command(\\\"cmdDisp.CMD_NO_OP\\\", max_delay=0.1)\\n assert fprime_test_api.get_command_test_history().size() == 2\",\n \"def __del__(self):\\n if self.child_pid:\\n self.host.Kill(self.child_pid, IperfClient.KILL_STRING)\",\n \"def test_kill(self):\\n s = 'hello world'\\n n = 5\\n self.widget.buffer = s\\n self.widget.cursor = n\\n self.widget.keystrokeReceived('\\\\x0b', None) # C-k\\n self.assertEqual(self.widget.buffer, s[:n])\\n self.assertEqual(self.widget.killRing, [s[n:]])\",\n \"def kill(targets, controller=False):\",\n \"def test_do_quit(self):\\n for string in self.random_strings:\\n self.assertTrue(self.CommandParser.do_quit(string))\",\n \"def testBogusCommand(self):\\n self.client_connect()\\n self.client_send('bogus\\\\r\\\\n')\\n self.client_recv('.*ERROR.*\\\\r\\\\n')\\n self.assertTrue(self.mock_quiet())\",\n \"def __del__(self):\\n if self.child_pid:\\n self.host.Kill(self.child_pid, IperfServer.KILL_STRING)\",\n \"def test_destroy_exit_code(destroy_result: Result) -> None:\\n assert destroy_result.exit_code == 0\",\n \"def watchdogReset(unitTestUtil, utilType, logger, cmd_bmc, hostname, headnode=None):\\n if utilType.daemonProcessesKill is None:\\n raise Exception(\\\"no daemon process kill commands listed\\\")\\n # Login and run WatchdogProcess\\n logger.debug(\\\"starting watchdog process from this test\\\")\\n cmd_run_wdp = \\\"python /tmp/tests/common/watchdogProcess.py\\\"\\n wdSubProcess = subprocess.Popen(cmd_bmc + cmd_run_wdp,\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n\\n # Login and kill daemon processes\\n logger.debug(\\\"killing all daemon processes\\\")\\n killcmds = utilType.daemonProcessesKill\\n for cmd in killcmds:\\n killSubProcess = subprocess.Popen(cmd_bmc + cmd,\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n output = killSubProcess.communicate()\\n # kill process that just started from this script\\n logger.debug(\\\"killing watchdog process started from this test\\\")\\n psSubProcess = subprocess.Popen(cmd_bmc + \\\"ps\\\",\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n output = psSubProcess.communicate()[0]\\n #info = output.split('\\\\n')\\n info = output.decode('utf-8').split('\\\\n')\\n for line in info:\\n if \\\"watchdogProcess\\\" in line:\\n line = line.split(' ')\\n for word in line:\\n if word != '':\\n killprocess = subprocess.Popen(cmd_bmc + 'kill ' + word,\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n output = killprocess.communicate()\\n break\\n\\n # check that host is pingable -> not pingable -> pingable\\n pingcmd = \\\"\\\"\\n if headnode is None or utilType.ConnectionTestPath is None:\\n pingcmd = 'python {0}tests/common/connectionTest.py {1} 6'.format(testPath, hostname)\\n #pingcmd = ['python', testPath + 'common/connectionTest.py', hostname, '6']\\n else:\\n pingcmd = 'python {0}{1} {2} {3} 6'.format(testPath, utilType.ConnectionTestPath, headnode, hostname)\\n logger.debug(\\\"checking that ping connection to host succeeds before reboot is triggered\\\")\\n f = subprocess.Popen(pingcmd,\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n out, err = f.communicate()\\n if len(err) != 0:\\n raise Exception(err)\\n if b'PASSED' not in out:\\n print(\\\"watchdog Reset Test [FAILED]\\\")\\n sys.exit(1)\\n logger.debug(\\\"waiting 30 seconds\\\")\\n time.sleep(30)\\n logger.debug(\\\"checking that ping connection to host fails because rebooting is occurring\\\")\\n f = subprocess.Popen(pingcmd,\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n out, err = f.communicate()\\n if len(err) != 0:\\n raise Exception(err)\\n if b'PASSED' in out:\\n print(\\\"No reset from watchdog [FAILED]\\\")\\n sys.exit(1)\\n logger.debug(\\\"waiting 900 seconds\\\")\\n time.sleep(900)\\n logger.debug(\\\"checking that ping connection to host succeeds, reboot should have completed\\\")\\n f = subprocess.Popen(pingcmd,\\n shell=True, stdin=None,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n out, err = f.communicate()\\n if len(err) != 0:\\n print(\\\"checking not connected: err\\\")\\n print(err)\\n raise Exception(err)\\n if b'PASSED' not in out:\\n print(\\\"Watchdog Reset Test [FAILED]\\\")\\n sys.exit(1)\\n else:\\n print(\\\"Watchdog Reset Test [PASSED]\\\")\\n sys.exit(0)\",\n \"def testBasicQuit(self):\\n self.client_connect()\\n self.client_send(\\\"get keyNotThere\\\\r\\\\n\\\")\\n self.mock_recv('get keyNotThere\\\\r\\\\n')\\n self.mock_send('END\\\\r\\\\n')\\n self.client_recv(\\\"END\\\\r\\\\n\\\")\\n\\n self.client_send(\\\"quit\\\\r\\\\n\\\")\\n self.assertTrue(self.mock_quiet())\",\n \"def test_void_command(self):\\n # make sure VOID is a valid command\\n command = Command('VOID')\\n self.assertTrue(type(command) == Command)\",\n \"def kill(self):\\n if self.process is not None:\\n LOGGER.info('Killing command...')\\n self.process.kill()\\n self.process = None\",\n \"def test_issue_delete_stop_watch(self):\\n pass\",\n \"def Deletetest(self):\\n # Test delete()\\n result = self.runner.invoke(\\n yoda.cli,\\n [\\\"setup\\\", \\\"delete\\\"],\\n input=\\\"n\\\\n\\\"\\n )\\n self.assertEqual(result.exit_code, 0)\\n self.assertIn(\\\"Operation cancelled\\\", result.output)\\n\\n result = self.runner.invoke(\\n yoda.cli,\\n [\\\"setup\\\", \\\"delete\\\"],\\n input=\\\"y\\\\n\\\"\\n )\\n self.assertEqual(result.exit_code, 0)\\n self.assertIn(\\\"Configuration file deleted\\\", result.output)\",\n \"def cmd_quit(args):\",\n \"def phone_kill(self) -> None:\",\n \"def kill(self):\\n self.status = Modem.Status.KILL\",\n \"def stopTest(self, test):\",\n \"def test_delete():\\n mock_ret = MagicMock(return_value=0)\\n mock_group = {\\\"passwd\\\": \\\"*\\\", \\\"gid\\\": 0, \\\"name\\\": \\\"test\\\", \\\"members\\\": [\\\"root\\\"]}\\n with patch.dict(mac_group.__salt__, {\\\"cmd.retcode\\\": mock_ret}), patch(\\n \\\"salt.modules.mac_group.info\\\", MagicMock(return_value=mock_group)\\n ):\\n assert mac_group.delete(\\\"test\\\")\",\n \"def _check_stop(self, guest_obj, stop_cmd):\\n # call method and verify if it executed cmd in ssh shell\\n guest_obj.stop()\\n self._mock_ssh_shell.run.assert_called_with(stop_cmd)\",\n \"def _kill_kernel(self):\",\n \"def test_emptyKill(self):\\n s = 'hello world'\\n self.widget.buffer = s\\n self.widget.cursor = len(s)\\n self.widget.keystrokeReceived('\\\\x0b', None) # C-k\\n self.assertEqual(self.widget.buffer, s)\\n self.assertEqual(self.widget.killRing, [])\",\n \"def test_stopService(self):\\r\\n self.pm.addProcess(\\\"foo\\\", [\\\"foo\\\"])\\r\\n self.pm.addProcess(\\\"bar\\\", [\\\"bar\\\"])\\r\\n # Schedule the process to start\\r\\n self.pm.startService()\\r\\n # advance the reactor to start the processes\\r\\n self.reactor.advance(self.pm.threshold)\\r\\n self.assertIn(\\\"foo\\\", self.pm.protocols)\\r\\n self.assertIn(\\\"bar\\\", self.pm.protocols)\\r\\n\\r\\n self.reactor.advance(1)\\r\\n\\r\\n self.pm.stopService()\\r\\n # Advance to beyond the killTime - all monitored processes\\r\\n # should have exited\\r\\n self.reactor.advance(self.pm.killTime + 1)\\r\\n # The processes shouldn't be restarted\\r\\n self.assertEqual({}, self.pm.protocols)\",\n \"def _kill():\\n\\n messagebox.showerror(\\n title=const.TSSD_ERROR_TITLE,\\n message=const.TSSD_ERROR_MSG\\n )\\n\\n sys.exit(3)\",\n \"def test_delete__volume(self):\\n arglist = [\\n '--volume',\\n self.projects[0].id,\\n ]\\n verifylist = [\\n ('service', 'volume'),\\n ('project', self.projects[0].id),\\n ]\\n\\n parsed_args = self.check_parser(self.cmd, arglist, verifylist)\\n\\n result = self.cmd.take_action(parsed_args)\\n\\n self.assertIsNone(result)\\n self.projects_mock.get.assert_called_once_with(self.projects[0].id)\\n self.compute_quotas_mock.delete.assert_not_called()\\n self.volume_quotas_mock.delete.assert_called_once_with(\\n self.projects[0].id,\\n )\\n self.network_mock.delete_quota.assert_not_called()\",\n \"def kill(self):\\n\\n self.proc.kill()\",\n \"def test_status_command(self):\\n # make sure STATUS is a valid command\\n command = Command('STATUS')\\n self.assertTrue(type(command) == Command)\",\n \"def test_delete_sms_message(self):\\n pass\",\n \"def kill(self):\\n if self.transport.pid is not None:\\n self.transport.signalProcess('KILL')\",\n \"def script_kill(self):\\n return self._execute([b'SCRIPT', b'KILL'], b'OK')\",\n \"def _kill(self) -> None:\\n if not hasattr(self, \\\"proc\\\"):\\n raise FuzzFrontendError(\\\"Attempted to kill non-running PID.\\\")\\n\\n self.proc.terminate()\\n try:\\n self.proc.wait(timeout=0.5)\\n L.info(\\\"Fuzzer subprocess exited with `%d`\\\", self.proc.returncode)\\n except subprocess.TimeoutExpired:\\n raise FuzzFrontendError(\\\"Subprocess could not terminate in time\\\")\\n\\n self._on = False\",\n \"def test_delete_destroy(self):\\n domain = mock.Mock()\\n logger = mock.Mock()\\n domain.isActive.return_value = True\\n lxc.domain_delete(domain, logger, None)\\n self.assertTrue(domain.destroy.called)\",\n \"def stopTestRun(self):\",\n \"def test_uninstall(self):\\n pass\",\n \"def __init__(self,cmd,logger,killsig=-1,killtime=0):\\n self.cmd = cmd\\n self.log = logger\\n self.killsig = killsig\\n self.killtime = killtime\\n self.exception = None\\n self.exit = None\\n self.stdout = None\\n self.stderr = None\\n self.status = None\",\n \"def test_delete(self):\\n\\n value = self.instance.delete()\\n self.client.delete_instance.assert_called_once_with('nginx')\\n self.assertEqual(value, self.client.delete_instance.return_value)\",\n \"def test_node_stop(self, m_docker_client, m_client):\\n # Call method under test\\n node.node_stop(True)\\n\\n # Assert\\n m_client.remove_host.assert_called_once_with(node.hostname)\\n m_docker_client.stop.assert_called_once_with('calico-node')\",\n \"def test_parser_destroy(parser):\\n parser.parse_args(['--destroy'])\",\n \"def test_users_remove(mocker):\\r\\n mocker.patch('subprocess.call')\\r\\n users.remove(user_dict)\\r\\n subprocess.call.assert_called_with([\\r\\n 'userdel',\\r\\n '-r',\\r\\n 'kevin',\\r\\n ])\",\n \"def test_command_tags_removed(self):\\r\\n\\r\\n COMMANDLIST['!toread'] = CommandMock\\r\\n\\r\\n bm = BmarkMock()\\r\\n bm.tags['!toread'] = True\\r\\n commander = Commander(bm)\\r\\n updated = commander.process()\\r\\n\\r\\n self.assertTrue(\\r\\n '!toread' not in updated.tags,\\r\\n \\\"Our commander should find !toread command to run\\\")\",\n \"def test_node_graceful_shutdown(self, proc_info, controller_node):\\n launch_testing.asserts.assertExitCodes(proc_info, process=controller_node)\",\n \"def test_removeProcess(self):\\r\\n self.pm.startService()\\r\\n self.pm.addProcess(\\\"foo\\\", [\\\"foo\\\"])\\r\\n self.assertEqual(len(self.pm.processes), 1)\\r\\n self.pm.removeProcess(\\\"foo\\\")\\r\\n self.assertEqual(len(self.pm.processes), 0)\",\n \"def test_do_delete(delete_resource: MagicMock, response: execution.ResponseInfo):\\n delete_resource.return_value = response\\n bundle = MagicMock()\\n bundle.resources.matching.return_value = [MagicMock(), MagicMock()]\\n action = interface.CommandAction(MagicMock(), [], bundle)\\n interface.do_delete(action)\\n assert delete_resource.call_count == 2\",\n \"def test_delete_destroy_error(self):\\n domain = mock.Mock()\\n logger = mock.Mock()\\n domain.isActive.return_value = True\\n domain.destroy.side_effect = libvirt.libvirtError(\\\"BOOM\\\")\\n lxc.domain_delete(domain, logger, None)\\n self.assertTrue(domain.undefine.called)\",\n \"def test_users_remove(mocker):\\n mocker.patch('subprocess.call')\\n users.remove(user_dict)\\n subprocess.call.assert_called_with([\\n 'userdel',\\n '-r',\\n 'kevin',\\n ])\",\n \"def do_destroy(self, arg):\\n arg_list = arg.split(\\\" \\\") if type(arg) == str else arg\\n if not arg:\\n print(\\\"** class name missing **\\\")\\n return\\n if arg_list[0] not in HBNBCommand.class_list:\\n print(\\\"** class doesn't exist **\\\")\\n return\\n if len(arg_list) < 2:\\n print(\\\"** instance id missing **\\\")\\n return\\n key = arg_list[0] + \\\".\\\" + arg_list[1]\\n if key in storage.all():\\n del storage.all()[key]\\n storage.save()\\n return\\n print(\\\"** no instance found **\\\")\",\n \"def test_delete(self):\\n self.request.access.allow_delete = [\\\"everyone\\\"]\\n pkg = make_package()\\n key = self.db.redis_key(pkg.filename)\\n self.redis[key] = \\\"foobar\\\"\\n self.db.delete(pkg)\\n val = self.redis.get(key)\\n self.assertIsNone(val)\\n count = self.redis.scard(self.db.redis_set)\\n self.assertEqual(count, 0)\\n self.storage.delete.assert_called_with(pkg)\",\n \"def test_stopProcessUnknownKeyError(self):\\r\\n self.assertRaises(KeyError, self.pm.stopProcess, \\\"foo\\\")\",\n \"def tearDown(self):\\n self.popen_patcher.stop()\",\n \"def tearDown(self):\\n self.popen_patcher.stop()\",\n \"def test_multiple_commands_at_same_time(self):\",\n \"def test_delete_device_by_id(self):\\n pass\",\n \"def test_deletion(self):\\n\\n # Set the current pipe to the 'orig' data pipe.\\n name = 'orig'\\n pipes.switch(name)\\n\\n # Delete the 'orig' data pipe.\\n pipes.delete(name)\\n\\n # Test that the data pipe no longer exists.\\n self.assert_(name not in ds)\\n\\n # Test that the current pipe is None (as the current pipe was deleted).\\n self.assertEqual(pipes.cdp_name(), None)\",\n \"def test_delete(self):\\n pass\",\n \"def kill(coro):\\n return KillEvent(coro)\",\n \"def kill(self):\\n\\n #Kill relevant process names\\n if self.driver_type != 'firefox_wdm':\\n os.system('pkill -f chrome')\\n os.system('pkill -f Chrome')\\n os.system('pkill -f chromedriver')\\n else:\\n os.system('pkill -f FireFox')\\n #TODO: confirm this -> os.system('pkill -f geckodriver')\",\n \"def test_delete_bios_policy(self):\\n pass\",\n \"def kill(self):\\n self.send_signal(signal.SIGKILL)\",\n \"def test_ctrl_c(u_boot_console):\\n\\n u_boot_console.kill(signal.SIGINT)\\n assert(u_boot_console.validate_exited())\",\n \"async def kill(self, restart: bool = False) -> None:\\n pass\",\n \"def test_cleanup(self, delete_mock, network_delete_mock, create_mock, libvirt_mock):\\n resources = lxc.LXCResources('foo', {'domain': 'bar'})\\n resources._domain = mock.Mock()\\n resources._network = mock.Mock()\\n resources._hypervisor = mock.Mock()\\n resources.cleanup()\\n delete_mock.assert_called_with(resources.domain, mock.ANY, None)\\n network_delete_mock.assert_called_with(resources.network)\\n self.assertTrue(resources._hypervisor.close.called)\",\n \"def test_destroy_container_privilege(self):\\n pass\",\n \"async def module_command_quit(self, ctx, parsed):\\n if parsed.invoker != ctx.owner:\\n return\\n reason = \\\" \\\".join(parsed.args[\\\"msg\\\"] or []) or \\\"Shutting down\\\"\\n self.quit(reason)\",\n \"def do_kill(self, args):\\n if (len(args.split()) < 1):\\n self.__bad_arguments(\\\"kill\\\")\\n else:\\n print \\\"Killed \\\" + args + \\\".\\\"\\n player_killed = args.split()[0]\\n AssassinsManager.remove_assassin(self.assassins_manager, player_killed)\",\n \"def test_unkown_command(self):\\n with patch('sys.stdout', new=StringIO()) as f:\\n HBNBCommand().onecmd(\\\"something\\\")\\n self.assertEqual(f.getvalue().strip(),\\n \\\"*** Unknown syntax: something\\\")\",\n \"def test_destroy_nas_share(self):\\n pass\",\n \"def test_delete_boat(self):\\n pass\",\n \"def test_004_delete(self):\\n ret = svcmgr.main(argv=[\\\"delete\\\", \\\"-s\\\", SVCNAME, \\\"--local\\\"])\\n assert ret == 0\",\n \"def test_execute_process_killed():\\n port = port_for.select_random()\\n passing_check = check_tcp(port)\\n\\n def failing_check_for_testing_purposes():\\n return False\\n\\n with pytest.raises(PostChecksFailed) as checks_failed:\\n execute([SERVICE, 'tcp', '--port', str(port)], [passing_check, failing_check_for_testing_purposes], timeout=1)\\n\\n assert 'function failing_check_for_testing_purposes' in str(checks_failed.value)\\n\\n # The process will be killed and nothing will be listening on that port.\\n wait_until(lambda: passing_check() is False)\",\n \"def test_delete_underscore():\\n pytest.raises(SaltInvocationError, mac_group.delete, \\\"_Test\\\")\",\n \"def test_delete_case(self):\\n pass\",\n \"def test_destroy_container(self):\\n pass\",\n \"def test_cmd(host, cmd, timeout=None):\\n ps = host.popen(cmd)\\n rs = monitor_ps(ps, timeout)\\n if rs is None:\\n ps.kill()\\n return False\\n return rs == 0\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7480365","0.71652985","0.6940902","0.6931124","0.6846783","0.6776122","0.6691397","0.6687754","0.6556142","0.6425788","0.64247656","0.6313827","0.6313541","0.6313541","0.63063496","0.62784046","0.6265679","0.6265679","0.62479097","0.6243085","0.6227352","0.6163061","0.61620635","0.61607546","0.6156892","0.61465085","0.60749865","0.60749364","0.60726583","0.60711807","0.6059071","0.60306025","0.59938186","0.5983895","0.5961666","0.5951114","0.5925659","0.5921963","0.591288","0.591104","0.59005487","0.59002465","0.58818525","0.5871522","0.5858352","0.5813104","0.57871807","0.5775357","0.5753625","0.5751591","0.57489777","0.5732287","0.57264334","0.57232654","0.5717177","0.5710125","0.5709482","0.57092386","0.5699558","0.569158","0.5672069","0.566879","0.5663716","0.5661636","0.5660252","0.5655364","0.56521434","0.56502086","0.56322294","0.5627669","0.5625833","0.5624708","0.5621669","0.5621314","0.56162554","0.56137884","0.56137884","0.561317","0.5612686","0.5612045","0.56096137","0.56014633","0.5599616","0.55990463","0.55985814","0.55962574","0.55953676","0.5590933","0.5589835","0.5583081","0.5572007","0.55580163","0.5557757","0.55575794","0.55569386","0.55556345","0.5553054","0.55502635","0.5548701","0.5548608"],"string":"[\n \"0.7480365\",\n \"0.71652985\",\n \"0.6940902\",\n \"0.6931124\",\n \"0.6846783\",\n \"0.6776122\",\n \"0.6691397\",\n \"0.6687754\",\n \"0.6556142\",\n \"0.6425788\",\n \"0.64247656\",\n \"0.6313827\",\n \"0.6313541\",\n \"0.6313541\",\n \"0.63063496\",\n \"0.62784046\",\n \"0.6265679\",\n \"0.6265679\",\n \"0.62479097\",\n \"0.6243085\",\n \"0.6227352\",\n \"0.6163061\",\n \"0.61620635\",\n \"0.61607546\",\n \"0.6156892\",\n \"0.61465085\",\n \"0.60749865\",\n \"0.60749364\",\n \"0.60726583\",\n \"0.60711807\",\n \"0.6059071\",\n \"0.60306025\",\n \"0.59938186\",\n \"0.5983895\",\n \"0.5961666\",\n \"0.5951114\",\n \"0.5925659\",\n \"0.5921963\",\n \"0.591288\",\n \"0.591104\",\n \"0.59005487\",\n \"0.59002465\",\n \"0.58818525\",\n \"0.5871522\",\n \"0.5858352\",\n \"0.5813104\",\n \"0.57871807\",\n \"0.5775357\",\n \"0.5753625\",\n \"0.5751591\",\n \"0.57489777\",\n \"0.5732287\",\n \"0.57264334\",\n \"0.57232654\",\n \"0.5717177\",\n \"0.5710125\",\n \"0.5709482\",\n \"0.57092386\",\n \"0.5699558\",\n \"0.569158\",\n \"0.5672069\",\n \"0.566879\",\n \"0.5663716\",\n \"0.5661636\",\n \"0.5660252\",\n \"0.5655364\",\n \"0.56521434\",\n \"0.56502086\",\n \"0.56322294\",\n \"0.5627669\",\n \"0.5625833\",\n \"0.5624708\",\n \"0.5621669\",\n \"0.5621314\",\n \"0.56162554\",\n \"0.56137884\",\n \"0.56137884\",\n \"0.561317\",\n \"0.5612686\",\n \"0.5612045\",\n \"0.56096137\",\n \"0.56014633\",\n \"0.5599616\",\n \"0.55990463\",\n \"0.55985814\",\n \"0.55962574\",\n \"0.55953676\",\n \"0.5590933\",\n \"0.5589835\",\n \"0.5583081\",\n \"0.5572007\",\n \"0.55580163\",\n \"0.5557757\",\n \"0.55575794\",\n \"0.55569386\",\n \"0.55556345\",\n \"0.5553054\",\n \"0.55502635\",\n \"0.5548701\",\n \"0.5548608\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7495398"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88376,"cells":{"query":{"kind":"string","value":"A hook to start the Selenium Server provided with SeleniumLibrary. `logfile` must be either an opened file (or filelike object) or None. If not None, Selenium Server log will be written to it. `jarpath` must be either the absolute path to the seleniumserver.jar or None. If None, the jar file distributed with the library will be used. It is possible to give a list of additional command line options to Selenium Server in `params`. A custom automation friendly Firefox profile is enabled by default using the `firefoxProfileTemplate` option. If there is `userextensions.js` file in the same directory as the jar, it is loaded automatically using the option `userExtensions`. For more information about these options, see the documentation of the start_selenium_server method of the Selenium class. Note that this function requires `subprocess` module which is available on Python/Jython 2.5 or newer."},"document":{"kind":"string","value":"def start_selenium_server(logfile=None, jarpath=None, *params):\n if not subprocess:\n raise RuntimeError('This function requires `subprocess` module which '\n 'is available on Python/Jython 2.5 or newer.')\n cmd = _server_startup_command(jarpath, *params)\n try:\n subprocess.Popen(cmd, stdout=logfile, stderr=subprocess.STDOUT)\n except OSError:\n raise RuntimeError('Starting Selenium Server failed. Check that you '\n 'have Java 1.5 or newer installed by running '\n '`java -version` on the command prompt.')\n print 'Selenium Server started with command \"%s\" ' % ' '.join(cmd)"},"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 start_selenium_server(self, *params):\n params = ('-port', str(self._server_port)) + params\n logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')\n self._selenium_log = open(logpath, 'w')\n start_selenium_server(self._selenium_log, self._jar_path, *params)\n self._html('Selenium server log is written to <a href=\"file://%s\">%s</a>.'\n % (logpath.replace('\\\\', '/'), logpath))","def start_server():\n if not os.path.exists(cf.get(\"Selenium\", \"server_path\")):\n jar_name = \"selenium-server-standalone-2.25.0.jar\"\n server_jar = os.path.join(tempfile.gettempdir(), jar_name)\n if not os.path.exists(server_jar):\n r = requests.get(\"http://selenium.googlecode.com/files/%s\" % jar_name)\n jar_on_disk = open(server_jar, \"wb\")\n jar_on_disk.write(r.content)\n jar_on_disk.close()\n else:\n server_jar = cf.get(\"Selenium\", \"server_path\")\n \n s = subprocess.Popen(['java', '-jar', server_jar], \n stdout=tempfile.TemporaryFile(), \n stderr=tempfile.TemporaryFile()).pid\n pidfile = open(pid_file_path, \"w\")\n pidfile.write(str(s))\n pidfile.close()\n\n # make sure the server is actually up\n server_up = False\n waiting = 0\n while server_up == False and waiting < 60:\n try:\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n s.connect((\"localhost\", 4444))\n s.close()\n server_up = True\n except socket.error:\n time.sleep(1)\n waiting = waiting + 1\n server_up = False\n\n return server_up","def start_server_and_driver(path_to_driver, path_to_browser):\n \n server = service.Service(path_to_driver)\n server.start()\n\n capabilities = {'chrome.binary': path_to_browser}\n driver = webdriver.Remote(server.service_url, capabilities)\n \n return server, driver","def __init__(self, logger, binary, webdriver_binary=\"chromedriver\",\n adb_binary=None,\n remote_queue=None,\n device_serial=None,\n webdriver_args=None,\n stackwalk_binary=None,\n symbols_path=None):\n super().__init__(logger,\n webdriver_binary, adb_binary, remote_queue,\n device_serial, webdriver_args, stackwalk_binary,\n symbols_path)\n self.binary = binary\n self.wptserver_ports = _wptserve_ports","def __init__(self, timeout=5.0, server_host='localhost', server_port=4444,\n jar_path=None, run_on_failure='Capture Screenshot'):\n self._cache = utils.ConnectionCache()\n self._selenium = NoBrowserOpen()\n self.set_selenium_timeout(timeout or 5.0)\n self._server_host, self._server_port \\\n = self._parse_host_and_port(server_host or 'localhost',\n server_port or 4444)\n self._jar_path = jar_path\n self._set_run_on_failure(run_on_failure)\n self._selenium_log = None\n self._locator_parser = LocatorParser(self)\n self._namegen = _NameGenerator()","def start(self, suite, args=[]):\n self.suite = suite\n self.output_file = \"%s_Output.xml\" % (self.name)\n temp, suiteName = os.path.split(payload) \n jyLog = open(os.path.join(logFolder, (\"%s_Log.txt\" % self.name)), \"w\") \n jybotCommand = \"pybot -o %s %s\" % (os.path.join(logFolder, self.output_file), self.suite)\n \n print \"Executing : %s ...\" % jybotCommand\n self.running = True\n self.process = subprocess.Popen([\"pybot\", \"-o\", \"%s\" % os.path.join(logFolder, self.output_file), \"%s\" % self.suite], cwd=clientCwd, stdout=jyLog, stderr=jyLog)","def _runner(self, classpath, main, jvm_options, args):","def _start_server():\n args = [sys.executable] + sys.argv\n args.insert(args.index('wserver'), 'server')\n args.remove('wserver')\n pid = os.spawnv(os.P_NOWAIT, sys.executable, args)\n return pid","def test_selenium_startup_shutdown_jar_single(self):\n self.configure({\n 'execution': {\n 'scenario': {'script': RESOURCES_DIR + 'selenium/junit/jar/'},\n 'runner': 'junit',\n 'executor': 'selenium'\n },\n 'reporting': [{'module': 'junit-xml'}]\n })\n self.obj.prepare()\n self.assertIsInstance(self.obj.runner, JUnitTester)\n self.obj.startup()\n while not self.obj.check():\n time.sleep(1)\n self.obj.shutdown()\n\n self.assertIsInstance(self.obj.runner, JavaTestRunner)\n prepared_files = listdir(self.obj.runner.working_dir)\n java_files = [fname for fname in prepared_files if fname.endswith(\".java\")]\n class_files = [fname for fname in prepared_files if fname.endswith(\".class\")]\n jars = [fname for fname in prepared_files if fname.endswith(\".jar\")]\n self.assertEqual(len(java_files), 0)\n self.assertEqual(len(class_files), 0)\n self.assertEqual(len(jars), 0)\n self.assertTrue(exists(self.obj.runner.report_file))","def start(self):\r\n if platform.system() == \"Windows\":\r\n # Use a local GeckoDriver on Windows\r\n ffo = Options()\r\n ffo.headless = self.state\r\n gecko = \"dependencies/geckodriver.exe\"\r\n full_gecko = os.path.abspath(gecko)\r\n self.web_driver = webdriver.Firefox(executable_path=full_gecko, options=ffo)\r\n else:\r\n # Use a remote server if testing on Travis\r\n username = os.environ[\"SAUCE_USERNAME\"]\r\n access_key = os.environ[\"SAUCE_ACCESS_KEY\"]\r\n capabilities = {}\r\n capabilities[\"tunnel-identifier\"] = os.environ[\"TRAVIS_JOB_NUMBER\"]\r\n capabilities['version'] = \"45.0\"\r\n capabilities['browserName'] = \"firefox\"\r\n hub_url = \"%s:%s@localhost:4445\" % (username, access_key)\r\n self.web_driver = webdriver.Remote(\r\n desired_capabilities=capabilities,\r\n command_executor=\"http://%s/wd/hub\" % hub_url)","def __init__(self, driver_path=None):\n\n if driver_path is None:\n self.driver = webdriver.Firefox()\n else:\n print(\"Alter gecko path\")\n self.driver = webdriver.Firefox(executable_path=driver_path)","def spawn(self, classpath, main, jvm_options=None, args=None, **subprocess_args):\r\n cmd = self._create_command(*self._scrub_args(classpath, main, jvm_options, args))\r\n return self._spawn(cmd, **subprocess_args)","def start_btslog(btslog_dir, log_type):\r\n \r\n log_type = log_type.upper()\r\n if \"BTSlog2\" in btslog_dir:\r\n if log_type == 'UDP':\r\n argument = 'start_udplog'\r\n elif log_type == 'TRACING':\r\n argument = 'start_tracing'\r\n elif log_type == 'BOTH':\r\n argument = 'start_both'\r\n else:\r\n raise Exception, \"log_type '%s' is not supported\" % log_type\r\n start_program_with_psexec('\\\"%s\\\" -nogui -%s' % (btslog_dir, argument))\r\n\r\n else:\r\n if log_type == 'UDP':\r\n argument = 'start_udplog'\r\n elif log_type == 'TRACING':\r\n argument = 'start_bssigrec'\r\n elif log_type == 'BOTH':\r\n argument = 'start_both'\r\n else:\r\n raise Exception, \"log_type '%s' is not supported\" % log_type\r\n ret = connections.execute_shell_command_without_check('\\\"%s\\\" %s' % (btslog_dir, argument))\r\n if ret.find('is not recognized') > 0: # probably given path is not avaialbe\r\n raise Exception, 'start %s log failed' % log_type","def __init__(self, logfile):\r\n super(PopenWrapper, self).__init__()\r\n self.logfile = logfile","def _start_mockserver(cls, h5filepath, same_process=False, disable_server_logging=True):\n return H5MockServer.create_and_start( h5filepath, \"localhost\", 8000, same_process, disable_server_logging )","def _start_server(cls, cmd_path, address='localhost:502',\n tags=(20, 20, 20, 20), mode=1):\n\n try:\n cmd = ModbusProtocol._start_server_cmd(cmd_path, address, tags, mode)\n server = subprocess.Popen(cmd, shell=False)\n\n return server\n\n except Exception as error:\n print('ERROR modbus _start_server: ', error)","def _run_java(self, *args):\n if self._java_properties is None:\n params = [self._java_call, '-jar', self._jar_file]\n else:\n params = [self._java_call] + self._java_properties \\\n + ['-jar', self._jar_file]\n params.extend(args)\n return subprocess.call(params)","def __init__(self, path_to_web_driver='/usr/local/bin/chrome'):\n self.path_to_web_driver = path_to_web_driver\n options = webdriver.ChromeOptions()\n options.add_argument('headless')\n webdriver.Chrome.__init__(self, executable_path=self.path_to_web_driver, chrome_options=options)","def launch_browser(option):\n if not option:\n chrome_options = Options()\n chrome_options.add_argument(\"--headless\")\n return webdriver.Chrome(\"/usr/bin/chromedriver\",\n chrome_options=chrome_options)\n else:\n return webdriver.Chrome(\"/usr/bin/chromedriver\")","def startserver(path):\n global urlpath\n urlpath = path\n app.run(debug=True, host='0.0.0.0', port=4444)","def start_selenium(site, headless=True):\n global DRIVER\n global PATH_DRIVER\n options = selenium.webdriver.ChromeOptions()\n prefs = {'profile.managed_default_content_settings.images': 2, 'disk-cache-size': 4096}\n options.add_argument('log-level=3')\n options.add_experimental_option(\"prefs\", prefs)\n if headless:\n options.add_argument(\"--headless\")\n options.add_argument(\"--disable-extensions\")\n print(PATH_DRIVER)\n DRIVER[site] = selenium.webdriver.Chrome(options=options)\n colorama.init()\n print(termcolor.colored('Driver started for {}'.format(site), 'green'))\n colorama.Style.RESET_ALL\n colorama.deinit()","def test_executable():\n arg1 = get_args(driver=\"chrome\", executable=\"/tmp\")\n assert arg1[\"executable_path\"] == \"/tmp\"","def runner(self, classpath, main, jvm_options=None, args=None):\r\n return self._runner(*self._scrub_args(classpath, main, jvm_options, args))","def start_server_proc(event, server_cmd, checking_env):\n proc = subprocess.Popen(server_cmd, env=checking_env)\n\n # Blocking termination until event is set.\n event.wait()\n\n # If proc is still running, stop it.\n if proc.poll() is None:\n proc.terminate()","def test_selenium_startup_shutdown_jar_folder(self):\n self.configure({\n 'execution': {\n 'scenario': {'script': RESOURCES_DIR + 'selenium/junit/jar/'},\n 'executor': 'selenium'\n },\n 'reporting': [{'module': 'junit-xml'}]\n })\n self.obj.prepare()\n self.obj.startup()\n while not self.obj.check():\n time.sleep(1)\n self.obj.shutdown()\n\n self.assertIsInstance(self.obj.runner, JavaTestRunner)\n prepared_files = listdir(self.obj.runner.working_dir)\n java_files = [fname for fname in prepared_files if fname.endswith(\".java\")]\n class_files = [fname for fname in prepared_files if fname.endswith(\".class\")]\n jars = [fname for fname in prepared_files if fname.endswith(\".jar\")]\n self.assertEqual(len(java_files), 0)\n self.assertEqual(len(class_files), 0)\n self.assertEqual(len(jars), 0)\n self.assertTrue(exists(self.obj.runner.report_file))","def test_webuidriver_remote(self):\n\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\n hub.start_server()\n\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\"localhost\", 4444))\n node.start_server()\n executors = SeleniumHatch.get_remote_executors(\"localhost\", 4444)\n\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\n\n self.driver.get('http://www.baidu.com')\n time.sleep(1)\n\n # webuidriver.Remote 是 webdriver.Chrome 的子类\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\n self.assertIsInstance(self.driver, webdriver.Remote)\n\n self.driver.close()\n self.driver.quit()\n\n hub.stop_server()\n node.stop_server()","def test_application_start():\n\n process = subprocess.Popen(['python', 'runserver.py'],\n stderr=subprocess.STDOUT,\n stdout=subprocess.PIPE)\n\n assert process.pid\n debug_logging = process.stdout.read(100)\n process.kill()\n assert 'Starting application' in debug_logging","def execute_to_log(cmd, logfile, timeout=-1,\n watch_logs=[\n ('[syslog]', '/var/log/syslog'),\n ('[sqlslo]', '/var/log/mysql/slow-queries.log'),\n ('[sqlerr]', '/var/log/mysql/error.log')\n ],\n heartbeat=True, env=None, cwd=None\n ):\n\n if not os.path.isdir(os.path.dirname(logfile)):\n os.makedirs(os.path.dirname(logfile))\n\n logger = logging.getLogger(logfile)\n log_handler = logging.FileHandler(logfile)\n log_formatter = logging.Formatter('%(asctime)s %(message)s')\n log_handler.setFormatter(log_formatter)\n logger.addHandler(log_handler)\n\n descriptors = {}\n\n for watch_file in watch_logs:\n if not os.path.exists(watch_file[1]):\n logger.warning('Failed to monitor log file %s: file not found'\n % watch_file[1])\n continue\n\n try:\n fd = os.open(watch_file[1], os.O_RDONLY)\n os.lseek(fd, 0, os.SEEK_END)\n descriptors[fd] = {'name': watch_file[0],\n 'poll': select.POLLIN,\n 'lines': ''}\n except Exception as e:\n logger.warning('Failed to monitor log file %s: %s'\n % (watch_file[1], e))\n\n cmd += ' 2>&1'\n start_time = time.time()\n p = subprocess.Popen(\n cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,\n env=env, cwd=cwd)\n\n descriptors[p.stdout.fileno()] = dict(\n name='[output]',\n poll=(select.POLLIN | select.POLLHUP),\n lines=''\n )\n\n poll_obj = select.poll()\n for fd, descriptor in descriptors.items():\n poll_obj.register(fd, descriptor['poll'])\n\n last_heartbeat = time.time()\n\n def process(fd):\n \"\"\" Write the fd to log \"\"\"\n global last_heartbeat\n descriptors[fd]['lines'] += os.read(fd, 1024 * 1024)\n # Avoid partial lines by only processing input with breaks\n if descriptors[fd]['lines'].find('\\n') != -1:\n elems = descriptors[fd]['lines'].split('\\n')\n # Take all but the partial line\n for l in elems[:-1]:\n if len(l) > 0:\n l = '%s %s' % (descriptors[fd]['name'], l)\n logger.info(l)\n last_heartbeat = time.time()\n # Place the partial line back into lines to be processed\n descriptors[fd]['lines'] = elems[-1]\n\n while p.poll() is None:\n if timeout > 0 and time.time() - start_time > timeout:\n # Append to logfile\n logger.info(\"[timeout]\")\n os.kill(p.pid, 9)\n\n for fd, flag in poll_obj.poll(0):\n process(fd)\n\n if time.time() - last_heartbeat > 30:\n # Append to logfile\n logger.info(\"[heartbeat]\")\n last_heartbeat = time.time()\n\n # Do one last write to get the remaining lines\n for fd, flag in poll_obj.poll(0):\n process(fd)\n\n # Clean up\n for fd, descriptor in descriptors.items():\n poll_obj.unregister(fd)\n os.close(fd)\n try:\n p.kill()\n except OSError:\n pass\n\n logger.info('[script exit code = %d]' % p.returncode)\n logger.removeHandler(log_handler)\n log_handler.flush()\n log_handler.close()\n return p.returncode","def start_server(self,\n server,\n expect_launch,\n expect_exit=True,\n expected_exitcode=0,\n **kwargs):\n self.cleanup()\n\n # Start up the requested server\n exitcode, out, err = server.start(expect_exit=expect_exit,\n expected_exitcode=expected_exitcode,\n **kwargs)\n if expect_exit:\n self.assertEqual(expected_exitcode, exitcode,\n \"Failed to spin up the requested server. \"\n \"Got: %s\" % err)\n\n self.launched_servers.append(server)\n\n launch_msg = self.wait_for_servers([server], expect_launch)\n self.assertTrue(launch_msg is None, launch_msg)","def __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\n\n # selecting driver\n if not driver_path:\n driver = webdriver.Firefox\n driver_options = FireFoxOptions()\n else:\n driver = webdriver.Chrome\n driver_options = ChromeOptions()\n\n # add config\n if options:\n for option in options:\n driver_options.add_argument(option)\n\n self.driver = driver(driver_path, options=driver_options)\n self.waiter = WebDriverWait(self.driver, waiter_timeout)","def start(cfg: 'Settings', server: str):\n\n try:\n server_path = find_server(cfg.parent_directory, server)\n except (ParentDirMissing, ServerNotFound, NoInvocation) as e:\n e.log_this()\n return\n\n if isUp(server):\n log.info(f'{server} appears to be running already!')\n else:\n invocation = get_invocation(server_path)\n os.chdir(server_path)\n log.info(f'Starting {server}')\n run(['screen', '-h', '5000', '-dmS', server, *invocation, 'nogui'])\n sleep(5)\n if isUp(server):\n log.info(f'{server} is now running!')\n # run_startup_commands(server)\n else:\n log.warning(f'{server} does not appear to have started!')","def cmd_monitor_plugin_install(self, *argv, **kwargs):\n \n url = kwargs.get('url', None)\n content = None\n \n if not url:\n raise ecm.InvalidParameters(self.cmd_monitor_plugin_install.__doc__)\n \n try:\n content = ecm.get_url(url)\n except:\n pass\n \n if not content:\n raise Exception(\"Unable to get URL: %s\" % url)\n \n try: \n plugin = json.loads(content)\n except:\n raise Exception(\"Invalid data received\")\n\n id = plugin.get('id')\n runas = plugin.get('runas')\n \n arg_config = plugin.get('config')\n arg_script_b64 = plugin.get('script')\n \n script = None\n try:\n script = b64decode(arg_script_b64)\n except:\n pass\n \n config = {\n 'id': id,\n 'runas': runas,\n 'name': plugin.get('name'),\n 'interval': plugin.get('interval'),\n 'version': plugin.get('version'),\n 'config': arg_config\n }\n \n if id and config and script:\n mplugin = MPlugin(MPLUGIN_PATH)\n if mplugin.install(id, config, script):\n # Installation ok, run it\n script_file = os.path.abspath(os.path.join(MPLUGIN_PATH, id, id))\n _run_background_file(script_file, runas)\n \n return True\n \n return False","def start_audit_manager(path) -> WebDriver:\n # close existing instance(s) if exists\n import os\n os.system(\"taskkill /FI \\\"IMAGENAME eq mmc.exe\\\" /F\")\n # run new instance\n exp_cap = {\"app\": \"mmc.exe\",\n \"deviceName\": \"WindowsPC\",\n \"appArguments\": \"\\\"\" + path + \"\\\"\"\n }\n exp_session = webdriver.Remote(\n command_executor='http://127.0.0.1:4723',\n desired_capabilities=exp_cap)\n return exp_session\n # region old\n # desktoppath = r\"C:\\Users\\administrator\\Desktop\"\n # exp_cap = {\"app\": \"explorer.exe\", \"deviceName\": \"WindowsPC\", \"appArguments\": desktoppath}\n # exp_session = webdriver.Remote(\n # command_executor='http://127.0.0.1:4723',\n # desired_capabilities=exp_cap)","def startServer(logServer, host=\"localhost\", ports=(globalconst.DEFAULTPORT_XMLRPC,), readyMsg=True):\n\t# v0.3.0: The order of host,ports has changed for consistency\n\t# warn:\n\tif type(host) in (tuple,list) or type(ports) in (str,str):\n\t\tmsg = \"Unexpected host or ports type. Note: The argument order in startServer has changed. Use host,ports now instead of ports,host. That has been inconsistent before (sorry)\"\n\t\twarnings.warn(msg)\n\t\traise TypeError(msg)\n\t\n\tserver = createSimpleXMLRPCServer(host,ports)\n\tadapter = LogAdapter(logServer)\n\tserver.register_function(adapter.log, \"log\")\n\tserver.register_function(adapter.addClient, \"addClient\")\n\tif readyMsg: print(\"log server ready. Available at host,port: %s\"%(str(server.server_address)))\n\tserver.serve_forever()","def launch_server(message_handler, options):\n logger = logging.getLogger(__name__)\n # if (options.debug):\n # logger.setLevel(logging.DEBUG)\n\n# if not options.monitor_port:\n# logger.warning(\n# \"Monitoring not enabled. No monitor-port option defined.\")\n# else:\n# threading.Thread(target=launch_monitor_server, args=(options.host, options.monitor_port, logger)).start()\n\n # Create the server, binding to specified host on configured port\n\n# logger.info(\n# 'Starting server on host %s port %d Python version %s.%s.%s' % ((options.host, options.port) + sys.version_info[:3]))\n# server = ThreadedTCPServer((options.host, options.port),\n\n # Activate the server; this will keep running until you\n # interrupt the program with Ctrl-C\n try:\n while True:\n logger.debug('waiting for more data')\n if not message_handler.handle():\n break\n logger.warning(\"I/O stream closed from client\")\n\n except KeyboardInterrupt:\n logger.info(\"I/O stream closed from client exiting...\")\n os._exit(142)\n\n except:\n logger.exception(\"Error encountered handling message\")","def main(server):\n config_parser = ConfigParser()\n config_parser.read('resources/conf/config.ini')\n\n log_level = log_levels.get(config_parser.get('core', 'log.level'))\n log_filename = config_parser.get('core', 'log.path')\n logging.basicConfig(level=log_level,\n format='%(levelname)s:%(asctime)s:%(message)s',\n filename=log_filename)\n replicator = Replicator(config_parser)\n executor = ThreadPoolExecutor(max_workers=2)\n executor.submit(replicator.start)\n logger = logging.getLogger('replicator')\n if log_level == 'DEBUG':\n handler = logging.StreamHandler()\n handler.setLevel(logging.DEBUG)\n logger.addHandler(handler)\n if server:\n if config_parser.has_section('server'):\n check_server_configuration(config_parser, logger)\n server_config = {\n 'server.socket_host' : config_parser.get('server', 'socket_host'),\n 'server.socket_port' : config_parser.getint('server', 'socket_port'),\n 'log.access_file' : config_parser.get('server', 'log.access_file'),\n 'log.error_file' : config_parser.get('server', 'log.error_file')\n }\n cherrypy.config.update(server_config)\n logger.info('Server will be started at %s:%d' % (server_config['server.socket_host'],\n server_config['server.socket_port']))\n else:\n logger.info('No settings found, using the default one. (localhost:8080)')\n executor.submit(cherrypy.quickstart(ReplicatorServer(replicator)))","def setup_logging(filepath=core.ServerConfiguration.LOGDIR,\n log_name='server_process'):\n\n if not os.path.exists(filepath):\n raise IOError('LOG_DIR filepath does not exist: {0:s}'.format(filepath))\n\n if not log_name in core.DEFAULT_LOGGER_PROCESSES:\n raise ValueError('Log_name should be in {0:s}.'\n .format(core.DEFAULT_LOGGER_PROCESSES))\n\n filename = generate_log_filename()\n log_file = os.path.join(filepath, filename)\n\n # configure log formatter\n log_fmt = logging.Formatter('[%(levelname)s][%(asctime)s] %(message)s',\n datefmt='%Y/%m/%d %I:%M:%S %p')\n\n # configure file handler\n file_handler = logging.FileHandler(log_file)\n file_handler.setFormatter(log_fmt)\n\n # stream handler\n stream_handler = logging.StreamHandler()\n stream_handler.setFormatter(log_fmt)\n\n # setup a server log, add file and stream handlers\n logger = logging.getLogger(log_name)\n logger.addHandler(file_handler)\n logger.addHandler(stream_handler)\n logger.setLevel(logging.DEBUG)\n\n return log_file","def start_local_cmd(log_path, log_name=\"localcmd\"):\n log_dir = os.path.abspath(log_path)\n try:\n os.makedirs(log_dir)\n except OSError:\n pass\n return CmdRunner.CmdRunner(log_dir, log_name)","def startJybot(name, suite, args=[]):\n jybot = Jybot(name)\n jybot.start(suite, args)\n return jybot","def set_logger(log_path, terminal=True):\n logger = logging.getLogger()\n logger.setLevel(logging.INFO)\n\n if not logger.handlers:\n # Logging to a file\n file_handler = logging.FileHandler(log_path)\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\n logger.addHandler(file_handler)\n\n # Logging to console\n if terminal:\n stream_handler = logging.StreamHandler()\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\n logger.addHandler(stream_handler)","def before_productline_steps():\n cmd = ['phantomjs', '--webdriver', '4444']\n click.echo(\"Running command\" + subprocess.list2cmdline(cmd))\n process = subprocess.Popen(cmd)\n RUNNING_TEST_PROCESSES.append(process)","def selenium_server(request) -> Optional[str]:\n return (\n # CLI arg takes precedence\n request.config.getoption(\"selenium_server\")\n # Otherwise, we look for a non-empty string\n or os.environ.get('SELENIUM_SERVER', '').strip()\n # If the result is still Falsey, we always return None.\n or None\n )","def execute(self, classpath, main, jvm_options=None, args=None, stdout=None, stderr=None):\r\n executor = self.runner(classpath=classpath, main=main, jvm_options=jvm_options, args=args)\r\n return executor.run(stdout=stdout, stderr=stderr)","def _load_jupyter_server_extension(server_app):\n\n server_app.log.info('jupyterlab_slurm server extension loaded')\n slurm_commands = SlurmCommandPaths(parent=server_app)\n server_app.log.info(slurm_commands.get_paths())\n\n web_app = server_app.web_app\n web_app.settings.update(slurm_commands.get_paths())\n\n temporary_directory = web_app.settings['temporary_directory'] if 'temporary_directory' in web_app.settings else None\n #server_app.log.addHandler(logging.FileHandler('/tmp/jupyter_debug'))\n #server_app.log.setLevel(logging.DEBUG)\n\n # add get_example url\n setup_handlers(\n web_app, temporary_directory=temporary_directory, log=server_app.log)","def run_server(\n server_host=bridge.DEFAULT_HOST,\n server_port=DEFAULT_SERVER_PORT,\n response_timeout=bridge.DEFAULT_RESPONSE_TIMEOUT,\n background=True,\n):\n server = bridge.BridgeServer(\n server_host=server_host,\n server_port=server_port,\n loglevel=logging.INFO,\n response_timeout=response_timeout,\n local_call_hook=hook_local_call,\n local_eval_hook=hook_local_eval,\n local_exec_hook=hook_local_exec,\n )\n\n if background:\n server.start()\n print(\n \"Server launching in background - will continue to run after launch script finishes...\\n\"\n )\n else:\n server.run()","def _launch_minecraft(self, port, headless, minecraft_dir):\n replaceable = False\n\n launch_script = 'launchClient.sh'\n if os.name == 'nt':\n launch_script = 'launchClient.bat'\n\n launch_script = os.path.join(minecraft_dir, launch_script)\n rundir = os.path.join(minecraft_dir, 'run')\n \n cmd = [launch_script, '-port', str(port), '-env', '-runDir', rundir]\n if self.status_dir:\n cmd += ['-performanceDir', self.status_dir]\n if self._seed:\n cmd += ['-seed', \",\".join(self._seed)]\n\n cmd_to_print = cmd[:] if not self._seed else cmd[:-2]\n self._logger.info(\"Starting Minecraft process: \" + str(cmd_to_print))\n # print(cmd)\n\n if replaceable:\n cmd.append('-replaceable')\n preexec_fn = os.setsid if 'linux' in str(sys.platform) or sys.platform == 'darwin' else None\n # print(preexec_fn)\n minecraft_process = subprocess.Popen(cmd,\n cwd=InstanceManager.MINECRAFT_DIR,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT,\n # use process group, see http://stackoverflow.com/a/4791612/18576\n preexec_fn=preexec_fn\n )\n return minecraft_process","def start(self, logfile_name):\n\n self._verify_not_running()\n\n # The package structure for LiteServ is different pre 1.4. Handle for this case\n if has_dot_net4_dot_5(self.version_build):\n binary_path = \"{}/couchbase-lite-net-mono-{}-liteserv/net45/LiteServ.exe\".format(BINARY_DIR, self.version_build)\n else:\n binary_path = \"{}/couchbase-lite-net-mono-{}-liteserv/LiteServ.exe\".format(BINARY_DIR, self.version_build)\n\n process_args = [\n \"mono\",\n binary_path,\n \"--port\", str(self.port),\n \"--dir\", \"{}/dbs/net-mono/\".format(RESULTS_DIR)\n ]\n\n if self.storage_engine == \"ForestDB\" or self.storage_engine == \"ForestDB+Encryption\":\n process_args.append(\"--storage\")\n process_args.append(\"ForestDB\")\n else:\n process_args.append(\"--storage\")\n process_args.append(\"SQLite\")\n\n if self.storage_engine == \"SQLCipher\" or self.storage_engine == \"ForestDB+Encryption\":\n log_info(\"Using Encryption ...\")\n db_flags = []\n for db_name in REGISTERED_CLIENT_DBS:\n db_flags.append(\"--dbpassword\")\n db_flags.append(\"{}=pass\".format(db_name))\n process_args.extend(db_flags)\n\n log_info(\"Launching: {} with args: {}\".format(binary_path, process_args))\n\n self.logfile = open(logfile_name, \"w\")\n self.process = subprocess.Popen(args=process_args, stdout=self.logfile)\n\n self._verify_launched()\n\n return \"http://{}:{}\".format(self.host, self.port)","def _start_server(self, repo_root):\r\n # By default, hglib uses 'hg'. User might need to change that on\r\n # Windows, for example.\r\n hg_bin = get_hg_exe_name()\r\n server = client.CmdServerClient(hg_bin=hg_bin, repo_root=repo_root)\r\n return server","def __run_server(self):\n os.chdir(os.path.dirname(self.server_path))\n self.server_process = subprocess.Popen([self.server_path, \\\n \"{}:{}\".format(self.args.ip, self.args.port)])","def _run_web_server(q, log_filepath, dist_dir, custom_headers):\n\n os.chdir(dist_dir)\n\n log_fh = log_filepath.open(\"w\", buffering=1)\n sys.stdout = log_fh\n sys.stderr = log_fh\n\n class Handler(http.server.SimpleHTTPRequestHandler):\n def log_message(self, format_, *args):\n print(\n \"[%s] source: %s:%s - %s\"\n % (self.log_date_time_string(), *self.client_address, format_ % args)\n )\n\n def end_headers(self):\n # Enable Cross-Origin Resource Sharing (CORS)\n for k, v in custom_headers.items():\n self.send_header(k, v)\n self.send_header(\"Access-Control-Allow-Origin\", \"*\")\n super().end_headers()\n\n with socketserver.TCPServer((\"\", 0), Handler) as httpd:\n host, port = httpd.server_address\n print(f\"Starting webserver at http://{host}:{port}\")\n httpd.server_name = \"test-server\" # type: ignore[attr-defined]\n httpd.server_port = port # type: ignore[attr-defined]\n q.put(port)\n\n def service_actions():\n try:\n if q.get(False) == \"TERMINATE\":\n print(\"Stopping server...\")\n sys.exit(0)\n except queue.Empty:\n pass\n\n httpd.service_actions = service_actions # type: ignore[assignment]\n httpd.serve_forever()","def browserConfiguration(path):\n\tprofile = FirefoxProfile()\n\tprofile.set_preference(\"browser.download.panel.shown\", False)\n\tprofile.set_preference(\"browser.download.manager.showWhenStarting\", False)\n\tprofile.set_preference(\"browser.helperApps.neverAsk.saveToDisk\", \"application/octet-stream\")\n\tprofile.set_preference(\"browser.download.folderList\", 2)\n\tprofile.set_preference(\"browser.download.dir\", path)\n\toptions = Options()\n\toptions.add_argument(\"--headless\")\n\treturn webdriver.Firefox(firefox_profile=profile, options=options, service_log_path=os.path.devnull)","def _serverThreadRunner(self):\n args = self._argsForSubprocess()\n logging.info(\"Test server popen() args: %s\" % str.join(\" \", args))\n self._server_process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\n with self._has_launched_cv:\n self._has_launched = True\n self._has_launched_cv.notify_all()\n stdout, stderr = self._server_process.communicate()\n logging.info(\"Process stdout: %s\", stdout.decode(\"utf-8\"))\n logging.info(\"Process stderr: %s\", stderr.decode(\"utf-8\"))\n return stdout, stderr","def logging_setup(args, log_dir):\n timestamp_file = datetime.now().strftime(\"%Y%m%d-%H.%M_rcf_abb.log\")\n log_file = Path(log_dir) / timestamp_file\n\n handlers = []\n\n if not args.skip_logfile:\n handlers.append(log.FileHandler(log_file, mode=\"a\"))\n if not args.quiet:\n handlers.append(log.StreamHandler(sys.stdout))\n\n log.basicConfig(\n level=log.DEBUG if args.debug else log.INFO,\n format=\"%(asctime)s:%(levelname)s:%(funcName)s:%(message)s\",\n handlers=handlers,\n )","def test_install_should_call_subprocess_run(self, mock_subprocess):\n manifest = self.generate_mock_manifest(cfg={\n EXTCFG_SECTION.INSTALL: {\n EXTCFG_OPTION.EXEC_EXT_CMD: ['command'],\n }\n })\n ext_manager = PkgInstExtrasManager(manifest)\n ext_manager.handle_install_extras()\n mock_subprocess.assert_called_with(\n 'command',\n check=True,\n stderr=-1,\n stdout=-1,\n timeout=90,\n universal_newlines=True)","def run_test_server(site_path, new_env=None):\n args = ['python', 'runserver.py', '--no_reload', site_path]\n # Werkzeug is a dependency of flask which we are using for the mock api\n # however there is an issue with Werkzeug that prevents it from properly\n # handling the SIGTERM sent by p.kill() or terminate()\n # Issue: https://github.com/pallets/werkzeug/issues/58\n p = subprocess.Popen(args, stdout=subprocess.PIPE, preexec_fn=os.setsid,\n env=new_env)\n\n try:\n _wait_for_server()\n yield 'http://localhost:5000/'\n finally:\n os.killpg(os.getpgid(p.pid), signal.SIGINT)","def _start_server(apps, port, no_browser):\n # necessary for the dashboard to work when called from a notebook\n asyncio.set_event_loop(asyncio.new_event_loop())\n\n # this is adapted from bokeh.subcommands.serve\n with report_server_init_errors(port=port):\n server = Server(apps, port=port)\n\n # On a remote server, we do not want to start the dashboard here.\n if not no_browser:\n\n def show_callback():\n server.show(\"/\")\n\n server.io_loop.add_callback(show_callback)\n\n address_string = server.address if server.address else \"localhost\"\n\n print( # noqa: T201\n \"Bokeh app running at:\",\n f\"http://{address_string}:{server.port}{server.prefix}/\",\n )\n server._loop.start()\n server.start()","def launch(*args, directory: AnyStr=\"\", movie: AnyStr=\"\", pdfFile: AnyStr=\"\", webPage:\n AnyStr=\"\", **kwargs)->None:\n pass","def __init__(self, senna_path, executable):\n self.senna_path = senna_path\n self.p = sp.Popen(['blabla', '-path', senna_path],\n executable=os.path.join(senna_path, executable),\n stdin=sp.PIPE,\n stdout=sp.PIPE)","def run(filepath=\"log.txt\"):\n if (is_windows(False)):\n print(color.red(\"\\nYour system isn't *unix\\n\"))\n return\n filepath = path.abspath(filepath)\n # 获取filepath的文件夹路径\n dirpath = path.dirname(filepath)\n # 判断文件夹是否存在\n if not path.exists(dirpath):\n print(color.red(\"\\nFile path is invalid\\n\"))\n return\n # 判断文件夹是否可写\n if access(dirpath, W_OK):\n print(color.green(f\"\\nSet log in {filepath}\\n\"))\n sys.stdout = Logger(filepath, sys.__stdout__)\n sys.stderr = Logger(filepath, sys.__stderr__)\n gset(\"log_filepath\", filepath, True)\n gset(\"log_stdout\", sys.stdout, True)\n gset(\"log_stderr\", sys.stderr, True)\n else:\n print(color.red(\"\\nFile path is invalid\\n\"))","def setup_logging(log=None, level=logging.INFO\n , program=\"\", syslog_address=\"\", tcp_address=\"\", udp_address=\"\"\n , only_message=False, json_to_console=False, logging_handler_file=sys.stderr\n ):\n log = log if log is not None else logging.getLogger(log)\n\n if syslog_address:\n address = syslog_address\n if not syslog_address.startswith(\"/\") and \":\" in syslog_address:\n split = address.split(\":\", 2)\n address = (split[0], int(split[1]))\n handler = SyslogHandler(address = address)\n elif udp_address:\n handler = JsonOverUDPHandler(program, udp_address.split(\":\")[0], int(udp_address.split(\":\")[1]))\n elif tcp_address:\n handler = JsonOverTCPHandler(program, tcp_address.split(\":\")[0], int(tcp_address.split(\":\")[1]))\n else:\n if json_to_console:\n handler = JsonToConsoleHandler(program, logging_handler_file)\n else:\n handler = RainbowHandler(logging_handler_file)\n\n # Protect against this being called multiple times\n handler.delfick_logging = True\n if any(getattr(h, \"delfick_logging\", False) for h in log.handlers):\n return\n\n if syslog_address:\n handler.setFormatter(SimpleFormatter(\"{0}[{1}]: %(message)s\".format(program, os.getpid()), ignore_extra=True))\n elif udp_address or tcp_address or json_to_console:\n handler.setFormatter(SimpleFormatter(\"%(message)s\"))\n else:\n base_format = \"%(name)-15s %(message)s\"\n if only_message:\n base_format = \"%(message)s\"\n\n handler._column_color['%(asctime)s'] = ('cyan', None, False)\n handler._column_color['%(levelname)-7s'] = ('green', None, False)\n handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False)\n if only_message:\n handler.setFormatter(SimpleFormatter(base_format))\n else:\n handler.setFormatter(SimpleFormatter(\"{0} {1}\".format(\"%(asctime)s %(levelname)-7s\", base_format)))\n\n log.addHandler(handler)\n log.setLevel(level)\n return handler","def set_logger(log_path):\r\n logger = logging.getLogger()\r\n logger.setLevel(logging.INFO)\r\n\r\n if not logger.handlers:\r\n # Logging to a file\r\n file_handler = logging.FileHandler(log_path)\r\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\r\n logger.addHandler(file_handler)\r\n\r\n # Logging to console\r\n stream_handler = logging.StreamHandler()\r\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\r\n logger.addHandler(stream_handler)","def run_server():\n\n if not rpyc_available:\n print('rpyc module not installed.')\n print('To instal rpyc from PyPI use: pip install rpyc')\n return\n\n parser = ArgumentParser()\n parser.add_argument('-b','--bin-dir',help=\"Directory where Firebird binaries tools are\")\n parser.add_argument('-d','--db-dir',help=\"Directory to use for test databases\")\n parser.add_argument('-w','--password',default='masterkey',help=\"SYSDBA password\")\n parser.add_argument('-o','--host', default='localhost',help=\"Firebird host machine identification\")\n parser.add_argument('-r','--register',action='store_true',help=\"Automatically register RPyC slave server\")\n parser.add_argument('-p','--person', default=UNKNOWN,help=\"Firebird host machine identification\")\n parser.add_argument('-a','--arch',help=\"Firebird architecture: SS, CS, SC\")\n parser.set_defaults(server=False,register=False,arch='SS')\n\n script_runner.run_server(parser.parse_args())","def launch_sdp(path):\n # Get Logger\n logger = logging.getLogger('matlab.sdp')\n\n # Look for the Matlab current working directory, and set the environment code for SDP;\n # Get Matlab run bash line:\n matlab_scripts = path + '\\\\Matlab\\\\PDB_aux.m'\n\n # TODO: This code works for matlab R2019b and later. For earlier versions we should add an equivalent command.\n run_command = 'matlab -batch \"addpath(' + f\"'{matlab_scripts}'); try sdpaux; catch ME; end\" + '\"'\n\n # Run and wait for process finishes\n try:\n process = Popen(run_command, stdout=PIPE, stderr=STDOUT)\n while True:\n try:\n line = process.stdout.readline()\n except StopIteration:\n break\n if line != b'':\n if isinstance(line, bytes):\n line = line.decode('utf-8')\n logger.info(line.rstrip())\n else:\n break\n\n except Exception as e:\n print(f\":: Attempt to run Matlab script failed with error: \\n {e}.\")","def run_server(host=CONFIG.host, port=CONFIG.port, loglevel=CONFIG.loglevel,\n logfile=CONFIG.logfile, logfmt=CONFIG.logfmt,\n shell=CONFIG.shell, encoding=CONFIG.encoding,\n force_binary=CONFIG.force_binary, timeout=CONFIG.timeout,\n# connect_maxwait=CONFIG.connect_maxwait\n ):\n log = make_logger(\n name=__name__,\n loglevel=loglevel,\n logfile=logfile,\n logfmt=logfmt)\n\n anyio.run(partial(\n server_loop, host, port, shell=shell, encoding=encoding,\n force_binary=force_binary, timeout=timeout, log=log))\n\n\n # await completion of server stop\n try:\n loop.run_until_complete(server.wait_closed())\n finally:\n # remove signal handler on stop\n loop.remove_signal_handler(signal.SIGTERM)\n\n log.info('Server stop.')","def _get_selenium_browser(navigator, fLOG=noLOG):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n from selenium import webdriver\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\n\n fLOG(\"[webshot] navigator=\", navigator)\n if navigator == \"firefox\":\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\n firefox_capabilities['marionette'] = True\n firefox_capabilities[\n 'binary'] = r\"C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe\"\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\n elif navigator == \"chrome\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n install_chromedriver(fLOG=fLOG)\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install 'chromedriver.exe'\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'chromedriver'\n\n start_navi = True\n if start_navi:\n fLOG(\"[_get_selenium_browser] start\", navigator)\n chrome_options = webdriver.ChromeOptions()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--verbose')\n browser = webdriver.Chrome(executable_path=chromed,\n chrome_options=chrome_options)\n else:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n import selenium.webdriver.chrome.service as wservice\n fLOG(\"[_get_selenium_browser] create service\")\n service = wservice.Service(chromed)\n fLOG(\"[_get_selenium_browser] start service\")\n service.start()\n fLOG(\"[_get_selenium_browser] declare remote\")\n capabilities = {'chrome.binary': chromed}\n browser = webdriver.Remote(service.service_url, capabilities)\n elif navigator == \"ie\":\n browser = webdriver.Ie()\n elif navigator == \"opera\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n install_operadriver(fLOG=fLOG)\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install operadriver.exe\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'operadriver'\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\n elif navigator == \"edge\":\n browser = webdriver.Edge()\n else:\n raise RuntimeError(\n f\"unable to interpret the navigator '{navigator}'\")\n fLOG(\"[_get_selenium_browser] navigator is started\")\n return browser","def set_up(self,driver_path,browser_path):\n\n option = webdriver.ChromeOptions()\n option.binary_location = browser_path\n browser = webdriver.Chrome(executable_path=driver_path, chrome_options=option)\n return browser","def main(call_args):\n\n args = parse_args(call_args)\n init_logging(args.loglevel)\n\n _log.info(\"'scrape-jobs' called with args: %s\", args)\n runner.run_with_config_file(args.site, args.config_file)","def start_recording(self, log_file):\n ret = 0\n if os.path.exists(log_file):\n os.unlink(log_file)\n if len(self.kernel_categories) or len(self.user_categories):\n command = ['xperf']\n if len(self.kernel_categories):\n command.extend(['-on', '+'.join(self.kernel_categories)])\n command.append('-start')\n self.trace_name = 'WebPageTest'\n command.append(self.trace_name)\n if len(self.user_categories):\n command.extend(['-on', '+'.join(self.user_categories)])\n command.extend(['-BufferSize', '1024'])\n command.extend(['-f', log_file])\n logging.debug('Capturing ETW trace {0} to \"{1}\"'.format(self.trace_name, log_file))\n ret = subprocess.call(command, shell=True)\n self.started = True\n self.log_file = log_file\n return ret","def run(\n socket_handler,\n runtime_dir: RuntimeDir,\n server_idle_timeout: Optional[float],\n user_data: Optional[Any],\n):\n logger.debug(\"Starting server launcher\")\n\n daemon_options = {\n # This ensures that relative files are created in the context of the\n # actual runtime dir and not at the path that happens to exist at the\n # time.\n \"working_directory\": runtime_dir.fileno()\n }\n\n target = functools.partial(\n _run_server, socket_handler, server_idle_timeout, user_data\n )\n return run_in_process(daemonize, args=(target, daemon_options), allow_detach=True)","def test_selenium_startup_shutdown_java_single(self):\n self.obj.engine.config.merge({\n 'execution': {\n 'scenario': {'script': RESOURCES_DIR + 'selenium/junit/java/'},\n 'executor': 'selenium'\n },\n 'reporting': [{'module': 'junit-xml'}]\n })\n self.obj.execution.merge({\n \"scenario\": {\"script\": RESOURCES_DIR + \"selenium/junit/java/TestBlazemeterFail.java\"}\n })\n self.obj.prepare()\n self.obj.startup()\n while not self.obj.check():\n time.sleep(1)\n self.obj.shutdown()\n\n self.assertIsInstance(self.obj.runner, JavaTestRunner)\n prepared_files = listdir(self.obj.runner.working_dir)\n java_files = [fname for fname in prepared_files if fname.endswith(\".java\")]\n class_files = [fname for fname in prepared_files if fname.endswith(\".class\")]\n jars = [fname for fname in prepared_files if fname.endswith(\".jar\")]\n self.assertEqual(0, len(java_files))\n self.assertEqual(1, len(class_files))\n self.assertEqual(1, len(jars))\n self.assertTrue(exists(join(self.obj.runner.working_dir, \"compiled.jar\")))\n self.assertTrue(exists(self.obj.runner.report_file))","def set_logger(log_path):\n logger = logging.getLogger()\n logger.setLevel(logging.INFO)\n\n if not logger.handlers:\n # Logging to a file\n file_handler = logging.FileHandler(log_path)\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\n logger.addHandler(file_handler)\n\n # Logging to console\n stream_handler = logging.StreamHandler()\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\n logger.addHandler(stream_handler)","def _start_server_cmd(cls, cmd_path, address='localhost:502',\n tags=(20, 20, 20, 20), mode=1):\n\n if sys.platform.startswith('linux'):\n SHELL = '/bin/bash -c '\n LOG = '--log logs/protocols_tests_modbus_server '\n else:\n raise OSError\n\n colon_index = address.find(':')\n IP = '-i {} '.format(address[:colon_index])\n PORT = '-p {} '.format(address[colon_index+1:])\n MODE = '-m {} '.format(mode)\n DI = '-d {} '.format(tags[0])\n CO = '-c {} '.format(tags[1])\n IR = '-r {} '.format(tags[2])\n HR = '-R {} '.format(tags[3])\n # TAGS = ModbusProtocol._tuple_to_pymodbus_tags(tags)\n\n cmd = shlex.split(\n cmd_path +\n IP +\n PORT +\n MODE +\n DI + CO + IR + HR\n )\n print('DEBUG modbus _start_server cmd: ', cmd)\n\n return cmd","def __init__(self, browser='firefox'):\n if browser == 'firefox' or browser == 'ff':\n driver = webdriver.Firefox()\n elif browser == 'chrome':\n driver = webdriver.Chrome('util/chromedriver')\n elif browser == 'safari':\n driver = webdriver.Safari()\n try:\n self.driver = driver\n except Exception:\n raise NameError(\"Not found %s browser, you should enter 'firefox','ff','chrome','safari'.\" % browser)","def log_cmd(cmd, cnt, args):\n if cnt > 1:\n log_file = args[1]\n start_logging(log_file)\n else:\n stop_logging()","def start_server(self, server, script):\n self.connector.sendline(script)\n expect = \"88.Exit\"\n i = self.connector.expect([expect, TIMEOUT], timeout=2)\n if i == 0:\n info_log(\"Start server[%s] success!\",server)\n return True\n else:\n warn_log(\"Start server[%s] failed!\",server)\n return False","def test_explicit_start_stop(self, runpath):\n driver = self.MyDriver(name=\"MyDriver\", runpath=runpath)\n\n assert not driver.pre_start_called\n assert not driver.post_start_called\n\n driver.start()\n\n assert driver.pre_start_called\n assert not driver.post_start_called\n\n driver.wait(driver.STATUS.STARTED)\n\n assert driver.post_start_called\n assert not driver.pre_stop_called\n assert not driver.post_stop_called\n\n driver.stop()\n\n assert driver.pre_stop_called\n assert not driver.post_stop_called\n\n driver.wait(driver.STATUS.STOPPED)\n\n assert driver.post_stop_called","def start_browser_with(self, browser: 'Browserify', url: 'Url') -> 'StartableClient':","def _run(self, args, cwd=None, env=None, logmode='wb'):\n args = tuple(str(arg) for arg in args)\n if self.process and self.process.poll() is None: \n raise RuntimeError(\"A process is already running\")\n if self.logfile:\n self.logfile.close()\n self.logfile = open(self.logfilename, logmode, buffering=0)\n if env is not None:\n env = dict(os.environ, **env, \n PYTHONPATH=os.pathsep.join(sys.path))\n \n self.process = subprocess.Popen(args, cwd=cwd, stdout=self.logfile,\n stderr=subprocess.STDOUT, env=env)","def main():\n return run_server(**parse_server_args())","def check_args(args: argparse.Namespace):\n if not os.path.isfile(args.driver_path):\n raise FileNotFoundError(\"Unable to find the geckodriver\")\n if not os.path.isfile(args.log_path) and args.log:\n warnings.warn(f\"Unable to find the log:{args.log_path}, create it now\")\n with open(args.log_path, \"w\") as f:\n f.write(\"\")","def init_driver(driver_path):\n # user_agent = user_agent_rotator.get_random_user_agent()\n try:\n if driver_path != \"\":\n chrome_options = Options()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--disable-dev-shm-usage')\n chrome_options.add_argument('--window-size=1420,1080')\n chrome_options.add_argument('--disable-gpu')\n chrome_options.add_argument(f'user-agent={USER_AGENT}')\n Driver._driver = webdriver.Chrome(executable_path=driver_path, chrome_options=chrome_options)\n else:\n raise Exception(\"Please provide a path to the chromedriver\")\n except Exception as e:\n logging.error(f\"Driver cannot be found. Path entered: {driver_path}\")\n raise FileNotFoundError(\"Could not execute webdriver. Make sure you provided the correct path to the \"\n \"chromedriver\", e)","def init_chrome_webdriver(\n executable_path='chromedriver', download_dir=None,\n window_size=None, user_agent=None, log_path=None,\n headless=True, incognito=True,\n ignore_certificate_errors=True,\n disable_gpu=True, disable_notifications=True, disable_infobars=True):\n options = webdriver.ChromeOptions()\n\n # set boolean switch args\n if headless is True:\n options.add_argument('--headless')\n if incognito is True:\n options.add_argument('--incognito')\n if ignore_certificate_errors is True:\n options.add_argument('--ignore-certificate-errors')\n if disable_gpu is True:\n options.add_argument('--disable-gpu')\n if disable_notifications is True:\n options.add_argument('--disable-notifications')\n if disable_infobars is True:\n options.add_argument('--disable-infobars')\n\n # Needed to run in docker\n options.add_argument('--no-sandbox')\n\n # set window size, using a global default if not specified\n # (does this matter if `headless=True`?)\n if not window_size:\n window_size = DEFAULT_WINDOW_SIZE\n options.add_argument('--window-size={w},{h}'.format(w=window_size[0], h=window_size[1]))\n\n # set user-agent, using a randomly selected default if not specified\n if not user_agent:\n user_agent = random.choice(USER_AGENTS)\n options.add_argument('--user-agent=\"{}\"'.format(user_agent))\n\n # get a global default for logging path if not specified\n # value passed in webdriver.Chrome init\n if not log_path:\n log_path = DEFAULT_LOG_PATH\n\n capabilities = DesiredCapabilities.CHROME.copy()\n capabilities['version'] = 'latest'\n capabilities['loggingPref'] = {\n 'driver': 'WARNING', 'server': 'WARNING', 'browser': 'WARNING'}\n\n prefs = {\n 'profile.default_content_settings.popups': False,\n 'directory_upgrade': True,\n }\n if download_dir:\n prefs['download.default_directory'] = download_dir\n options.add_experimental_option('prefs', prefs)\n\n # initialize the driver with specified configuration\n driver = webdriver.Chrome(\n executable_path=executable_path,\n options=options,\n desired_capabilities=capabilities,\n service_log_path=log_path)\n\n return driver","def main(args=None):\n args = args or sys.argv[1:]\n parser = parse_options()\n common.main_cli(experiment_parse_and_run, parser, args)","def launch(**kwargs):\n\n logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs)\n config = load_config(kwargs['config'], logger=logger)\n\n\n ao_client = find_client(logger, clients, 'nidaqmx')\n ai_client = find_client(logger, clients, 'nidaqmx_ai')\n\n # Instantiate Monitor script\n laser_stabilizer = LaserStabilizer(\n config=kwargs['config'],\n ao_client=ao_client,\n ai_client=ai_client\n )\n\n update_service = Service()\n update_service.assign_module(module=laser_stabilizer)\n update_service.assign_logger(logger=logger)\n update_server, update_port = create_server(update_service, logger, host=get_ip())\n logger.update_data(data={'port': update_port})\n laser_stabilizer.gui.set_network_info(port=update_port)\n update_server.start()\n\n # Run continuously\n # Note that the actual operation inside run() can be paused using the update server\n while True:\n\n laser_stabilizer.run()","def add_arguments(self, parser):\n parser.add_argument('chrome_exec_path', type=str)\n parser.add_argument('chrome_webdriver_path', type=str)","def start_comp(command_line, log='', env='', foreground='no', no_stdin = 'yes'):\n proc_title_argv = command_line.split()\n\n if proc_title_argv[0] == 'taskset':\n real_program = proc_title_argv[3]\n else:\n real_program = proc_title_argv[0]\n\n # first test shared library link\n try:\n can_find_all_shared_libs(real_program)\n except IOError, e:\n print e;\n raise\n\n my_stdout = None\n my_stderr = None\n my_stdin = None\n if (no_stdin == 'yes'):\n my_stdin = open('/dev/null', 'r')\n\n if log:\n dir = os.path.dirname(log)\n if dir:\n try:\n exist_ok_makedirs(dir, 0777)\n except OSError, (errno, strerror):\n sys.stderr.write('%s: %s\\n' % (dir, strerror))\n raise\n try:\n log_fd = open(log, \"w\")\n except IOError, (errno, strerror):\n print 'cannot open %s: %s' % (log, strerror)\n raise\n else:\n my_stdout = log_fd\n my_stderr = subprocess.STDOUT\n\n #command = [ path ]\n #if options:\n # command += options\n\n my_env = {}\n if env != '':\n env_list = env.split('\\t')\n env_val = '%s:%s' % (env_list[1], env_list[2])\n my_env[env_list[0]] = env_val\n\n try:\n p = subprocess.Popen(proc_title_argv, shell = False,\n # stdin = subprocess.PIPE,\\\n #stdin = None,\n stdin = my_stdin,\n stdout = my_stdout,\n stderr = my_stderr,#)\n env = my_env)\n except OSError, (errno, strerror):\n #sys.exit('cannot execute %s: %s' % (path, strerror))\n print 'cannot execute %s: %s' % (real_program, strerror)\n raise\n except ValueError, strerror:\n #sys.exit('subprocess.Popen value error: %s' %strerror)\n print 'subprocess.Popen value error: %s' % (strerror)\n raise\n\n #proc_name = os.path.basename(path)\n if proc_title_argv[0] == 'taskset':\n try:\n proc_name = os.path.basename(proc_title_argv[3])\n except IndexError,e:\n print \"path: \", path\n sys.exit(e)\n else:\n proc_name = os.path.basename(proc_title_argv[0])\n\n max_retry = 20\n retry = 0\n while True:\n if retry == max_retry:\n sys.exit('cannot exec. %s' % proc_name)\n\n #if kill_proc_exact.lookup_process_exact(proc):\n if get_pids_exact(proc_name):\n break;\n else:\n time.sleep(0.1)\n retry += 1\n\n if foreground == 'yes':\n try:\n p.wait()\n except KeyboardInterrupt, strerror:\n pass","def set_logger(log_path):\n logger = logging.getLogger()\n logger.setLevel(logging.INFO)\n\n if not logger.handlers:\n # Logging to a file\n file_handler = logging.FileHandler(log_path, mode='w')\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\n logger.addHandler(file_handler)\n\n # Logging to console\n stream_handler = logging.StreamHandler()\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\n logger.addHandler(stream_handler)","def launch_proxy(local_port, remote_port, remote_ip):\n\n path = os.path.abspath(os.path.dirname(__file__))\n ws = os.path.join(path, \"../../proxy/bin/wistar_proxy.py\")\n\n wistar_proxy_path = os.path.abspath(ws)\n\n cmd = \"/usr/bin/env python %s --local-port=%s --remote-ip=%s --remote-port=%s &\" % (wistar_proxy_path,\n local_port,\n remote_ip,\n remote_port)\n\n logger.debug(cmd)\n\n proc = subprocess.Popen(cmd, shell=True, close_fds=True)\n time.sleep(1)\n return proc.pid","def setup_wrapper(wcl, logfilename, workdir, ins):\n\n if miscutils.fwdebug_check(3, \"PFWRUNJOB_DEBUG\"):\n miscutils.fwdebug_print(\"BEG\")\n\n if workdir is not None:\n wcl['pre_disk_usage'] = 0\n else:\n wcl['pre_disk_usage'] = pfwutils.diskusage(wcl['jobroot'])\n\n\n # make directory for log file\n logdir = os.path.dirname(logfilename)\n miscutils.coremakedirs(logdir)\n\n # get execnames to put on command line for QC Framework\n wcl['execnames'] = wcl['wrapper']['wrappername'] + ',' + get_exec_names(wcl)\n\n\n # get input files from targetnode\n get_wrapper_inputs(wcl, ins)\n\n # if running in a fw thread, run in separate safe directory\n if workdir is not None:\n setup_working_dir(workdir, ins, os.getcwd())\n\n if miscutils.fwdebug_check(3, \"PFWRUNJOB_DEBUG\"):\n miscutils.fwdebug_print(\"END\\n\\n\")","def _ConstructStep(self, log_processor_class, logfile,\n factory_properties=None, perf_expectations_path=None):\n factory_properties = factory_properties or {}\n self._log_processor_class = chromium_utils.InitializePartiallyWithArguments(\n log_processor_class, factory_properties=factory_properties,\n report_link=self._report_link, output_dir=self._output_dir,\n perf_name='test-system', test_name='test-name',\n perf_filename=perf_expectations_path)\n step = chromium_step.ProcessLogShellStep(self._log_processor_class)\n log_file = self._LogFile(\n 'stdio', open(os.path.join(test_env.DATA_PATH, logfile)).read())\n self._SetupBuild(step, self._revision, self._webkit_revision, log_file)\n return step","def run_plugin(argv):\n\treturn subprocess.Popen(argv, stdout=subprocess.PIPE)","def java_args(jar: str, jar_args: List[str] | None = None,\n jvm_opts: List[str] | None = None) -> List[str]:\n args = []\n\n if jvm_opts:\n args.extend(jvm_opts)\n\n args.extend(('-jar', jar))\n\n if jar_args:\n args.extend(jar_args)\n\n return args","def start_test_exec(cls):\n time_str = cls.get_current_time()\n os.system(\"robot -l ./logs/log_{0}.html -r ./logs/report_{0}.html -o ./logs/output_{0}.xml \\\n ./test_suite/{1}\".format(time_str, test_suite))","def _start_server(codechecker_cfg, test_config, auth=False):\n def start_server_proc(event, server_cmd, checking_env):\n \"\"\"Target function for starting the CodeChecker server.\"\"\"\n proc = subprocess.Popen(server_cmd, env=checking_env)\n\n # Blocking termination until event is set.\n event.wait()\n\n # If proc is still running, stop it.\n if proc.poll() is None:\n proc.terminate()\n\n server_cmd = codechecker.serv_cmd(codechecker_cfg['workspace'],\n str(codechecker_cfg['viewer_port']),\n env.get_postgresql_cfg())\n\n server_proc = multiprocessing.Process(\n name='server',\n target=start_server_proc,\n args=(__STOP_SERVER, server_cmd, codechecker_cfg['check_env']))\n\n server_proc.start()\n\n # Wait for server to start and connect to database.\n time.sleep(20)","def run_starter(self, expect_to_fail=False):\n logging.info(\"running starter \" + self.name)\n args = [self.cfg.bin_dir / \"arangodb\"] + self.hotbackup_args + self.default_starter_args + self.arguments\n\n lh.log_cmd(args)\n self.instance = psutil.Popen(args)\n logging.info(\"my starter has PID:\" + str(self.instance.pid))\n if not expect_to_fail:\n self.wait_for_logfile()\n self.wait_for_port_bind()","def browser(path, driver='chrome'):\n\n if driver=='chrome':\n driver = webdriver.Chrome()\n elif driver=='firefox':\n driver = webdriver.Firefox()\n elif driver=='edge':\n driver = webdriver.Edge()\n else:\n raise Exception(\"driver \"+driver+ \" is not supported\")\n\n driver.get(\"file:///\"+ path)\n return driver","def initDriver(browser):\n if browser == \"firefox\":\n opts = Options()\n opts.log.level = \"trace\"\n driver = webdriver.Firefox(options=opts)\n return driver\n elif browser == \"chrome\":\n options = webdriver.ChromeOptions()\n options.add_argument(\"start-maximized\")\n #d = DesiredCapabilities.CHROME\n d = options.to_capabilities()\n d['loggingPrefs'] = { 'browser':'ALL'}\n driver = webdriver.Chrome('../Data/chromedriver_linux64/chromedriver',desired_capabilities=d)\n return driver\n else:\n print(\"------- Navegador no compatible ---------\")\n return null","def start_beam_jobserver(flink_session_name,\n artifacts_dir=\"Resources\",\n jobserver_jar=None):\n if jobserver_jar is None:\n jobserver_jar = os.path.join(util.get_flink_conf_dir(), \"beam-runners-flink-1.9-job-server-2.19.0.jar\")\n # Get Flink master URL (flink session cluster) from an ExecutionDTO\n method = constants.HTTP_CONFIG.HTTP_GET\n resource_url = constants.DELIMITERS.SLASH_DELIMITER + \\\n constants.REST_CONFIG.HOPSWORKS_REST_RESOURCE + constants.DELIMITERS.SLASH_DELIMITER + \\\n constants.REST_CONFIG.HOPSWORKS_PROJECT_RESOURCE + constants.DELIMITERS.SLASH_DELIMITER + \\\n hopsfs.project_id() + constants.DELIMITERS.SLASH_DELIMITER + \\\n \"jobs\" + constants.DELIMITERS.SLASH_DELIMITER + \\\n flink_session_name + constants.DELIMITERS.SLASH_DELIMITER + \\\n \"executions\" + \\\n \"?limit=1&offset=0&sort_by=submissionTime:desc\"\n response = util.send_request(method, resource_url)\n response_object = response.json()\n flink_master_url = response_object['items'][0]['flinkMasterURL']\n artifact_port = randint(10000, 65000)\n expansion_port = randint(10000, 65000)\n job_port = randint(10000, 65000)\n job_host = socket.getfqdn()\n log_base_path = \"\"\n if 'LOG_DIRS' in os.environ:\n log_base_path += os.environ['LOG_DIRS'] + \"/\"\n\n beam_jobserver_log = log_base_path + \"beamjobserver-\" + hopsfs.project_name().lower() + \"-\" + flink_session_name + \\\n \"-\" + str(job_port) + \".log\"\n # copy jar to local\n with open(beam_jobserver_log, \"wb\") as out, open(beam_jobserver_log, \"wb\") as err:\n jobserver = subprocess.Popen([\"java\",\n \"-jar\", jobserver_jar,\n \"--artifacts-dir=%s\" % hopsfs.project_path() + artifacts_dir,\n \"--flink-master-url=%s\" % flink_master_url,\n \"--artifact-port=%d\" % artifact_port,\n \"--expansion-port=%d\" % expansion_port,\n \"--job-host=%s\" % job_host,\n \"--job-port=%d\" % job_port],\n stdout=out,\n stderr=err,\n preexec_fn=util._on_executor_exit('SIGTERM'))\n global clusters\n clusters.append(flink_session_name)\n global jobserver_host\n jobserver_host = job_host\n global jobserver_port\n jobserver_port = job_port\n return {\"jobserver_log\": beam_jobserver_log,\n \"artifact_port\": artifact_port,\n \"expansion_port\": expansion_port,\n \"job_host\": job_host,\n \"job_port\": job_port,\n \"jobserver.pid\": jobserver.pid}","def run(path):\n\n cwd = os.getcwd()\n\n os.chdir(path)\n\n if platform.system == \"Windows\":\n os.popen(\"run.bat >> log-\" +\n datetime.datetime.now().isoformat().split(\".\")[0].replace(':', '-') + \".txt\")\n else:\n os.popen(\"./run >> log-\" +\n datetime.datetime.now().isoformat().split(\".\")[0].replace(':', '-') + \".txt\")\n\n while is_alive() == False:\n time.sleep(0.1)\n\n os.chdir(cwd)","def __init__(self,\n geckodriver_path = None,\n headless_browser = False,\n disable_image_load = False,\n page_delay = 10,\n logfolder = 'logs/',\n user_agent = None,\n proxy_address = None,\n proxy_port = None,\n proxy_username = None,\n proxy_password = None,\n limit_scropes = None,\n exclude_hosts = None,\n browser_profile_path = None,\n browser_executable_path = None,\n geckodriver_log_level = 'info'\n ):\n firefox_options = Firefox_Options()\n seleniumwire_options = {}\n\n if headless_browser:\n firefox_options.add_argument(\"-headless\")\n\n if browser_profile_path is not None:\n firefox_profile = webdriver.FirefoxProfile(browser_profile_path)\n else:\n firefox_profile = webdriver.FirefoxProfile()\n\n if browser_executable_path is not None:\n firefox_options.binary = browser_executable_path\n\n\n # set \"info\" by default\n # set \"trace\" for debubging, Development only\n firefox_options.log.level = geckodriver_log_level\n\n # set English language\n firefox_profile.set_preference(\"intl.accept_languages\", \"en-US\")\n\n # set User-Agent\n if user_agent is not None:\n firefox_profile.set_preference(\"general.useragent.override\", user_agent)\n\n if disable_image_load:\n # permissions.default.image = 2: Disable images load,\n # this setting can improve pageload & save bandwidth\n firefox_profile.set_preference(\"permissions.default.image\", 2)\n \n # mute audio while watching stories\n firefox_profile.set_preference(\"media.volume_scale\", \"0.0\")\n\n # prevent Hide Selenium Extension: error\n firefox_profile.set_preference(\"dom.webdriver.enabled\", False)\n firefox_profile.set_preference(\"useAutomationExtension\", False)\n firefox_profile.set_preference(\"general.platform.override\", \"iPhone\")\n firefox_profile.update_preferences()\n\n # geckodriver log in specific user logfolder\n geckodriver_log = \"{}geckodriver.log\".format(logfolder)\n check_and_create_file(geckodriver_log)\n\n\n # The list exclude hosts for capturing\n if exclude_hosts:\n seleniumwire_options['exclude_hosts'] = exclude_hosts\n\n # Add proxy with username and password authentication\n if proxy_address and proxy_port:\n if proxy_username and proxy_password:\n seleniumwire_options['proxy'] = {\n 'http': f'http://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\n 'https': f'https://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\n 'no_proxy': 'localhost,127.0.0.1'\n }\n else:\n seleniumwire_options['proxy'] = {\n 'http': f'http://{proxy_address}:{proxy_port}',\n 'https': f'https://{proxy_address}:{proxy_port}',\n 'no_proxy': 'localhost,127.0.0.1'\n }\n\n\n\n self.driver = webdriver.Firefox(\n firefox_profile=firefox_profile,\n executable_path=geckodriver_path,\n log_path=geckodriver_log,\n options=firefox_options,\n seleniumwire_options=seleniumwire_options\n )\n # Limit capture urls with regulater expression\n if limit_scropes:\n self.driver.scopes = limit_scropes\n\n # Set implicitly wait\n self.driver.implicitly_wait(page_delay)\n\n # Set maximum windows\n self.driver.maximize_window()"],"string":"[\n \"def start_selenium_server(self, *params):\\n params = ('-port', str(self._server_port)) + params\\n logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')\\n self._selenium_log = open(logpath, 'w')\\n start_selenium_server(self._selenium_log, self._jar_path, *params)\\n self._html('Selenium server log is written to <a href=\\\"file://%s\\\">%s</a>.'\\n % (logpath.replace('\\\\\\\\', '/'), logpath))\",\n \"def start_server():\\n if not os.path.exists(cf.get(\\\"Selenium\\\", \\\"server_path\\\")):\\n jar_name = \\\"selenium-server-standalone-2.25.0.jar\\\"\\n server_jar = os.path.join(tempfile.gettempdir(), jar_name)\\n if not os.path.exists(server_jar):\\n r = requests.get(\\\"http://selenium.googlecode.com/files/%s\\\" % jar_name)\\n jar_on_disk = open(server_jar, \\\"wb\\\")\\n jar_on_disk.write(r.content)\\n jar_on_disk.close()\\n else:\\n server_jar = cf.get(\\\"Selenium\\\", \\\"server_path\\\")\\n \\n s = subprocess.Popen(['java', '-jar', server_jar], \\n stdout=tempfile.TemporaryFile(), \\n stderr=tempfile.TemporaryFile()).pid\\n pidfile = open(pid_file_path, \\\"w\\\")\\n pidfile.write(str(s))\\n pidfile.close()\\n\\n # make sure the server is actually up\\n server_up = False\\n waiting = 0\\n while server_up == False and waiting < 60:\\n try:\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n s.connect((\\\"localhost\\\", 4444))\\n s.close()\\n server_up = True\\n except socket.error:\\n time.sleep(1)\\n waiting = waiting + 1\\n server_up = False\\n\\n return server_up\",\n \"def start_server_and_driver(path_to_driver, path_to_browser):\\n \\n server = service.Service(path_to_driver)\\n server.start()\\n\\n capabilities = {'chrome.binary': path_to_browser}\\n driver = webdriver.Remote(server.service_url, capabilities)\\n \\n return server, driver\",\n \"def __init__(self, logger, binary, webdriver_binary=\\\"chromedriver\\\",\\n adb_binary=None,\\n remote_queue=None,\\n device_serial=None,\\n webdriver_args=None,\\n stackwalk_binary=None,\\n symbols_path=None):\\n super().__init__(logger,\\n webdriver_binary, adb_binary, remote_queue,\\n device_serial, webdriver_args, stackwalk_binary,\\n symbols_path)\\n self.binary = binary\\n self.wptserver_ports = _wptserve_ports\",\n \"def __init__(self, timeout=5.0, server_host='localhost', server_port=4444,\\n jar_path=None, run_on_failure='Capture Screenshot'):\\n self._cache = utils.ConnectionCache()\\n self._selenium = NoBrowserOpen()\\n self.set_selenium_timeout(timeout or 5.0)\\n self._server_host, self._server_port \\\\\\n = self._parse_host_and_port(server_host or 'localhost',\\n server_port or 4444)\\n self._jar_path = jar_path\\n self._set_run_on_failure(run_on_failure)\\n self._selenium_log = None\\n self._locator_parser = LocatorParser(self)\\n self._namegen = _NameGenerator()\",\n \"def start(self, suite, args=[]):\\n self.suite = suite\\n self.output_file = \\\"%s_Output.xml\\\" % (self.name)\\n temp, suiteName = os.path.split(payload) \\n jyLog = open(os.path.join(logFolder, (\\\"%s_Log.txt\\\" % self.name)), \\\"w\\\") \\n jybotCommand = \\\"pybot -o %s %s\\\" % (os.path.join(logFolder, self.output_file), self.suite)\\n \\n print \\\"Executing : %s ...\\\" % jybotCommand\\n self.running = True\\n self.process = subprocess.Popen([\\\"pybot\\\", \\\"-o\\\", \\\"%s\\\" % os.path.join(logFolder, self.output_file), \\\"%s\\\" % self.suite], cwd=clientCwd, stdout=jyLog, stderr=jyLog)\",\n \"def _runner(self, classpath, main, jvm_options, args):\",\n \"def _start_server():\\n args = [sys.executable] + sys.argv\\n args.insert(args.index('wserver'), 'server')\\n args.remove('wserver')\\n pid = os.spawnv(os.P_NOWAIT, sys.executable, args)\\n return pid\",\n \"def test_selenium_startup_shutdown_jar_single(self):\\n self.configure({\\n 'execution': {\\n 'scenario': {'script': RESOURCES_DIR + 'selenium/junit/jar/'},\\n 'runner': 'junit',\\n 'executor': 'selenium'\\n },\\n 'reporting': [{'module': 'junit-xml'}]\\n })\\n self.obj.prepare()\\n self.assertIsInstance(self.obj.runner, JUnitTester)\\n self.obj.startup()\\n while not self.obj.check():\\n time.sleep(1)\\n self.obj.shutdown()\\n\\n self.assertIsInstance(self.obj.runner, JavaTestRunner)\\n prepared_files = listdir(self.obj.runner.working_dir)\\n java_files = [fname for fname in prepared_files if fname.endswith(\\\".java\\\")]\\n class_files = [fname for fname in prepared_files if fname.endswith(\\\".class\\\")]\\n jars = [fname for fname in prepared_files if fname.endswith(\\\".jar\\\")]\\n self.assertEqual(len(java_files), 0)\\n self.assertEqual(len(class_files), 0)\\n self.assertEqual(len(jars), 0)\\n self.assertTrue(exists(self.obj.runner.report_file))\",\n \"def start(self):\\r\\n if platform.system() == \\\"Windows\\\":\\r\\n # Use a local GeckoDriver on Windows\\r\\n ffo = Options()\\r\\n ffo.headless = self.state\\r\\n gecko = \\\"dependencies/geckodriver.exe\\\"\\r\\n full_gecko = os.path.abspath(gecko)\\r\\n self.web_driver = webdriver.Firefox(executable_path=full_gecko, options=ffo)\\r\\n else:\\r\\n # Use a remote server if testing on Travis\\r\\n username = os.environ[\\\"SAUCE_USERNAME\\\"]\\r\\n access_key = os.environ[\\\"SAUCE_ACCESS_KEY\\\"]\\r\\n capabilities = {}\\r\\n capabilities[\\\"tunnel-identifier\\\"] = os.environ[\\\"TRAVIS_JOB_NUMBER\\\"]\\r\\n capabilities['version'] = \\\"45.0\\\"\\r\\n capabilities['browserName'] = \\\"firefox\\\"\\r\\n hub_url = \\\"%s:%s@localhost:4445\\\" % (username, access_key)\\r\\n self.web_driver = webdriver.Remote(\\r\\n desired_capabilities=capabilities,\\r\\n command_executor=\\\"http://%s/wd/hub\\\" % hub_url)\",\n \"def __init__(self, driver_path=None):\\n\\n if driver_path is None:\\n self.driver = webdriver.Firefox()\\n else:\\n print(\\\"Alter gecko path\\\")\\n self.driver = webdriver.Firefox(executable_path=driver_path)\",\n \"def spawn(self, classpath, main, jvm_options=None, args=None, **subprocess_args):\\r\\n cmd = self._create_command(*self._scrub_args(classpath, main, jvm_options, args))\\r\\n return self._spawn(cmd, **subprocess_args)\",\n \"def start_btslog(btslog_dir, log_type):\\r\\n \\r\\n log_type = log_type.upper()\\r\\n if \\\"BTSlog2\\\" in btslog_dir:\\r\\n if log_type == 'UDP':\\r\\n argument = 'start_udplog'\\r\\n elif log_type == 'TRACING':\\r\\n argument = 'start_tracing'\\r\\n elif log_type == 'BOTH':\\r\\n argument = 'start_both'\\r\\n else:\\r\\n raise Exception, \\\"log_type '%s' is not supported\\\" % log_type\\r\\n start_program_with_psexec('\\\\\\\"%s\\\\\\\" -nogui -%s' % (btslog_dir, argument))\\r\\n\\r\\n else:\\r\\n if log_type == 'UDP':\\r\\n argument = 'start_udplog'\\r\\n elif log_type == 'TRACING':\\r\\n argument = 'start_bssigrec'\\r\\n elif log_type == 'BOTH':\\r\\n argument = 'start_both'\\r\\n else:\\r\\n raise Exception, \\\"log_type '%s' is not supported\\\" % log_type\\r\\n ret = connections.execute_shell_command_without_check('\\\\\\\"%s\\\\\\\" %s' % (btslog_dir, argument))\\r\\n if ret.find('is not recognized') > 0: # probably given path is not avaialbe\\r\\n raise Exception, 'start %s log failed' % log_type\",\n \"def __init__(self, logfile):\\r\\n super(PopenWrapper, self).__init__()\\r\\n self.logfile = logfile\",\n \"def _start_mockserver(cls, h5filepath, same_process=False, disable_server_logging=True):\\n return H5MockServer.create_and_start( h5filepath, \\\"localhost\\\", 8000, same_process, disable_server_logging )\",\n \"def _start_server(cls, cmd_path, address='localhost:502',\\n tags=(20, 20, 20, 20), mode=1):\\n\\n try:\\n cmd = ModbusProtocol._start_server_cmd(cmd_path, address, tags, mode)\\n server = subprocess.Popen(cmd, shell=False)\\n\\n return server\\n\\n except Exception as error:\\n print('ERROR modbus _start_server: ', error)\",\n \"def _run_java(self, *args):\\n if self._java_properties is None:\\n params = [self._java_call, '-jar', self._jar_file]\\n else:\\n params = [self._java_call] + self._java_properties \\\\\\n + ['-jar', self._jar_file]\\n params.extend(args)\\n return subprocess.call(params)\",\n \"def __init__(self, path_to_web_driver='/usr/local/bin/chrome'):\\n self.path_to_web_driver = path_to_web_driver\\n options = webdriver.ChromeOptions()\\n options.add_argument('headless')\\n webdriver.Chrome.__init__(self, executable_path=self.path_to_web_driver, chrome_options=options)\",\n \"def launch_browser(option):\\n if not option:\\n chrome_options = Options()\\n chrome_options.add_argument(\\\"--headless\\\")\\n return webdriver.Chrome(\\\"/usr/bin/chromedriver\\\",\\n chrome_options=chrome_options)\\n else:\\n return webdriver.Chrome(\\\"/usr/bin/chromedriver\\\")\",\n \"def startserver(path):\\n global urlpath\\n urlpath = path\\n app.run(debug=True, host='0.0.0.0', port=4444)\",\n \"def start_selenium(site, headless=True):\\n global DRIVER\\n global PATH_DRIVER\\n options = selenium.webdriver.ChromeOptions()\\n prefs = {'profile.managed_default_content_settings.images': 2, 'disk-cache-size': 4096}\\n options.add_argument('log-level=3')\\n options.add_experimental_option(\\\"prefs\\\", prefs)\\n if headless:\\n options.add_argument(\\\"--headless\\\")\\n options.add_argument(\\\"--disable-extensions\\\")\\n print(PATH_DRIVER)\\n DRIVER[site] = selenium.webdriver.Chrome(options=options)\\n colorama.init()\\n print(termcolor.colored('Driver started for {}'.format(site), 'green'))\\n colorama.Style.RESET_ALL\\n colorama.deinit()\",\n \"def test_executable():\\n arg1 = get_args(driver=\\\"chrome\\\", executable=\\\"/tmp\\\")\\n assert arg1[\\\"executable_path\\\"] == \\\"/tmp\\\"\",\n \"def runner(self, classpath, main, jvm_options=None, args=None):\\r\\n return self._runner(*self._scrub_args(classpath, main, jvm_options, args))\",\n \"def start_server_proc(event, server_cmd, checking_env):\\n proc = subprocess.Popen(server_cmd, env=checking_env)\\n\\n # Blocking termination until event is set.\\n event.wait()\\n\\n # If proc is still running, stop it.\\n if proc.poll() is None:\\n proc.terminate()\",\n \"def test_selenium_startup_shutdown_jar_folder(self):\\n self.configure({\\n 'execution': {\\n 'scenario': {'script': RESOURCES_DIR + 'selenium/junit/jar/'},\\n 'executor': 'selenium'\\n },\\n 'reporting': [{'module': 'junit-xml'}]\\n })\\n self.obj.prepare()\\n self.obj.startup()\\n while not self.obj.check():\\n time.sleep(1)\\n self.obj.shutdown()\\n\\n self.assertIsInstance(self.obj.runner, JavaTestRunner)\\n prepared_files = listdir(self.obj.runner.working_dir)\\n java_files = [fname for fname in prepared_files if fname.endswith(\\\".java\\\")]\\n class_files = [fname for fname in prepared_files if fname.endswith(\\\".class\\\")]\\n jars = [fname for fname in prepared_files if fname.endswith(\\\".jar\\\")]\\n self.assertEqual(len(java_files), 0)\\n self.assertEqual(len(class_files), 0)\\n self.assertEqual(len(jars), 0)\\n self.assertTrue(exists(self.obj.runner.report_file))\",\n \"def test_webuidriver_remote(self):\\n\\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\\n hub.start_server()\\n\\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\\\"localhost\\\", 4444))\\n node.start_server()\\n executors = SeleniumHatch.get_remote_executors(\\\"localhost\\\", 4444)\\n\\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\\n\\n self.driver.get('http://www.baidu.com')\\n time.sleep(1)\\n\\n # webuidriver.Remote 是 webdriver.Chrome 的子类\\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\\n self.assertIsInstance(self.driver, webdriver.Remote)\\n\\n self.driver.close()\\n self.driver.quit()\\n\\n hub.stop_server()\\n node.stop_server()\",\n \"def test_application_start():\\n\\n process = subprocess.Popen(['python', 'runserver.py'],\\n stderr=subprocess.STDOUT,\\n stdout=subprocess.PIPE)\\n\\n assert process.pid\\n debug_logging = process.stdout.read(100)\\n process.kill()\\n assert 'Starting application' in debug_logging\",\n \"def execute_to_log(cmd, logfile, timeout=-1,\\n watch_logs=[\\n ('[syslog]', '/var/log/syslog'),\\n ('[sqlslo]', '/var/log/mysql/slow-queries.log'),\\n ('[sqlerr]', '/var/log/mysql/error.log')\\n ],\\n heartbeat=True, env=None, cwd=None\\n ):\\n\\n if not os.path.isdir(os.path.dirname(logfile)):\\n os.makedirs(os.path.dirname(logfile))\\n\\n logger = logging.getLogger(logfile)\\n log_handler = logging.FileHandler(logfile)\\n log_formatter = logging.Formatter('%(asctime)s %(message)s')\\n log_handler.setFormatter(log_formatter)\\n logger.addHandler(log_handler)\\n\\n descriptors = {}\\n\\n for watch_file in watch_logs:\\n if not os.path.exists(watch_file[1]):\\n logger.warning('Failed to monitor log file %s: file not found'\\n % watch_file[1])\\n continue\\n\\n try:\\n fd = os.open(watch_file[1], os.O_RDONLY)\\n os.lseek(fd, 0, os.SEEK_END)\\n descriptors[fd] = {'name': watch_file[0],\\n 'poll': select.POLLIN,\\n 'lines': ''}\\n except Exception as e:\\n logger.warning('Failed to monitor log file %s: %s'\\n % (watch_file[1], e))\\n\\n cmd += ' 2>&1'\\n start_time = time.time()\\n p = subprocess.Popen(\\n cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE,\\n env=env, cwd=cwd)\\n\\n descriptors[p.stdout.fileno()] = dict(\\n name='[output]',\\n poll=(select.POLLIN | select.POLLHUP),\\n lines=''\\n )\\n\\n poll_obj = select.poll()\\n for fd, descriptor in descriptors.items():\\n poll_obj.register(fd, descriptor['poll'])\\n\\n last_heartbeat = time.time()\\n\\n def process(fd):\\n \\\"\\\"\\\" Write the fd to log \\\"\\\"\\\"\\n global last_heartbeat\\n descriptors[fd]['lines'] += os.read(fd, 1024 * 1024)\\n # Avoid partial lines by only processing input with breaks\\n if descriptors[fd]['lines'].find('\\\\n') != -1:\\n elems = descriptors[fd]['lines'].split('\\\\n')\\n # Take all but the partial line\\n for l in elems[:-1]:\\n if len(l) > 0:\\n l = '%s %s' % (descriptors[fd]['name'], l)\\n logger.info(l)\\n last_heartbeat = time.time()\\n # Place the partial line back into lines to be processed\\n descriptors[fd]['lines'] = elems[-1]\\n\\n while p.poll() is None:\\n if timeout > 0 and time.time() - start_time > timeout:\\n # Append to logfile\\n logger.info(\\\"[timeout]\\\")\\n os.kill(p.pid, 9)\\n\\n for fd, flag in poll_obj.poll(0):\\n process(fd)\\n\\n if time.time() - last_heartbeat > 30:\\n # Append to logfile\\n logger.info(\\\"[heartbeat]\\\")\\n last_heartbeat = time.time()\\n\\n # Do one last write to get the remaining lines\\n for fd, flag in poll_obj.poll(0):\\n process(fd)\\n\\n # Clean up\\n for fd, descriptor in descriptors.items():\\n poll_obj.unregister(fd)\\n os.close(fd)\\n try:\\n p.kill()\\n except OSError:\\n pass\\n\\n logger.info('[script exit code = %d]' % p.returncode)\\n logger.removeHandler(log_handler)\\n log_handler.flush()\\n log_handler.close()\\n return p.returncode\",\n \"def start_server(self,\\n server,\\n expect_launch,\\n expect_exit=True,\\n expected_exitcode=0,\\n **kwargs):\\n self.cleanup()\\n\\n # Start up the requested server\\n exitcode, out, err = server.start(expect_exit=expect_exit,\\n expected_exitcode=expected_exitcode,\\n **kwargs)\\n if expect_exit:\\n self.assertEqual(expected_exitcode, exitcode,\\n \\\"Failed to spin up the requested server. \\\"\\n \\\"Got: %s\\\" % err)\\n\\n self.launched_servers.append(server)\\n\\n launch_msg = self.wait_for_servers([server], expect_launch)\\n self.assertTrue(launch_msg is None, launch_msg)\",\n \"def __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\\n\\n # selecting driver\\n if not driver_path:\\n driver = webdriver.Firefox\\n driver_options = FireFoxOptions()\\n else:\\n driver = webdriver.Chrome\\n driver_options = ChromeOptions()\\n\\n # add config\\n if options:\\n for option in options:\\n driver_options.add_argument(option)\\n\\n self.driver = driver(driver_path, options=driver_options)\\n self.waiter = WebDriverWait(self.driver, waiter_timeout)\",\n \"def start(cfg: 'Settings', server: str):\\n\\n try:\\n server_path = find_server(cfg.parent_directory, server)\\n except (ParentDirMissing, ServerNotFound, NoInvocation) as e:\\n e.log_this()\\n return\\n\\n if isUp(server):\\n log.info(f'{server} appears to be running already!')\\n else:\\n invocation = get_invocation(server_path)\\n os.chdir(server_path)\\n log.info(f'Starting {server}')\\n run(['screen', '-h', '5000', '-dmS', server, *invocation, 'nogui'])\\n sleep(5)\\n if isUp(server):\\n log.info(f'{server} is now running!')\\n # run_startup_commands(server)\\n else:\\n log.warning(f'{server} does not appear to have started!')\",\n \"def cmd_monitor_plugin_install(self, *argv, **kwargs):\\n \\n url = kwargs.get('url', None)\\n content = None\\n \\n if not url:\\n raise ecm.InvalidParameters(self.cmd_monitor_plugin_install.__doc__)\\n \\n try:\\n content = ecm.get_url(url)\\n except:\\n pass\\n \\n if not content:\\n raise Exception(\\\"Unable to get URL: %s\\\" % url)\\n \\n try: \\n plugin = json.loads(content)\\n except:\\n raise Exception(\\\"Invalid data received\\\")\\n\\n id = plugin.get('id')\\n runas = plugin.get('runas')\\n \\n arg_config = plugin.get('config')\\n arg_script_b64 = plugin.get('script')\\n \\n script = None\\n try:\\n script = b64decode(arg_script_b64)\\n except:\\n pass\\n \\n config = {\\n 'id': id,\\n 'runas': runas,\\n 'name': plugin.get('name'),\\n 'interval': plugin.get('interval'),\\n 'version': plugin.get('version'),\\n 'config': arg_config\\n }\\n \\n if id and config and script:\\n mplugin = MPlugin(MPLUGIN_PATH)\\n if mplugin.install(id, config, script):\\n # Installation ok, run it\\n script_file = os.path.abspath(os.path.join(MPLUGIN_PATH, id, id))\\n _run_background_file(script_file, runas)\\n \\n return True\\n \\n return False\",\n \"def start_audit_manager(path) -> WebDriver:\\n # close existing instance(s) if exists\\n import os\\n os.system(\\\"taskkill /FI \\\\\\\"IMAGENAME eq mmc.exe\\\\\\\" /F\\\")\\n # run new instance\\n exp_cap = {\\\"app\\\": \\\"mmc.exe\\\",\\n \\\"deviceName\\\": \\\"WindowsPC\\\",\\n \\\"appArguments\\\": \\\"\\\\\\\"\\\" + path + \\\"\\\\\\\"\\\"\\n }\\n exp_session = webdriver.Remote(\\n command_executor='http://127.0.0.1:4723',\\n desired_capabilities=exp_cap)\\n return exp_session\\n # region old\\n # desktoppath = r\\\"C:\\\\Users\\\\administrator\\\\Desktop\\\"\\n # exp_cap = {\\\"app\\\": \\\"explorer.exe\\\", \\\"deviceName\\\": \\\"WindowsPC\\\", \\\"appArguments\\\": desktoppath}\\n # exp_session = webdriver.Remote(\\n # command_executor='http://127.0.0.1:4723',\\n # desired_capabilities=exp_cap)\",\n \"def startServer(logServer, host=\\\"localhost\\\", ports=(globalconst.DEFAULTPORT_XMLRPC,), readyMsg=True):\\n\\t# v0.3.0: The order of host,ports has changed for consistency\\n\\t# warn:\\n\\tif type(host) in (tuple,list) or type(ports) in (str,str):\\n\\t\\tmsg = \\\"Unexpected host or ports type. Note: The argument order in startServer has changed. Use host,ports now instead of ports,host. That has been inconsistent before (sorry)\\\"\\n\\t\\twarnings.warn(msg)\\n\\t\\traise TypeError(msg)\\n\\t\\n\\tserver = createSimpleXMLRPCServer(host,ports)\\n\\tadapter = LogAdapter(logServer)\\n\\tserver.register_function(adapter.log, \\\"log\\\")\\n\\tserver.register_function(adapter.addClient, \\\"addClient\\\")\\n\\tif readyMsg: print(\\\"log server ready. Available at host,port: %s\\\"%(str(server.server_address)))\\n\\tserver.serve_forever()\",\n \"def launch_server(message_handler, options):\\n logger = logging.getLogger(__name__)\\n # if (options.debug):\\n # logger.setLevel(logging.DEBUG)\\n\\n# if not options.monitor_port:\\n# logger.warning(\\n# \\\"Monitoring not enabled. No monitor-port option defined.\\\")\\n# else:\\n# threading.Thread(target=launch_monitor_server, args=(options.host, options.monitor_port, logger)).start()\\n\\n # Create the server, binding to specified host on configured port\\n\\n# logger.info(\\n# 'Starting server on host %s port %d Python version %s.%s.%s' % ((options.host, options.port) + sys.version_info[:3]))\\n# server = ThreadedTCPServer((options.host, options.port),\\n\\n # Activate the server; this will keep running until you\\n # interrupt the program with Ctrl-C\\n try:\\n while True:\\n logger.debug('waiting for more data')\\n if not message_handler.handle():\\n break\\n logger.warning(\\\"I/O stream closed from client\\\")\\n\\n except KeyboardInterrupt:\\n logger.info(\\\"I/O stream closed from client exiting...\\\")\\n os._exit(142)\\n\\n except:\\n logger.exception(\\\"Error encountered handling message\\\")\",\n \"def main(server):\\n config_parser = ConfigParser()\\n config_parser.read('resources/conf/config.ini')\\n\\n log_level = log_levels.get(config_parser.get('core', 'log.level'))\\n log_filename = config_parser.get('core', 'log.path')\\n logging.basicConfig(level=log_level,\\n format='%(levelname)s:%(asctime)s:%(message)s',\\n filename=log_filename)\\n replicator = Replicator(config_parser)\\n executor = ThreadPoolExecutor(max_workers=2)\\n executor.submit(replicator.start)\\n logger = logging.getLogger('replicator')\\n if log_level == 'DEBUG':\\n handler = logging.StreamHandler()\\n handler.setLevel(logging.DEBUG)\\n logger.addHandler(handler)\\n if server:\\n if config_parser.has_section('server'):\\n check_server_configuration(config_parser, logger)\\n server_config = {\\n 'server.socket_host' : config_parser.get('server', 'socket_host'),\\n 'server.socket_port' : config_parser.getint('server', 'socket_port'),\\n 'log.access_file' : config_parser.get('server', 'log.access_file'),\\n 'log.error_file' : config_parser.get('server', 'log.error_file')\\n }\\n cherrypy.config.update(server_config)\\n logger.info('Server will be started at %s:%d' % (server_config['server.socket_host'],\\n server_config['server.socket_port']))\\n else:\\n logger.info('No settings found, using the default one. (localhost:8080)')\\n executor.submit(cherrypy.quickstart(ReplicatorServer(replicator)))\",\n \"def setup_logging(filepath=core.ServerConfiguration.LOGDIR,\\n log_name='server_process'):\\n\\n if not os.path.exists(filepath):\\n raise IOError('LOG_DIR filepath does not exist: {0:s}'.format(filepath))\\n\\n if not log_name in core.DEFAULT_LOGGER_PROCESSES:\\n raise ValueError('Log_name should be in {0:s}.'\\n .format(core.DEFAULT_LOGGER_PROCESSES))\\n\\n filename = generate_log_filename()\\n log_file = os.path.join(filepath, filename)\\n\\n # configure log formatter\\n log_fmt = logging.Formatter('[%(levelname)s][%(asctime)s] %(message)s',\\n datefmt='%Y/%m/%d %I:%M:%S %p')\\n\\n # configure file handler\\n file_handler = logging.FileHandler(log_file)\\n file_handler.setFormatter(log_fmt)\\n\\n # stream handler\\n stream_handler = logging.StreamHandler()\\n stream_handler.setFormatter(log_fmt)\\n\\n # setup a server log, add file and stream handlers\\n logger = logging.getLogger(log_name)\\n logger.addHandler(file_handler)\\n logger.addHandler(stream_handler)\\n logger.setLevel(logging.DEBUG)\\n\\n return log_file\",\n \"def start_local_cmd(log_path, log_name=\\\"localcmd\\\"):\\n log_dir = os.path.abspath(log_path)\\n try:\\n os.makedirs(log_dir)\\n except OSError:\\n pass\\n return CmdRunner.CmdRunner(log_dir, log_name)\",\n \"def startJybot(name, suite, args=[]):\\n jybot = Jybot(name)\\n jybot.start(suite, args)\\n return jybot\",\n \"def set_logger(log_path, terminal=True):\\n logger = logging.getLogger()\\n logger.setLevel(logging.INFO)\\n\\n if not logger.handlers:\\n # Logging to a file\\n file_handler = logging.FileHandler(log_path)\\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\\n logger.addHandler(file_handler)\\n\\n # Logging to console\\n if terminal:\\n stream_handler = logging.StreamHandler()\\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\\n logger.addHandler(stream_handler)\",\n \"def before_productline_steps():\\n cmd = ['phantomjs', '--webdriver', '4444']\\n click.echo(\\\"Running command\\\" + subprocess.list2cmdline(cmd))\\n process = subprocess.Popen(cmd)\\n RUNNING_TEST_PROCESSES.append(process)\",\n \"def selenium_server(request) -> Optional[str]:\\n return (\\n # CLI arg takes precedence\\n request.config.getoption(\\\"selenium_server\\\")\\n # Otherwise, we look for a non-empty string\\n or os.environ.get('SELENIUM_SERVER', '').strip()\\n # If the result is still Falsey, we always return None.\\n or None\\n )\",\n \"def execute(self, classpath, main, jvm_options=None, args=None, stdout=None, stderr=None):\\r\\n executor = self.runner(classpath=classpath, main=main, jvm_options=jvm_options, args=args)\\r\\n return executor.run(stdout=stdout, stderr=stderr)\",\n \"def _load_jupyter_server_extension(server_app):\\n\\n server_app.log.info('jupyterlab_slurm server extension loaded')\\n slurm_commands = SlurmCommandPaths(parent=server_app)\\n server_app.log.info(slurm_commands.get_paths())\\n\\n web_app = server_app.web_app\\n web_app.settings.update(slurm_commands.get_paths())\\n\\n temporary_directory = web_app.settings['temporary_directory'] if 'temporary_directory' in web_app.settings else None\\n #server_app.log.addHandler(logging.FileHandler('/tmp/jupyter_debug'))\\n #server_app.log.setLevel(logging.DEBUG)\\n\\n # add get_example url\\n setup_handlers(\\n web_app, temporary_directory=temporary_directory, log=server_app.log)\",\n \"def run_server(\\n server_host=bridge.DEFAULT_HOST,\\n server_port=DEFAULT_SERVER_PORT,\\n response_timeout=bridge.DEFAULT_RESPONSE_TIMEOUT,\\n background=True,\\n):\\n server = bridge.BridgeServer(\\n server_host=server_host,\\n server_port=server_port,\\n loglevel=logging.INFO,\\n response_timeout=response_timeout,\\n local_call_hook=hook_local_call,\\n local_eval_hook=hook_local_eval,\\n local_exec_hook=hook_local_exec,\\n )\\n\\n if background:\\n server.start()\\n print(\\n \\\"Server launching in background - will continue to run after launch script finishes...\\\\n\\\"\\n )\\n else:\\n server.run()\",\n \"def _launch_minecraft(self, port, headless, minecraft_dir):\\n replaceable = False\\n\\n launch_script = 'launchClient.sh'\\n if os.name == 'nt':\\n launch_script = 'launchClient.bat'\\n\\n launch_script = os.path.join(minecraft_dir, launch_script)\\n rundir = os.path.join(minecraft_dir, 'run')\\n \\n cmd = [launch_script, '-port', str(port), '-env', '-runDir', rundir]\\n if self.status_dir:\\n cmd += ['-performanceDir', self.status_dir]\\n if self._seed:\\n cmd += ['-seed', \\\",\\\".join(self._seed)]\\n\\n cmd_to_print = cmd[:] if not self._seed else cmd[:-2]\\n self._logger.info(\\\"Starting Minecraft process: \\\" + str(cmd_to_print))\\n # print(cmd)\\n\\n if replaceable:\\n cmd.append('-replaceable')\\n preexec_fn = os.setsid if 'linux' in str(sys.platform) or sys.platform == 'darwin' else None\\n # print(preexec_fn)\\n minecraft_process = subprocess.Popen(cmd,\\n cwd=InstanceManager.MINECRAFT_DIR,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT,\\n # use process group, see http://stackoverflow.com/a/4791612/18576\\n preexec_fn=preexec_fn\\n )\\n return minecraft_process\",\n \"def start(self, logfile_name):\\n\\n self._verify_not_running()\\n\\n # The package structure for LiteServ is different pre 1.4. Handle for this case\\n if has_dot_net4_dot_5(self.version_build):\\n binary_path = \\\"{}/couchbase-lite-net-mono-{}-liteserv/net45/LiteServ.exe\\\".format(BINARY_DIR, self.version_build)\\n else:\\n binary_path = \\\"{}/couchbase-lite-net-mono-{}-liteserv/LiteServ.exe\\\".format(BINARY_DIR, self.version_build)\\n\\n process_args = [\\n \\\"mono\\\",\\n binary_path,\\n \\\"--port\\\", str(self.port),\\n \\\"--dir\\\", \\\"{}/dbs/net-mono/\\\".format(RESULTS_DIR)\\n ]\\n\\n if self.storage_engine == \\\"ForestDB\\\" or self.storage_engine == \\\"ForestDB+Encryption\\\":\\n process_args.append(\\\"--storage\\\")\\n process_args.append(\\\"ForestDB\\\")\\n else:\\n process_args.append(\\\"--storage\\\")\\n process_args.append(\\\"SQLite\\\")\\n\\n if self.storage_engine == \\\"SQLCipher\\\" or self.storage_engine == \\\"ForestDB+Encryption\\\":\\n log_info(\\\"Using Encryption ...\\\")\\n db_flags = []\\n for db_name in REGISTERED_CLIENT_DBS:\\n db_flags.append(\\\"--dbpassword\\\")\\n db_flags.append(\\\"{}=pass\\\".format(db_name))\\n process_args.extend(db_flags)\\n\\n log_info(\\\"Launching: {} with args: {}\\\".format(binary_path, process_args))\\n\\n self.logfile = open(logfile_name, \\\"w\\\")\\n self.process = subprocess.Popen(args=process_args, stdout=self.logfile)\\n\\n self._verify_launched()\\n\\n return \\\"http://{}:{}\\\".format(self.host, self.port)\",\n \"def _start_server(self, repo_root):\\r\\n # By default, hglib uses 'hg'. User might need to change that on\\r\\n # Windows, for example.\\r\\n hg_bin = get_hg_exe_name()\\r\\n server = client.CmdServerClient(hg_bin=hg_bin, repo_root=repo_root)\\r\\n return server\",\n \"def __run_server(self):\\n os.chdir(os.path.dirname(self.server_path))\\n self.server_process = subprocess.Popen([self.server_path, \\\\\\n \\\"{}:{}\\\".format(self.args.ip, self.args.port)])\",\n \"def _run_web_server(q, log_filepath, dist_dir, custom_headers):\\n\\n os.chdir(dist_dir)\\n\\n log_fh = log_filepath.open(\\\"w\\\", buffering=1)\\n sys.stdout = log_fh\\n sys.stderr = log_fh\\n\\n class Handler(http.server.SimpleHTTPRequestHandler):\\n def log_message(self, format_, *args):\\n print(\\n \\\"[%s] source: %s:%s - %s\\\"\\n % (self.log_date_time_string(), *self.client_address, format_ % args)\\n )\\n\\n def end_headers(self):\\n # Enable Cross-Origin Resource Sharing (CORS)\\n for k, v in custom_headers.items():\\n self.send_header(k, v)\\n self.send_header(\\\"Access-Control-Allow-Origin\\\", \\\"*\\\")\\n super().end_headers()\\n\\n with socketserver.TCPServer((\\\"\\\", 0), Handler) as httpd:\\n host, port = httpd.server_address\\n print(f\\\"Starting webserver at http://{host}:{port}\\\")\\n httpd.server_name = \\\"test-server\\\" # type: ignore[attr-defined]\\n httpd.server_port = port # type: ignore[attr-defined]\\n q.put(port)\\n\\n def service_actions():\\n try:\\n if q.get(False) == \\\"TERMINATE\\\":\\n print(\\\"Stopping server...\\\")\\n sys.exit(0)\\n except queue.Empty:\\n pass\\n\\n httpd.service_actions = service_actions # type: ignore[assignment]\\n httpd.serve_forever()\",\n \"def browserConfiguration(path):\\n\\tprofile = FirefoxProfile()\\n\\tprofile.set_preference(\\\"browser.download.panel.shown\\\", False)\\n\\tprofile.set_preference(\\\"browser.download.manager.showWhenStarting\\\", False)\\n\\tprofile.set_preference(\\\"browser.helperApps.neverAsk.saveToDisk\\\", \\\"application/octet-stream\\\")\\n\\tprofile.set_preference(\\\"browser.download.folderList\\\", 2)\\n\\tprofile.set_preference(\\\"browser.download.dir\\\", path)\\n\\toptions = Options()\\n\\toptions.add_argument(\\\"--headless\\\")\\n\\treturn webdriver.Firefox(firefox_profile=profile, options=options, service_log_path=os.path.devnull)\",\n \"def _serverThreadRunner(self):\\n args = self._argsForSubprocess()\\n logging.info(\\\"Test server popen() args: %s\\\" % str.join(\\\" \\\", args))\\n self._server_process = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n with self._has_launched_cv:\\n self._has_launched = True\\n self._has_launched_cv.notify_all()\\n stdout, stderr = self._server_process.communicate()\\n logging.info(\\\"Process stdout: %s\\\", stdout.decode(\\\"utf-8\\\"))\\n logging.info(\\\"Process stderr: %s\\\", stderr.decode(\\\"utf-8\\\"))\\n return stdout, stderr\",\n \"def logging_setup(args, log_dir):\\n timestamp_file = datetime.now().strftime(\\\"%Y%m%d-%H.%M_rcf_abb.log\\\")\\n log_file = Path(log_dir) / timestamp_file\\n\\n handlers = []\\n\\n if not args.skip_logfile:\\n handlers.append(log.FileHandler(log_file, mode=\\\"a\\\"))\\n if not args.quiet:\\n handlers.append(log.StreamHandler(sys.stdout))\\n\\n log.basicConfig(\\n level=log.DEBUG if args.debug else log.INFO,\\n format=\\\"%(asctime)s:%(levelname)s:%(funcName)s:%(message)s\\\",\\n handlers=handlers,\\n )\",\n \"def test_install_should_call_subprocess_run(self, mock_subprocess):\\n manifest = self.generate_mock_manifest(cfg={\\n EXTCFG_SECTION.INSTALL: {\\n EXTCFG_OPTION.EXEC_EXT_CMD: ['command'],\\n }\\n })\\n ext_manager = PkgInstExtrasManager(manifest)\\n ext_manager.handle_install_extras()\\n mock_subprocess.assert_called_with(\\n 'command',\\n check=True,\\n stderr=-1,\\n stdout=-1,\\n timeout=90,\\n universal_newlines=True)\",\n \"def run_test_server(site_path, new_env=None):\\n args = ['python', 'runserver.py', '--no_reload', site_path]\\n # Werkzeug is a dependency of flask which we are using for the mock api\\n # however there is an issue with Werkzeug that prevents it from properly\\n # handling the SIGTERM sent by p.kill() or terminate()\\n # Issue: https://github.com/pallets/werkzeug/issues/58\\n p = subprocess.Popen(args, stdout=subprocess.PIPE, preexec_fn=os.setsid,\\n env=new_env)\\n\\n try:\\n _wait_for_server()\\n yield 'http://localhost:5000/'\\n finally:\\n os.killpg(os.getpgid(p.pid), signal.SIGINT)\",\n \"def _start_server(apps, port, no_browser):\\n # necessary for the dashboard to work when called from a notebook\\n asyncio.set_event_loop(asyncio.new_event_loop())\\n\\n # this is adapted from bokeh.subcommands.serve\\n with report_server_init_errors(port=port):\\n server = Server(apps, port=port)\\n\\n # On a remote server, we do not want to start the dashboard here.\\n if not no_browser:\\n\\n def show_callback():\\n server.show(\\\"/\\\")\\n\\n server.io_loop.add_callback(show_callback)\\n\\n address_string = server.address if server.address else \\\"localhost\\\"\\n\\n print( # noqa: T201\\n \\\"Bokeh app running at:\\\",\\n f\\\"http://{address_string}:{server.port}{server.prefix}/\\\",\\n )\\n server._loop.start()\\n server.start()\",\n \"def launch(*args, directory: AnyStr=\\\"\\\", movie: AnyStr=\\\"\\\", pdfFile: AnyStr=\\\"\\\", webPage:\\n AnyStr=\\\"\\\", **kwargs)->None:\\n pass\",\n \"def __init__(self, senna_path, executable):\\n self.senna_path = senna_path\\n self.p = sp.Popen(['blabla', '-path', senna_path],\\n executable=os.path.join(senna_path, executable),\\n stdin=sp.PIPE,\\n stdout=sp.PIPE)\",\n \"def run(filepath=\\\"log.txt\\\"):\\n if (is_windows(False)):\\n print(color.red(\\\"\\\\nYour system isn't *unix\\\\n\\\"))\\n return\\n filepath = path.abspath(filepath)\\n # 获取filepath的文件夹路径\\n dirpath = path.dirname(filepath)\\n # 判断文件夹是否存在\\n if not path.exists(dirpath):\\n print(color.red(\\\"\\\\nFile path is invalid\\\\n\\\"))\\n return\\n # 判断文件夹是否可写\\n if access(dirpath, W_OK):\\n print(color.green(f\\\"\\\\nSet log in {filepath}\\\\n\\\"))\\n sys.stdout = Logger(filepath, sys.__stdout__)\\n sys.stderr = Logger(filepath, sys.__stderr__)\\n gset(\\\"log_filepath\\\", filepath, True)\\n gset(\\\"log_stdout\\\", sys.stdout, True)\\n gset(\\\"log_stderr\\\", sys.stderr, True)\\n else:\\n print(color.red(\\\"\\\\nFile path is invalid\\\\n\\\"))\",\n \"def setup_logging(log=None, level=logging.INFO\\n , program=\\\"\\\", syslog_address=\\\"\\\", tcp_address=\\\"\\\", udp_address=\\\"\\\"\\n , only_message=False, json_to_console=False, logging_handler_file=sys.stderr\\n ):\\n log = log if log is not None else logging.getLogger(log)\\n\\n if syslog_address:\\n address = syslog_address\\n if not syslog_address.startswith(\\\"/\\\") and \\\":\\\" in syslog_address:\\n split = address.split(\\\":\\\", 2)\\n address = (split[0], int(split[1]))\\n handler = SyslogHandler(address = address)\\n elif udp_address:\\n handler = JsonOverUDPHandler(program, udp_address.split(\\\":\\\")[0], int(udp_address.split(\\\":\\\")[1]))\\n elif tcp_address:\\n handler = JsonOverTCPHandler(program, tcp_address.split(\\\":\\\")[0], int(tcp_address.split(\\\":\\\")[1]))\\n else:\\n if json_to_console:\\n handler = JsonToConsoleHandler(program, logging_handler_file)\\n else:\\n handler = RainbowHandler(logging_handler_file)\\n\\n # Protect against this being called multiple times\\n handler.delfick_logging = True\\n if any(getattr(h, \\\"delfick_logging\\\", False) for h in log.handlers):\\n return\\n\\n if syslog_address:\\n handler.setFormatter(SimpleFormatter(\\\"{0}[{1}]: %(message)s\\\".format(program, os.getpid()), ignore_extra=True))\\n elif udp_address or tcp_address or json_to_console:\\n handler.setFormatter(SimpleFormatter(\\\"%(message)s\\\"))\\n else:\\n base_format = \\\"%(name)-15s %(message)s\\\"\\n if only_message:\\n base_format = \\\"%(message)s\\\"\\n\\n handler._column_color['%(asctime)s'] = ('cyan', None, False)\\n handler._column_color['%(levelname)-7s'] = ('green', None, False)\\n handler._column_color['%(message)s'][logging.INFO] = ('blue', None, False)\\n if only_message:\\n handler.setFormatter(SimpleFormatter(base_format))\\n else:\\n handler.setFormatter(SimpleFormatter(\\\"{0} {1}\\\".format(\\\"%(asctime)s %(levelname)-7s\\\", base_format)))\\n\\n log.addHandler(handler)\\n log.setLevel(level)\\n return handler\",\n \"def set_logger(log_path):\\r\\n logger = logging.getLogger()\\r\\n logger.setLevel(logging.INFO)\\r\\n\\r\\n if not logger.handlers:\\r\\n # Logging to a file\\r\\n file_handler = logging.FileHandler(log_path)\\r\\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\\r\\n logger.addHandler(file_handler)\\r\\n\\r\\n # Logging to console\\r\\n stream_handler = logging.StreamHandler()\\r\\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\\r\\n logger.addHandler(stream_handler)\",\n \"def run_server():\\n\\n if not rpyc_available:\\n print('rpyc module not installed.')\\n print('To instal rpyc from PyPI use: pip install rpyc')\\n return\\n\\n parser = ArgumentParser()\\n parser.add_argument('-b','--bin-dir',help=\\\"Directory where Firebird binaries tools are\\\")\\n parser.add_argument('-d','--db-dir',help=\\\"Directory to use for test databases\\\")\\n parser.add_argument('-w','--password',default='masterkey',help=\\\"SYSDBA password\\\")\\n parser.add_argument('-o','--host', default='localhost',help=\\\"Firebird host machine identification\\\")\\n parser.add_argument('-r','--register',action='store_true',help=\\\"Automatically register RPyC slave server\\\")\\n parser.add_argument('-p','--person', default=UNKNOWN,help=\\\"Firebird host machine identification\\\")\\n parser.add_argument('-a','--arch',help=\\\"Firebird architecture: SS, CS, SC\\\")\\n parser.set_defaults(server=False,register=False,arch='SS')\\n\\n script_runner.run_server(parser.parse_args())\",\n \"def launch_sdp(path):\\n # Get Logger\\n logger = logging.getLogger('matlab.sdp')\\n\\n # Look for the Matlab current working directory, and set the environment code for SDP;\\n # Get Matlab run bash line:\\n matlab_scripts = path + '\\\\\\\\Matlab\\\\\\\\PDB_aux.m'\\n\\n # TODO: This code works for matlab R2019b and later. For earlier versions we should add an equivalent command.\\n run_command = 'matlab -batch \\\"addpath(' + f\\\"'{matlab_scripts}'); try sdpaux; catch ME; end\\\" + '\\\"'\\n\\n # Run and wait for process finishes\\n try:\\n process = Popen(run_command, stdout=PIPE, stderr=STDOUT)\\n while True:\\n try:\\n line = process.stdout.readline()\\n except StopIteration:\\n break\\n if line != b'':\\n if isinstance(line, bytes):\\n line = line.decode('utf-8')\\n logger.info(line.rstrip())\\n else:\\n break\\n\\n except Exception as e:\\n print(f\\\":: Attempt to run Matlab script failed with error: \\\\n {e}.\\\")\",\n \"def run_server(host=CONFIG.host, port=CONFIG.port, loglevel=CONFIG.loglevel,\\n logfile=CONFIG.logfile, logfmt=CONFIG.logfmt,\\n shell=CONFIG.shell, encoding=CONFIG.encoding,\\n force_binary=CONFIG.force_binary, timeout=CONFIG.timeout,\\n# connect_maxwait=CONFIG.connect_maxwait\\n ):\\n log = make_logger(\\n name=__name__,\\n loglevel=loglevel,\\n logfile=logfile,\\n logfmt=logfmt)\\n\\n anyio.run(partial(\\n server_loop, host, port, shell=shell, encoding=encoding,\\n force_binary=force_binary, timeout=timeout, log=log))\\n\\n\\n # await completion of server stop\\n try:\\n loop.run_until_complete(server.wait_closed())\\n finally:\\n # remove signal handler on stop\\n loop.remove_signal_handler(signal.SIGTERM)\\n\\n log.info('Server stop.')\",\n \"def _get_selenium_browser(navigator, fLOG=noLOG):\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n from selenium import webdriver\\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\\n\\n fLOG(\\\"[webshot] navigator=\\\", navigator)\\n if navigator == \\\"firefox\\\":\\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\\n firefox_capabilities['marionette'] = True\\n firefox_capabilities[\\n 'binary'] = r\\\"C:\\\\Program Files (x86)\\\\Mozilla Firefox\\\\firefox.exe\\\"\\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\\n elif navigator == \\\"chrome\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n install_chromedriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install 'chromedriver.exe'\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'chromedriver'\\n\\n start_navi = True\\n if start_navi:\\n fLOG(\\\"[_get_selenium_browser] start\\\", navigator)\\n chrome_options = webdriver.ChromeOptions()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--verbose')\\n browser = webdriver.Chrome(executable_path=chromed,\\n chrome_options=chrome_options)\\n else:\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n import selenium.webdriver.chrome.service as wservice\\n fLOG(\\\"[_get_selenium_browser] create service\\\")\\n service = wservice.Service(chromed)\\n fLOG(\\\"[_get_selenium_browser] start service\\\")\\n service.start()\\n fLOG(\\\"[_get_selenium_browser] declare remote\\\")\\n capabilities = {'chrome.binary': chromed}\\n browser = webdriver.Remote(service.service_url, capabilities)\\n elif navigator == \\\"ie\\\":\\n browser = webdriver.Ie()\\n elif navigator == \\\"opera\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n install_operadriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install operadriver.exe\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'operadriver'\\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\\n elif navigator == \\\"edge\\\":\\n browser = webdriver.Edge()\\n else:\\n raise RuntimeError(\\n f\\\"unable to interpret the navigator '{navigator}'\\\")\\n fLOG(\\\"[_get_selenium_browser] navigator is started\\\")\\n return browser\",\n \"def set_up(self,driver_path,browser_path):\\n\\n option = webdriver.ChromeOptions()\\n option.binary_location = browser_path\\n browser = webdriver.Chrome(executable_path=driver_path, chrome_options=option)\\n return browser\",\n \"def main(call_args):\\n\\n args = parse_args(call_args)\\n init_logging(args.loglevel)\\n\\n _log.info(\\\"'scrape-jobs' called with args: %s\\\", args)\\n runner.run_with_config_file(args.site, args.config_file)\",\n \"def start_recording(self, log_file):\\n ret = 0\\n if os.path.exists(log_file):\\n os.unlink(log_file)\\n if len(self.kernel_categories) or len(self.user_categories):\\n command = ['xperf']\\n if len(self.kernel_categories):\\n command.extend(['-on', '+'.join(self.kernel_categories)])\\n command.append('-start')\\n self.trace_name = 'WebPageTest'\\n command.append(self.trace_name)\\n if len(self.user_categories):\\n command.extend(['-on', '+'.join(self.user_categories)])\\n command.extend(['-BufferSize', '1024'])\\n command.extend(['-f', log_file])\\n logging.debug('Capturing ETW trace {0} to \\\"{1}\\\"'.format(self.trace_name, log_file))\\n ret = subprocess.call(command, shell=True)\\n self.started = True\\n self.log_file = log_file\\n return ret\",\n \"def run(\\n socket_handler,\\n runtime_dir: RuntimeDir,\\n server_idle_timeout: Optional[float],\\n user_data: Optional[Any],\\n):\\n logger.debug(\\\"Starting server launcher\\\")\\n\\n daemon_options = {\\n # This ensures that relative files are created in the context of the\\n # actual runtime dir and not at the path that happens to exist at the\\n # time.\\n \\\"working_directory\\\": runtime_dir.fileno()\\n }\\n\\n target = functools.partial(\\n _run_server, socket_handler, server_idle_timeout, user_data\\n )\\n return run_in_process(daemonize, args=(target, daemon_options), allow_detach=True)\",\n \"def test_selenium_startup_shutdown_java_single(self):\\n self.obj.engine.config.merge({\\n 'execution': {\\n 'scenario': {'script': RESOURCES_DIR + 'selenium/junit/java/'},\\n 'executor': 'selenium'\\n },\\n 'reporting': [{'module': 'junit-xml'}]\\n })\\n self.obj.execution.merge({\\n \\\"scenario\\\": {\\\"script\\\": RESOURCES_DIR + \\\"selenium/junit/java/TestBlazemeterFail.java\\\"}\\n })\\n self.obj.prepare()\\n self.obj.startup()\\n while not self.obj.check():\\n time.sleep(1)\\n self.obj.shutdown()\\n\\n self.assertIsInstance(self.obj.runner, JavaTestRunner)\\n prepared_files = listdir(self.obj.runner.working_dir)\\n java_files = [fname for fname in prepared_files if fname.endswith(\\\".java\\\")]\\n class_files = [fname for fname in prepared_files if fname.endswith(\\\".class\\\")]\\n jars = [fname for fname in prepared_files if fname.endswith(\\\".jar\\\")]\\n self.assertEqual(0, len(java_files))\\n self.assertEqual(1, len(class_files))\\n self.assertEqual(1, len(jars))\\n self.assertTrue(exists(join(self.obj.runner.working_dir, \\\"compiled.jar\\\")))\\n self.assertTrue(exists(self.obj.runner.report_file))\",\n \"def set_logger(log_path):\\n logger = logging.getLogger()\\n logger.setLevel(logging.INFO)\\n\\n if not logger.handlers:\\n # Logging to a file\\n file_handler = logging.FileHandler(log_path)\\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\\n logger.addHandler(file_handler)\\n\\n # Logging to console\\n stream_handler = logging.StreamHandler()\\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\\n logger.addHandler(stream_handler)\",\n \"def _start_server_cmd(cls, cmd_path, address='localhost:502',\\n tags=(20, 20, 20, 20), mode=1):\\n\\n if sys.platform.startswith('linux'):\\n SHELL = '/bin/bash -c '\\n LOG = '--log logs/protocols_tests_modbus_server '\\n else:\\n raise OSError\\n\\n colon_index = address.find(':')\\n IP = '-i {} '.format(address[:colon_index])\\n PORT = '-p {} '.format(address[colon_index+1:])\\n MODE = '-m {} '.format(mode)\\n DI = '-d {} '.format(tags[0])\\n CO = '-c {} '.format(tags[1])\\n IR = '-r {} '.format(tags[2])\\n HR = '-R {} '.format(tags[3])\\n # TAGS = ModbusProtocol._tuple_to_pymodbus_tags(tags)\\n\\n cmd = shlex.split(\\n cmd_path +\\n IP +\\n PORT +\\n MODE +\\n DI + CO + IR + HR\\n )\\n print('DEBUG modbus _start_server cmd: ', cmd)\\n\\n return cmd\",\n \"def __init__(self, browser='firefox'):\\n if browser == 'firefox' or browser == 'ff':\\n driver = webdriver.Firefox()\\n elif browser == 'chrome':\\n driver = webdriver.Chrome('util/chromedriver')\\n elif browser == 'safari':\\n driver = webdriver.Safari()\\n try:\\n self.driver = driver\\n except Exception:\\n raise NameError(\\\"Not found %s browser, you should enter 'firefox','ff','chrome','safari'.\\\" % browser)\",\n \"def log_cmd(cmd, cnt, args):\\n if cnt > 1:\\n log_file = args[1]\\n start_logging(log_file)\\n else:\\n stop_logging()\",\n \"def start_server(self, server, script):\\n self.connector.sendline(script)\\n expect = \\\"88.Exit\\\"\\n i = self.connector.expect([expect, TIMEOUT], timeout=2)\\n if i == 0:\\n info_log(\\\"Start server[%s] success!\\\",server)\\n return True\\n else:\\n warn_log(\\\"Start server[%s] failed!\\\",server)\\n return False\",\n \"def test_explicit_start_stop(self, runpath):\\n driver = self.MyDriver(name=\\\"MyDriver\\\", runpath=runpath)\\n\\n assert not driver.pre_start_called\\n assert not driver.post_start_called\\n\\n driver.start()\\n\\n assert driver.pre_start_called\\n assert not driver.post_start_called\\n\\n driver.wait(driver.STATUS.STARTED)\\n\\n assert driver.post_start_called\\n assert not driver.pre_stop_called\\n assert not driver.post_stop_called\\n\\n driver.stop()\\n\\n assert driver.pre_stop_called\\n assert not driver.post_stop_called\\n\\n driver.wait(driver.STATUS.STOPPED)\\n\\n assert driver.post_stop_called\",\n \"def start_browser_with(self, browser: 'Browserify', url: 'Url') -> 'StartableClient':\",\n \"def _run(self, args, cwd=None, env=None, logmode='wb'):\\n args = tuple(str(arg) for arg in args)\\n if self.process and self.process.poll() is None: \\n raise RuntimeError(\\\"A process is already running\\\")\\n if self.logfile:\\n self.logfile.close()\\n self.logfile = open(self.logfilename, logmode, buffering=0)\\n if env is not None:\\n env = dict(os.environ, **env, \\n PYTHONPATH=os.pathsep.join(sys.path))\\n \\n self.process = subprocess.Popen(args, cwd=cwd, stdout=self.logfile,\\n stderr=subprocess.STDOUT, env=env)\",\n \"def main():\\n return run_server(**parse_server_args())\",\n \"def check_args(args: argparse.Namespace):\\n if not os.path.isfile(args.driver_path):\\n raise FileNotFoundError(\\\"Unable to find the geckodriver\\\")\\n if not os.path.isfile(args.log_path) and args.log:\\n warnings.warn(f\\\"Unable to find the log:{args.log_path}, create it now\\\")\\n with open(args.log_path, \\\"w\\\") as f:\\n f.write(\\\"\\\")\",\n \"def init_driver(driver_path):\\n # user_agent = user_agent_rotator.get_random_user_agent()\\n try:\\n if driver_path != \\\"\\\":\\n chrome_options = Options()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--disable-dev-shm-usage')\\n chrome_options.add_argument('--window-size=1420,1080')\\n chrome_options.add_argument('--disable-gpu')\\n chrome_options.add_argument(f'user-agent={USER_AGENT}')\\n Driver._driver = webdriver.Chrome(executable_path=driver_path, chrome_options=chrome_options)\\n else:\\n raise Exception(\\\"Please provide a path to the chromedriver\\\")\\n except Exception as e:\\n logging.error(f\\\"Driver cannot be found. Path entered: {driver_path}\\\")\\n raise FileNotFoundError(\\\"Could not execute webdriver. Make sure you provided the correct path to the \\\"\\n \\\"chromedriver\\\", e)\",\n \"def init_chrome_webdriver(\\n executable_path='chromedriver', download_dir=None,\\n window_size=None, user_agent=None, log_path=None,\\n headless=True, incognito=True,\\n ignore_certificate_errors=True,\\n disable_gpu=True, disable_notifications=True, disable_infobars=True):\\n options = webdriver.ChromeOptions()\\n\\n # set boolean switch args\\n if headless is True:\\n options.add_argument('--headless')\\n if incognito is True:\\n options.add_argument('--incognito')\\n if ignore_certificate_errors is True:\\n options.add_argument('--ignore-certificate-errors')\\n if disable_gpu is True:\\n options.add_argument('--disable-gpu')\\n if disable_notifications is True:\\n options.add_argument('--disable-notifications')\\n if disable_infobars is True:\\n options.add_argument('--disable-infobars')\\n\\n # Needed to run in docker\\n options.add_argument('--no-sandbox')\\n\\n # set window size, using a global default if not specified\\n # (does this matter if `headless=True`?)\\n if not window_size:\\n window_size = DEFAULT_WINDOW_SIZE\\n options.add_argument('--window-size={w},{h}'.format(w=window_size[0], h=window_size[1]))\\n\\n # set user-agent, using a randomly selected default if not specified\\n if not user_agent:\\n user_agent = random.choice(USER_AGENTS)\\n options.add_argument('--user-agent=\\\"{}\\\"'.format(user_agent))\\n\\n # get a global default for logging path if not specified\\n # value passed in webdriver.Chrome init\\n if not log_path:\\n log_path = DEFAULT_LOG_PATH\\n\\n capabilities = DesiredCapabilities.CHROME.copy()\\n capabilities['version'] = 'latest'\\n capabilities['loggingPref'] = {\\n 'driver': 'WARNING', 'server': 'WARNING', 'browser': 'WARNING'}\\n\\n prefs = {\\n 'profile.default_content_settings.popups': False,\\n 'directory_upgrade': True,\\n }\\n if download_dir:\\n prefs['download.default_directory'] = download_dir\\n options.add_experimental_option('prefs', prefs)\\n\\n # initialize the driver with specified configuration\\n driver = webdriver.Chrome(\\n executable_path=executable_path,\\n options=options,\\n desired_capabilities=capabilities,\\n service_log_path=log_path)\\n\\n return driver\",\n \"def main(args=None):\\n args = args or sys.argv[1:]\\n parser = parse_options()\\n common.main_cli(experiment_parse_and_run, parser, args)\",\n \"def launch(**kwargs):\\n\\n logger, loghost, logport, clients, guis, params = unpack_launcher(**kwargs)\\n config = load_config(kwargs['config'], logger=logger)\\n\\n\\n ao_client = find_client(logger, clients, 'nidaqmx')\\n ai_client = find_client(logger, clients, 'nidaqmx_ai')\\n\\n # Instantiate Monitor script\\n laser_stabilizer = LaserStabilizer(\\n config=kwargs['config'],\\n ao_client=ao_client,\\n ai_client=ai_client\\n )\\n\\n update_service = Service()\\n update_service.assign_module(module=laser_stabilizer)\\n update_service.assign_logger(logger=logger)\\n update_server, update_port = create_server(update_service, logger, host=get_ip())\\n logger.update_data(data={'port': update_port})\\n laser_stabilizer.gui.set_network_info(port=update_port)\\n update_server.start()\\n\\n # Run continuously\\n # Note that the actual operation inside run() can be paused using the update server\\n while True:\\n\\n laser_stabilizer.run()\",\n \"def add_arguments(self, parser):\\n parser.add_argument('chrome_exec_path', type=str)\\n parser.add_argument('chrome_webdriver_path', type=str)\",\n \"def start_comp(command_line, log='', env='', foreground='no', no_stdin = 'yes'):\\n proc_title_argv = command_line.split()\\n\\n if proc_title_argv[0] == 'taskset':\\n real_program = proc_title_argv[3]\\n else:\\n real_program = proc_title_argv[0]\\n\\n # first test shared library link\\n try:\\n can_find_all_shared_libs(real_program)\\n except IOError, e:\\n print e;\\n raise\\n\\n my_stdout = None\\n my_stderr = None\\n my_stdin = None\\n if (no_stdin == 'yes'):\\n my_stdin = open('/dev/null', 'r')\\n\\n if log:\\n dir = os.path.dirname(log)\\n if dir:\\n try:\\n exist_ok_makedirs(dir, 0777)\\n except OSError, (errno, strerror):\\n sys.stderr.write('%s: %s\\\\n' % (dir, strerror))\\n raise\\n try:\\n log_fd = open(log, \\\"w\\\")\\n except IOError, (errno, strerror):\\n print 'cannot open %s: %s' % (log, strerror)\\n raise\\n else:\\n my_stdout = log_fd\\n my_stderr = subprocess.STDOUT\\n\\n #command = [ path ]\\n #if options:\\n # command += options\\n\\n my_env = {}\\n if env != '':\\n env_list = env.split('\\\\t')\\n env_val = '%s:%s' % (env_list[1], env_list[2])\\n my_env[env_list[0]] = env_val\\n\\n try:\\n p = subprocess.Popen(proc_title_argv, shell = False,\\n # stdin = subprocess.PIPE,\\\\\\n #stdin = None,\\n stdin = my_stdin,\\n stdout = my_stdout,\\n stderr = my_stderr,#)\\n env = my_env)\\n except OSError, (errno, strerror):\\n #sys.exit('cannot execute %s: %s' % (path, strerror))\\n print 'cannot execute %s: %s' % (real_program, strerror)\\n raise\\n except ValueError, strerror:\\n #sys.exit('subprocess.Popen value error: %s' %strerror)\\n print 'subprocess.Popen value error: %s' % (strerror)\\n raise\\n\\n #proc_name = os.path.basename(path)\\n if proc_title_argv[0] == 'taskset':\\n try:\\n proc_name = os.path.basename(proc_title_argv[3])\\n except IndexError,e:\\n print \\\"path: \\\", path\\n sys.exit(e)\\n else:\\n proc_name = os.path.basename(proc_title_argv[0])\\n\\n max_retry = 20\\n retry = 0\\n while True:\\n if retry == max_retry:\\n sys.exit('cannot exec. %s' % proc_name)\\n\\n #if kill_proc_exact.lookup_process_exact(proc):\\n if get_pids_exact(proc_name):\\n break;\\n else:\\n time.sleep(0.1)\\n retry += 1\\n\\n if foreground == 'yes':\\n try:\\n p.wait()\\n except KeyboardInterrupt, strerror:\\n pass\",\n \"def set_logger(log_path):\\n logger = logging.getLogger()\\n logger.setLevel(logging.INFO)\\n\\n if not logger.handlers:\\n # Logging to a file\\n file_handler = logging.FileHandler(log_path, mode='w')\\n file_handler.setFormatter(logging.Formatter('%(asctime)s:%(levelname)s: %(message)s'))\\n logger.addHandler(file_handler)\\n\\n # Logging to console\\n stream_handler = logging.StreamHandler()\\n stream_handler.setFormatter(logging.Formatter('%(message)s'))\\n logger.addHandler(stream_handler)\",\n \"def launch_proxy(local_port, remote_port, remote_ip):\\n\\n path = os.path.abspath(os.path.dirname(__file__))\\n ws = os.path.join(path, \\\"../../proxy/bin/wistar_proxy.py\\\")\\n\\n wistar_proxy_path = os.path.abspath(ws)\\n\\n cmd = \\\"/usr/bin/env python %s --local-port=%s --remote-ip=%s --remote-port=%s &\\\" % (wistar_proxy_path,\\n local_port,\\n remote_ip,\\n remote_port)\\n\\n logger.debug(cmd)\\n\\n proc = subprocess.Popen(cmd, shell=True, close_fds=True)\\n time.sleep(1)\\n return proc.pid\",\n \"def setup_wrapper(wcl, logfilename, workdir, ins):\\n\\n if miscutils.fwdebug_check(3, \\\"PFWRUNJOB_DEBUG\\\"):\\n miscutils.fwdebug_print(\\\"BEG\\\")\\n\\n if workdir is not None:\\n wcl['pre_disk_usage'] = 0\\n else:\\n wcl['pre_disk_usage'] = pfwutils.diskusage(wcl['jobroot'])\\n\\n\\n # make directory for log file\\n logdir = os.path.dirname(logfilename)\\n miscutils.coremakedirs(logdir)\\n\\n # get execnames to put on command line for QC Framework\\n wcl['execnames'] = wcl['wrapper']['wrappername'] + ',' + get_exec_names(wcl)\\n\\n\\n # get input files from targetnode\\n get_wrapper_inputs(wcl, ins)\\n\\n # if running in a fw thread, run in separate safe directory\\n if workdir is not None:\\n setup_working_dir(workdir, ins, os.getcwd())\\n\\n if miscutils.fwdebug_check(3, \\\"PFWRUNJOB_DEBUG\\\"):\\n miscutils.fwdebug_print(\\\"END\\\\n\\\\n\\\")\",\n \"def _ConstructStep(self, log_processor_class, logfile,\\n factory_properties=None, perf_expectations_path=None):\\n factory_properties = factory_properties or {}\\n self._log_processor_class = chromium_utils.InitializePartiallyWithArguments(\\n log_processor_class, factory_properties=factory_properties,\\n report_link=self._report_link, output_dir=self._output_dir,\\n perf_name='test-system', test_name='test-name',\\n perf_filename=perf_expectations_path)\\n step = chromium_step.ProcessLogShellStep(self._log_processor_class)\\n log_file = self._LogFile(\\n 'stdio', open(os.path.join(test_env.DATA_PATH, logfile)).read())\\n self._SetupBuild(step, self._revision, self._webkit_revision, log_file)\\n return step\",\n \"def run_plugin(argv):\\n\\treturn subprocess.Popen(argv, stdout=subprocess.PIPE)\",\n \"def java_args(jar: str, jar_args: List[str] | None = None,\\n jvm_opts: List[str] | None = None) -> List[str]:\\n args = []\\n\\n if jvm_opts:\\n args.extend(jvm_opts)\\n\\n args.extend(('-jar', jar))\\n\\n if jar_args:\\n args.extend(jar_args)\\n\\n return args\",\n \"def start_test_exec(cls):\\n time_str = cls.get_current_time()\\n os.system(\\\"robot -l ./logs/log_{0}.html -r ./logs/report_{0}.html -o ./logs/output_{0}.xml \\\\\\n ./test_suite/{1}\\\".format(time_str, test_suite))\",\n \"def _start_server(codechecker_cfg, test_config, auth=False):\\n def start_server_proc(event, server_cmd, checking_env):\\n \\\"\\\"\\\"Target function for starting the CodeChecker server.\\\"\\\"\\\"\\n proc = subprocess.Popen(server_cmd, env=checking_env)\\n\\n # Blocking termination until event is set.\\n event.wait()\\n\\n # If proc is still running, stop it.\\n if proc.poll() is None:\\n proc.terminate()\\n\\n server_cmd = codechecker.serv_cmd(codechecker_cfg['workspace'],\\n str(codechecker_cfg['viewer_port']),\\n env.get_postgresql_cfg())\\n\\n server_proc = multiprocessing.Process(\\n name='server',\\n target=start_server_proc,\\n args=(__STOP_SERVER, server_cmd, codechecker_cfg['check_env']))\\n\\n server_proc.start()\\n\\n # Wait for server to start and connect to database.\\n time.sleep(20)\",\n \"def run_starter(self, expect_to_fail=False):\\n logging.info(\\\"running starter \\\" + self.name)\\n args = [self.cfg.bin_dir / \\\"arangodb\\\"] + self.hotbackup_args + self.default_starter_args + self.arguments\\n\\n lh.log_cmd(args)\\n self.instance = psutil.Popen(args)\\n logging.info(\\\"my starter has PID:\\\" + str(self.instance.pid))\\n if not expect_to_fail:\\n self.wait_for_logfile()\\n self.wait_for_port_bind()\",\n \"def browser(path, driver='chrome'):\\n\\n if driver=='chrome':\\n driver = webdriver.Chrome()\\n elif driver=='firefox':\\n driver = webdriver.Firefox()\\n elif driver=='edge':\\n driver = webdriver.Edge()\\n else:\\n raise Exception(\\\"driver \\\"+driver+ \\\" is not supported\\\")\\n\\n driver.get(\\\"file:///\\\"+ path)\\n return driver\",\n \"def initDriver(browser):\\n if browser == \\\"firefox\\\":\\n opts = Options()\\n opts.log.level = \\\"trace\\\"\\n driver = webdriver.Firefox(options=opts)\\n return driver\\n elif browser == \\\"chrome\\\":\\n options = webdriver.ChromeOptions()\\n options.add_argument(\\\"start-maximized\\\")\\n #d = DesiredCapabilities.CHROME\\n d = options.to_capabilities()\\n d['loggingPrefs'] = { 'browser':'ALL'}\\n driver = webdriver.Chrome('../Data/chromedriver_linux64/chromedriver',desired_capabilities=d)\\n return driver\\n else:\\n print(\\\"------- Navegador no compatible ---------\\\")\\n return null\",\n \"def start_beam_jobserver(flink_session_name,\\n artifacts_dir=\\\"Resources\\\",\\n jobserver_jar=None):\\n if jobserver_jar is None:\\n jobserver_jar = os.path.join(util.get_flink_conf_dir(), \\\"beam-runners-flink-1.9-job-server-2.19.0.jar\\\")\\n # Get Flink master URL (flink session cluster) from an ExecutionDTO\\n method = constants.HTTP_CONFIG.HTTP_GET\\n resource_url = constants.DELIMITERS.SLASH_DELIMITER + \\\\\\n constants.REST_CONFIG.HOPSWORKS_REST_RESOURCE + constants.DELIMITERS.SLASH_DELIMITER + \\\\\\n constants.REST_CONFIG.HOPSWORKS_PROJECT_RESOURCE + constants.DELIMITERS.SLASH_DELIMITER + \\\\\\n hopsfs.project_id() + constants.DELIMITERS.SLASH_DELIMITER + \\\\\\n \\\"jobs\\\" + constants.DELIMITERS.SLASH_DELIMITER + \\\\\\n flink_session_name + constants.DELIMITERS.SLASH_DELIMITER + \\\\\\n \\\"executions\\\" + \\\\\\n \\\"?limit=1&offset=0&sort_by=submissionTime:desc\\\"\\n response = util.send_request(method, resource_url)\\n response_object = response.json()\\n flink_master_url = response_object['items'][0]['flinkMasterURL']\\n artifact_port = randint(10000, 65000)\\n expansion_port = randint(10000, 65000)\\n job_port = randint(10000, 65000)\\n job_host = socket.getfqdn()\\n log_base_path = \\\"\\\"\\n if 'LOG_DIRS' in os.environ:\\n log_base_path += os.environ['LOG_DIRS'] + \\\"/\\\"\\n\\n beam_jobserver_log = log_base_path + \\\"beamjobserver-\\\" + hopsfs.project_name().lower() + \\\"-\\\" + flink_session_name + \\\\\\n \\\"-\\\" + str(job_port) + \\\".log\\\"\\n # copy jar to local\\n with open(beam_jobserver_log, \\\"wb\\\") as out, open(beam_jobserver_log, \\\"wb\\\") as err:\\n jobserver = subprocess.Popen([\\\"java\\\",\\n \\\"-jar\\\", jobserver_jar,\\n \\\"--artifacts-dir=%s\\\" % hopsfs.project_path() + artifacts_dir,\\n \\\"--flink-master-url=%s\\\" % flink_master_url,\\n \\\"--artifact-port=%d\\\" % artifact_port,\\n \\\"--expansion-port=%d\\\" % expansion_port,\\n \\\"--job-host=%s\\\" % job_host,\\n \\\"--job-port=%d\\\" % job_port],\\n stdout=out,\\n stderr=err,\\n preexec_fn=util._on_executor_exit('SIGTERM'))\\n global clusters\\n clusters.append(flink_session_name)\\n global jobserver_host\\n jobserver_host = job_host\\n global jobserver_port\\n jobserver_port = job_port\\n return {\\\"jobserver_log\\\": beam_jobserver_log,\\n \\\"artifact_port\\\": artifact_port,\\n \\\"expansion_port\\\": expansion_port,\\n \\\"job_host\\\": job_host,\\n \\\"job_port\\\": job_port,\\n \\\"jobserver.pid\\\": jobserver.pid}\",\n \"def run(path):\\n\\n cwd = os.getcwd()\\n\\n os.chdir(path)\\n\\n if platform.system == \\\"Windows\\\":\\n os.popen(\\\"run.bat >> log-\\\" +\\n datetime.datetime.now().isoformat().split(\\\".\\\")[0].replace(':', '-') + \\\".txt\\\")\\n else:\\n os.popen(\\\"./run >> log-\\\" +\\n datetime.datetime.now().isoformat().split(\\\".\\\")[0].replace(':', '-') + \\\".txt\\\")\\n\\n while is_alive() == False:\\n time.sleep(0.1)\\n\\n os.chdir(cwd)\",\n \"def __init__(self,\\n geckodriver_path = None,\\n headless_browser = False,\\n disable_image_load = False,\\n page_delay = 10,\\n logfolder = 'logs/',\\n user_agent = None,\\n proxy_address = None,\\n proxy_port = None,\\n proxy_username = None,\\n proxy_password = None,\\n limit_scropes = None,\\n exclude_hosts = None,\\n browser_profile_path = None,\\n browser_executable_path = None,\\n geckodriver_log_level = 'info'\\n ):\\n firefox_options = Firefox_Options()\\n seleniumwire_options = {}\\n\\n if headless_browser:\\n firefox_options.add_argument(\\\"-headless\\\")\\n\\n if browser_profile_path is not None:\\n firefox_profile = webdriver.FirefoxProfile(browser_profile_path)\\n else:\\n firefox_profile = webdriver.FirefoxProfile()\\n\\n if browser_executable_path is not None:\\n firefox_options.binary = browser_executable_path\\n\\n\\n # set \\\"info\\\" by default\\n # set \\\"trace\\\" for debubging, Development only\\n firefox_options.log.level = geckodriver_log_level\\n\\n # set English language\\n firefox_profile.set_preference(\\\"intl.accept_languages\\\", \\\"en-US\\\")\\n\\n # set User-Agent\\n if user_agent is not None:\\n firefox_profile.set_preference(\\\"general.useragent.override\\\", user_agent)\\n\\n if disable_image_load:\\n # permissions.default.image = 2: Disable images load,\\n # this setting can improve pageload & save bandwidth\\n firefox_profile.set_preference(\\\"permissions.default.image\\\", 2)\\n \\n # mute audio while watching stories\\n firefox_profile.set_preference(\\\"media.volume_scale\\\", \\\"0.0\\\")\\n\\n # prevent Hide Selenium Extension: error\\n firefox_profile.set_preference(\\\"dom.webdriver.enabled\\\", False)\\n firefox_profile.set_preference(\\\"useAutomationExtension\\\", False)\\n firefox_profile.set_preference(\\\"general.platform.override\\\", \\\"iPhone\\\")\\n firefox_profile.update_preferences()\\n\\n # geckodriver log in specific user logfolder\\n geckodriver_log = \\\"{}geckodriver.log\\\".format(logfolder)\\n check_and_create_file(geckodriver_log)\\n\\n\\n # The list exclude hosts for capturing\\n if exclude_hosts:\\n seleniumwire_options['exclude_hosts'] = exclude_hosts\\n\\n # Add proxy with username and password authentication\\n if proxy_address and proxy_port:\\n if proxy_username and proxy_password:\\n seleniumwire_options['proxy'] = {\\n 'http': f'http://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\\n 'https': f'https://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\\n 'no_proxy': 'localhost,127.0.0.1'\\n }\\n else:\\n seleniumwire_options['proxy'] = {\\n 'http': f'http://{proxy_address}:{proxy_port}',\\n 'https': f'https://{proxy_address}:{proxy_port}',\\n 'no_proxy': 'localhost,127.0.0.1'\\n }\\n\\n\\n\\n self.driver = webdriver.Firefox(\\n firefox_profile=firefox_profile,\\n executable_path=geckodriver_path,\\n log_path=geckodriver_log,\\n options=firefox_options,\\n seleniumwire_options=seleniumwire_options\\n )\\n # Limit capture urls with regulater expression\\n if limit_scropes:\\n self.driver.scopes = limit_scropes\\n\\n # Set implicitly wait\\n self.driver.implicitly_wait(page_delay)\\n\\n # Set maximum windows\\n self.driver.maximize_window()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6576157","0.59147495","0.551453","0.5020369","0.4867105","0.48326635","0.48120183","0.48082626","0.4748094","0.4661346","0.4636292","0.46114662","0.4580532","0.4558185","0.45508748","0.45206273","0.45122933","0.44885132","0.4487213","0.44591105","0.44545212","0.44339418","0.44279718","0.43955734","0.43512815","0.4338622","0.4338448","0.43327445","0.43246368","0.431713","0.4306877","0.4289637","0.42868116","0.42674443","0.42543003","0.42270634","0.4217071","0.4209835","0.4208322","0.41905287","0.4188302","0.4187547","0.4179568","0.4178172","0.41735113","0.41711387","0.41506454","0.41404545","0.4135402","0.41311213","0.41259697","0.41158074","0.41085842","0.41027594","0.4099762","0.4091529","0.40894228","0.40873125","0.4082908","0.408149","0.40804306","0.4079192","0.4078155","0.40776387","0.40770453","0.40745008","0.40721178","0.40662235","0.4052277","0.40464565","0.40389377","0.40368566","0.4035146","0.4034716","0.40325233","0.4031054","0.40266737","0.4026533","0.4020154","0.4020026","0.40091795","0.40074107","0.40011945","0.399269","0.39840975","0.39789328","0.3963022","0.39584082","0.39582995","0.39570782","0.39570755","0.39462763","0.39456978","0.39445764","0.3941297","0.39381614","0.39372316","0.39353356","0.3933832","0.39334676"],"string":"[\n \"0.6576157\",\n \"0.59147495\",\n \"0.551453\",\n \"0.5020369\",\n \"0.4867105\",\n \"0.48326635\",\n \"0.48120183\",\n \"0.48082626\",\n \"0.4748094\",\n \"0.4661346\",\n \"0.4636292\",\n \"0.46114662\",\n \"0.4580532\",\n \"0.4558185\",\n \"0.45508748\",\n \"0.45206273\",\n \"0.45122933\",\n \"0.44885132\",\n \"0.4487213\",\n \"0.44591105\",\n \"0.44545212\",\n \"0.44339418\",\n \"0.44279718\",\n \"0.43955734\",\n \"0.43512815\",\n \"0.4338622\",\n \"0.4338448\",\n \"0.43327445\",\n \"0.43246368\",\n \"0.431713\",\n \"0.4306877\",\n \"0.4289637\",\n \"0.42868116\",\n \"0.42674443\",\n \"0.42543003\",\n \"0.42270634\",\n \"0.4217071\",\n \"0.4209835\",\n \"0.4208322\",\n \"0.41905287\",\n \"0.4188302\",\n \"0.4187547\",\n \"0.4179568\",\n \"0.4178172\",\n \"0.41735113\",\n \"0.41711387\",\n \"0.41506454\",\n \"0.41404545\",\n \"0.4135402\",\n \"0.41311213\",\n \"0.41259697\",\n \"0.41158074\",\n \"0.41085842\",\n \"0.41027594\",\n \"0.4099762\",\n \"0.4091529\",\n \"0.40894228\",\n \"0.40873125\",\n \"0.4082908\",\n \"0.408149\",\n \"0.40804306\",\n \"0.4079192\",\n \"0.4078155\",\n \"0.40776387\",\n \"0.40770453\",\n \"0.40745008\",\n \"0.40721178\",\n \"0.40662235\",\n \"0.4052277\",\n \"0.40464565\",\n \"0.40389377\",\n \"0.40368566\",\n \"0.4035146\",\n \"0.4034716\",\n \"0.40325233\",\n \"0.4031054\",\n \"0.40266737\",\n \"0.4026533\",\n \"0.4020154\",\n \"0.4020026\",\n \"0.40091795\",\n \"0.40074107\",\n \"0.40011945\",\n \"0.399269\",\n \"0.39840975\",\n \"0.39789328\",\n \"0.3963022\",\n \"0.39584082\",\n \"0.39582995\",\n \"0.39570782\",\n \"0.39570755\",\n \"0.39462763\",\n \"0.39456978\",\n \"0.39445764\",\n \"0.3941297\",\n \"0.39381614\",\n \"0.39372316\",\n \"0.39353356\",\n \"0.3933832\",\n \"0.39334676\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.81625164"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88377,"cells":{"query":{"kind":"string","value":"Shuts down the Selenium Server. `host` and `port` define where the location of Selenium Server. Does not fail even if the Selenium Server is not running."},"document":{"kind":"string","value":"def shut_down_selenium_server(host='localhost', port=4444):\n try:\n selenium(host, port, '', '').shut_down_selenium_server()\n except socket.error:\n pass"},"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 stop_selenium_server(self):\n shut_down_selenium_server(self._server_host, self._server_port)\n self._selenium = NoBrowserOpen()\n if self._selenium_log:\n self._selenium_log.close()","def shutdown(self):\n # TODO: Build a certificate chain so we can verify our localhost and remove the verify=False workaround.\n requests.get('{local_server_address}/shutdown'.format(local_server_address=self.local_server_address),\n verify=False)","def __exit__(self, exc_type, exc_val, exc_tb):\n self.server.stop()\n self.driver.quit()","def shutdown():\n return subprocess.run([\"powershell.exe\", \"-Command\", \"Stop-Computer\", \"-ComputerName\", \"localhost\"], shell=True, universal_newlines=True, check=False).returncode","def stop(self):\n\n net_tuple = self.read_nodestate(0)\n\n # 1. Kill localhost client\n try:\n localhost_socket = self.lookup_socket(\"127.0.0.1\")\n localhost_connection = (localhost_socket, \"127.0.0.1\")\n self.send(localhost_connection, \"stop\")\n\n except ConnectionRefusedError:\n pass # Localhost is already disconnected\n\n log_msg = \"Attempting to gracefully disconnect and disassociate from all clients...\"\n Primitives.log(log_msg, in_log_level=\"Info\")\n\n # 2. Disconnect from all clients\n for connection in net_tuple:\n log_msg = str(\"Trying to disconnect from socket: \" + str(connection[0]))\n Primitives.log(log_msg, in_log_level=\"Debug\")\n\n try:\n self.disconnect(connection, disallow_local_disconnect=True)\n\n except OSError:\n another_log_msg = str(\"Failed to disconnect from socket: \"+str(connection[0]))\n Primitives.log(another_log_msg, in_log_level=\"Warning\")\n\n finally:\n Primitives.log(\"Successfully disconnected\", in_log_level=\"Debug\")\n\n # Forcefully close localhost socket\n localhost_sock_name = localhost.getsockname()\n localhost.close()\n\n Primitives.log(\"Exiting gracefully;\", in_log_level=\"Info\")\n\n # 3. Kill the network injector and terminate the Server.\n\n self.write_nodestate(nodeState, 2, True) # set terminated=True\n self.write_nodestate(nodeState, 4, True) # set injector_terminated = True\n\n # Hack the socket.listen() loop in the init() function by connecting to it(localhost),\n # which will force it to terminate.\n\n temp = socket.socket()\n temp.connect(localhost_sock_name) # This will kill the localhost socket\n temp.close()\n\n # noinspection PyProtectedMember\n os._exit(0)","def stop_server_and_driver(server, driver):\n \n driver.close()\n server.stop()","def stop() -> None:\n global _server\n if _server:\n try:\n _server.shutdown()\n except Exception:\n pass","def shutdown():\n\n cmd = dict()\n cmd[\"type_\"] = \"shutdown\"\n cmd[\"name_\"] = \"all\"\n\n ## In case of the shutdown there will be no returned message to\n ## check the success.\n s = comm.send_and_receive_socket(cmd)\n\n s.close()","def close_and_finish_execution():\n driver.close()\n driver.quit()\n exit(0)","def Quit(self):\n t = threading.Thread(target=self.server.shutdown)\n t.start()","def stop_daemon(api_port=None, api_host=None):\n if api_port is not None:\n port = api_port\n else:\n port = _api_port()\n if api_host is not None:\n host = api_host\n else:\n host = _api_host()\n url = f'http://{host}:{port}/halt'\n try:\n x = _http_get_json(url)\n except:\n return False\n return x.get('success')","def shutdown_server():\n func = request.environ.get('werkzeug.server.shutdown')\n if func is None:\n raise RuntimeError('Not running with the Werkzeug Server')\n func()","def disconnect(self) -> None:\n self.driver.quit()","def shutdown(self):\n try:\n self._request(\"POST /shutdown\")\n time.sleep(0.300)\n except requests.exceptions.ConnectionError:\n pass\n if self._process and self._process.poll() is None:\n self._process.kill()\n if self._session:\n self._session.close()","def quit(self):\n \n if 'driver' in self.__dict__:\n self.driver.quit()\n if 'session' in self.__dict__:\n self.session.close()\n if 'conn' in self.__dict__:\n self.conn.close()","def ShutdownServerAndConnection(self): # real signature unknown; restored from __doc__\n pass","def _shutdown(self, *args):\n self.server.shutdown()","def shutdown_server():\n func = flask.request.environ.get('werkzeug.server.shutdown')\n if func is None:\n raise RuntimeError('Not running with the Werkzeug Server')\n func()","def stop(self):\n self.logger.info('Shutting down SimpleHTTPServer')\n stop_cmd = \"pkill -9 -f '{0}'\".format(self.server_cmd)\n self._execute_command(stop_cmd)","def server_shutdown():\n if not current_app.testing:\n abort(404)\n shutdown = request.environ.get('werkzeug.server.shutdown')\n if not shutdown:\n abort(500)\n shutdown()\n return 'Shutting down...'","def stop():\n server = current_server()\n server.stop()","def shutDown(self):\n self.host = None\n self.port = None\n if(self.loop is not None):\n test = asyncio.run_coroutine_threadsafe(self.stopLoop(), self.loop)\n self.thread.join()\n if(self.loop.is_running()):\n self.loop.stop()\n else:\n self.loop.close()\n self.pool.shutDown()\n self.pool = None\n self.loop = None\n self.thread = None","def shutdown():\n shutdown_server()\n return \"Shutting down server\"","def shutdown_server(self):\n try:\n ans = self.xmlproxy.shutdown()\n except socket_error as err:\n self.class_logger.info(\"xmlrpc shutdown complete. (DEBUG: {0})\".format(err))\n except XmlrpcProtocolError as err:\n self.class_logger.info(\"xmlrpc shutdown complete. (DEBUG: {0})\".format(err))\n except Exception as err:\n self.class_logger.info(\"xmlrpc shutdown expected error: {0} - {1}\".format(type(err), err))\n else:\n self.class_logger.info(\"xmlrpc shutdown query answer: %s\" % (ans, ))\n # except socket.error, err:\n # if err[0] == 111:\n # print \"!\"*100\n # print \"ERR '{0}' handled\".format(err)\n # else:\n # raise","async def quit(self):\n await self.kill_server()\n await self.logout()","def stop(self):\n response = self._shell_client.exec_command('{} stop'.format(self._executable_path), async=False)\n\n if not response.is_success():\n self._logger.error('clusterrunner stop failed on host {} with output: {}, error: {}'.format(\n self.host, response.raw_output, response.raw_error))","def _StopServer( self ):\n with self._gocode_lock:\n if self._ServerIsRunning():\n _logger.info( 'Stopping Gocode server with PID {0}'.format(\n self._gocode_handle.pid ) )\n try:\n self._ExecuteCommand( [ self._gocode_binary_path,\n '-sock', 'tcp',\n '-addr', self._gocode_host,\n 'close' ] )\n utils.WaitUntilProcessIsTerminated( self._gocode_handle, timeout = 5 )\n _logger.info( 'Gocode server stopped' )\n except Exception:\n _logger.exception( 'Error while stopping Gocode server' )\n\n self._CleanUp()","def shutdown(self, wait):\n\n try:\n self._machine.shutdown(wait)\n except VMError, e:\n raise CoreError(e.msg, True)","async def gracefully_shutdown_browser(self, browser: Browser) -> None:","def deactivate(self):\n self._activate_event.clear()\n self._ready_event.clear()\n if not self._ready_event.wait(settings.SELENIUM_TEST_SERVER_TIMEOUT):\n raise Exception('Test server hung. Timed out after %i seconds' % settings.SELENIUM_TEST_SERVER_TIMEOUT)","def shutdown():\n shutdown_func = request.environ.get(\n 'werkzeug.server.shutdown') # default web server with flask\n if shutdown_func is None:\n return 'unable to shutdown server!', 501\n shutdown_func()\n return \"server shutting down...\"","def destroy_server(server):\n server.stop_and_destroy()","def test_driver_stop_after_shutdown(self, runpath):\n\n driver = self.MyDriver(\n name=\"MyDriver\",\n runpath=runpath,\n pre_start=pre_start_fn,\n post_start=post_start_fn,\n pre_stop=pre_stop_fn,\n post_stop=post_stop_fn,\n )\n\n driver.start()\n driver.wait(driver.STATUS.STARTED)\n assert driver.status.tag == driver.status.STARTED\n\n driver.stop()\n driver.wait(driver.STATUS.STOPPED)\n assert driver.status.tag == driver.status.STOPPED\n\n driver.stop()","def test_shutdown_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as exc:\n server.shutdown()\n if platform == \"win32\":\n assert exc.value.args[0] == ESHUTDOWN\n else:\n assert exc.value.args[0] == EPIPE","def stop(self):\n shutdown_url = self._env[\"DATASTORE_HOST\"] + \"/shutdown\"\n req = urllib.request.Request(shutdown_url, method=\"POST\")\n urllib.request.urlopen(req)","def shutdown():\n\n # Earlier versions of traffic_ctl do not support\n # \"server stop\", so we prefer traffic_line here.\n if _TRAFFICLINE:\n cmd = _traffic_line(\"-S\")\n else:\n cmd = _traffic_ctl(\"server\", \"stop\")\n\n _subprocess(cmd)\n return _statuscmd()","def __exit__(self, *args):\n self.driver.quit()","def terminate_server(self, port):\n proc = self.processes.pop(port, None)\n if proc is None:\n raise ValueError(f\"Server for port {port} does not exists.\"\n \"It might have been closed already.\"\n )\n proc.terminate()","def shutdown(self) -> None:\n self.system.notify('Jarvis::SHUTTING DOWN now')\n sleep(3)\n self.system.power_off()","def __shutdownParallel(self):\n if self._parallelLib == ParallelLibEnum.ray and self._server is not None and not self.rayInstanciatedOutside:\n # we need to ssh and stop each remote node cluster (ray)\n servers = []\n if 'remoteNodes' in self.runInfoDict:\n servers += self.runInfoDict['remoteNodes']\n if 'headNode' in self.runInfoDict:\n servers += [self.runInfoDict['headNode']]\n # get local enviroment\n localEnv = os.environ.copy()\n localEnv[\"PYTHONPATH\"] = os.pathsep.join(sys.path)\n for nodeAddress in servers:\n self.raiseAMessage(\"Shutting down ray at address: \"+ nodeAddress)\n command=\"ray stop\"\n rayTerminate = utils.pickleSafeSubprocessPopen(['ssh',nodeAddress.split(\":\")[0],\"COMMAND='\"+command+\"'\",\"RAVEN_FRAMEWORK_DIR='\"+self.runInfoDict[\"FrameworkDir\"]+\"'\",self.runInfoDict['RemoteRunCommand']],shell=False,env=localEnv)\n rayTerminate.wait()\n if rayTerminate.returncode != 0:\n self.raiseAWarning(\"RAY FAILED TO TERMINATE ON NODE: \"+nodeAddress)\n # shutdown ray API (object storage, plasma, etc.)\n ray.shutdown()\n elif self._parallelLib == ParallelLibEnum.dask and self._server is not None and not self.rayInstanciatedOutside:\n self._server.close()\n if self._daskScheduler is not None:\n self._daskScheduler.terminate()","def stop_server(setname=None, hosts=None):\n global SESSIONS # pylint: disable=global-variable-not-assigned\n try:\n if setname is None:\n for _key, val in SESSIONS.items():\n val.send_signal(signal.SIGINT)\n time.sleep(5)\n if val.poll() is None:\n val.kill()\n val.wait()\n else:\n SESSIONS[setname].send_signal(signal.SIGINT)\n time.sleep(5)\n if SESSIONS[setname].poll() is None:\n SESSIONS[setname].kill()\n SESSIONS[setname].wait()\n print(\"<SERVER> server stopped\")\n\n except Exception as error:\n print(\"<SERVER> Exception occurred: {0}\".format(str(error)))\n raise ServerFailed(\"Server didn't stop!\")\n\n if not hosts:\n return\n\n # Make sure the servers actually stopped. Give them time to stop first\n # pgrep exit status:\n # 0 - One or more processes matched the criteria.\n # 1 - No processes matched.\n # 2 - Syntax error in the command line.\n # 3 - Fatal error: out of memory etc.\n time.sleep(5)\n result = pcmd(\n hosts, \"pgrep '(daos_server|daos_io_server)'\", False, expect_rc=1)\n if len(result) > 1 or 1 not in result:\n bad_hosts = [\n node for key in result if key != 1 for node in list(result[key])]\n kill_server(bad_hosts)\n raise ServerFailed(\n \"DAOS server processes detected after attempted stop on {}\".format(\n \", \".join([str(result[key]) for key in result if key != 1])))\n\n # we can also have orphaned ssh processes that started an orted on a\n # remote node but never get cleaned up when that remote node spontaneiously\n # reboots\n subprocess.call([\"pkill\", \"^ssh$\"])","def test_node_stop(self, m_docker_client, m_client):\n # Call method under test\n node.node_stop(True)\n\n # Assert\n m_client.remove_host.assert_called_once_with(node.hostname)\n m_docker_client.stop.assert_called_once_with('calico-node')","def quit(self):\n self.driver.quit()","def Disconnect_from_ePCSim_Server(ePCSim_conn):\r\n ePCSim_conn.Disconnect()","def shutdown(self):\n try:\n self.driver.stop()\n except:\n logging.exception(\"Could not stop driver on shutdown\")\n\n self.arduino.stop()","def _stop(self, host):\n pass","def adb_down(self, port):\n self.adb_transport = None\n self.check_adb([\"disconnect\", \"localhost:%d\" % port])\n\n # Wait until QEMU's forward has expired\n CONNECT_MAX_TRIES = 15\n connect_tries = 0\n while True:\n try:\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n sock.connect((\"localhost\", port))\n sock.close()\n connect_tries += 1\n if connect_tries >= CONNECT_MAX_TRIES:\n raise Timeout(\"Wait for port forward to go away\",\n CONNECT_MAX_TRIES)\n time.sleep(1)\n except IOError:\n break","def teardown_package():\n # TODO If environment variable is set keep the workspace\n # and print out the path.\n global TEST_WORKSPACE\n\n # Removing the product through this server requires credentials.\n codechecker_cfg = env.import_test_cfg(TEST_WORKSPACE)['codechecker_cfg']\n codechecker.remove_test_package_product(TEST_WORKSPACE,\n codechecker_cfg['check_env'])\n\n __STOP_SERVER.set()\n\n # The custom server stated in a separate home needs to be waited, so it\n # can properly execute its finalizers.\n time.sleep(5)\n\n print(\"Removing: \" + TEST_WORKSPACE)\n shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)","def stop_echo_server(self, ip_addr='localhost',\n port=zephyr_constants.DEFAULT_ECHO_PORT):\n out = None\n if (port in self.echo_server_procs and\n self.echo_server_procs[port] is not None):\n es_proc = self.echo_server_procs[port]\n out = es_proc.terminate()\n self.echo_server_procs.pop(port)\n return out","def quit(self):\n driver.quit()","def stop_server(self):\r\n # TODO-SDH Add way to stop the server from running.\r","def i_close_the_browser():\n driver.close()\n driver.quit()","def quit(self):\n if self.webdriver is not None:\n self.webdriver.quit()\n self.webdriver = None","def tearDown(self):\n self.log.debug(\"Started TearDown\")\n self.driver.quit()\n self.log.debug(\"Completed TearDown\")","def shutdown_server(server_target):\n assassin = threading.Thread(target=server_target.shutdown)\n assassin.daemon = True\n assassin.start()","def close_browser():\n driver.close()","def stop_server(self, server, name):\n # Spin down the requested server\n server.stop()","def shutdown():\n query = {\n \"type\": \"op\",\n \"cmd\": \"<request><shutdown><system></system></shutdown></request>\",\n }\n\n return __proxy__[\"panos.call\"](query)","def closeBrowser(driver):\n driver.quit()","def Quit(self, timeout=5.0):\n assert self._process, 'server was not started'\n if self._process.poll() is None:\n try:\n urllib2.urlopen(self.url + QUIT_PATH)\n except urllib2.URLError:\n\n\n pass\n\n finish_time = time.time() + timeout\n while time.time() < finish_time and self._process.poll() is None:\n time.sleep(0.2)\n if self._process.returncode is None:\n logging.warning('api_server did not quit cleanly, killing')\n self._process.kill()","def shutdown(self, hub=True, targets='all', block=False):\n self.unit_manager.close()\n self.pilot_manager.close()\n self.session.close(download=True)\n logger.info(\"Attempting RADICALExecutor shutdown\")\n\n return True","def shutdown(self):\n self._send_command('shutdown')\n self.sock.close()\n self.disconnected = True","def shutdown(self) -> None:\n prefix = f\"In {ThreadedServer.__name__}.{ThreadedServer.shutdown.__name__}\"\n\n print(f\"{prefix}: Instructing the server to shut down...\", file=self.stdout)\n with self._server_exception_lock:\n if self._server_exception is not None:\n raise self._server_exception\n\n print(f\"{prefix}: Waiting for server to shut down...\", file=self.stdout)\n self._httpd.shutdown()","def shutdown(self):\n\n raise NotImplementedError","def tearDown(self):\n\n self._checkJSErrors()\n swt.active_driver = None\n self.driver.quit()","def testServerShutdown(self):\n d = self.testSimpleRequest()\n d.addCallback(lambda _: self.factory.shutdown())\n d.addCallback(lambda _: self.listeningPort.stopListening())\n d.addCallback(lambda _: self.client.check_rate_limit())\n d.addTimeout(0.01, reactor)\n return self.assertFailure(d, ConnectionClosed)","def stop(self: RemoteCluster, wait: bool = False, timeout: int = None) -> None:\n self.server.stop(wait=wait, timeout=timeout)\n self.clients.terminate()\n super().stop(wait=wait, timeout=timeout)","def teardown(self):\r\n self.driver.quit()","def shutdown(self):\n self._shutdown_browser()","def tearDownClass(cls):\n cls.driver.close()\n cls.driver.quit()","def tearDownClass(cls):\n cls.driver.close()\n cls.driver.quit()","def shutdown(opts):\n log.debug(\"Proxy module %s shutting down!!\", opts[\"id\"])\n try:\n thisproxy[\"conn\"].close()\n\n except Exception: # pylint: disable=broad-except\n pass","def stop_browser(self):\n self.driver.quit()","def test_server_no_port(self):\n (code, out, err) = run([\"./server\"]);\n self.assertEqual(code, 1)","def server(host, port, debug):\n run_server(host, port, debug)","def tearDown(self):\n self.server.stop()\n self._server_thread.join()","def quit(self):\n self.driver.close_app()\n self.driver.quit()","def _stop_server(cls, server):\n\n try:\n server.kill()\n except Exception as error:\n print('ERROR stop enip server: ', error)","def close(self):\n self._server.shutdown()\n self._server = None","def shutdown_cluster(self):\n self.cluster.shutdown()","def shutdown(name):\n ret = {\"name\": name, \"changes\": {}, \"result\": None, \"comment\": \"\"}\n\n if __opts__[\"test\"]:\n ret[\"comment\"] = \"Shutting down local node\"\n return ret\n\n __salt__[\"trafficserver.shutdown\"]()\n\n ret[\"result\"] = True\n ret[\"comment\"] = \"Shutdown local node\"\n return ret","def tear_down(self):\n self.driver.close()\n self.driver.quit()","def webserver_stop():\n run(\"kill $(cat %s)\" % GUNICORN_PIDFILE)\n run(\"rm %s\" % GUNICORN_PIDFILE)","def tearDown(self):\n self.driver.quit()","def tearDown(self):\n self.driver.quit()","def tearDown(self):\n self.driver.quit()","def _stop_server(cls, address):\n\n print('_stop_server: please override me.')","def stop_server(self):\n if not self.server:\n raise Exception(\"Error owamp: the server must be opened to be closed\\n\")\n self.server.close_owampd()","async def _internalStop(self):\n self.wserver.close()\n await self.wserver.wait_closed()\n self.server.stop()\n while (self.server.is_running()):\n time.sleep(0.5)\n self.server.close()\n self.server = None","def Stop_ePCSim(ePCSim_conn):\r\n ePCSim_conn.SendCmd(\"exit\")\r\n ePCSim_conn.prompt = \"#\"\r\n ePCSim_conn.SendCmd(\"pkill egate\")\r\n ePCSim_conn.SendCmd(\"pkill edaemon\")","def close(self):\n\n #Kill all zombie PIDs and exit gracefully\n try:\n self.webdriver.quit()\n except:\n pass\n if 'p' not in sys.argv:\n self.kill()\n sys.exit()","def test_closed(self):\n server, client = loopback()\n server.sock_shutdown(2)\n with pytest.raises(SysCallError) as err:\n server.sendall(b\"hello, world\")\n if platform == \"win32\":\n assert err.value.args[0] == ESHUTDOWN\n else:\n assert err.value.args[0] == EPIPE","def shutdown():\n func = flask.request.environ.get('werkzeug.server.shutdown')\n if func is None:\n raise RuntimeError('Not running with the Werkzeug Server')\n func()\n return 'Server shutting down...'","def stopESServer():\n statusES = 'systemctl status elasticsearch.service'\n stopES = 'systemctl stop elasticsearch.service'\n\n os.popen(stopES, 'w')\n print(\"\\nPLEASE WAIT 20 SECONDS... STOPPING ELASTICSEARCH SERVER.\\n\")\n sleep(20)\n os.popen(statusES, 'w')","def stop_server(manager):\n if not manager.is_daemon:\n return\n web_server = WebServer()\n if web_server.is_alive():\n web_server.stop()","def stop_server(manager):\n if not manager.is_daemon:\n return\n web_server = WebServer()\n if web_server.is_alive():\n web_server.stop()","def stop(self) -> None:\n # Call the server shutdown functions and wait for them to finish. These\n # must be called on the server thread's event loop.\n future = asyncio.run_coroutine_threadsafe(self._stop(), self._server_loop)\n future.result(5)\n\n # Stop the server thread's event loop\n self._server_loop.call_soon_threadsafe(self._server_loop.stop)","def shutdown(self) -> None:","def shutdown(self) -> None:","def shutdown(self, *args):\n return _SALOMERuntime.PythonNode_shutdown(self, *args)"],"string":"[\n \"def stop_selenium_server(self):\\n shut_down_selenium_server(self._server_host, self._server_port)\\n self._selenium = NoBrowserOpen()\\n if self._selenium_log:\\n self._selenium_log.close()\",\n \"def shutdown(self):\\n # TODO: Build a certificate chain so we can verify our localhost and remove the verify=False workaround.\\n requests.get('{local_server_address}/shutdown'.format(local_server_address=self.local_server_address),\\n verify=False)\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n self.server.stop()\\n self.driver.quit()\",\n \"def shutdown():\\n return subprocess.run([\\\"powershell.exe\\\", \\\"-Command\\\", \\\"Stop-Computer\\\", \\\"-ComputerName\\\", \\\"localhost\\\"], shell=True, universal_newlines=True, check=False).returncode\",\n \"def stop(self):\\n\\n net_tuple = self.read_nodestate(0)\\n\\n # 1. Kill localhost client\\n try:\\n localhost_socket = self.lookup_socket(\\\"127.0.0.1\\\")\\n localhost_connection = (localhost_socket, \\\"127.0.0.1\\\")\\n self.send(localhost_connection, \\\"stop\\\")\\n\\n except ConnectionRefusedError:\\n pass # Localhost is already disconnected\\n\\n log_msg = \\\"Attempting to gracefully disconnect and disassociate from all clients...\\\"\\n Primitives.log(log_msg, in_log_level=\\\"Info\\\")\\n\\n # 2. Disconnect from all clients\\n for connection in net_tuple:\\n log_msg = str(\\\"Trying to disconnect from socket: \\\" + str(connection[0]))\\n Primitives.log(log_msg, in_log_level=\\\"Debug\\\")\\n\\n try:\\n self.disconnect(connection, disallow_local_disconnect=True)\\n\\n except OSError:\\n another_log_msg = str(\\\"Failed to disconnect from socket: \\\"+str(connection[0]))\\n Primitives.log(another_log_msg, in_log_level=\\\"Warning\\\")\\n\\n finally:\\n Primitives.log(\\\"Successfully disconnected\\\", in_log_level=\\\"Debug\\\")\\n\\n # Forcefully close localhost socket\\n localhost_sock_name = localhost.getsockname()\\n localhost.close()\\n\\n Primitives.log(\\\"Exiting gracefully;\\\", in_log_level=\\\"Info\\\")\\n\\n # 3. Kill the network injector and terminate the Server.\\n\\n self.write_nodestate(nodeState, 2, True) # set terminated=True\\n self.write_nodestate(nodeState, 4, True) # set injector_terminated = True\\n\\n # Hack the socket.listen() loop in the init() function by connecting to it(localhost),\\n # which will force it to terminate.\\n\\n temp = socket.socket()\\n temp.connect(localhost_sock_name) # This will kill the localhost socket\\n temp.close()\\n\\n # noinspection PyProtectedMember\\n os._exit(0)\",\n \"def stop_server_and_driver(server, driver):\\n \\n driver.close()\\n server.stop()\",\n \"def stop() -> None:\\n global _server\\n if _server:\\n try:\\n _server.shutdown()\\n except Exception:\\n pass\",\n \"def shutdown():\\n\\n cmd = dict()\\n cmd[\\\"type_\\\"] = \\\"shutdown\\\"\\n cmd[\\\"name_\\\"] = \\\"all\\\"\\n\\n ## In case of the shutdown there will be no returned message to\\n ## check the success.\\n s = comm.send_and_receive_socket(cmd)\\n\\n s.close()\",\n \"def close_and_finish_execution():\\n driver.close()\\n driver.quit()\\n exit(0)\",\n \"def Quit(self):\\n t = threading.Thread(target=self.server.shutdown)\\n t.start()\",\n \"def stop_daemon(api_port=None, api_host=None):\\n if api_port is not None:\\n port = api_port\\n else:\\n port = _api_port()\\n if api_host is not None:\\n host = api_host\\n else:\\n host = _api_host()\\n url = f'http://{host}:{port}/halt'\\n try:\\n x = _http_get_json(url)\\n except:\\n return False\\n return x.get('success')\",\n \"def shutdown_server():\\n func = request.environ.get('werkzeug.server.shutdown')\\n if func is None:\\n raise RuntimeError('Not running with the Werkzeug Server')\\n func()\",\n \"def disconnect(self) -> None:\\n self.driver.quit()\",\n \"def shutdown(self):\\n try:\\n self._request(\\\"POST /shutdown\\\")\\n time.sleep(0.300)\\n except requests.exceptions.ConnectionError:\\n pass\\n if self._process and self._process.poll() is None:\\n self._process.kill()\\n if self._session:\\n self._session.close()\",\n \"def quit(self):\\n \\n if 'driver' in self.__dict__:\\n self.driver.quit()\\n if 'session' in self.__dict__:\\n self.session.close()\\n if 'conn' in self.__dict__:\\n self.conn.close()\",\n \"def ShutdownServerAndConnection(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def _shutdown(self, *args):\\n self.server.shutdown()\",\n \"def shutdown_server():\\n func = flask.request.environ.get('werkzeug.server.shutdown')\\n if func is None:\\n raise RuntimeError('Not running with the Werkzeug Server')\\n func()\",\n \"def stop(self):\\n self.logger.info('Shutting down SimpleHTTPServer')\\n stop_cmd = \\\"pkill -9 -f '{0}'\\\".format(self.server_cmd)\\n self._execute_command(stop_cmd)\",\n \"def server_shutdown():\\n if not current_app.testing:\\n abort(404)\\n shutdown = request.environ.get('werkzeug.server.shutdown')\\n if not shutdown:\\n abort(500)\\n shutdown()\\n return 'Shutting down...'\",\n \"def stop():\\n server = current_server()\\n server.stop()\",\n \"def shutDown(self):\\n self.host = None\\n self.port = None\\n if(self.loop is not None):\\n test = asyncio.run_coroutine_threadsafe(self.stopLoop(), self.loop)\\n self.thread.join()\\n if(self.loop.is_running()):\\n self.loop.stop()\\n else:\\n self.loop.close()\\n self.pool.shutDown()\\n self.pool = None\\n self.loop = None\\n self.thread = None\",\n \"def shutdown():\\n shutdown_server()\\n return \\\"Shutting down server\\\"\",\n \"def shutdown_server(self):\\n try:\\n ans = self.xmlproxy.shutdown()\\n except socket_error as err:\\n self.class_logger.info(\\\"xmlrpc shutdown complete. (DEBUG: {0})\\\".format(err))\\n except XmlrpcProtocolError as err:\\n self.class_logger.info(\\\"xmlrpc shutdown complete. (DEBUG: {0})\\\".format(err))\\n except Exception as err:\\n self.class_logger.info(\\\"xmlrpc shutdown expected error: {0} - {1}\\\".format(type(err), err))\\n else:\\n self.class_logger.info(\\\"xmlrpc shutdown query answer: %s\\\" % (ans, ))\\n # except socket.error, err:\\n # if err[0] == 111:\\n # print \\\"!\\\"*100\\n # print \\\"ERR '{0}' handled\\\".format(err)\\n # else:\\n # raise\",\n \"async def quit(self):\\n await self.kill_server()\\n await self.logout()\",\n \"def stop(self):\\n response = self._shell_client.exec_command('{} stop'.format(self._executable_path), async=False)\\n\\n if not response.is_success():\\n self._logger.error('clusterrunner stop failed on host {} with output: {}, error: {}'.format(\\n self.host, response.raw_output, response.raw_error))\",\n \"def _StopServer( self ):\\n with self._gocode_lock:\\n if self._ServerIsRunning():\\n _logger.info( 'Stopping Gocode server with PID {0}'.format(\\n self._gocode_handle.pid ) )\\n try:\\n self._ExecuteCommand( [ self._gocode_binary_path,\\n '-sock', 'tcp',\\n '-addr', self._gocode_host,\\n 'close' ] )\\n utils.WaitUntilProcessIsTerminated( self._gocode_handle, timeout = 5 )\\n _logger.info( 'Gocode server stopped' )\\n except Exception:\\n _logger.exception( 'Error while stopping Gocode server' )\\n\\n self._CleanUp()\",\n \"def shutdown(self, wait):\\n\\n try:\\n self._machine.shutdown(wait)\\n except VMError, e:\\n raise CoreError(e.msg, True)\",\n \"async def gracefully_shutdown_browser(self, browser: Browser) -> None:\",\n \"def deactivate(self):\\n self._activate_event.clear()\\n self._ready_event.clear()\\n if not self._ready_event.wait(settings.SELENIUM_TEST_SERVER_TIMEOUT):\\n raise Exception('Test server hung. Timed out after %i seconds' % settings.SELENIUM_TEST_SERVER_TIMEOUT)\",\n \"def shutdown():\\n shutdown_func = request.environ.get(\\n 'werkzeug.server.shutdown') # default web server with flask\\n if shutdown_func is None:\\n return 'unable to shutdown server!', 501\\n shutdown_func()\\n return \\\"server shutting down...\\\"\",\n \"def destroy_server(server):\\n server.stop_and_destroy()\",\n \"def test_driver_stop_after_shutdown(self, runpath):\\n\\n driver = self.MyDriver(\\n name=\\\"MyDriver\\\",\\n runpath=runpath,\\n pre_start=pre_start_fn,\\n post_start=post_start_fn,\\n pre_stop=pre_stop_fn,\\n post_stop=post_stop_fn,\\n )\\n\\n driver.start()\\n driver.wait(driver.STATUS.STARTED)\\n assert driver.status.tag == driver.status.STARTED\\n\\n driver.stop()\\n driver.wait(driver.STATUS.STOPPED)\\n assert driver.status.tag == driver.status.STOPPED\\n\\n driver.stop()\",\n \"def test_shutdown_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as exc:\\n server.shutdown()\\n if platform == \\\"win32\\\":\\n assert exc.value.args[0] == ESHUTDOWN\\n else:\\n assert exc.value.args[0] == EPIPE\",\n \"def stop(self):\\n shutdown_url = self._env[\\\"DATASTORE_HOST\\\"] + \\\"/shutdown\\\"\\n req = urllib.request.Request(shutdown_url, method=\\\"POST\\\")\\n urllib.request.urlopen(req)\",\n \"def shutdown():\\n\\n # Earlier versions of traffic_ctl do not support\\n # \\\"server stop\\\", so we prefer traffic_line here.\\n if _TRAFFICLINE:\\n cmd = _traffic_line(\\\"-S\\\")\\n else:\\n cmd = _traffic_ctl(\\\"server\\\", \\\"stop\\\")\\n\\n _subprocess(cmd)\\n return _statuscmd()\",\n \"def __exit__(self, *args):\\n self.driver.quit()\",\n \"def terminate_server(self, port):\\n proc = self.processes.pop(port, None)\\n if proc is None:\\n raise ValueError(f\\\"Server for port {port} does not exists.\\\"\\n \\\"It might have been closed already.\\\"\\n )\\n proc.terminate()\",\n \"def shutdown(self) -> None:\\n self.system.notify('Jarvis::SHUTTING DOWN now')\\n sleep(3)\\n self.system.power_off()\",\n \"def __shutdownParallel(self):\\n if self._parallelLib == ParallelLibEnum.ray and self._server is not None and not self.rayInstanciatedOutside:\\n # we need to ssh and stop each remote node cluster (ray)\\n servers = []\\n if 'remoteNodes' in self.runInfoDict:\\n servers += self.runInfoDict['remoteNodes']\\n if 'headNode' in self.runInfoDict:\\n servers += [self.runInfoDict['headNode']]\\n # get local enviroment\\n localEnv = os.environ.copy()\\n localEnv[\\\"PYTHONPATH\\\"] = os.pathsep.join(sys.path)\\n for nodeAddress in servers:\\n self.raiseAMessage(\\\"Shutting down ray at address: \\\"+ nodeAddress)\\n command=\\\"ray stop\\\"\\n rayTerminate = utils.pickleSafeSubprocessPopen(['ssh',nodeAddress.split(\\\":\\\")[0],\\\"COMMAND='\\\"+command+\\\"'\\\",\\\"RAVEN_FRAMEWORK_DIR='\\\"+self.runInfoDict[\\\"FrameworkDir\\\"]+\\\"'\\\",self.runInfoDict['RemoteRunCommand']],shell=False,env=localEnv)\\n rayTerminate.wait()\\n if rayTerminate.returncode != 0:\\n self.raiseAWarning(\\\"RAY FAILED TO TERMINATE ON NODE: \\\"+nodeAddress)\\n # shutdown ray API (object storage, plasma, etc.)\\n ray.shutdown()\\n elif self._parallelLib == ParallelLibEnum.dask and self._server is not None and not self.rayInstanciatedOutside:\\n self._server.close()\\n if self._daskScheduler is not None:\\n self._daskScheduler.terminate()\",\n \"def stop_server(setname=None, hosts=None):\\n global SESSIONS # pylint: disable=global-variable-not-assigned\\n try:\\n if setname is None:\\n for _key, val in SESSIONS.items():\\n val.send_signal(signal.SIGINT)\\n time.sleep(5)\\n if val.poll() is None:\\n val.kill()\\n val.wait()\\n else:\\n SESSIONS[setname].send_signal(signal.SIGINT)\\n time.sleep(5)\\n if SESSIONS[setname].poll() is None:\\n SESSIONS[setname].kill()\\n SESSIONS[setname].wait()\\n print(\\\"<SERVER> server stopped\\\")\\n\\n except Exception as error:\\n print(\\\"<SERVER> Exception occurred: {0}\\\".format(str(error)))\\n raise ServerFailed(\\\"Server didn't stop!\\\")\\n\\n if not hosts:\\n return\\n\\n # Make sure the servers actually stopped. Give them time to stop first\\n # pgrep exit status:\\n # 0 - One or more processes matched the criteria.\\n # 1 - No processes matched.\\n # 2 - Syntax error in the command line.\\n # 3 - Fatal error: out of memory etc.\\n time.sleep(5)\\n result = pcmd(\\n hosts, \\\"pgrep '(daos_server|daos_io_server)'\\\", False, expect_rc=1)\\n if len(result) > 1 or 1 not in result:\\n bad_hosts = [\\n node for key in result if key != 1 for node in list(result[key])]\\n kill_server(bad_hosts)\\n raise ServerFailed(\\n \\\"DAOS server processes detected after attempted stop on {}\\\".format(\\n \\\", \\\".join([str(result[key]) for key in result if key != 1])))\\n\\n # we can also have orphaned ssh processes that started an orted on a\\n # remote node but never get cleaned up when that remote node spontaneiously\\n # reboots\\n subprocess.call([\\\"pkill\\\", \\\"^ssh$\\\"])\",\n \"def test_node_stop(self, m_docker_client, m_client):\\n # Call method under test\\n node.node_stop(True)\\n\\n # Assert\\n m_client.remove_host.assert_called_once_with(node.hostname)\\n m_docker_client.stop.assert_called_once_with('calico-node')\",\n \"def quit(self):\\n self.driver.quit()\",\n \"def Disconnect_from_ePCSim_Server(ePCSim_conn):\\r\\n ePCSim_conn.Disconnect()\",\n \"def shutdown(self):\\n try:\\n self.driver.stop()\\n except:\\n logging.exception(\\\"Could not stop driver on shutdown\\\")\\n\\n self.arduino.stop()\",\n \"def _stop(self, host):\\n pass\",\n \"def adb_down(self, port):\\n self.adb_transport = None\\n self.check_adb([\\\"disconnect\\\", \\\"localhost:%d\\\" % port])\\n\\n # Wait until QEMU's forward has expired\\n CONNECT_MAX_TRIES = 15\\n connect_tries = 0\\n while True:\\n try:\\n sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n sock.connect((\\\"localhost\\\", port))\\n sock.close()\\n connect_tries += 1\\n if connect_tries >= CONNECT_MAX_TRIES:\\n raise Timeout(\\\"Wait for port forward to go away\\\",\\n CONNECT_MAX_TRIES)\\n time.sleep(1)\\n except IOError:\\n break\",\n \"def teardown_package():\\n # TODO If environment variable is set keep the workspace\\n # and print out the path.\\n global TEST_WORKSPACE\\n\\n # Removing the product through this server requires credentials.\\n codechecker_cfg = env.import_test_cfg(TEST_WORKSPACE)['codechecker_cfg']\\n codechecker.remove_test_package_product(TEST_WORKSPACE,\\n codechecker_cfg['check_env'])\\n\\n __STOP_SERVER.set()\\n\\n # The custom server stated in a separate home needs to be waited, so it\\n # can properly execute its finalizers.\\n time.sleep(5)\\n\\n print(\\\"Removing: \\\" + TEST_WORKSPACE)\\n shutil.rmtree(TEST_WORKSPACE, ignore_errors=True)\",\n \"def stop_echo_server(self, ip_addr='localhost',\\n port=zephyr_constants.DEFAULT_ECHO_PORT):\\n out = None\\n if (port in self.echo_server_procs and\\n self.echo_server_procs[port] is not None):\\n es_proc = self.echo_server_procs[port]\\n out = es_proc.terminate()\\n self.echo_server_procs.pop(port)\\n return out\",\n \"def quit(self):\\n driver.quit()\",\n \"def stop_server(self):\\r\\n # TODO-SDH Add way to stop the server from running.\\r\",\n \"def i_close_the_browser():\\n driver.close()\\n driver.quit()\",\n \"def quit(self):\\n if self.webdriver is not None:\\n self.webdriver.quit()\\n self.webdriver = None\",\n \"def tearDown(self):\\n self.log.debug(\\\"Started TearDown\\\")\\n self.driver.quit()\\n self.log.debug(\\\"Completed TearDown\\\")\",\n \"def shutdown_server(server_target):\\n assassin = threading.Thread(target=server_target.shutdown)\\n assassin.daemon = True\\n assassin.start()\",\n \"def close_browser():\\n driver.close()\",\n \"def stop_server(self, server, name):\\n # Spin down the requested server\\n server.stop()\",\n \"def shutdown():\\n query = {\\n \\\"type\\\": \\\"op\\\",\\n \\\"cmd\\\": \\\"<request><shutdown><system></system></shutdown></request>\\\",\\n }\\n\\n return __proxy__[\\\"panos.call\\\"](query)\",\n \"def closeBrowser(driver):\\n driver.quit()\",\n \"def Quit(self, timeout=5.0):\\n assert self._process, 'server was not started'\\n if self._process.poll() is None:\\n try:\\n urllib2.urlopen(self.url + QUIT_PATH)\\n except urllib2.URLError:\\n\\n\\n pass\\n\\n finish_time = time.time() + timeout\\n while time.time() < finish_time and self._process.poll() is None:\\n time.sleep(0.2)\\n if self._process.returncode is None:\\n logging.warning('api_server did not quit cleanly, killing')\\n self._process.kill()\",\n \"def shutdown(self, hub=True, targets='all', block=False):\\n self.unit_manager.close()\\n self.pilot_manager.close()\\n self.session.close(download=True)\\n logger.info(\\\"Attempting RADICALExecutor shutdown\\\")\\n\\n return True\",\n \"def shutdown(self):\\n self._send_command('shutdown')\\n self.sock.close()\\n self.disconnected = True\",\n \"def shutdown(self) -> None:\\n prefix = f\\\"In {ThreadedServer.__name__}.{ThreadedServer.shutdown.__name__}\\\"\\n\\n print(f\\\"{prefix}: Instructing the server to shut down...\\\", file=self.stdout)\\n with self._server_exception_lock:\\n if self._server_exception is not None:\\n raise self._server_exception\\n\\n print(f\\\"{prefix}: Waiting for server to shut down...\\\", file=self.stdout)\\n self._httpd.shutdown()\",\n \"def shutdown(self):\\n\\n raise NotImplementedError\",\n \"def tearDown(self):\\n\\n self._checkJSErrors()\\n swt.active_driver = None\\n self.driver.quit()\",\n \"def testServerShutdown(self):\\n d = self.testSimpleRequest()\\n d.addCallback(lambda _: self.factory.shutdown())\\n d.addCallback(lambda _: self.listeningPort.stopListening())\\n d.addCallback(lambda _: self.client.check_rate_limit())\\n d.addTimeout(0.01, reactor)\\n return self.assertFailure(d, ConnectionClosed)\",\n \"def stop(self: RemoteCluster, wait: bool = False, timeout: int = None) -> None:\\n self.server.stop(wait=wait, timeout=timeout)\\n self.clients.terminate()\\n super().stop(wait=wait, timeout=timeout)\",\n \"def teardown(self):\\r\\n self.driver.quit()\",\n \"def shutdown(self):\\n self._shutdown_browser()\",\n \"def tearDownClass(cls):\\n cls.driver.close()\\n cls.driver.quit()\",\n \"def tearDownClass(cls):\\n cls.driver.close()\\n cls.driver.quit()\",\n \"def shutdown(opts):\\n log.debug(\\\"Proxy module %s shutting down!!\\\", opts[\\\"id\\\"])\\n try:\\n thisproxy[\\\"conn\\\"].close()\\n\\n except Exception: # pylint: disable=broad-except\\n pass\",\n \"def stop_browser(self):\\n self.driver.quit()\",\n \"def test_server_no_port(self):\\n (code, out, err) = run([\\\"./server\\\"]);\\n self.assertEqual(code, 1)\",\n \"def server(host, port, debug):\\n run_server(host, port, debug)\",\n \"def tearDown(self):\\n self.server.stop()\\n self._server_thread.join()\",\n \"def quit(self):\\n self.driver.close_app()\\n self.driver.quit()\",\n \"def _stop_server(cls, server):\\n\\n try:\\n server.kill()\\n except Exception as error:\\n print('ERROR stop enip server: ', error)\",\n \"def close(self):\\n self._server.shutdown()\\n self._server = None\",\n \"def shutdown_cluster(self):\\n self.cluster.shutdown()\",\n \"def shutdown(name):\\n ret = {\\\"name\\\": name, \\\"changes\\\": {}, \\\"result\\\": None, \\\"comment\\\": \\\"\\\"}\\n\\n if __opts__[\\\"test\\\"]:\\n ret[\\\"comment\\\"] = \\\"Shutting down local node\\\"\\n return ret\\n\\n __salt__[\\\"trafficserver.shutdown\\\"]()\\n\\n ret[\\\"result\\\"] = True\\n ret[\\\"comment\\\"] = \\\"Shutdown local node\\\"\\n return ret\",\n \"def tear_down(self):\\n self.driver.close()\\n self.driver.quit()\",\n \"def webserver_stop():\\n run(\\\"kill $(cat %s)\\\" % GUNICORN_PIDFILE)\\n run(\\\"rm %s\\\" % GUNICORN_PIDFILE)\",\n \"def tearDown(self):\\n self.driver.quit()\",\n \"def tearDown(self):\\n self.driver.quit()\",\n \"def tearDown(self):\\n self.driver.quit()\",\n \"def _stop_server(cls, address):\\n\\n print('_stop_server: please override me.')\",\n \"def stop_server(self):\\n if not self.server:\\n raise Exception(\\\"Error owamp: the server must be opened to be closed\\\\n\\\")\\n self.server.close_owampd()\",\n \"async def _internalStop(self):\\n self.wserver.close()\\n await self.wserver.wait_closed()\\n self.server.stop()\\n while (self.server.is_running()):\\n time.sleep(0.5)\\n self.server.close()\\n self.server = None\",\n \"def Stop_ePCSim(ePCSim_conn):\\r\\n ePCSim_conn.SendCmd(\\\"exit\\\")\\r\\n ePCSim_conn.prompt = \\\"#\\\"\\r\\n ePCSim_conn.SendCmd(\\\"pkill egate\\\")\\r\\n ePCSim_conn.SendCmd(\\\"pkill edaemon\\\")\",\n \"def close(self):\\n\\n #Kill all zombie PIDs and exit gracefully\\n try:\\n self.webdriver.quit()\\n except:\\n pass\\n if 'p' not in sys.argv:\\n self.kill()\\n sys.exit()\",\n \"def test_closed(self):\\n server, client = loopback()\\n server.sock_shutdown(2)\\n with pytest.raises(SysCallError) as err:\\n server.sendall(b\\\"hello, world\\\")\\n if platform == \\\"win32\\\":\\n assert err.value.args[0] == ESHUTDOWN\\n else:\\n assert err.value.args[0] == EPIPE\",\n \"def shutdown():\\n func = flask.request.environ.get('werkzeug.server.shutdown')\\n if func is None:\\n raise RuntimeError('Not running with the Werkzeug Server')\\n func()\\n return 'Server shutting down...'\",\n \"def stopESServer():\\n statusES = 'systemctl status elasticsearch.service'\\n stopES = 'systemctl stop elasticsearch.service'\\n\\n os.popen(stopES, 'w')\\n print(\\\"\\\\nPLEASE WAIT 20 SECONDS... STOPPING ELASTICSEARCH SERVER.\\\\n\\\")\\n sleep(20)\\n os.popen(statusES, 'w')\",\n \"def stop_server(manager):\\n if not manager.is_daemon:\\n return\\n web_server = WebServer()\\n if web_server.is_alive():\\n web_server.stop()\",\n \"def stop_server(manager):\\n if not manager.is_daemon:\\n return\\n web_server = WebServer()\\n if web_server.is_alive():\\n web_server.stop()\",\n \"def stop(self) -> None:\\n # Call the server shutdown functions and wait for them to finish. These\\n # must be called on the server thread's event loop.\\n future = asyncio.run_coroutine_threadsafe(self._stop(), self._server_loop)\\n future.result(5)\\n\\n # Stop the server thread's event loop\\n self._server_loop.call_soon_threadsafe(self._server_loop.stop)\",\n \"def shutdown(self) -> None:\",\n \"def shutdown(self) -> None:\",\n \"def shutdown(self, *args):\\n return _SALOMERuntime.PythonNode_shutdown(self, *args)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6310834","0.6110192","0.6078012","0.59138757","0.57922274","0.5763965","0.56827766","0.566105","0.55425066","0.55398613","0.5532105","0.5505663","0.54810226","0.5456112","0.5435537","0.5409633","0.5404485","0.5392909","0.53838885","0.53706366","0.5325386","0.53095007","0.52994144","0.52878416","0.5280602","0.5275959","0.5266465","0.5258423","0.524951","0.52435803","0.5241501","0.52166927","0.5205741","0.5199013","0.5193783","0.5191322","0.51849854","0.51810634","0.51358527","0.51311463","0.51296836","0.5124685","0.51226187","0.5112739","0.5110554","0.5110088","0.5108966","0.51074445","0.51046777","0.5092957","0.5087624","0.5069936","0.5064973","0.5048201","0.5045617","0.5036121","0.5032562","0.5021293","0.50201917","0.5014264","0.5013713","0.50032336","0.50022376","0.4997754","0.49967396","0.49957708","0.4992678","0.49921057","0.49814835","0.49789158","0.49789158","0.49606827","0.49584308","0.49383274","0.49333975","0.4927476","0.49267343","0.49261189","0.49204114","0.49172577","0.49145317","0.49106815","0.49095395","0.4907112","0.4907112","0.4907112","0.49018547","0.49010274","0.49008676","0.48926663","0.48914686","0.48893324","0.4883044","0.4882525","0.48709893","0.48709893","0.48623815","0.4855608","0.4855608","0.48522204"],"string":"[\n \"0.6310834\",\n \"0.6110192\",\n \"0.6078012\",\n \"0.59138757\",\n \"0.57922274\",\n \"0.5763965\",\n \"0.56827766\",\n \"0.566105\",\n \"0.55425066\",\n \"0.55398613\",\n \"0.5532105\",\n \"0.5505663\",\n \"0.54810226\",\n \"0.5456112\",\n \"0.5435537\",\n \"0.5409633\",\n \"0.5404485\",\n \"0.5392909\",\n \"0.53838885\",\n \"0.53706366\",\n \"0.5325386\",\n \"0.53095007\",\n \"0.52994144\",\n \"0.52878416\",\n \"0.5280602\",\n \"0.5275959\",\n \"0.5266465\",\n \"0.5258423\",\n \"0.524951\",\n \"0.52435803\",\n \"0.5241501\",\n \"0.52166927\",\n \"0.5205741\",\n \"0.5199013\",\n \"0.5193783\",\n \"0.5191322\",\n \"0.51849854\",\n \"0.51810634\",\n \"0.51358527\",\n \"0.51311463\",\n \"0.51296836\",\n \"0.5124685\",\n \"0.51226187\",\n \"0.5112739\",\n \"0.5110554\",\n \"0.5110088\",\n \"0.5108966\",\n \"0.51074445\",\n \"0.51046777\",\n \"0.5092957\",\n \"0.5087624\",\n \"0.5069936\",\n \"0.5064973\",\n \"0.5048201\",\n \"0.5045617\",\n \"0.5036121\",\n \"0.5032562\",\n \"0.5021293\",\n \"0.50201917\",\n \"0.5014264\",\n \"0.5013713\",\n \"0.50032336\",\n \"0.50022376\",\n \"0.4997754\",\n \"0.49967396\",\n \"0.49957708\",\n \"0.4992678\",\n \"0.49921057\",\n \"0.49814835\",\n \"0.49789158\",\n \"0.49789158\",\n \"0.49606827\",\n \"0.49584308\",\n \"0.49383274\",\n \"0.49333975\",\n \"0.4927476\",\n \"0.49267343\",\n \"0.49261189\",\n \"0.49204114\",\n \"0.49172577\",\n \"0.49145317\",\n \"0.49106815\",\n \"0.49095395\",\n \"0.4907112\",\n \"0.4907112\",\n \"0.4907112\",\n \"0.49018547\",\n \"0.49010274\",\n \"0.49008676\",\n \"0.48926663\",\n \"0.48914686\",\n \"0.48893324\",\n \"0.4883044\",\n \"0.4882525\",\n \"0.48709893\",\n \"0.48709893\",\n \"0.48623815\",\n \"0.4855608\",\n \"0.4855608\",\n \"0.48522204\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8380863"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88378,"cells":{"query":{"kind":"string","value":"SeleniumLibrary can be imported with optional arguments. `timeout` is the default timeout used to wait for page load actions. It can be later set with `Set Selenium Timeout` `server_host` and `server_port` are used to connect to Selenium Server. Browsers opened with this SeleniumLibrary instance will be attached to that server. Note that the Selenium Server must be running before `Open Browser` keyword can be used. Selenium Server can be started with keyword `Start Selenium Server`. Starting from SeleniumLibrary 2.6.1, it is possible to give `server_host` as a URL with a possible embedded"},"document":{"kind":"string","value":"def __init__(self, timeout=5.0, server_host='localhost', server_port=4444,\n jar_path=None, run_on_failure='Capture Screenshot'):\n self._cache = utils.ConnectionCache()\n self._selenium = NoBrowserOpen()\n self.set_selenium_timeout(timeout or 5.0)\n self._server_host, self._server_port \\\n = self._parse_host_and_port(server_host or 'localhost',\n server_port or 4444)\n self._jar_path = jar_path\n self._set_run_on_failure(run_on_failure)\n self._selenium_log = None\n self._locator_parser = LocatorParser(self)\n self._namegen = _NameGenerator()"},"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 __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\n\n # selecting driver\n if not driver_path:\n driver = webdriver.Firefox\n driver_options = FireFoxOptions()\n else:\n driver = webdriver.Chrome\n driver_options = ChromeOptions()\n\n # add config\n if options:\n for option in options:\n driver_options.add_argument(option)\n\n self.driver = driver(driver_path, options=driver_options)\n self.waiter = WebDriverWait(self.driver, waiter_timeout)","def initialize(url) -> webdriver.Firefox:\n driver = webdriver.Firefox()\n driver.get(url)\n return driver","def __init__(self, wdriver, timeout=300):\n self.wait = ui.WebDriverWait(wdriver, timeout)\n self.driver = wdriver","def __init__(self, timeout=5.0, implicit_wait=0.0,\n run_on_failure='Capture Page Screenshot',\n screenshot_root_directory=None):\n self.timeout = timestr_to_secs(timeout)\n self.implicit_wait = timestr_to_secs(implicit_wait)\n self.speed = 0.0\n self.run_on_failure_keyword \\\n = RunOnFailureKeywords.resolve_keyword(run_on_failure)\n self._running_on_failure_keyword = False\n self.screenshot_root_directory = screenshot_root_directory\n libraries = [\n GerenciamentoDeBrowser(self),\n ]\n self._drivers = WebDriverCache()\n DynamicCore.__init__(self, libraries)\n self.ROBOT_LIBRARY_LISTENER = LibraryListener()\n self._element_finder = ElementFinder(self)","def setup_selenium():\n # Define the options to run with headless mode enabled\n options = Options()\n options.headless = True\n\n # Instatiate the browser object here, pointing at an exectable location which should be located in the same\n # base directory as the script\n driver = webdriver.Firefox(options=options, executable_path='./geckodriver')\n\n # Impicit wait tell the browser to wait up to 30s for an object to appear, this helps if the connection is slow.\n driver.implicitly_wait(30)\n return driver","def init_driver():\n driver = webdriver.Firefox()\n driver.wait = WebDriverWait(driver,5)\n return driver","def initial_setup(server):\r\n world.absorb(settings.LETTUCE_SELENIUM_CLIENT, 'LETTUCE_SELENIUM_CLIENT')\r\n\r\n if world.LETTUCE_SELENIUM_CLIENT == 'local':\r\n browser_driver = getattr(settings, 'LETTUCE_BROWSER', 'chrome')\r\n\r\n # There is an issue with ChromeDriver2 r195627 on Ubuntu\r\n # in which we sometimes get an invalid browser session.\r\n # This is a work-around to ensure that we get a valid session.\r\n success = False\r\n num_attempts = 0\r\n while (not success) and num_attempts < MAX_VALID_BROWSER_ATTEMPTS:\r\n\r\n # Load the browser and try to visit the main page\r\n # If the browser couldn't be reached or\r\n # the browser session is invalid, this will\r\n # raise a WebDriverException\r\n try:\r\n world.browser = Browser(browser_driver)\r\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\r\n world.visit('/')\r\n\r\n except WebDriverException:\r\n if hasattr(world, 'browser'):\r\n world.browser.quit()\r\n num_attempts += 1\r\n\r\n else:\r\n success = True\r\n\r\n # If we were unable to get a valid session within the limit of attempts,\r\n # then we cannot run the tests.\r\n if not success:\r\n raise IOError(\"Could not acquire valid {driver} browser session.\".format(driver=browser_driver))\r\n\r\n world.absorb(0, 'IMPLICIT_WAIT')\r\n world.browser.driver.set_window_size(1280, 1024)\r\n\r\n elif world.LETTUCE_SELENIUM_CLIENT == 'saucelabs':\r\n config = get_saucelabs_username_and_key()\r\n world.browser = Browser(\r\n 'remote',\r\n url=\"http://{}:{}@ondemand.saucelabs.com:80/wd/hub\".format(config['username'], config['access-key']),\r\n **make_saucelabs_desired_capabilities()\r\n )\r\n world.absorb(30, 'IMPLICIT_WAIT')\r\n world.browser.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\r\n\r\n elif world.LETTUCE_SELENIUM_CLIENT == 'grid':\r\n world.browser = Browser(\r\n 'remote',\r\n url=settings.SELENIUM_GRID.get('URL'),\r\n browser=settings.SELENIUM_GRID.get('BROWSER'),\r\n )\r\n world.absorb(30, 'IMPLICIT_WAIT')\r\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\r\n\r\n else:\r\n raise Exception(\"Unknown selenium client '{}'\".format(world.LETTUCE_SELENIUM_CLIENT))\r\n\r\n world.browser.driver.implicitly_wait(world.IMPLICIT_WAIT)\r\n world.absorb(world.browser.driver.session_id, 'jobid')","def set_selenium_driver_timeouts(driver: WebDriver) -> None:\n driver.set_script_timeout(90)\n driver.set_page_load_timeout(60)","def __init__(self,\n geckodriver_path = None,\n headless_browser = False,\n disable_image_load = False,\n page_delay = 10,\n logfolder = 'logs/',\n user_agent = None,\n proxy_address = None,\n proxy_port = None,\n proxy_username = None,\n proxy_password = None,\n limit_scropes = None,\n exclude_hosts = None,\n browser_profile_path = None,\n browser_executable_path = None,\n geckodriver_log_level = 'info'\n ):\n firefox_options = Firefox_Options()\n seleniumwire_options = {}\n\n if headless_browser:\n firefox_options.add_argument(\"-headless\")\n\n if browser_profile_path is not None:\n firefox_profile = webdriver.FirefoxProfile(browser_profile_path)\n else:\n firefox_profile = webdriver.FirefoxProfile()\n\n if browser_executable_path is not None:\n firefox_options.binary = browser_executable_path\n\n\n # set \"info\" by default\n # set \"trace\" for debubging, Development only\n firefox_options.log.level = geckodriver_log_level\n\n # set English language\n firefox_profile.set_preference(\"intl.accept_languages\", \"en-US\")\n\n # set User-Agent\n if user_agent is not None:\n firefox_profile.set_preference(\"general.useragent.override\", user_agent)\n\n if disable_image_load:\n # permissions.default.image = 2: Disable images load,\n # this setting can improve pageload & save bandwidth\n firefox_profile.set_preference(\"permissions.default.image\", 2)\n \n # mute audio while watching stories\n firefox_profile.set_preference(\"media.volume_scale\", \"0.0\")\n\n # prevent Hide Selenium Extension: error\n firefox_profile.set_preference(\"dom.webdriver.enabled\", False)\n firefox_profile.set_preference(\"useAutomationExtension\", False)\n firefox_profile.set_preference(\"general.platform.override\", \"iPhone\")\n firefox_profile.update_preferences()\n\n # geckodriver log in specific user logfolder\n geckodriver_log = \"{}geckodriver.log\".format(logfolder)\n check_and_create_file(geckodriver_log)\n\n\n # The list exclude hosts for capturing\n if exclude_hosts:\n seleniumwire_options['exclude_hosts'] = exclude_hosts\n\n # Add proxy with username and password authentication\n if proxy_address and proxy_port:\n if proxy_username and proxy_password:\n seleniumwire_options['proxy'] = {\n 'http': f'http://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\n 'https': f'https://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\n 'no_proxy': 'localhost,127.0.0.1'\n }\n else:\n seleniumwire_options['proxy'] = {\n 'http': f'http://{proxy_address}:{proxy_port}',\n 'https': f'https://{proxy_address}:{proxy_port}',\n 'no_proxy': 'localhost,127.0.0.1'\n }\n\n\n\n self.driver = webdriver.Firefox(\n firefox_profile=firefox_profile,\n executable_path=geckodriver_path,\n log_path=geckodriver_log,\n options=firefox_options,\n seleniumwire_options=seleniumwire_options\n )\n # Limit capture urls with regulater expression\n if limit_scropes:\n self.driver.scopes = limit_scropes\n\n # Set implicitly wait\n self.driver.implicitly_wait(page_delay)\n\n # Set maximum windows\n self.driver.maximize_window()","def build_driver(options: Options = None, headless=True, timeout=20) -> webdriver:\n\n if options is not None:\n driver = webdriver.Chrome(options=options)\n else:\n default_options = get_default_driver_options()\n default_options.headless = headless\n driver = webdriver.Chrome(options=default_options)\n\n driver.set_page_load_timeout(timeout)\n return driver","def setUp(self):\r\n self.verificationErrors = []\r\n self.selenium = (selenium(selvars.set_localhost(), selvars.set_port(), selvars.set_browser(self.id(),self.shortDescription()), selvars.set_site()))\r\n self.selenium.start()\r\n self.session = self.selenium.sessionId\r\n self.selenium.set_timeout(testvars.timeout)","def __init__(self, base_url=\"\",\n driver=None,\n driver_kwargs=None,\n enable_highlighting=False,\n enable_screen_shot_highlight=False,\n implicit_wait=0,\n think_time=0,\n download_folder='',\n screen_shots_folder='',\n highlighting_color='',\n highlighting_size=0,\n highlighting_time=0,\n remote_ip=None,\n remote_port=None,\n desired_capability=None,\n headless=None,\n display_width=None,\n display_height=None\n ):\n\n if isinstance(driver, str):\n driver = get_driver_from_name(driver)\n\n if driver is None:\n driver = get_driver_from_name(settings.DEFAULT_DRIVER_EXECUTABLE)\n\n self.web_driver = driver\n self._driver_kwargs = driver_kwargs or {}\n self.driver = None # type: WebDriver\n\n self.url = base_url if base_url.startswith('http') else (\"http://\" + base_url) if base_url else ''\n self.accept_next_alert = True\n\n self.download_folder = download_folder or settings.DOWNLOAD_FOLDER\n self.implicit_wait = implicit_wait or settings.IMPLICIT_WAIT\n screen_shots_folder = screen_shots_folder or os.path.join(self.download_folder, settings.SCREEN_SHOTS_FOLDER)\n self.screen_shot_folder = os.path.realpath(screen_shots_folder)\n self.think_time = think_time\n\n self._is_driver_open = False\n self._default_find_element_method = self._default_find_elements_method = None\n\n self._enable_highlighted_find_elements = enable_highlighting or settings.ENABLE_HIGHTLIGHTING\n self._screen_shot_highlights = enable_screen_shot_highlight or settings.ENABLE_SCREENSHOT_HIGHTLIGHTING\n self._highlighting_color = highlighting_color or settings.HIGHLIGHTING_COLOR\n self._highlighting_size = highlighting_size or settings.HIGHLIGHTING_SIZE\n self._highlighting_time = highlighting_time or settings.HIGHLIGHTING_TIME\n\n\n # headless vars\n self._headless = headless or settings.HEADLESS\n self._display_height = display_height\n self._display_width = display_width\n\n self._create_download_shots_folders()\n\n self._remote_ip = remote_ip\n self._remote_port = remote_port or settings.REMOTE_PORT\n self._desired_capability = desired_capability\n\n self._jquery_available = self._jquery_checked = False","def setUpClass(cls) -> None:\n desired_caps: dict[str, Any] = {}\n desired_caps[\"app\"] = \"plasmawindowed -p org.kde.plasma.nano org.kde.plasma.systemtray\"\n desired_caps[\"timeouts\"] = {'implicit': 10000}\n cls.driver = webdriver.Remote(command_executor='http://127.0.0.1:4723', desired_capabilities=desired_caps)\n cls.driver.implicitly_wait = 10","def __init__(self, driver):\n self.driver = driver\n self.driver.implicitly_wait(self.IMPLICIT_WAIT_TIME)\n self.timeout = self.TIMEOUT\n self.screenshot()","def selenium(self):\n return self.builtin.get_library_instance(\"SeleniumLibrary\")","def setup_selenium():\n options = webdriver.FirefoxOptions()\n options.add_argument('--ignore-certificate-errors')\n options.add_argument('--incognito')\n options.add_argument('--headless')\n\n return webdriver.Firefox(\n # UNCOMMENT WHEN IN LINUX executable_path=\"drivers/geckodriver-linux\",\n executable_path=\"drivers/geckodriver-macos\",\n firefox_options=options\n )","def httpGetSelenium(url, delaySecs, mustGet=False):\n global display\n global browser\n logging.info('Downloading %s using Selenium/Firefox' % url)\n host = urlparse.urlsplit(url)[1]\n delaySecs = getDelaySecs(host, delaySecs)\n wait(delaySecs, host)\n if not seleniumLoaded:\n raise pubGetError('Cannot get page, selenium is not installed on this machine', 'noSelenium')\n page = {}\n if not display:\n logging.info('Starting pseudo-display')\n display = Display(visible=0, size=(1024, 768))\n display.start()\n proxy = None\n if pubConf.httpProxy:\n proxy = Proxy({'proxyType': ProxyType.MANUAL,\n 'httpProxy': pubConf.httpProxy,\n 'ftpProxy': pubConf.httpProxy,\n 'sslProxy': pubConf.httpProxy})\n if not browser:\n logging.info('Starting firefox on pseudo-display')\n browser = webdriver.Firefox(proxy=proxy)\n count = 0\n while count < 5:\n try:\n browser.get(url)\n break\n except (requests.Timeout, timeout):\n logging.warn('timeout from selenium')\n count += 1\n except httplib.CannotSendRequest:\n logging.warn(\"selenium's firefox died, restarting\")\n count += 1\n browser = webdriver.Firefox(proxy=proxy)\n\n if count >= 5:\n logging.warn('too many timeouts/errors from selenium')\n if mustGet:\n raise pubGetError('too many timeouts', 'httpTimeout')\n return\n else:\n page['seleniumDriver'] = browser\n page['url'] = browser.current_url\n page['data'] = browser.page_source\n page['mimeType'] = 'unknown'\n if type(page['data']) == str:\n page['data'] = page['data'].encode('utf8')\n return page","def create_webdriver_with_retry(self, *args, **kwargs):\n # Get selenium without referencing selenium.driver which doesn't exist yet\n selenium = self.builtin.get_library_instance(\"SeleniumLibrary\")\n for _ in range(12):\n try:\n return selenium.create_webdriver(*args, **kwargs)\n except ProtocolError:\n # Give browser some more time to start up\n time.sleep(5)\n raise Exception(\"Could not connect to remote webdriver after 1 minute\")","def get_selenium2libraryExtend_instance():\n\n # selenium = BuiltIn().get_library_instance('Selenium2Library')\n return selenium","def start_server_and_driver(path_to_driver, path_to_browser):\n \n server = service.Service(path_to_driver)\n server.start()\n\n capabilities = {'chrome.binary': path_to_browser}\n driver = webdriver.Remote(server.service_url, capabilities)\n \n return server, driver","def start(self):\r\n if platform.system() == \"Windows\":\r\n # Use a local GeckoDriver on Windows\r\n ffo = Options()\r\n ffo.headless = self.state\r\n gecko = \"dependencies/geckodriver.exe\"\r\n full_gecko = os.path.abspath(gecko)\r\n self.web_driver = webdriver.Firefox(executable_path=full_gecko, options=ffo)\r\n else:\r\n # Use a remote server if testing on Travis\r\n username = os.environ[\"SAUCE_USERNAME\"]\r\n access_key = os.environ[\"SAUCE_ACCESS_KEY\"]\r\n capabilities = {}\r\n capabilities[\"tunnel-identifier\"] = os.environ[\"TRAVIS_JOB_NUMBER\"]\r\n capabilities['version'] = \"45.0\"\r\n capabilities['browserName'] = \"firefox\"\r\n hub_url = \"%s:%s@localhost:4445\" % (username, access_key)\r\n self.web_driver = webdriver.Remote(\r\n desired_capabilities=capabilities,\r\n command_executor=\"http://%s/wd/hub\" % hub_url)","def browser(config, config_url, config_browser, config_wait_time):\n try:\n kwargs = {}\n if 'binary' in config:\n binary = config['binary']\n if config['selenium_grid']:\n caps = {'browserName': config_browser}\n command_executor_url = \"http://{}:4444/wd/hub\".format(config['hub_host'])\n driver = webdriver.Remote(\n command_executor=command_executor_url,\n desired_capabilities=caps\n )\n else:\n if config_browser == 'chrome':\n if binary:\n kwargs.update({'executable_path': binary})\n options = webdriver.ChromeOptions()\n options.add_argument('disable-web-security')\n options.add_argument(\"--no-sandbox\")\n options.add_argument(\"--disable-dev-shm-usage\")\n kwargs.update({'options': options})\n driver = webdriver.Chrome(**kwargs)\n elif config_browser == 'firefox':\n driver = webdriver.Firefox(**kwargs)\n else:\n raise Exception('\"{config_browser}\" is not a supported browser')\n\n # Wait implicitly for elements to be ready before attempting interactions\n driver.implicitly_wait(config_wait_time)\n driver.get(config_url)\n driver.maximize_window()\n\n # Return the driver object at the end of setup\n yield driver\n finally:\n # For cleanup, quit the driver\n driver.quit()","def browser_chrome(context, timeout=30, **kwargs):\n if settings.BROWSER == 'remote':\n browser = splinter.Browser(\n driver_name='remote',\n browser='chrome',\n url=settings.SELENIUM_URL,\n )\n else:\n browser = splinter.Browser(\n driver_name=settings.BROWSER,\n headless=settings.RUN_HEADLESS,\n )\n context.browser = browser\n context.add_cleanup(browser.quit)\n return browser","def startBrowser(self):\n if 'TRAVIS' in os.environ:\n # Initialize hidden display for Firefox.\n # Less annoying and allows remote execution.\n display = Display(visible=0, size=(800, 600))\n display.start()\n\n self.browser = webdriver.Firefox()\n self.browser.implicitly_wait(3)","def getWebDriverInstance(self):\n #baseURL = \"https://qa-test.avenuecode.com/\"\n if self.device == \"ios_mobile\":\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\n self.driver.implicitly_wait(10)\n #return driver\n #driver.get(baseURL)\n\n else:\n print(\"Hello\")\n # Setting Driver Implicit Time out for An Element\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\n self.driver.implicitly_wait(10)\n return self.driver\n # Maximize the window\n #driver.maximize_window()\n # Loading browser with App URL\n #driver.get(baseURL)\n #return driver","def start_browser_with(self, browser: 'Browserify', url: 'Url') -> 'StartableClient':","async def _launch_remote_browser(self, server_ip,\r\n launch_options: Dict[str, Any] = None) -> Browser:\r\n logger.info(\r\n f\"Launching remote browser on {server_ip}:\\n{pformat(launch_options)}\")\r\n endpoint = f\"http://{server_ip}/new_browser\"\r\n resp = requests.get(endpoint, json=launch_options)\r\n if resp.status_code != 200:\r\n logger.error(\r\n f\"Could not add browser ({resp.status_code}): {endpoint}\")\r\n return\r\n logger.info(\r\n f\"[{resp.status_code}] Added Browser on {server_ip}\")\r\n # construct DevTools endpoint.\r\n dev_tools_endpoint = resp.json()['dev_tools'].replace(\r\n '127.0.0.1', server_ip.split(':')[0])\r\n logger.info(\r\n f\"Connecting to {server_ip} browser: {dev_tools_endpoint}\")\r\n # connect to new browser's DevTools endpoint.\r\n browser = await pyppeteer.launcher.connect(browserWSEndpoint=dev_tools_endpoint)\r\n logger.info(f\"Connected to browser {dev_tools_endpoint}: {browser}\")\r\n return browser","def __init__(self, BrowserType=\"Chrome\", Remote=False, Headless=False, BrowserWidth=1920,\n BrowserHeight=1080, SeleniumGridHost=\"\", SeleniumGridPort=4444, Options=[], DesiredCapabilities={}):\n self.BrowserType = BrowserType\n self.Remote = Remote\n self.Headless = Headless\n self.BrowserWidth = BrowserWidth\n self.BrowserHeight = BrowserHeight\n self.SeleniumGridHost = SeleniumGridHost\n self.SeleniumGridPort = SeleniumGridPort\n self.Options = Options\n self.DesiredCapabilities = DesiredCapabilities","def open_website(url):\n browser = webdriver.Firefox()\n browser.get(url)\n return browser","def test_webuidriver_remote(self):\n\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\n hub.start_server()\n\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\"localhost\", 4444))\n node.start_server()\n executors = SeleniumHatch.get_remote_executors(\"localhost\", 4444)\n\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\n\n self.driver.get('http://www.baidu.com')\n time.sleep(1)\n\n # webuidriver.Remote 是 webdriver.Chrome 的子类\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\n self.assertIsInstance(self.driver, webdriver.Remote)\n\n self.driver.close()\n self.driver.quit()\n\n hub.stop_server()\n node.stop_server()","def __init__(self):\n driver = webdriver.Firefox() #working with firefox. see above comment and edit it to change the browser\n\n self.driver.get(\"https://moodle.niituniversity.in\")\n self.tLogin()","def seleniumDriver():\n chrome_options = Options()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--disable-dev-shm-usage')\n driver = webdriver.Chrome(\"/usr/bin/chromedriver\",\n options=chrome_options\n )\n driver.set_page_load_timeout(10)\n return driver","def _browser(self):\n RemoteConnection.set_timeout(CONNECTION_TIMEOUT)\n\n profile = webdriver.FirefoxProfile()\n preferences = self.config.get('preferences', {})\n for key, value in preferences.items():\n profile.set_preference(key, value)\n\n driver = webdriver.Firefox(profile)\n # Wait for UI events to complete before failing to find an element.\n driver.implicitly_wait(IMPLICIT_TIMEOUT)\n\n return driver","def getdriver(url):\n options = Options()\n options.add_argument('-headless')\n driver = webdriver.Chrome(executable_path='geckodriver',options=options)\n driver.get(url)\n wait = WebDriverWait(driver,3)\n return driver","def __init__(self, url_address, type=\"Chrome\"):\n from webdriverwrapper import Chrome\n from selenium import webdriver\n options = webdriver.ChromeOptions()\n options.add_experimental_option(\"excludeSwitches\", [\"enable-automation\"])\n options.add_experimental_option('useAutomationExtension', False)\n self.driver = Chrome(options=options)\n # Open a website\n window_before = self.driver.window_handles[0]\n self.driver.get(url_address)","def create_browser_instance():\n cmd = [browser_sync_path, 'start', '--proxy=localhost:8000']\n check_output(cmd)","def initialize():\n\n logging.basicConfig(level=logging.INFO)\n\n browser = webdriver.Firefox()\n browser.get(\"http://www.wrappa.org/\")\n browser.find_element_by_name(\"termsAccepted\").click()\n browser.find_element_by_name(\"termsAccepted\").submit()\n return browser","def __init__(self, base_url=None):\n self.driver = webdriver.Chrome()\n if base_url:\n self.base_url = base_url","def setUpClass(cls):\n super().setUpClass()\n options = Options()\n options.headless = True\n cls.selenium = WebDriver(options=options)\n cls.selenium.implicitly_wait(10)","def doOpen(self, targetUrl, timeout=30.0, withFirefox=True, withIe=False, withChrome=False, withOpera=False, withEdge=False, useMarionette=True,\n browserProfile=None, sessionName=\"default\" ):\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\n \n ret = True\n if withFirefox:\n cap = SELENIUM_FIREFOX\n cap['marionette'] = useMarionette\n cap['acceptInsecureCerts'] = True\n elif withIe:\n cap = SELENIUM_INTERNETEXPLORER\n elif withChrome:\n cap = SELENIUM_CHROME\n elif withOpera:\n cap = SELENIUM_OPERA\n elif withEdge:\n cap = SELENIUM_EDGE\n else:\n cap = SELENIUM_FIREFOX\n cmdId = self.openNavig( desiredCapabilities=cap, browserProfile=browserProfile, sessionName=sessionName) \n if self.isNavigStarted(timeout=timeout, commandId=cmdId) is None:\n ret = False\n else:\n if not( targetUrl.startswith(\"http://\") or targetUrl.startswith(\"https://\") ):\n raise TestAdapterLib.ValueException(TestAdapterLib.caller(), \"target url not start with http(s):// (%s)\" % type(targetUrl) )\n cmdId = self.loadUrl(url=targetUrl)\n if self.isUrlLoaded(timeout=timeout, commandId=cmdId) is None:\n ret = False\n return ret","def __init__(self, driver_path=None):\n\n if driver_path is None:\n self.driver = webdriver.Firefox()\n else:\n print(\"Alter gecko path\")\n self.driver = webdriver.Firefox(executable_path=driver_path)","def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver","def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver","def create_a_book(article_urls, book_title, book_subtitle=\"\", book_fmt=\"epub\", \\\n webdriverType=WebDrivers.Firefox):\n if len(article_urls) == 0:\n logging.error('create_a_book: article_urls is empty, nothing to do')\n return\n article_url = article_urls.pop(0)\n driver = None\n if webdriverType == WebDrivers.Firefox:\n driver = webdriver.Firefox()\n elif webdriverType == WebDrivers.RemoteChrome:\n driver = webdriver.Remote(\n command_executor='http://localhost:9515',\n desired_capabilities=DesiredCapabilities.CHROME)\n\n article_url, wiki = get_wiki_url(driver, article_url)\n\n #h3 = driver.find_element_by_id(\"p-coll-print_export-label\")\n #a = h3.find_element_by_tag_name(\"a\") \n #a.click() # cliquer \"Imprimer / exporter\"\n #driver.implicitly_wait(1)\n while True:\n try:\n div = driver.find_element_by_id(\"p-coll-print_export\")\n li = div.find_element_by_id(\"coll-create_a_book\")\n a = li.find_element_by_tag_name(\"a\")\n a.click() # cliquer \"Créer un livre\"\n break\n except:\n logging.debug('Caught {0} Retrying... '.format(sys.exc_info()[0]))\n driver.implicitly_wait(1)\n\n driver.implicitly_wait(3)\n div = driver.find_element_by_class_name(\"ok\")\n a = div.find_element_by_tag_name(\"a\")\n a.click() # cliquer \"Démarrer le créateur de livres\"\n\n a = driver.find_element_by_id(\"coll-add_article\")\n a.click() # cliquer \"Ajouter cette page à votre livre\"\n \n # Add the rest of the articles to the book\n while len(article_urls):\n article_url = article_urls.pop(0)\n article_url, wiki = get_wiki_url(driver, article_url)\n a = driver.find_element_by_id(\"coll-add_article\")\n a.click() # cliquer \"Ajouter cette page à votre livre\"\n\n # click \"Show book (1 page)\" (seems to work for any lang wikipedia)\n driver.get(\"http://\" + wiki + \"/wiki/Special:Book\")\n\n title_txt = driver.find_element_by_id(\"titleInput\") # \"Titre\"\n title_txt.send_keys(book_title)\n subtitle_txt = driver.find_element_by_id(\"subtitleInput\") # \"Sous-titre\"\n subtitle_txt.send_keys(book_subtitle)\n select = Select(driver.find_element_by_id(\"formatSelect\")) # \"Format\"\n option_value = book_fmt\n if book_fmt == 'pdf':\n option_value = 'rl'\n select.select_by_value(option_value)\n btn = driver.find_element_by_id(\"downloadButton\") # \"Télécharger\n btn.click()\n\n url = ''\n while True:\n try:\n div = driver.find_element_by_id(\"mw-content-text\")\n a = div.find_element_by_tag_name(\"a\") # \"Télécharger le fichier\"\n url = a.get_attribute(\"href\")\n if url.find(\"bookcmd=download\") != -1:\n logging.debug(\"found bookcmd=download\")\n logging.debug(\"url: {0}\".format(url)) \n #a.click() #Télécharger\n break\n except:\n logging.debug('Caught {0} Retrying... '.format(sys.exc_info()[0]))\n driver.implicitly_wait(1)\n filename = ''\n try:\n req = urllib2.Request(url=url)\n resp = urllib2.urlopen(req)\n _, params = cgi.parse_header(resp.headers.get('Content-Disposition', ''))\n filename = params['filename']\n logging.debug('Content-Disposition filename: {0}'.format(filename))\n with open(filename, 'wb') as f:\n f.write(resp.read())\n except:\n logging.error('Error: {0}'.format(sys.exc_info()[0]))\n driver.close()\n return filename","def connect_firefox_driver(headless):\n #initialise chrome options\n options = FirefoxOptions()\n #set headless option on driver\n options.headless = headless\n #initialise driver\n driver = webdriver.Firefox(executable_path=GeckoDriverManager().install(), options=options)\n return driver","def build_browser(searchurl):\n options = webdriver.ChromeOptions()\n options.add_argument('--no-sandbox')\n try:\n browser = webdriver.Chrome(ChromeDriverManager().install())\n except Exception as e:\n print(f'No found chromedriver in this environment.')\n print(f'Install on your machine. exception: {e}')\n sys.exit()\n\n browser.set_window_size(1280, 1024)\n browser.get(searchurl)\n time.sleep(1)\n\n print(f'Getting you a lot of images. This may take a few moments...')\n body = browser.find_element_by_tag_name('body')\n return body, browser","def connect(self) -> None:\n self.driver.get(self.base_url)","def open_browser():\n def _open_browser():\n webbrowser.open('http://localhost:%s/%s' % (PORT, FILE))\n pass\n thread = threading.Timer(0.5, _open_browser)\n thread.start()","def open_browser():\n def _open_browser():\n if AIPS_WEBSERVER_HOST == \"localhost\":\n webbrowser.open(WEBSERVER_URL + '/%s' % FILE)\n thread = threading.Timer(0.5, _open_browser)\n thread.start()","def connect():\n\n driver = webdriver.Chrome(driver_exe) # Run the simulated chrome driver\n driver.get(url) # go to the whatsapp web page\n driver.implicitly_wait(10) # wait a little to make sure the page loads\n return driver","def get_around_welcome_screen(driver = None, timeout = None):\n\tdriver.implicitly_wait(0) #reset implicity wait. It is not need in here as there is only explicit wait.\n\tspinnerWait=30\n\t#timeoutValue = timeout if timeout != None else 1\n\ttimeoutValue=1\n\ttimeoutPopUp = 1\n\tif driver == None:\n\t\tprint \"ERROR in get_around_welcome_screen(): Please sent webdriver as argument. Timeout value is optional.\"\n\telse:\n\t\t#-------------------------\n\t\t#verify if link page was loaded\n\t\ttry:\n\t\t\tWebDriverWait(driver, spinnerWait).until(EC.invisibility_of_element_located((By.ID,\"loading\")))\n\t\texcept TimeoutException:\n\t\t\tprint \"FATAL:\\tPage did not load at all.\"\n\t\t\tsys.exit(\"taking too long to load page\")\n\t\t#-------------------------\n\t\tfor x in range(0,3):\n\t\t\t#get around the welcome screen\n\t\t\ttry:\n\t\t\t\tprint \"INFO:\\tTrying to close Welcome popup\"\n\t\t\t\twelcomePopupClose = WebDriverWait(driver,timeoutPopUp).until(EC.element_to_be_clickable((By.ID,\"welcomePopupCloseButton\")))\n\t\t\t\twelcomePopupClose.click()\n\t\t\t\t#driver.implicitly_wait(8)\n\t\t\t\treturn None #abort function as pop is already closed.\n\t\t\texcept TimeoutException:\n\t\t\t\tpass\n\t\t\ttry:\n\t\t\t\tprint \"INFO:\\tTrying to close New feature popup\"\n\t\t\t\tnewFeatPopupClose = WebDriverWait(driver,timeoutPopUp).until(EC.element_to_be_clickable((By.ID,\"newFeaturePopupCloseButton\")))\n\t\t\t\tnewFeatPopupClose.click()\n\t\t\t\t#driver.implicitly_wait(8)\n\t\t\t\treturn None #abort function as pop is already closed.\n\t\t\texcept TimeoutException:\n\t\t\t\tpass\n\t\t\ttry:\n\t\t\t\tprint \"INFO:\\tTrying to close startJostlingNow\"\n\t\t\t\tstartJostlingPopupClose = WebDriverWait(driver,timeoutPopUp).until(EC.element_to_be_clickable((By.ID,\"QA:startJostlingNow\")))\n\t\t\t\tstartJostlingPopupClose.click()\n\t\t\t\t#driver.implicitly_wait(5)\n\t\t\t\treturn None #abort function as pop is already closed.\n\t\t\texcept TimeoutException:\n\t\t\t\tpass\n\treturn None","def setUp(self):\n self.driver = webdriver.PhantomJS()\n self.driver.get(self.get_server_url())","def setup_phantomjs():\n try:\n # Setup capabilities for the PhantomJS browser\n phantomjs_capabilities = DesiredCapabilities.PHANTOMJS\n # Some basic creds to use against an HTTP Basic Auth prompt\n phantomjs_capabilities['phantomjs.page.settings.userName'] = 'none'\n phantomjs_capabilities['phantomjs.page.settings.password'] = 'none'\n # Flags to ignore SSL problems and get screenshots\n service_args = []\n service_args.append('--ignore-ssl-errors=true')\n service_args.append('--web-security=no')\n service_args.append('--ssl-protocol=any')\n # Create the PhantomJS browser and set the window size\n browser = webdriver.PhantomJS(desired_capabilities=phantomjs_capabilities,service_args=service_args)\n browser.set_window_size(1920,1080)\n except Exception as error:\n click.secho(\"[!] Bad news: PhantomJS failed to load (not installed?), so activities \\\nrequiring a web browser will be skipped.\",fg=\"red\")\n click.secho(\"L.. Details: {}\".format(error),fg=\"red\")\n browser = None\n return browser","def connect(executable_path=CHROMEDRIVER_PATH) -> webdriver.Chrome:\n return webdriver.Chrome(executable_path=executable_path)","def _get_selenium_browser(navigator, fLOG=noLOG):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n from selenium import webdriver\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\n\n fLOG(\"[webshot] navigator=\", navigator)\n if navigator == \"firefox\":\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\n firefox_capabilities['marionette'] = True\n firefox_capabilities[\n 'binary'] = r\"C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe\"\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\n elif navigator == \"chrome\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n install_chromedriver(fLOG=fLOG)\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install 'chromedriver.exe'\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'chromedriver'\n\n start_navi = True\n if start_navi:\n fLOG(\"[_get_selenium_browser] start\", navigator)\n chrome_options = webdriver.ChromeOptions()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--verbose')\n browser = webdriver.Chrome(executable_path=chromed,\n chrome_options=chrome_options)\n else:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n import selenium.webdriver.chrome.service as wservice\n fLOG(\"[_get_selenium_browser] create service\")\n service = wservice.Service(chromed)\n fLOG(\"[_get_selenium_browser] start service\")\n service.start()\n fLOG(\"[_get_selenium_browser] declare remote\")\n capabilities = {'chrome.binary': chromed}\n browser = webdriver.Remote(service.service_url, capabilities)\n elif navigator == \"ie\":\n browser = webdriver.Ie()\n elif navigator == \"opera\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n install_operadriver(fLOG=fLOG)\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install operadriver.exe\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'operadriver'\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\n elif navigator == \"edge\":\n browser = webdriver.Edge()\n else:\n raise RuntimeError(\n f\"unable to interpret the navigator '{navigator}'\")\n fLOG(\"[_get_selenium_browser] navigator is started\")\n return browser","def __init__(self,\n http_proxy=\"\",\n tries=2,\n wait_seconds=3,\n user_agent=\"Firefox/%s\" % __version__,\n timeout=30,\n ):\n assert tries >= 1\n assert wait_seconds >= 0\n assert timeout >= 0\n self.http_proxy = http_proxy\n self.tries = tries\n self.wait_seconds = wait_seconds\n self.user_agent = user_agent\n self.timeout = timeout\n socket.setdefaulttimeout(self.timeout)","def __init__(self, browser='firefox'):\n if browser == 'firefox' or browser == 'ff':\n driver = webdriver.Firefox()\n elif browser == 'chrome':\n driver = webdriver.Chrome('util/chromedriver')\n elif browser == 'safari':\n driver = webdriver.Safari()\n try:\n self.driver = driver\n except Exception:\n raise NameError(\"Not found %s browser, you should enter 'firefox','ff','chrome','safari'.\" % browser)","def start_selenium_server(self, *params):\n params = ('-port', str(self._server_port)) + params\n logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')\n self._selenium_log = open(logpath, 'w')\n start_selenium_server(self._selenium_log, self._jar_path, *params)\n self._html('Selenium server log is written to <a href=\"file://%s\">%s</a>.'\n % (logpath.replace('\\\\', '/'), logpath))","def open_firefox():\r\n driver = install_firefox_proxy(LOCALHOST, PROXY_PORT_NUMBER)\r\n driver.get(STARTING_WEBSITE)","def _get_browser(self, webpage):\n options = self._build_options()\n\n chrome_path = 'C:/Users/jorda/.wdm/drivers/chromedriver/81/win32/chromedriver.exe'\n browser = webdriver.Chrome(executable_path = chrome_path, options=options)\n\n# browser = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n browser.get(webpage)\n wait = WebDriverWait(browser, 20) # maximum wait time is 20 seconds \n return browser, wait","def driver(request):\n browser = request.config.getoption(\"--browser\")\n wait = request.config.getoption(\"--wait\")\n if browser == 'firefox':\n capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()\n capabilities['timeouts'] = {'implicit': wait, 'pageLoad': 30000, 'script': 1000}\n capabilities['loggingPrefs'] = {'browser': 'ALL', 'client': 'ALL', 'driver': 'ALL',\n 'performance': 'ALL', 'server': 'ALL'}\n profile = webdriver.FirefoxProfile()\n profile.set_preference('app.update.auto', False)\n profile.set_preference('app.update.enabled', False)\n profile.accept_untrusted_certs = True\n wd = EventFiringWebDriver(webdriver.Firefox(firefox_profile=profile, capabilities=capabilities), TestListener())\n wd.maximize_window()\n elif browser == 'chrome':\n chrome_options = webdriver.ChromeOptions()\n capabilities = webdriver.DesiredCapabilities.CHROME.copy()\n capabilities['acceptSslCerts'] = True\n capabilities['acceptInsecureCerts'] = True\n capabilities['loggingPrefs'] = {'performance': 'ALL'}\n driver = webdriver.Chrome(desired_capabilities=capabilities, options=chrome_options)\n driver.implicitly_wait(wait)\n wd = driver\n else:\n print('Unsupported browser!')\n sys.exit(1)\n yield wd\n wd.quit()","def start_selenium_server(logfile=None, jarpath=None, *params):\n if not subprocess:\n raise RuntimeError('This function requires `subprocess` module which '\n 'is available on Python/Jython 2.5 or newer.')\n cmd = _server_startup_command(jarpath, *params)\n try:\n subprocess.Popen(cmd, stdout=logfile, stderr=subprocess.STDOUT)\n except OSError:\n raise RuntimeError('Starting Selenium Server failed. Check that you '\n 'have Java 1.5 or newer installed by running '\n '`java -version` on the command prompt.')\n print 'Selenium Server started with command \"%s\" ' % ' '.join(cmd)","def __init__(self, url, epRange):\n self.driver = webdriver.PhantomJS()\n self.downloads = OrderedDict() # sort episodes in asending order\n self.pbar = \"\" # Download Progressbar\n self.Main(url, epRange)","def create_local(\n options: Optional[\"ChromeOptions\"] = None,\n timeout: Optional[float] = None,\n headless: bool = True,\n user_data_dir: Optional[str] = None,\n soup_maker: Optional[SoupMaker] = None,\n **kwargs,\n) -> WebDriver:\n _acquire_queue(timeout)\n is_debug = os.getenv(\"debug_mode\")\n\n if not options:\n options = ChromeOptions()\n\n if not has_display():\n headless = True\n\n # Set default language\n try:\n language = locale.getdefaultlocale()[0].replace(\"_\", \"-\")\n except Exception:\n pass\n options.add_argument(\"--lang=%s\" % (language or \"en-US\"))\n\n # Logging configs\n LOGGER.setLevel(logging.WARN)\n options.add_argument(f\"--log-level={0 if is_debug else 3}\")\n if not is_debug:\n LOGGER.setLevel(1000)\n\n # Suppress bothersome stuffs\n options.add_argument(\"--no-default-browser-check\")\n options.add_argument(\"--disable-infobars\")\n options.add_argument(\"--no-first-run\")\n # options.add_argument(\"--disable-extensions\")\n # options.add_argument(\"--disable-gpu\")\n # options.add_argument(\"--disable-dev-shm-usage\")\n\n # Add capabilities\n #options.set_capability(\"quietExceptions\", True)\n options.set_capability(\"acceptInsecureCerts\", True)\n #options.set_capability(\"useAutomationExtension\", False)\n\n # Configure window behavior\n if headless:\n options.add_argument(\"--window-size=1920,1080\")\n options.add_argument(\"--start-maximized\")\n options.add_argument(\"--no-sandbox\")\n options.add_argument(\"--headless=new\")\n else:\n width = max(640, Screen.view_width * 3 // 4)\n height = max(480, Screen.view_height * 3 // 4)\n width = int(os.getenv(\"CHROME_WIDTH\", width))\n height = int(os.getenv(\"CHROME_HEIGHT\", height))\n options.add_argument(f\"--window-size={width},{height}\")\n\n # Chrome specific experimental options\n options.accept_insecure_certs = True\n options.unhandled_prompt_behavior = \"dismiss\"\n options.strict_file_interactability = False\n # options.add_experimental_option(\"excludeSwitches\", [\"enable-automation\"])\n # if not is_debug:\n # options.add_experimental_option(\"excludeSwitches\", [\"enable-logging\"])\n\n # # Set remote debuging host and port\n # debug_host = \"127.0.0.1\"\n # debug_port = free_port(debug_host)\n # options.add_argument(f\"--remote-debugging-host={debug_host}\")\n # options.add_argument(f\"--remote-debugging-port={debug_port}\")\n # options.debugger_address = f\"{debug_host}:{debug_port}\"\n\n executable_path = _acquire_chrome_driver_path()\n logger.debug(\n \"Creating chrome instance | \"\n + f\"headless={headless} | \"\n + f\"driver_path={executable_path}\"\n )\n chrome = Chrome(\n driver_executable_path=executable_path,\n options=options,\n desired_capabilities=options.to_capabilities(),\n keep_alive=True,\n user_data_dir=user_data_dir,\n headless=headless,\n )\n logger.info(\"Created chrome instance > %s\", chrome.session_id)\n chrome.set_window_position(0, 0)\n\n if not soup_maker:\n soup_maker = SoupMaker()\n chrome._soup_maker = soup_maker\n chrome._web_element_cls = WebElement\n\n # _add_virtual_authenticator(chrome)\n # _override_get(chrome)\n\n _release_queue(chrome)\n return chrome","def setUpClass(cls):\n cls.driver = webdriver.Chrome()\n cls.driver.maximize_window()\n cls.driver.get('https://letskodeit.teachable.com/p/practice')","def initDriver(browser):\n if browser == \"firefox\":\n opts = Options()\n opts.log.level = \"trace\"\n driver = webdriver.Firefox(options=opts)\n return driver\n elif browser == \"chrome\":\n options = webdriver.ChromeOptions()\n options.add_argument(\"start-maximized\")\n #d = DesiredCapabilities.CHROME\n d = options.to_capabilities()\n d['loggingPrefs'] = { 'browser':'ALL'}\n driver = webdriver.Chrome('../Data/chromedriver_linux64/chromedriver',desired_capabilities=d)\n return driver\n else:\n print(\"------- Navegador no compatible ---------\")\n return null","def launch_browser2(self, clean_session=False):\n try:\n if self._browserName[0:2] == \"IE\":\n if clean_session:\n self._browser = webdriver.Ie(log_level=\"TRACE\", log_file=\"iedriver_stdout.log\",\n capabilities={'ie.ensureCleanSession': True})\n else:\n self._browser = webdriver.Ie(log_level=\"TRACE\", log_file=\"iedriver_stdout.log\")\n elif self._browserName == \"RemoteIE\":\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\n desired_capabilities={'browserName': 'internet explorer'})\n elif self._browserName == \"RemoteFF\":\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\n desired_capabilities={'browserName': 'firefox'})\n \n elif self._browserName == \"Firefox\":\n fp = webdriver.FirefoxProfile()\n fp.set_preference('app.update.auto', False)\n fp.set_preference('app.update.enabled', False)\n fp.native_events_enabled = False\n proxy = None\n if self._configuration.security:\n self.logger.info(\"we use a proxy\")\n fp.accept_untrusted_certs = True\n proxy = webdriver.Proxy()\n proxy.http_proxy = \"localhost:9080\"\n proxy.ssl_proxy = \"localhost:9080\"\n self._browser = webdriver.Firefox(firefox_profile=fp, proxy=proxy)\n elif self._browserName == \"Chrome\":\n # dirty way to launch chromedriver as the current webdriver fail after the xth command\n import subprocess\n\n self._chrome_log_file_stdout = open('chromedriver_stdout.log', 'w')\n self._chrome_log_file_stderr = open('chromedriver_stderr.log', 'w')\n subprocess.Popen(\"chromedriver\", stdout=self._chrome_log_file_stdout,\n stderr=self._chrome_log_file_stderr)\n time.sleep(2)\n self._browser = webdriver.Remote('http://localhost:9515', {\"nativeEvents\": False,\n \"javascriptEnabled\": True})\n else:\n raise NotKnown(\"Unknown browser : \" + self._browserName)\n self.set_implicit_wait_default()\n self._browser.maximize_window()\n self._currentFrame = \"main\"\n self.logger.info(\"Launching : \" + str(self._browserName))\n except Exception as e:\n self.logger.error(\"Error launching browser : \" + str(e))\n raise","def get_driver_with_options():\n #options = get_driver_options()\n #return webdriver.Chrome(options=options)\n return webdriver.Chrome()","def driver():\n driver = webdriver.Chrome(chrome_options=ChromeOptions(), project_name=\"Examples\", job_name=\"Pytest Example\")\n yield driver\n driver.quit()","def test_keep_alive(simple_page, browser, splinter_webdriver):\n if splinter_webdriver != \"remote\":\n pytest.skip(\"Only Remote WebDriver uses keep_alive argument\")\n assert browser.driver.command_executor.keep_alive","def setUp(self):\n self.browser = webdriver.Firefox()\n self.url = 'http://127.0.0.1:8000/'","def __init__(self, driver, selector, wait_time=10):\n\n logger.debug(\n \"Initialize class: {0} with selector {1}:\".format(\n self.__class__.__name__, selector))\n self._selector = selector\n self._driver = driver\n self._wait = WebDriverWait(self._driver, wait_time)","def set_up_driver(self):\r\n\t\ttry:\r\n\t\t\tself.driver = webdriver.Firefox()\r\n\t\texcept Exception:\r\n\t\t\tself.driver = False","def __init__(self, selenium_test):\n self.selenium_test = selenium_test","def pytest_addoption(parser):\n parser.addoption(\"--address\", action=\"store\",\n default=\"http://192.168.145.130/\", help=\"Opencart web address\")\n parser.addoption(\"--browser\", action=\"store\", default=\"chrome\", help=\"Browser name\")\n parser.addoption(\"--wait\", action=\"store\", default=10, help=\"Implicity wait\")","def __init__(self):\n self.driver = webdriver.Chrome()","def init_driver(self):\n # Set UserAgent to prevent issues with blocking bot\n self.chrome_options.add_argument(\n \"user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36\")\n # Set headless\n if self.headless:\n self.chrome_options.add_argument('headless')\n # Initiate driver\n driver = webdriver.Chrome(\n self.chromedriver_path + \"/chromedriver\", options=self.chrome_options)\n self.driver = driver\n self.wait = WebDriverWait(self.driver, 20)\n return self.driver","def __init__(self, code, year, season):\n self.code = code\n self.year = year\n self.season = season\n # 使用headless browser抓取資料\n self.fireFoxOptions = webdriver.FirefoxOptions()\n self.fireFoxOptions.headless = True\n url = 'https://mops.twse.com.tw/server-java/t164sb01?step=1&REPORT_ID=C&CO_ID=' + str(code) \\\n + '&SYEAR=' + str(year) + '&SSEASON=' + str(season)\n self.driver = webdriver.Firefox(options=self.fireFoxOptions)\n self.driver.get(url)","def test_from_crawler_method_should_initialize_the_driver(self):\n\n crawler = Crawler(\n spidercls=self.spider_klass,\n settings=self.settings\n )\n selenium_middleware = SeleniumMiddleware.from_crawler(crawler)\n\n # The driver must be initialized\n self.assertIsNotNone(selenium_middleware.driver)\n\n # We can now use the driver\n selenium_middleware.driver.get('http://www.python.org')\n self.assertIn('Python', selenium_middleware.driver.title)\n\n selenium_middleware.driver.close()","def refresh_browser(timeout=None): \n if timeout is None:\n restart_browser()\n return\n\n else:\n echo_highlight('Checking server status...')\n for i in range(5):\n time.sleep(timeout)\n try:\n response = get('http://localhost:8000/health_check')\n except ConnectionError:\n echo_highlight('Still checking...')\n else:\n if response and response.status_code == 200:\n restart_browser()\n return\n\n echo_warning('Maximum attempts reached! Something might be wrong.')","def start_server():\n if not os.path.exists(cf.get(\"Selenium\", \"server_path\")):\n jar_name = \"selenium-server-standalone-2.25.0.jar\"\n server_jar = os.path.join(tempfile.gettempdir(), jar_name)\n if not os.path.exists(server_jar):\n r = requests.get(\"http://selenium.googlecode.com/files/%s\" % jar_name)\n jar_on_disk = open(server_jar, \"wb\")\n jar_on_disk.write(r.content)\n jar_on_disk.close()\n else:\n server_jar = cf.get(\"Selenium\", \"server_path\")\n \n s = subprocess.Popen(['java', '-jar', server_jar], \n stdout=tempfile.TemporaryFile(), \n stderr=tempfile.TemporaryFile()).pid\n pidfile = open(pid_file_path, \"w\")\n pidfile.write(str(s))\n pidfile.close()\n\n # make sure the server is actually up\n server_up = False\n waiting = 0\n while server_up == False and waiting < 60:\n try:\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n s.connect((\"localhost\", 4444))\n s.close()\n server_up = True\n except socket.error:\n time.sleep(1)\n waiting = waiting + 1\n server_up = False\n\n return server_up","def __init_webdriver(self):\n try:\n # Inicializar driver para Firefox\n # - Configuración parámetro profile\n profile = webdriver.FirefoxProfile()\n # - Indicar que no se ha de usar el directorio por defecto de Downloads\n profile.set_preference(\"browser.download.folderList\",2)\n # - Deshabilitar showing download progress\n profile.set_preference(\"browser.download.manager.showWhenStarting\", False)\n # - Establecer el directorio para los Downloads\n profile.set_preference(\"browser.download.dir\", self.xbrl_download_dir)\n # - Especificar a Firefox que descarge automátiamente las ficheros de mime-types especificados\n profile.set_preference(\"browser.helperApps.neverAsk.saveToDisk\", \"application/zip\");\n # - Especificar User Agent\n user_agent = self.__get_default_user_agent()+' - '+self.selenium_user_agent_comment\n profile.set_preference(\"general.useragent.override\", user_agent)\n\n # -Configuración parámetro binary\n binary = FirefoxBinary(self.selenium_firefox_path)\n # Instanciar driver par Firefox\n self.driver = webdriver.Firefox(firefox_profile=profile, firefox_binary=binary, executable_path=self.selenium_firefox_driver)\n agent = self.driver.execute_script(\"return navigator.userAgent\")\n print(' * Web driver inicializado con userAgent: '+agent)\n except Exception:\n traceback.print_exc() \n raise Exception('Error en WebScraper.__init_webdriver.')","def __init__(self, timeout=None, heartbeat=None):\n\n assert timeout, 'External runner requires a timeout.'\n\n self.timeout = lambda ctx=None: timeout\n self.heartbeat = lambda ctx=None: (heartbeat or timeout)","def __init__(self, user_agent=default_user_agent, operate_timeout=10, loading_timeout=60, log_level=logging.WARNING,\n display=False, viewport_size=(1024, 768), accept_language='en,*', ignore_ssl_errors=True,\n cache_dir=os.path.join(tempfile.gettempdir(), \"GRobot\"),\n image_enabled=True, plugins_enabled=False, java_enabled=False, javascript_enabled=True,\n plugin_path=None, develop=False, proxy=None, sleep=0.5, jquery_namespace='GRobot'):\n\n GRobot.exit_lock.acquire()\n\n if GRobot._kill_loop:\n gevent.kill(GRobot._kill_loop)\n GRobot._kill_loop=None\n\n logger.setLevel(log_level)\n\n plugin_path = plugin_path or ['/usr/lib/mozilla/plugins', ]\n\n GRobot._liveRobot += 1\n\n self.develop = develop\n self.inspector = None\n self.plugin = False\n self.exitLoop = False\n self._deleted = False\n\n self.set_proxy(proxy)\n\n self.sleep = sleep\n self.jquery_namespace = jquery_namespace\n self.popup_messages = None\n self.accept_language = accept_language\n\n self._loaded = True\n\n self._confirm_expected = None\n self._prompt_expected = None\n self._upload_file = None\n self._alert = None\n\n self.http_resources = []\n\n self.user_agent = user_agent\n\n self.loading_timeout = loading_timeout\n self.operate_timeout = operate_timeout\n\n self.ignore_ssl_errors = ignore_ssl_errors\n\n if not sys.platform.startswith('win') and not 'DISPLAY' in os.environ \\\n and not hasattr(GRobot, 'xvfb'):\n try:\n os.environ['DISPLAY'] = ':99'\n GRobot.xvfb = subprocess.Popen(['Xvfb', ':99'])\n except OSError:\n raise Exception('Xvfb is required to a GRobot run oustside ' + \\\n 'an X instance')\n\n self.display = display\n\n if not GRobot._app:\n GRobot._app = QApplication.instance() or QApplication(['GRobot'])\n if plugin_path:\n for p in plugin_path:\n GRobot._app.addLibraryPath(p)\n\n self.page = GRobotWebPage(self, GRobot._app)\n\n QtWebKit.QWebSettings.setMaximumPagesInCache(0)\n QtWebKit.QWebSettings.setObjectCacheCapacities(0, 0, 0)\n QtWebKit.QWebSettings.globalSettings().setAttribute(QtWebKit.QWebSettings.LocalStorageEnabled, True)\n\n self.page.setForwardUnsupportedContent(True)\n\n # Page signals\n self.page.loadFinished.connect(self._page_loaded)\n self.page.loadStarted.connect(self._page_load_started)\n self.page.unsupportedContent.connect(self._unsupported_content)\n\n self.manager = self.page.networkAccessManager()\n\n #TODO:Think about how to handle the network accessible signal\n #self.manager.networkAccessibleChanged.connect()\n\n self.manager.finished.connect(self._request_ended)\n self.manager.sslErrors.connect(self._on_manager_ssl_errors)\n\n # Cache\n self.cache = QNetworkDiskCache()\n self.cache.setCacheDirectory(cache_dir)\n\n self.manager.setCache(self.cache)\n\n # Cookie jar\n self.cookie_jar = QNetworkCookieJar()\n self.manager.setCookieJar(self.cookie_jar)\n\n # User Agent\n self.page.setUserAgent(self.user_agent)\n\n self.page.networkAccessManager().authenticationRequired \\\n .connect(self._authenticate)\n self.page.networkAccessManager().proxyAuthenticationRequired \\\n .connect(self._authenticate)\n\n self.main_frame = self.page.mainFrame()\n\n self.webview = None\n\n self.viewport_size = viewport_size\n\n self.webview = QtWebKit.QWebView()\n self.webview.setPage(self.page)\n\n self.webview.show() if display else self.webview.hide()\n\n self.set_viewport_size(*viewport_size)\n\n self.page.settings().setAttribute(QtWebKit.QWebSettings.PluginsEnabled, plugins_enabled)\n self.page.settings().setAttribute(QtWebKit.QWebSettings.JavaEnabled, java_enabled)\n self.page.settings().setAttribute(QWebSettings.DeveloperExtrasEnabled, self.develop)\n\n self.enable_image = image_enabled\n self.enable_javascript = javascript_enabled\n\n #always open link in current window instead of new window\n self.page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)\n self.page.linkClicked.connect(self._link_clicked)\n\n #start the qt main loop\n GRobot._loop = QtMainLoop(GRobot._app)\n GRobot._loop.start()\n GRobot.exit_lock.release()","async def _launch_local_browser(self, launch_options: Dict[str, Any] = None) -> Browser:\r\n logger.info(\r\n f\"Launching local browser:\\n{pformat(launch_options)}\")\r\n return await pyppeteer.launcher.launch(launch_options)","def browser_module(choose_driver):\n yield choose_driver\n choose_driver.quit()","def initBrowser(browserConfig, isUseSeleniumwire=False):\n webdriver = getWebDirver(isUseSeleniumwire=isUseSeleniumwire)\n chromeOptions = webdriver.ChromeOptions()\n\n if \"headless\" in browserConfig:\n isCurHeadless = browserConfig[\"headless\"]\n if isCurHeadless:\n chromeOptions.add_argument('--headless')\n\n if \"disableGpu\" in browserConfig:\n isDisableGpu = browserConfig[\"disableGpu\"]\n if isDisableGpu:\n chromeOptions.add_argument('--disable-gpu')\n\n # for debug\n # chromeOptions.add_experimental_option(\"excludeSwitches\", [\"enable-automation\"])\n # chromeOptions.add_experimental_option('useAutomationExtension', False)\n # chromeOptions.add_argument('window-size=1920x1080')\n # chromeOptions.add_argument('--window-size=1920x1080')\n\n driverConfigDict = {\n \"options\": chromeOptions\n }\n\n if \"seleniumwire\" in browserConfig:\n if isUseSeleniumwire:\n driverConfigDict[\"seleniumwire_options\"] = browserConfig[\"seleniumwire\"]\n else:\n del browserConfig[\"seleniumwire\"]\n\n driver = webdriver.Chrome(**driverConfigDict)\n # driver = webdriver.Chrome(options=chromeOptions)\n\n # # for debug\n # driver.set_window_size(1920, 1080)\n\n if \"pageLoadTimeout\" in browserConfig:\n curPageLoadTimeout = browserConfig[\"pageLoadTimeout\"]\n driver.set_page_load_timeout(curPageLoadTimeout)\n\n return driver","def sleep(timeout=1):\n if os.environ.get('JS9_TEST_TIMEOUT'):\n timeout = int(os.environ.get('JS9_TEST_TIMEOUT'));\n time.sleep(timeout)","def setup_driver():\n os.environ[\"webdriver.chrome.driver\"] = chrome_driver_location\n driver = webdriver.Chrome(chrome_driver_location)\n driver.set_window_size(1280, 800)\n return driver","def execute_driver(self, script: str, script_type: str = 'webdriverio', timeout_ms: Optional[int] = None) -> Any:\n\n class Result:\n def __init__(self, res: Dict):\n self.result = res['result']\n self.logs = res['logs']\n\n option: Dict[str, Union[str, int]] = {'script': script, 'type': script_type}\n if timeout_ms is not None:\n option['timeout'] = timeout_ms\n\n response = self.execute(Command.EXECUTE_DRIVER, option)['value']\n return Result(response)","def setUpClass(cls):\n\n super().setUpClass()\n cls.selenium = WebDriver(executable_path=\"C:\\Program Files (x86)\\chromedriver.exe\")\n cls.selenium.implicitly_wait(10)","def create_browser():\n browser = selenium.webdriver.Chrome()\n return browser","def connect(\n servers=None, timeout=None, retry_time=10, connection=None, *args, **kwargs\n):\n if not connection:\n connection = connection_http.HTTPConnection()\n\n verify.verifyObject(interfaces.IConnection, connection)\n connection.connect(\n servers=servers, timeout=timeout,\n retry_time=retry_time, *args, **kwargs)\n return connection","async def main():\n # Create the queue of work\n work_queue = asyncio.Queue()\n\n # Put some work in the queue\n for url in [\n \"http://google.com\",\n \"http://yahoo.com\",\n \"http://linkedin.com\",\n \"http://apple.com\",\n \"http://microsoft.com\",\n \"http://facebook.com\",\n \"http://twitter.com\",\n ]:\n await work_queue.put(url)\n\n browser = HTTPBrowser(2,\n work_queue.qsize(),\n LoadBalancing()\n )\n\n await browser.browser_session(work_queue)","def create_connection(url, timeout=None, **options):\r\n websock = WebSocket()\r\n websock.settimeout(timeout != None and timeout or default_timeout)\r\n websock.connect(url, **options)\r\n return websock","def __init__(self, timeout=0.1):\n self.poller = select.epoll()\n self.timeout = timeout","def __init__(self, timeout=0.1):\n self.poller = select.epoll()\n self.timeout = timeout","def load_script(browser, url):\r\n if browser.current_url.startswith('file:'):\r\n url = 'https:' + url\r\n browser.execute_script(\"\"\"\r\n var script_tag = document.createElement(\"script\");\r\n script_tag.setAttribute(\"type\", \"text/javascript\");\r\n script_tag.setAttribute(\"src\", arguments[0]);\r\n document.getElementsByTagName(\"head\")[0].appendChild(script_tag);\r\n \"\"\", url)","def runBrowser(driver, url):\n\tdriver.get(url)\n\ttime.sleep(3) #REACT app need to sleep and wait app load.\n\tall_links=driver.execute_script('all_links = []; links = document.querySelectorAll(\".style-module--action--1Avvt>a\"); links.forEach(url => all_links.push(url.href)); return all_links');\n\tbar = IncrementalBar('📥 Icons Downloaded', max = len(all_links))\n\t\n\tfor i, link in enumerate(all_links):\n\t\tdriver.execute_script('''window.open(\"'''+link+'''\",\"_blank\");''')\n\t\tbar.next()\n\tprint('\\n')\n\tdriver.close()\n\tMessage.success('🎉 Download done!')","def __init__(self, **kwargs):\n super(DesktopInternetExplorerWebDriver, self).__init__(\n default_capabilities=False, # ensure that HackedWebDriver doesn't mess with the capabilities\n **kwargs\n )"],"string":"[\n \"def __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\\n\\n # selecting driver\\n if not driver_path:\\n driver = webdriver.Firefox\\n driver_options = FireFoxOptions()\\n else:\\n driver = webdriver.Chrome\\n driver_options = ChromeOptions()\\n\\n # add config\\n if options:\\n for option in options:\\n driver_options.add_argument(option)\\n\\n self.driver = driver(driver_path, options=driver_options)\\n self.waiter = WebDriverWait(self.driver, waiter_timeout)\",\n \"def initialize(url) -> webdriver.Firefox:\\n driver = webdriver.Firefox()\\n driver.get(url)\\n return driver\",\n \"def __init__(self, wdriver, timeout=300):\\n self.wait = ui.WebDriverWait(wdriver, timeout)\\n self.driver = wdriver\",\n \"def __init__(self, timeout=5.0, implicit_wait=0.0,\\n run_on_failure='Capture Page Screenshot',\\n screenshot_root_directory=None):\\n self.timeout = timestr_to_secs(timeout)\\n self.implicit_wait = timestr_to_secs(implicit_wait)\\n self.speed = 0.0\\n self.run_on_failure_keyword \\\\\\n = RunOnFailureKeywords.resolve_keyword(run_on_failure)\\n self._running_on_failure_keyword = False\\n self.screenshot_root_directory = screenshot_root_directory\\n libraries = [\\n GerenciamentoDeBrowser(self),\\n ]\\n self._drivers = WebDriverCache()\\n DynamicCore.__init__(self, libraries)\\n self.ROBOT_LIBRARY_LISTENER = LibraryListener()\\n self._element_finder = ElementFinder(self)\",\n \"def setup_selenium():\\n # Define the options to run with headless mode enabled\\n options = Options()\\n options.headless = True\\n\\n # Instatiate the browser object here, pointing at an exectable location which should be located in the same\\n # base directory as the script\\n driver = webdriver.Firefox(options=options, executable_path='./geckodriver')\\n\\n # Impicit wait tell the browser to wait up to 30s for an object to appear, this helps if the connection is slow.\\n driver.implicitly_wait(30)\\n return driver\",\n \"def init_driver():\\n driver = webdriver.Firefox()\\n driver.wait = WebDriverWait(driver,5)\\n return driver\",\n \"def initial_setup(server):\\r\\n world.absorb(settings.LETTUCE_SELENIUM_CLIENT, 'LETTUCE_SELENIUM_CLIENT')\\r\\n\\r\\n if world.LETTUCE_SELENIUM_CLIENT == 'local':\\r\\n browser_driver = getattr(settings, 'LETTUCE_BROWSER', 'chrome')\\r\\n\\r\\n # There is an issue with ChromeDriver2 r195627 on Ubuntu\\r\\n # in which we sometimes get an invalid browser session.\\r\\n # This is a work-around to ensure that we get a valid session.\\r\\n success = False\\r\\n num_attempts = 0\\r\\n while (not success) and num_attempts < MAX_VALID_BROWSER_ATTEMPTS:\\r\\n\\r\\n # Load the browser and try to visit the main page\\r\\n # If the browser couldn't be reached or\\r\\n # the browser session is invalid, this will\\r\\n # raise a WebDriverException\\r\\n try:\\r\\n world.browser = Browser(browser_driver)\\r\\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\\r\\n world.visit('/')\\r\\n\\r\\n except WebDriverException:\\r\\n if hasattr(world, 'browser'):\\r\\n world.browser.quit()\\r\\n num_attempts += 1\\r\\n\\r\\n else:\\r\\n success = True\\r\\n\\r\\n # If we were unable to get a valid session within the limit of attempts,\\r\\n # then we cannot run the tests.\\r\\n if not success:\\r\\n raise IOError(\\\"Could not acquire valid {driver} browser session.\\\".format(driver=browser_driver))\\r\\n\\r\\n world.absorb(0, 'IMPLICIT_WAIT')\\r\\n world.browser.driver.set_window_size(1280, 1024)\\r\\n\\r\\n elif world.LETTUCE_SELENIUM_CLIENT == 'saucelabs':\\r\\n config = get_saucelabs_username_and_key()\\r\\n world.browser = Browser(\\r\\n 'remote',\\r\\n url=\\\"http://{}:{}@ondemand.saucelabs.com:80/wd/hub\\\".format(config['username'], config['access-key']),\\r\\n **make_saucelabs_desired_capabilities()\\r\\n )\\r\\n world.absorb(30, 'IMPLICIT_WAIT')\\r\\n world.browser.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\\r\\n\\r\\n elif world.LETTUCE_SELENIUM_CLIENT == 'grid':\\r\\n world.browser = Browser(\\r\\n 'remote',\\r\\n url=settings.SELENIUM_GRID.get('URL'),\\r\\n browser=settings.SELENIUM_GRID.get('BROWSER'),\\r\\n )\\r\\n world.absorb(30, 'IMPLICIT_WAIT')\\r\\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\\r\\n\\r\\n else:\\r\\n raise Exception(\\\"Unknown selenium client '{}'\\\".format(world.LETTUCE_SELENIUM_CLIENT))\\r\\n\\r\\n world.browser.driver.implicitly_wait(world.IMPLICIT_WAIT)\\r\\n world.absorb(world.browser.driver.session_id, 'jobid')\",\n \"def set_selenium_driver_timeouts(driver: WebDriver) -> None:\\n driver.set_script_timeout(90)\\n driver.set_page_load_timeout(60)\",\n \"def __init__(self,\\n geckodriver_path = None,\\n headless_browser = False,\\n disable_image_load = False,\\n page_delay = 10,\\n logfolder = 'logs/',\\n user_agent = None,\\n proxy_address = None,\\n proxy_port = None,\\n proxy_username = None,\\n proxy_password = None,\\n limit_scropes = None,\\n exclude_hosts = None,\\n browser_profile_path = None,\\n browser_executable_path = None,\\n geckodriver_log_level = 'info'\\n ):\\n firefox_options = Firefox_Options()\\n seleniumwire_options = {}\\n\\n if headless_browser:\\n firefox_options.add_argument(\\\"-headless\\\")\\n\\n if browser_profile_path is not None:\\n firefox_profile = webdriver.FirefoxProfile(browser_profile_path)\\n else:\\n firefox_profile = webdriver.FirefoxProfile()\\n\\n if browser_executable_path is not None:\\n firefox_options.binary = browser_executable_path\\n\\n\\n # set \\\"info\\\" by default\\n # set \\\"trace\\\" for debubging, Development only\\n firefox_options.log.level = geckodriver_log_level\\n\\n # set English language\\n firefox_profile.set_preference(\\\"intl.accept_languages\\\", \\\"en-US\\\")\\n\\n # set User-Agent\\n if user_agent is not None:\\n firefox_profile.set_preference(\\\"general.useragent.override\\\", user_agent)\\n\\n if disable_image_load:\\n # permissions.default.image = 2: Disable images load,\\n # this setting can improve pageload & save bandwidth\\n firefox_profile.set_preference(\\\"permissions.default.image\\\", 2)\\n \\n # mute audio while watching stories\\n firefox_profile.set_preference(\\\"media.volume_scale\\\", \\\"0.0\\\")\\n\\n # prevent Hide Selenium Extension: error\\n firefox_profile.set_preference(\\\"dom.webdriver.enabled\\\", False)\\n firefox_profile.set_preference(\\\"useAutomationExtension\\\", False)\\n firefox_profile.set_preference(\\\"general.platform.override\\\", \\\"iPhone\\\")\\n firefox_profile.update_preferences()\\n\\n # geckodriver log in specific user logfolder\\n geckodriver_log = \\\"{}geckodriver.log\\\".format(logfolder)\\n check_and_create_file(geckodriver_log)\\n\\n\\n # The list exclude hosts for capturing\\n if exclude_hosts:\\n seleniumwire_options['exclude_hosts'] = exclude_hosts\\n\\n # Add proxy with username and password authentication\\n if proxy_address and proxy_port:\\n if proxy_username and proxy_password:\\n seleniumwire_options['proxy'] = {\\n 'http': f'http://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\\n 'https': f'https://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\\n 'no_proxy': 'localhost,127.0.0.1'\\n }\\n else:\\n seleniumwire_options['proxy'] = {\\n 'http': f'http://{proxy_address}:{proxy_port}',\\n 'https': f'https://{proxy_address}:{proxy_port}',\\n 'no_proxy': 'localhost,127.0.0.1'\\n }\\n\\n\\n\\n self.driver = webdriver.Firefox(\\n firefox_profile=firefox_profile,\\n executable_path=geckodriver_path,\\n log_path=geckodriver_log,\\n options=firefox_options,\\n seleniumwire_options=seleniumwire_options\\n )\\n # Limit capture urls with regulater expression\\n if limit_scropes:\\n self.driver.scopes = limit_scropes\\n\\n # Set implicitly wait\\n self.driver.implicitly_wait(page_delay)\\n\\n # Set maximum windows\\n self.driver.maximize_window()\",\n \"def build_driver(options: Options = None, headless=True, timeout=20) -> webdriver:\\n\\n if options is not None:\\n driver = webdriver.Chrome(options=options)\\n else:\\n default_options = get_default_driver_options()\\n default_options.headless = headless\\n driver = webdriver.Chrome(options=default_options)\\n\\n driver.set_page_load_timeout(timeout)\\n return driver\",\n \"def setUp(self):\\r\\n self.verificationErrors = []\\r\\n self.selenium = (selenium(selvars.set_localhost(), selvars.set_port(), selvars.set_browser(self.id(),self.shortDescription()), selvars.set_site()))\\r\\n self.selenium.start()\\r\\n self.session = self.selenium.sessionId\\r\\n self.selenium.set_timeout(testvars.timeout)\",\n \"def __init__(self, base_url=\\\"\\\",\\n driver=None,\\n driver_kwargs=None,\\n enable_highlighting=False,\\n enable_screen_shot_highlight=False,\\n implicit_wait=0,\\n think_time=0,\\n download_folder='',\\n screen_shots_folder='',\\n highlighting_color='',\\n highlighting_size=0,\\n highlighting_time=0,\\n remote_ip=None,\\n remote_port=None,\\n desired_capability=None,\\n headless=None,\\n display_width=None,\\n display_height=None\\n ):\\n\\n if isinstance(driver, str):\\n driver = get_driver_from_name(driver)\\n\\n if driver is None:\\n driver = get_driver_from_name(settings.DEFAULT_DRIVER_EXECUTABLE)\\n\\n self.web_driver = driver\\n self._driver_kwargs = driver_kwargs or {}\\n self.driver = None # type: WebDriver\\n\\n self.url = base_url if base_url.startswith('http') else (\\\"http://\\\" + base_url) if base_url else ''\\n self.accept_next_alert = True\\n\\n self.download_folder = download_folder or settings.DOWNLOAD_FOLDER\\n self.implicit_wait = implicit_wait or settings.IMPLICIT_WAIT\\n screen_shots_folder = screen_shots_folder or os.path.join(self.download_folder, settings.SCREEN_SHOTS_FOLDER)\\n self.screen_shot_folder = os.path.realpath(screen_shots_folder)\\n self.think_time = think_time\\n\\n self._is_driver_open = False\\n self._default_find_element_method = self._default_find_elements_method = None\\n\\n self._enable_highlighted_find_elements = enable_highlighting or settings.ENABLE_HIGHTLIGHTING\\n self._screen_shot_highlights = enable_screen_shot_highlight or settings.ENABLE_SCREENSHOT_HIGHTLIGHTING\\n self._highlighting_color = highlighting_color or settings.HIGHLIGHTING_COLOR\\n self._highlighting_size = highlighting_size or settings.HIGHLIGHTING_SIZE\\n self._highlighting_time = highlighting_time or settings.HIGHLIGHTING_TIME\\n\\n\\n # headless vars\\n self._headless = headless or settings.HEADLESS\\n self._display_height = display_height\\n self._display_width = display_width\\n\\n self._create_download_shots_folders()\\n\\n self._remote_ip = remote_ip\\n self._remote_port = remote_port or settings.REMOTE_PORT\\n self._desired_capability = desired_capability\\n\\n self._jquery_available = self._jquery_checked = False\",\n \"def setUpClass(cls) -> None:\\n desired_caps: dict[str, Any] = {}\\n desired_caps[\\\"app\\\"] = \\\"plasmawindowed -p org.kde.plasma.nano org.kde.plasma.systemtray\\\"\\n desired_caps[\\\"timeouts\\\"] = {'implicit': 10000}\\n cls.driver = webdriver.Remote(command_executor='http://127.0.0.1:4723', desired_capabilities=desired_caps)\\n cls.driver.implicitly_wait = 10\",\n \"def __init__(self, driver):\\n self.driver = driver\\n self.driver.implicitly_wait(self.IMPLICIT_WAIT_TIME)\\n self.timeout = self.TIMEOUT\\n self.screenshot()\",\n \"def selenium(self):\\n return self.builtin.get_library_instance(\\\"SeleniumLibrary\\\")\",\n \"def setup_selenium():\\n options = webdriver.FirefoxOptions()\\n options.add_argument('--ignore-certificate-errors')\\n options.add_argument('--incognito')\\n options.add_argument('--headless')\\n\\n return webdriver.Firefox(\\n # UNCOMMENT WHEN IN LINUX executable_path=\\\"drivers/geckodriver-linux\\\",\\n executable_path=\\\"drivers/geckodriver-macos\\\",\\n firefox_options=options\\n )\",\n \"def httpGetSelenium(url, delaySecs, mustGet=False):\\n global display\\n global browser\\n logging.info('Downloading %s using Selenium/Firefox' % url)\\n host = urlparse.urlsplit(url)[1]\\n delaySecs = getDelaySecs(host, delaySecs)\\n wait(delaySecs, host)\\n if not seleniumLoaded:\\n raise pubGetError('Cannot get page, selenium is not installed on this machine', 'noSelenium')\\n page = {}\\n if not display:\\n logging.info('Starting pseudo-display')\\n display = Display(visible=0, size=(1024, 768))\\n display.start()\\n proxy = None\\n if pubConf.httpProxy:\\n proxy = Proxy({'proxyType': ProxyType.MANUAL,\\n 'httpProxy': pubConf.httpProxy,\\n 'ftpProxy': pubConf.httpProxy,\\n 'sslProxy': pubConf.httpProxy})\\n if not browser:\\n logging.info('Starting firefox on pseudo-display')\\n browser = webdriver.Firefox(proxy=proxy)\\n count = 0\\n while count < 5:\\n try:\\n browser.get(url)\\n break\\n except (requests.Timeout, timeout):\\n logging.warn('timeout from selenium')\\n count += 1\\n except httplib.CannotSendRequest:\\n logging.warn(\\\"selenium's firefox died, restarting\\\")\\n count += 1\\n browser = webdriver.Firefox(proxy=proxy)\\n\\n if count >= 5:\\n logging.warn('too many timeouts/errors from selenium')\\n if mustGet:\\n raise pubGetError('too many timeouts', 'httpTimeout')\\n return\\n else:\\n page['seleniumDriver'] = browser\\n page['url'] = browser.current_url\\n page['data'] = browser.page_source\\n page['mimeType'] = 'unknown'\\n if type(page['data']) == str:\\n page['data'] = page['data'].encode('utf8')\\n return page\",\n \"def create_webdriver_with_retry(self, *args, **kwargs):\\n # Get selenium without referencing selenium.driver which doesn't exist yet\\n selenium = self.builtin.get_library_instance(\\\"SeleniumLibrary\\\")\\n for _ in range(12):\\n try:\\n return selenium.create_webdriver(*args, **kwargs)\\n except ProtocolError:\\n # Give browser some more time to start up\\n time.sleep(5)\\n raise Exception(\\\"Could not connect to remote webdriver after 1 minute\\\")\",\n \"def get_selenium2libraryExtend_instance():\\n\\n # selenium = BuiltIn().get_library_instance('Selenium2Library')\\n return selenium\",\n \"def start_server_and_driver(path_to_driver, path_to_browser):\\n \\n server = service.Service(path_to_driver)\\n server.start()\\n\\n capabilities = {'chrome.binary': path_to_browser}\\n driver = webdriver.Remote(server.service_url, capabilities)\\n \\n return server, driver\",\n \"def start(self):\\r\\n if platform.system() == \\\"Windows\\\":\\r\\n # Use a local GeckoDriver on Windows\\r\\n ffo = Options()\\r\\n ffo.headless = self.state\\r\\n gecko = \\\"dependencies/geckodriver.exe\\\"\\r\\n full_gecko = os.path.abspath(gecko)\\r\\n self.web_driver = webdriver.Firefox(executable_path=full_gecko, options=ffo)\\r\\n else:\\r\\n # Use a remote server if testing on Travis\\r\\n username = os.environ[\\\"SAUCE_USERNAME\\\"]\\r\\n access_key = os.environ[\\\"SAUCE_ACCESS_KEY\\\"]\\r\\n capabilities = {}\\r\\n capabilities[\\\"tunnel-identifier\\\"] = os.environ[\\\"TRAVIS_JOB_NUMBER\\\"]\\r\\n capabilities['version'] = \\\"45.0\\\"\\r\\n capabilities['browserName'] = \\\"firefox\\\"\\r\\n hub_url = \\\"%s:%s@localhost:4445\\\" % (username, access_key)\\r\\n self.web_driver = webdriver.Remote(\\r\\n desired_capabilities=capabilities,\\r\\n command_executor=\\\"http://%s/wd/hub\\\" % hub_url)\",\n \"def browser(config, config_url, config_browser, config_wait_time):\\n try:\\n kwargs = {}\\n if 'binary' in config:\\n binary = config['binary']\\n if config['selenium_grid']:\\n caps = {'browserName': config_browser}\\n command_executor_url = \\\"http://{}:4444/wd/hub\\\".format(config['hub_host'])\\n driver = webdriver.Remote(\\n command_executor=command_executor_url,\\n desired_capabilities=caps\\n )\\n else:\\n if config_browser == 'chrome':\\n if binary:\\n kwargs.update({'executable_path': binary})\\n options = webdriver.ChromeOptions()\\n options.add_argument('disable-web-security')\\n options.add_argument(\\\"--no-sandbox\\\")\\n options.add_argument(\\\"--disable-dev-shm-usage\\\")\\n kwargs.update({'options': options})\\n driver = webdriver.Chrome(**kwargs)\\n elif config_browser == 'firefox':\\n driver = webdriver.Firefox(**kwargs)\\n else:\\n raise Exception('\\\"{config_browser}\\\" is not a supported browser')\\n\\n # Wait implicitly for elements to be ready before attempting interactions\\n driver.implicitly_wait(config_wait_time)\\n driver.get(config_url)\\n driver.maximize_window()\\n\\n # Return the driver object at the end of setup\\n yield driver\\n finally:\\n # For cleanup, quit the driver\\n driver.quit()\",\n \"def browser_chrome(context, timeout=30, **kwargs):\\n if settings.BROWSER == 'remote':\\n browser = splinter.Browser(\\n driver_name='remote',\\n browser='chrome',\\n url=settings.SELENIUM_URL,\\n )\\n else:\\n browser = splinter.Browser(\\n driver_name=settings.BROWSER,\\n headless=settings.RUN_HEADLESS,\\n )\\n context.browser = browser\\n context.add_cleanup(browser.quit)\\n return browser\",\n \"def startBrowser(self):\\n if 'TRAVIS' in os.environ:\\n # Initialize hidden display for Firefox.\\n # Less annoying and allows remote execution.\\n display = Display(visible=0, size=(800, 600))\\n display.start()\\n\\n self.browser = webdriver.Firefox()\\n self.browser.implicitly_wait(3)\",\n \"def getWebDriverInstance(self):\\n #baseURL = \\\"https://qa-test.avenuecode.com/\\\"\\n if self.device == \\\"ios_mobile\\\":\\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\\n self.driver.implicitly_wait(10)\\n #return driver\\n #driver.get(baseURL)\\n\\n else:\\n print(\\\"Hello\\\")\\n # Setting Driver Implicit Time out for An Element\\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\\n self.driver.implicitly_wait(10)\\n return self.driver\\n # Maximize the window\\n #driver.maximize_window()\\n # Loading browser with App URL\\n #driver.get(baseURL)\\n #return driver\",\n \"def start_browser_with(self, browser: 'Browserify', url: 'Url') -> 'StartableClient':\",\n \"async def _launch_remote_browser(self, server_ip,\\r\\n launch_options: Dict[str, Any] = None) -> Browser:\\r\\n logger.info(\\r\\n f\\\"Launching remote browser on {server_ip}:\\\\n{pformat(launch_options)}\\\")\\r\\n endpoint = f\\\"http://{server_ip}/new_browser\\\"\\r\\n resp = requests.get(endpoint, json=launch_options)\\r\\n if resp.status_code != 200:\\r\\n logger.error(\\r\\n f\\\"Could not add browser ({resp.status_code}): {endpoint}\\\")\\r\\n return\\r\\n logger.info(\\r\\n f\\\"[{resp.status_code}] Added Browser on {server_ip}\\\")\\r\\n # construct DevTools endpoint.\\r\\n dev_tools_endpoint = resp.json()['dev_tools'].replace(\\r\\n '127.0.0.1', server_ip.split(':')[0])\\r\\n logger.info(\\r\\n f\\\"Connecting to {server_ip} browser: {dev_tools_endpoint}\\\")\\r\\n # connect to new browser's DevTools endpoint.\\r\\n browser = await pyppeteer.launcher.connect(browserWSEndpoint=dev_tools_endpoint)\\r\\n logger.info(f\\\"Connected to browser {dev_tools_endpoint}: {browser}\\\")\\r\\n return browser\",\n \"def __init__(self, BrowserType=\\\"Chrome\\\", Remote=False, Headless=False, BrowserWidth=1920,\\n BrowserHeight=1080, SeleniumGridHost=\\\"\\\", SeleniumGridPort=4444, Options=[], DesiredCapabilities={}):\\n self.BrowserType = BrowserType\\n self.Remote = Remote\\n self.Headless = Headless\\n self.BrowserWidth = BrowserWidth\\n self.BrowserHeight = BrowserHeight\\n self.SeleniumGridHost = SeleniumGridHost\\n self.SeleniumGridPort = SeleniumGridPort\\n self.Options = Options\\n self.DesiredCapabilities = DesiredCapabilities\",\n \"def open_website(url):\\n browser = webdriver.Firefox()\\n browser.get(url)\\n return browser\",\n \"def test_webuidriver_remote(self):\\n\\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\\n hub.start_server()\\n\\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\\\"localhost\\\", 4444))\\n node.start_server()\\n executors = SeleniumHatch.get_remote_executors(\\\"localhost\\\", 4444)\\n\\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\\n\\n self.driver.get('http://www.baidu.com')\\n time.sleep(1)\\n\\n # webuidriver.Remote 是 webdriver.Chrome 的子类\\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\\n self.assertIsInstance(self.driver, webdriver.Remote)\\n\\n self.driver.close()\\n self.driver.quit()\\n\\n hub.stop_server()\\n node.stop_server()\",\n \"def __init__(self):\\n driver = webdriver.Firefox() #working with firefox. see above comment and edit it to change the browser\\n\\n self.driver.get(\\\"https://moodle.niituniversity.in\\\")\\n self.tLogin()\",\n \"def seleniumDriver():\\n chrome_options = Options()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--disable-dev-shm-usage')\\n driver = webdriver.Chrome(\\\"/usr/bin/chromedriver\\\",\\n options=chrome_options\\n )\\n driver.set_page_load_timeout(10)\\n return driver\",\n \"def _browser(self):\\n RemoteConnection.set_timeout(CONNECTION_TIMEOUT)\\n\\n profile = webdriver.FirefoxProfile()\\n preferences = self.config.get('preferences', {})\\n for key, value in preferences.items():\\n profile.set_preference(key, value)\\n\\n driver = webdriver.Firefox(profile)\\n # Wait for UI events to complete before failing to find an element.\\n driver.implicitly_wait(IMPLICIT_TIMEOUT)\\n\\n return driver\",\n \"def getdriver(url):\\n options = Options()\\n options.add_argument('-headless')\\n driver = webdriver.Chrome(executable_path='geckodriver',options=options)\\n driver.get(url)\\n wait = WebDriverWait(driver,3)\\n return driver\",\n \"def __init__(self, url_address, type=\\\"Chrome\\\"):\\n from webdriverwrapper import Chrome\\n from selenium import webdriver\\n options = webdriver.ChromeOptions()\\n options.add_experimental_option(\\\"excludeSwitches\\\", [\\\"enable-automation\\\"])\\n options.add_experimental_option('useAutomationExtension', False)\\n self.driver = Chrome(options=options)\\n # Open a website\\n window_before = self.driver.window_handles[0]\\n self.driver.get(url_address)\",\n \"def create_browser_instance():\\n cmd = [browser_sync_path, 'start', '--proxy=localhost:8000']\\n check_output(cmd)\",\n \"def initialize():\\n\\n logging.basicConfig(level=logging.INFO)\\n\\n browser = webdriver.Firefox()\\n browser.get(\\\"http://www.wrappa.org/\\\")\\n browser.find_element_by_name(\\\"termsAccepted\\\").click()\\n browser.find_element_by_name(\\\"termsAccepted\\\").submit()\\n return browser\",\n \"def __init__(self, base_url=None):\\n self.driver = webdriver.Chrome()\\n if base_url:\\n self.base_url = base_url\",\n \"def setUpClass(cls):\\n super().setUpClass()\\n options = Options()\\n options.headless = True\\n cls.selenium = WebDriver(options=options)\\n cls.selenium.implicitly_wait(10)\",\n \"def doOpen(self, targetUrl, timeout=30.0, withFirefox=True, withIe=False, withChrome=False, withOpera=False, withEdge=False, useMarionette=True,\\n browserProfile=None, sessionName=\\\"default\\\" ):\\n TestAdapterLib.check_timeout(caller=TestAdapterLib.caller(), timeout=timeout)\\n \\n ret = True\\n if withFirefox:\\n cap = SELENIUM_FIREFOX\\n cap['marionette'] = useMarionette\\n cap['acceptInsecureCerts'] = True\\n elif withIe:\\n cap = SELENIUM_INTERNETEXPLORER\\n elif withChrome:\\n cap = SELENIUM_CHROME\\n elif withOpera:\\n cap = SELENIUM_OPERA\\n elif withEdge:\\n cap = SELENIUM_EDGE\\n else:\\n cap = SELENIUM_FIREFOX\\n cmdId = self.openNavig( desiredCapabilities=cap, browserProfile=browserProfile, sessionName=sessionName) \\n if self.isNavigStarted(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n else:\\n if not( targetUrl.startswith(\\\"http://\\\") or targetUrl.startswith(\\\"https://\\\") ):\\n raise TestAdapterLib.ValueException(TestAdapterLib.caller(), \\\"target url not start with http(s):// (%s)\\\" % type(targetUrl) )\\n cmdId = self.loadUrl(url=targetUrl)\\n if self.isUrlLoaded(timeout=timeout, commandId=cmdId) is None:\\n ret = False\\n return ret\",\n \"def __init__(self, driver_path=None):\\n\\n if driver_path is None:\\n self.driver = webdriver.Firefox()\\n else:\\n print(\\\"Alter gecko path\\\")\\n self.driver = webdriver.Firefox(executable_path=driver_path)\",\n \"def start(self):\\n # iPhone\\n #driver = webdriver.Remote(browser_name=\\\"iphone\\\", command_executor='http://172.24.101.36:3001/hub')\\n # Android\\n #driver = webdriver.Remote(browser_name=\\\"android\\\", command_executor='http://127.0.0.1:8080/hub')\\n # Google Chrome \\n #driver = webdriver.Chrome()\\n # Firefox \\n #FirefoxProfile fp = new FirefoxProfile();\\n #fp.setPreference(\\\"webdriver.load.strategy\\\", \\\"unstable\\\");\\n #WebDriver driver = new FirefoxDriver(fp);\\n \\n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\\n driver = webdriver.Firefox()\\n \\n self.driver = driver\",\n \"def start(self):\\n # iPhone\\n #driver = webdriver.Remote(browser_name=\\\"iphone\\\", command_executor='http://172.24.101.36:3001/hub')\\n # Android\\n #driver = webdriver.Remote(browser_name=\\\"android\\\", command_executor='http://127.0.0.1:8080/hub')\\n # Google Chrome \\n #driver = webdriver.Chrome()\\n # Firefox \\n #FirefoxProfile fp = new FirefoxProfile();\\n #fp.setPreference(\\\"webdriver.load.strategy\\\", \\\"unstable\\\");\\n #WebDriver driver = new FirefoxDriver(fp);\\n \\n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\\n driver = webdriver.Firefox()\\n \\n self.driver = driver\",\n \"def create_a_book(article_urls, book_title, book_subtitle=\\\"\\\", book_fmt=\\\"epub\\\", \\\\\\n webdriverType=WebDrivers.Firefox):\\n if len(article_urls) == 0:\\n logging.error('create_a_book: article_urls is empty, nothing to do')\\n return\\n article_url = article_urls.pop(0)\\n driver = None\\n if webdriverType == WebDrivers.Firefox:\\n driver = webdriver.Firefox()\\n elif webdriverType == WebDrivers.RemoteChrome:\\n driver = webdriver.Remote(\\n command_executor='http://localhost:9515',\\n desired_capabilities=DesiredCapabilities.CHROME)\\n\\n article_url, wiki = get_wiki_url(driver, article_url)\\n\\n #h3 = driver.find_element_by_id(\\\"p-coll-print_export-label\\\")\\n #a = h3.find_element_by_tag_name(\\\"a\\\") \\n #a.click() # cliquer \\\"Imprimer / exporter\\\"\\n #driver.implicitly_wait(1)\\n while True:\\n try:\\n div = driver.find_element_by_id(\\\"p-coll-print_export\\\")\\n li = div.find_element_by_id(\\\"coll-create_a_book\\\")\\n a = li.find_element_by_tag_name(\\\"a\\\")\\n a.click() # cliquer \\\"Créer un livre\\\"\\n break\\n except:\\n logging.debug('Caught {0} Retrying... '.format(sys.exc_info()[0]))\\n driver.implicitly_wait(1)\\n\\n driver.implicitly_wait(3)\\n div = driver.find_element_by_class_name(\\\"ok\\\")\\n a = div.find_element_by_tag_name(\\\"a\\\")\\n a.click() # cliquer \\\"Démarrer le créateur de livres\\\"\\n\\n a = driver.find_element_by_id(\\\"coll-add_article\\\")\\n a.click() # cliquer \\\"Ajouter cette page à votre livre\\\"\\n \\n # Add the rest of the articles to the book\\n while len(article_urls):\\n article_url = article_urls.pop(0)\\n article_url, wiki = get_wiki_url(driver, article_url)\\n a = driver.find_element_by_id(\\\"coll-add_article\\\")\\n a.click() # cliquer \\\"Ajouter cette page à votre livre\\\"\\n\\n # click \\\"Show book (1 page)\\\" (seems to work for any lang wikipedia)\\n driver.get(\\\"http://\\\" + wiki + \\\"/wiki/Special:Book\\\")\\n\\n title_txt = driver.find_element_by_id(\\\"titleInput\\\") # \\\"Titre\\\"\\n title_txt.send_keys(book_title)\\n subtitle_txt = driver.find_element_by_id(\\\"subtitleInput\\\") # \\\"Sous-titre\\\"\\n subtitle_txt.send_keys(book_subtitle)\\n select = Select(driver.find_element_by_id(\\\"formatSelect\\\")) # \\\"Format\\\"\\n option_value = book_fmt\\n if book_fmt == 'pdf':\\n option_value = 'rl'\\n select.select_by_value(option_value)\\n btn = driver.find_element_by_id(\\\"downloadButton\\\") # \\\"Télécharger\\n btn.click()\\n\\n url = ''\\n while True:\\n try:\\n div = driver.find_element_by_id(\\\"mw-content-text\\\")\\n a = div.find_element_by_tag_name(\\\"a\\\") # \\\"Télécharger le fichier\\\"\\n url = a.get_attribute(\\\"href\\\")\\n if url.find(\\\"bookcmd=download\\\") != -1:\\n logging.debug(\\\"found bookcmd=download\\\")\\n logging.debug(\\\"url: {0}\\\".format(url)) \\n #a.click() #Télécharger\\n break\\n except:\\n logging.debug('Caught {0} Retrying... '.format(sys.exc_info()[0]))\\n driver.implicitly_wait(1)\\n filename = ''\\n try:\\n req = urllib2.Request(url=url)\\n resp = urllib2.urlopen(req)\\n _, params = cgi.parse_header(resp.headers.get('Content-Disposition', ''))\\n filename = params['filename']\\n logging.debug('Content-Disposition filename: {0}'.format(filename))\\n with open(filename, 'wb') as f:\\n f.write(resp.read())\\n except:\\n logging.error('Error: {0}'.format(sys.exc_info()[0]))\\n driver.close()\\n return filename\",\n \"def connect_firefox_driver(headless):\\n #initialise chrome options\\n options = FirefoxOptions()\\n #set headless option on driver\\n options.headless = headless\\n #initialise driver\\n driver = webdriver.Firefox(executable_path=GeckoDriverManager().install(), options=options)\\n return driver\",\n \"def build_browser(searchurl):\\n options = webdriver.ChromeOptions()\\n options.add_argument('--no-sandbox')\\n try:\\n browser = webdriver.Chrome(ChromeDriverManager().install())\\n except Exception as e:\\n print(f'No found chromedriver in this environment.')\\n print(f'Install on your machine. exception: {e}')\\n sys.exit()\\n\\n browser.set_window_size(1280, 1024)\\n browser.get(searchurl)\\n time.sleep(1)\\n\\n print(f'Getting you a lot of images. This may take a few moments...')\\n body = browser.find_element_by_tag_name('body')\\n return body, browser\",\n \"def connect(self) -> None:\\n self.driver.get(self.base_url)\",\n \"def open_browser():\\n def _open_browser():\\n webbrowser.open('http://localhost:%s/%s' % (PORT, FILE))\\n pass\\n thread = threading.Timer(0.5, _open_browser)\\n thread.start()\",\n \"def open_browser():\\n def _open_browser():\\n if AIPS_WEBSERVER_HOST == \\\"localhost\\\":\\n webbrowser.open(WEBSERVER_URL + '/%s' % FILE)\\n thread = threading.Timer(0.5, _open_browser)\\n thread.start()\",\n \"def connect():\\n\\n driver = webdriver.Chrome(driver_exe) # Run the simulated chrome driver\\n driver.get(url) # go to the whatsapp web page\\n driver.implicitly_wait(10) # wait a little to make sure the page loads\\n return driver\",\n \"def get_around_welcome_screen(driver = None, timeout = None):\\n\\tdriver.implicitly_wait(0) #reset implicity wait. It is not need in here as there is only explicit wait.\\n\\tspinnerWait=30\\n\\t#timeoutValue = timeout if timeout != None else 1\\n\\ttimeoutValue=1\\n\\ttimeoutPopUp = 1\\n\\tif driver == None:\\n\\t\\tprint \\\"ERROR in get_around_welcome_screen(): Please sent webdriver as argument. Timeout value is optional.\\\"\\n\\telse:\\n\\t\\t#-------------------------\\n\\t\\t#verify if link page was loaded\\n\\t\\ttry:\\n\\t\\t\\tWebDriverWait(driver, spinnerWait).until(EC.invisibility_of_element_located((By.ID,\\\"loading\\\")))\\n\\t\\texcept TimeoutException:\\n\\t\\t\\tprint \\\"FATAL:\\\\tPage did not load at all.\\\"\\n\\t\\t\\tsys.exit(\\\"taking too long to load page\\\")\\n\\t\\t#-------------------------\\n\\t\\tfor x in range(0,3):\\n\\t\\t\\t#get around the welcome screen\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tprint \\\"INFO:\\\\tTrying to close Welcome popup\\\"\\n\\t\\t\\t\\twelcomePopupClose = WebDriverWait(driver,timeoutPopUp).until(EC.element_to_be_clickable((By.ID,\\\"welcomePopupCloseButton\\\")))\\n\\t\\t\\t\\twelcomePopupClose.click()\\n\\t\\t\\t\\t#driver.implicitly_wait(8)\\n\\t\\t\\t\\treturn None #abort function as pop is already closed.\\n\\t\\t\\texcept TimeoutException:\\n\\t\\t\\t\\tpass\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tprint \\\"INFO:\\\\tTrying to close New feature popup\\\"\\n\\t\\t\\t\\tnewFeatPopupClose = WebDriverWait(driver,timeoutPopUp).until(EC.element_to_be_clickable((By.ID,\\\"newFeaturePopupCloseButton\\\")))\\n\\t\\t\\t\\tnewFeatPopupClose.click()\\n\\t\\t\\t\\t#driver.implicitly_wait(8)\\n\\t\\t\\t\\treturn None #abort function as pop is already closed.\\n\\t\\t\\texcept TimeoutException:\\n\\t\\t\\t\\tpass\\n\\t\\t\\ttry:\\n\\t\\t\\t\\tprint \\\"INFO:\\\\tTrying to close startJostlingNow\\\"\\n\\t\\t\\t\\tstartJostlingPopupClose = WebDriverWait(driver,timeoutPopUp).until(EC.element_to_be_clickable((By.ID,\\\"QA:startJostlingNow\\\")))\\n\\t\\t\\t\\tstartJostlingPopupClose.click()\\n\\t\\t\\t\\t#driver.implicitly_wait(5)\\n\\t\\t\\t\\treturn None #abort function as pop is already closed.\\n\\t\\t\\texcept TimeoutException:\\n\\t\\t\\t\\tpass\\n\\treturn None\",\n \"def setUp(self):\\n self.driver = webdriver.PhantomJS()\\n self.driver.get(self.get_server_url())\",\n \"def setup_phantomjs():\\n try:\\n # Setup capabilities for the PhantomJS browser\\n phantomjs_capabilities = DesiredCapabilities.PHANTOMJS\\n # Some basic creds to use against an HTTP Basic Auth prompt\\n phantomjs_capabilities['phantomjs.page.settings.userName'] = 'none'\\n phantomjs_capabilities['phantomjs.page.settings.password'] = 'none'\\n # Flags to ignore SSL problems and get screenshots\\n service_args = []\\n service_args.append('--ignore-ssl-errors=true')\\n service_args.append('--web-security=no')\\n service_args.append('--ssl-protocol=any')\\n # Create the PhantomJS browser and set the window size\\n browser = webdriver.PhantomJS(desired_capabilities=phantomjs_capabilities,service_args=service_args)\\n browser.set_window_size(1920,1080)\\n except Exception as error:\\n click.secho(\\\"[!] Bad news: PhantomJS failed to load (not installed?), so activities \\\\\\nrequiring a web browser will be skipped.\\\",fg=\\\"red\\\")\\n click.secho(\\\"L.. Details: {}\\\".format(error),fg=\\\"red\\\")\\n browser = None\\n return browser\",\n \"def connect(executable_path=CHROMEDRIVER_PATH) -> webdriver.Chrome:\\n return webdriver.Chrome(executable_path=executable_path)\",\n \"def _get_selenium_browser(navigator, fLOG=noLOG):\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n from selenium import webdriver\\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\\n\\n fLOG(\\\"[webshot] navigator=\\\", navigator)\\n if navigator == \\\"firefox\\\":\\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\\n firefox_capabilities['marionette'] = True\\n firefox_capabilities[\\n 'binary'] = r\\\"C:\\\\Program Files (x86)\\\\Mozilla Firefox\\\\firefox.exe\\\"\\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\\n elif navigator == \\\"chrome\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n install_chromedriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install 'chromedriver.exe'\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'chromedriver'\\n\\n start_navi = True\\n if start_navi:\\n fLOG(\\\"[_get_selenium_browser] start\\\", navigator)\\n chrome_options = webdriver.ChromeOptions()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--verbose')\\n browser = webdriver.Chrome(executable_path=chromed,\\n chrome_options=chrome_options)\\n else:\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n import selenium.webdriver.chrome.service as wservice\\n fLOG(\\\"[_get_selenium_browser] create service\\\")\\n service = wservice.Service(chromed)\\n fLOG(\\\"[_get_selenium_browser] start service\\\")\\n service.start()\\n fLOG(\\\"[_get_selenium_browser] declare remote\\\")\\n capabilities = {'chrome.binary': chromed}\\n browser = webdriver.Remote(service.service_url, capabilities)\\n elif navigator == \\\"ie\\\":\\n browser = webdriver.Ie()\\n elif navigator == \\\"opera\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n install_operadriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install operadriver.exe\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'operadriver'\\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\\n elif navigator == \\\"edge\\\":\\n browser = webdriver.Edge()\\n else:\\n raise RuntimeError(\\n f\\\"unable to interpret the navigator '{navigator}'\\\")\\n fLOG(\\\"[_get_selenium_browser] navigator is started\\\")\\n return browser\",\n \"def __init__(self,\\n http_proxy=\\\"\\\",\\n tries=2,\\n wait_seconds=3,\\n user_agent=\\\"Firefox/%s\\\" % __version__,\\n timeout=30,\\n ):\\n assert tries >= 1\\n assert wait_seconds >= 0\\n assert timeout >= 0\\n self.http_proxy = http_proxy\\n self.tries = tries\\n self.wait_seconds = wait_seconds\\n self.user_agent = user_agent\\n self.timeout = timeout\\n socket.setdefaulttimeout(self.timeout)\",\n \"def __init__(self, browser='firefox'):\\n if browser == 'firefox' or browser == 'ff':\\n driver = webdriver.Firefox()\\n elif browser == 'chrome':\\n driver = webdriver.Chrome('util/chromedriver')\\n elif browser == 'safari':\\n driver = webdriver.Safari()\\n try:\\n self.driver = driver\\n except Exception:\\n raise NameError(\\\"Not found %s browser, you should enter 'firefox','ff','chrome','safari'.\\\" % browser)\",\n \"def start_selenium_server(self, *params):\\n params = ('-port', str(self._server_port)) + params\\n logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')\\n self._selenium_log = open(logpath, 'w')\\n start_selenium_server(self._selenium_log, self._jar_path, *params)\\n self._html('Selenium server log is written to <a href=\\\"file://%s\\\">%s</a>.'\\n % (logpath.replace('\\\\\\\\', '/'), logpath))\",\n \"def open_firefox():\\r\\n driver = install_firefox_proxy(LOCALHOST, PROXY_PORT_NUMBER)\\r\\n driver.get(STARTING_WEBSITE)\",\n \"def _get_browser(self, webpage):\\n options = self._build_options()\\n\\n chrome_path = 'C:/Users/jorda/.wdm/drivers/chromedriver/81/win32/chromedriver.exe'\\n browser = webdriver.Chrome(executable_path = chrome_path, options=options)\\n\\n# browser = webdriver.Chrome(ChromeDriverManager().install(), options=options)\\n browser.get(webpage)\\n wait = WebDriverWait(browser, 20) # maximum wait time is 20 seconds \\n return browser, wait\",\n \"def driver(request):\\n browser = request.config.getoption(\\\"--browser\\\")\\n wait = request.config.getoption(\\\"--wait\\\")\\n if browser == 'firefox':\\n capabilities = webdriver.DesiredCapabilities.FIREFOX.copy()\\n capabilities['timeouts'] = {'implicit': wait, 'pageLoad': 30000, 'script': 1000}\\n capabilities['loggingPrefs'] = {'browser': 'ALL', 'client': 'ALL', 'driver': 'ALL',\\n 'performance': 'ALL', 'server': 'ALL'}\\n profile = webdriver.FirefoxProfile()\\n profile.set_preference('app.update.auto', False)\\n profile.set_preference('app.update.enabled', False)\\n profile.accept_untrusted_certs = True\\n wd = EventFiringWebDriver(webdriver.Firefox(firefox_profile=profile, capabilities=capabilities), TestListener())\\n wd.maximize_window()\\n elif browser == 'chrome':\\n chrome_options = webdriver.ChromeOptions()\\n capabilities = webdriver.DesiredCapabilities.CHROME.copy()\\n capabilities['acceptSslCerts'] = True\\n capabilities['acceptInsecureCerts'] = True\\n capabilities['loggingPrefs'] = {'performance': 'ALL'}\\n driver = webdriver.Chrome(desired_capabilities=capabilities, options=chrome_options)\\n driver.implicitly_wait(wait)\\n wd = driver\\n else:\\n print('Unsupported browser!')\\n sys.exit(1)\\n yield wd\\n wd.quit()\",\n \"def start_selenium_server(logfile=None, jarpath=None, *params):\\n if not subprocess:\\n raise RuntimeError('This function requires `subprocess` module which '\\n 'is available on Python/Jython 2.5 or newer.')\\n cmd = _server_startup_command(jarpath, *params)\\n try:\\n subprocess.Popen(cmd, stdout=logfile, stderr=subprocess.STDOUT)\\n except OSError:\\n raise RuntimeError('Starting Selenium Server failed. Check that you '\\n 'have Java 1.5 or newer installed by running '\\n '`java -version` on the command prompt.')\\n print 'Selenium Server started with command \\\"%s\\\" ' % ' '.join(cmd)\",\n \"def __init__(self, url, epRange):\\n self.driver = webdriver.PhantomJS()\\n self.downloads = OrderedDict() # sort episodes in asending order\\n self.pbar = \\\"\\\" # Download Progressbar\\n self.Main(url, epRange)\",\n \"def create_local(\\n options: Optional[\\\"ChromeOptions\\\"] = None,\\n timeout: Optional[float] = None,\\n headless: bool = True,\\n user_data_dir: Optional[str] = None,\\n soup_maker: Optional[SoupMaker] = None,\\n **kwargs,\\n) -> WebDriver:\\n _acquire_queue(timeout)\\n is_debug = os.getenv(\\\"debug_mode\\\")\\n\\n if not options:\\n options = ChromeOptions()\\n\\n if not has_display():\\n headless = True\\n\\n # Set default language\\n try:\\n language = locale.getdefaultlocale()[0].replace(\\\"_\\\", \\\"-\\\")\\n except Exception:\\n pass\\n options.add_argument(\\\"--lang=%s\\\" % (language or \\\"en-US\\\"))\\n\\n # Logging configs\\n LOGGER.setLevel(logging.WARN)\\n options.add_argument(f\\\"--log-level={0 if is_debug else 3}\\\")\\n if not is_debug:\\n LOGGER.setLevel(1000)\\n\\n # Suppress bothersome stuffs\\n options.add_argument(\\\"--no-default-browser-check\\\")\\n options.add_argument(\\\"--disable-infobars\\\")\\n options.add_argument(\\\"--no-first-run\\\")\\n # options.add_argument(\\\"--disable-extensions\\\")\\n # options.add_argument(\\\"--disable-gpu\\\")\\n # options.add_argument(\\\"--disable-dev-shm-usage\\\")\\n\\n # Add capabilities\\n #options.set_capability(\\\"quietExceptions\\\", True)\\n options.set_capability(\\\"acceptInsecureCerts\\\", True)\\n #options.set_capability(\\\"useAutomationExtension\\\", False)\\n\\n # Configure window behavior\\n if headless:\\n options.add_argument(\\\"--window-size=1920,1080\\\")\\n options.add_argument(\\\"--start-maximized\\\")\\n options.add_argument(\\\"--no-sandbox\\\")\\n options.add_argument(\\\"--headless=new\\\")\\n else:\\n width = max(640, Screen.view_width * 3 // 4)\\n height = max(480, Screen.view_height * 3 // 4)\\n width = int(os.getenv(\\\"CHROME_WIDTH\\\", width))\\n height = int(os.getenv(\\\"CHROME_HEIGHT\\\", height))\\n options.add_argument(f\\\"--window-size={width},{height}\\\")\\n\\n # Chrome specific experimental options\\n options.accept_insecure_certs = True\\n options.unhandled_prompt_behavior = \\\"dismiss\\\"\\n options.strict_file_interactability = False\\n # options.add_experimental_option(\\\"excludeSwitches\\\", [\\\"enable-automation\\\"])\\n # if not is_debug:\\n # options.add_experimental_option(\\\"excludeSwitches\\\", [\\\"enable-logging\\\"])\\n\\n # # Set remote debuging host and port\\n # debug_host = \\\"127.0.0.1\\\"\\n # debug_port = free_port(debug_host)\\n # options.add_argument(f\\\"--remote-debugging-host={debug_host}\\\")\\n # options.add_argument(f\\\"--remote-debugging-port={debug_port}\\\")\\n # options.debugger_address = f\\\"{debug_host}:{debug_port}\\\"\\n\\n executable_path = _acquire_chrome_driver_path()\\n logger.debug(\\n \\\"Creating chrome instance | \\\"\\n + f\\\"headless={headless} | \\\"\\n + f\\\"driver_path={executable_path}\\\"\\n )\\n chrome = Chrome(\\n driver_executable_path=executable_path,\\n options=options,\\n desired_capabilities=options.to_capabilities(),\\n keep_alive=True,\\n user_data_dir=user_data_dir,\\n headless=headless,\\n )\\n logger.info(\\\"Created chrome instance > %s\\\", chrome.session_id)\\n chrome.set_window_position(0, 0)\\n\\n if not soup_maker:\\n soup_maker = SoupMaker()\\n chrome._soup_maker = soup_maker\\n chrome._web_element_cls = WebElement\\n\\n # _add_virtual_authenticator(chrome)\\n # _override_get(chrome)\\n\\n _release_queue(chrome)\\n return chrome\",\n \"def setUpClass(cls):\\n cls.driver = webdriver.Chrome()\\n cls.driver.maximize_window()\\n cls.driver.get('https://letskodeit.teachable.com/p/practice')\",\n \"def initDriver(browser):\\n if browser == \\\"firefox\\\":\\n opts = Options()\\n opts.log.level = \\\"trace\\\"\\n driver = webdriver.Firefox(options=opts)\\n return driver\\n elif browser == \\\"chrome\\\":\\n options = webdriver.ChromeOptions()\\n options.add_argument(\\\"start-maximized\\\")\\n #d = DesiredCapabilities.CHROME\\n d = options.to_capabilities()\\n d['loggingPrefs'] = { 'browser':'ALL'}\\n driver = webdriver.Chrome('../Data/chromedriver_linux64/chromedriver',desired_capabilities=d)\\n return driver\\n else:\\n print(\\\"------- Navegador no compatible ---------\\\")\\n return null\",\n \"def launch_browser2(self, clean_session=False):\\n try:\\n if self._browserName[0:2] == \\\"IE\\\":\\n if clean_session:\\n self._browser = webdriver.Ie(log_level=\\\"TRACE\\\", log_file=\\\"iedriver_stdout.log\\\",\\n capabilities={'ie.ensureCleanSession': True})\\n else:\\n self._browser = webdriver.Ie(log_level=\\\"TRACE\\\", log_file=\\\"iedriver_stdout.log\\\")\\n elif self._browserName == \\\"RemoteIE\\\":\\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\\n desired_capabilities={'browserName': 'internet explorer'})\\n elif self._browserName == \\\"RemoteFF\\\":\\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\\n desired_capabilities={'browserName': 'firefox'})\\n \\n elif self._browserName == \\\"Firefox\\\":\\n fp = webdriver.FirefoxProfile()\\n fp.set_preference('app.update.auto', False)\\n fp.set_preference('app.update.enabled', False)\\n fp.native_events_enabled = False\\n proxy = None\\n if self._configuration.security:\\n self.logger.info(\\\"we use a proxy\\\")\\n fp.accept_untrusted_certs = True\\n proxy = webdriver.Proxy()\\n proxy.http_proxy = \\\"localhost:9080\\\"\\n proxy.ssl_proxy = \\\"localhost:9080\\\"\\n self._browser = webdriver.Firefox(firefox_profile=fp, proxy=proxy)\\n elif self._browserName == \\\"Chrome\\\":\\n # dirty way to launch chromedriver as the current webdriver fail after the xth command\\n import subprocess\\n\\n self._chrome_log_file_stdout = open('chromedriver_stdout.log', 'w')\\n self._chrome_log_file_stderr = open('chromedriver_stderr.log', 'w')\\n subprocess.Popen(\\\"chromedriver\\\", stdout=self._chrome_log_file_stdout,\\n stderr=self._chrome_log_file_stderr)\\n time.sleep(2)\\n self._browser = webdriver.Remote('http://localhost:9515', {\\\"nativeEvents\\\": False,\\n \\\"javascriptEnabled\\\": True})\\n else:\\n raise NotKnown(\\\"Unknown browser : \\\" + self._browserName)\\n self.set_implicit_wait_default()\\n self._browser.maximize_window()\\n self._currentFrame = \\\"main\\\"\\n self.logger.info(\\\"Launching : \\\" + str(self._browserName))\\n except Exception as e:\\n self.logger.error(\\\"Error launching browser : \\\" + str(e))\\n raise\",\n \"def get_driver_with_options():\\n #options = get_driver_options()\\n #return webdriver.Chrome(options=options)\\n return webdriver.Chrome()\",\n \"def driver():\\n driver = webdriver.Chrome(chrome_options=ChromeOptions(), project_name=\\\"Examples\\\", job_name=\\\"Pytest Example\\\")\\n yield driver\\n driver.quit()\",\n \"def test_keep_alive(simple_page, browser, splinter_webdriver):\\n if splinter_webdriver != \\\"remote\\\":\\n pytest.skip(\\\"Only Remote WebDriver uses keep_alive argument\\\")\\n assert browser.driver.command_executor.keep_alive\",\n \"def setUp(self):\\n self.browser = webdriver.Firefox()\\n self.url = 'http://127.0.0.1:8000/'\",\n \"def __init__(self, driver, selector, wait_time=10):\\n\\n logger.debug(\\n \\\"Initialize class: {0} with selector {1}:\\\".format(\\n self.__class__.__name__, selector))\\n self._selector = selector\\n self._driver = driver\\n self._wait = WebDriverWait(self._driver, wait_time)\",\n \"def set_up_driver(self):\\r\\n\\t\\ttry:\\r\\n\\t\\t\\tself.driver = webdriver.Firefox()\\r\\n\\t\\texcept Exception:\\r\\n\\t\\t\\tself.driver = False\",\n \"def __init__(self, selenium_test):\\n self.selenium_test = selenium_test\",\n \"def pytest_addoption(parser):\\n parser.addoption(\\\"--address\\\", action=\\\"store\\\",\\n default=\\\"http://192.168.145.130/\\\", help=\\\"Opencart web address\\\")\\n parser.addoption(\\\"--browser\\\", action=\\\"store\\\", default=\\\"chrome\\\", help=\\\"Browser name\\\")\\n parser.addoption(\\\"--wait\\\", action=\\\"store\\\", default=10, help=\\\"Implicity wait\\\")\",\n \"def __init__(self):\\n self.driver = webdriver.Chrome()\",\n \"def init_driver(self):\\n # Set UserAgent to prevent issues with blocking bot\\n self.chrome_options.add_argument(\\n \\\"user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36\\\")\\n # Set headless\\n if self.headless:\\n self.chrome_options.add_argument('headless')\\n # Initiate driver\\n driver = webdriver.Chrome(\\n self.chromedriver_path + \\\"/chromedriver\\\", options=self.chrome_options)\\n self.driver = driver\\n self.wait = WebDriverWait(self.driver, 20)\\n return self.driver\",\n \"def __init__(self, code, year, season):\\n self.code = code\\n self.year = year\\n self.season = season\\n # 使用headless browser抓取資料\\n self.fireFoxOptions = webdriver.FirefoxOptions()\\n self.fireFoxOptions.headless = True\\n url = 'https://mops.twse.com.tw/server-java/t164sb01?step=1&REPORT_ID=C&CO_ID=' + str(code) \\\\\\n + '&SYEAR=' + str(year) + '&SSEASON=' + str(season)\\n self.driver = webdriver.Firefox(options=self.fireFoxOptions)\\n self.driver.get(url)\",\n \"def test_from_crawler_method_should_initialize_the_driver(self):\\n\\n crawler = Crawler(\\n spidercls=self.spider_klass,\\n settings=self.settings\\n )\\n selenium_middleware = SeleniumMiddleware.from_crawler(crawler)\\n\\n # The driver must be initialized\\n self.assertIsNotNone(selenium_middleware.driver)\\n\\n # We can now use the driver\\n selenium_middleware.driver.get('http://www.python.org')\\n self.assertIn('Python', selenium_middleware.driver.title)\\n\\n selenium_middleware.driver.close()\",\n \"def refresh_browser(timeout=None): \\n if timeout is None:\\n restart_browser()\\n return\\n\\n else:\\n echo_highlight('Checking server status...')\\n for i in range(5):\\n time.sleep(timeout)\\n try:\\n response = get('http://localhost:8000/health_check')\\n except ConnectionError:\\n echo_highlight('Still checking...')\\n else:\\n if response and response.status_code == 200:\\n restart_browser()\\n return\\n\\n echo_warning('Maximum attempts reached! Something might be wrong.')\",\n \"def start_server():\\n if not os.path.exists(cf.get(\\\"Selenium\\\", \\\"server_path\\\")):\\n jar_name = \\\"selenium-server-standalone-2.25.0.jar\\\"\\n server_jar = os.path.join(tempfile.gettempdir(), jar_name)\\n if not os.path.exists(server_jar):\\n r = requests.get(\\\"http://selenium.googlecode.com/files/%s\\\" % jar_name)\\n jar_on_disk = open(server_jar, \\\"wb\\\")\\n jar_on_disk.write(r.content)\\n jar_on_disk.close()\\n else:\\n server_jar = cf.get(\\\"Selenium\\\", \\\"server_path\\\")\\n \\n s = subprocess.Popen(['java', '-jar', server_jar], \\n stdout=tempfile.TemporaryFile(), \\n stderr=tempfile.TemporaryFile()).pid\\n pidfile = open(pid_file_path, \\\"w\\\")\\n pidfile.write(str(s))\\n pidfile.close()\\n\\n # make sure the server is actually up\\n server_up = False\\n waiting = 0\\n while server_up == False and waiting < 60:\\n try:\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n s.connect((\\\"localhost\\\", 4444))\\n s.close()\\n server_up = True\\n except socket.error:\\n time.sleep(1)\\n waiting = waiting + 1\\n server_up = False\\n\\n return server_up\",\n \"def __init_webdriver(self):\\n try:\\n # Inicializar driver para Firefox\\n # - Configuración parámetro profile\\n profile = webdriver.FirefoxProfile()\\n # - Indicar que no se ha de usar el directorio por defecto de Downloads\\n profile.set_preference(\\\"browser.download.folderList\\\",2)\\n # - Deshabilitar showing download progress\\n profile.set_preference(\\\"browser.download.manager.showWhenStarting\\\", False)\\n # - Establecer el directorio para los Downloads\\n profile.set_preference(\\\"browser.download.dir\\\", self.xbrl_download_dir)\\n # - Especificar a Firefox que descarge automátiamente las ficheros de mime-types especificados\\n profile.set_preference(\\\"browser.helperApps.neverAsk.saveToDisk\\\", \\\"application/zip\\\");\\n # - Especificar User Agent\\n user_agent = self.__get_default_user_agent()+' - '+self.selenium_user_agent_comment\\n profile.set_preference(\\\"general.useragent.override\\\", user_agent)\\n\\n # -Configuración parámetro binary\\n binary = FirefoxBinary(self.selenium_firefox_path)\\n # Instanciar driver par Firefox\\n self.driver = webdriver.Firefox(firefox_profile=profile, firefox_binary=binary, executable_path=self.selenium_firefox_driver)\\n agent = self.driver.execute_script(\\\"return navigator.userAgent\\\")\\n print(' * Web driver inicializado con userAgent: '+agent)\\n except Exception:\\n traceback.print_exc() \\n raise Exception('Error en WebScraper.__init_webdriver.')\",\n \"def __init__(self, timeout=None, heartbeat=None):\\n\\n assert timeout, 'External runner requires a timeout.'\\n\\n self.timeout = lambda ctx=None: timeout\\n self.heartbeat = lambda ctx=None: (heartbeat or timeout)\",\n \"def __init__(self, user_agent=default_user_agent, operate_timeout=10, loading_timeout=60, log_level=logging.WARNING,\\n display=False, viewport_size=(1024, 768), accept_language='en,*', ignore_ssl_errors=True,\\n cache_dir=os.path.join(tempfile.gettempdir(), \\\"GRobot\\\"),\\n image_enabled=True, plugins_enabled=False, java_enabled=False, javascript_enabled=True,\\n plugin_path=None, develop=False, proxy=None, sleep=0.5, jquery_namespace='GRobot'):\\n\\n GRobot.exit_lock.acquire()\\n\\n if GRobot._kill_loop:\\n gevent.kill(GRobot._kill_loop)\\n GRobot._kill_loop=None\\n\\n logger.setLevel(log_level)\\n\\n plugin_path = plugin_path or ['/usr/lib/mozilla/plugins', ]\\n\\n GRobot._liveRobot += 1\\n\\n self.develop = develop\\n self.inspector = None\\n self.plugin = False\\n self.exitLoop = False\\n self._deleted = False\\n\\n self.set_proxy(proxy)\\n\\n self.sleep = sleep\\n self.jquery_namespace = jquery_namespace\\n self.popup_messages = None\\n self.accept_language = accept_language\\n\\n self._loaded = True\\n\\n self._confirm_expected = None\\n self._prompt_expected = None\\n self._upload_file = None\\n self._alert = None\\n\\n self.http_resources = []\\n\\n self.user_agent = user_agent\\n\\n self.loading_timeout = loading_timeout\\n self.operate_timeout = operate_timeout\\n\\n self.ignore_ssl_errors = ignore_ssl_errors\\n\\n if not sys.platform.startswith('win') and not 'DISPLAY' in os.environ \\\\\\n and not hasattr(GRobot, 'xvfb'):\\n try:\\n os.environ['DISPLAY'] = ':99'\\n GRobot.xvfb = subprocess.Popen(['Xvfb', ':99'])\\n except OSError:\\n raise Exception('Xvfb is required to a GRobot run oustside ' + \\\\\\n 'an X instance')\\n\\n self.display = display\\n\\n if not GRobot._app:\\n GRobot._app = QApplication.instance() or QApplication(['GRobot'])\\n if plugin_path:\\n for p in plugin_path:\\n GRobot._app.addLibraryPath(p)\\n\\n self.page = GRobotWebPage(self, GRobot._app)\\n\\n QtWebKit.QWebSettings.setMaximumPagesInCache(0)\\n QtWebKit.QWebSettings.setObjectCacheCapacities(0, 0, 0)\\n QtWebKit.QWebSettings.globalSettings().setAttribute(QtWebKit.QWebSettings.LocalStorageEnabled, True)\\n\\n self.page.setForwardUnsupportedContent(True)\\n\\n # Page signals\\n self.page.loadFinished.connect(self._page_loaded)\\n self.page.loadStarted.connect(self._page_load_started)\\n self.page.unsupportedContent.connect(self._unsupported_content)\\n\\n self.manager = self.page.networkAccessManager()\\n\\n #TODO:Think about how to handle the network accessible signal\\n #self.manager.networkAccessibleChanged.connect()\\n\\n self.manager.finished.connect(self._request_ended)\\n self.manager.sslErrors.connect(self._on_manager_ssl_errors)\\n\\n # Cache\\n self.cache = QNetworkDiskCache()\\n self.cache.setCacheDirectory(cache_dir)\\n\\n self.manager.setCache(self.cache)\\n\\n # Cookie jar\\n self.cookie_jar = QNetworkCookieJar()\\n self.manager.setCookieJar(self.cookie_jar)\\n\\n # User Agent\\n self.page.setUserAgent(self.user_agent)\\n\\n self.page.networkAccessManager().authenticationRequired \\\\\\n .connect(self._authenticate)\\n self.page.networkAccessManager().proxyAuthenticationRequired \\\\\\n .connect(self._authenticate)\\n\\n self.main_frame = self.page.mainFrame()\\n\\n self.webview = None\\n\\n self.viewport_size = viewport_size\\n\\n self.webview = QtWebKit.QWebView()\\n self.webview.setPage(self.page)\\n\\n self.webview.show() if display else self.webview.hide()\\n\\n self.set_viewport_size(*viewport_size)\\n\\n self.page.settings().setAttribute(QtWebKit.QWebSettings.PluginsEnabled, plugins_enabled)\\n self.page.settings().setAttribute(QtWebKit.QWebSettings.JavaEnabled, java_enabled)\\n self.page.settings().setAttribute(QWebSettings.DeveloperExtrasEnabled, self.develop)\\n\\n self.enable_image = image_enabled\\n self.enable_javascript = javascript_enabled\\n\\n #always open link in current window instead of new window\\n self.page.setLinkDelegationPolicy(QWebPage.DelegateAllLinks)\\n self.page.linkClicked.connect(self._link_clicked)\\n\\n #start the qt main loop\\n GRobot._loop = QtMainLoop(GRobot._app)\\n GRobot._loop.start()\\n GRobot.exit_lock.release()\",\n \"async def _launch_local_browser(self, launch_options: Dict[str, Any] = None) -> Browser:\\r\\n logger.info(\\r\\n f\\\"Launching local browser:\\\\n{pformat(launch_options)}\\\")\\r\\n return await pyppeteer.launcher.launch(launch_options)\",\n \"def browser_module(choose_driver):\\n yield choose_driver\\n choose_driver.quit()\",\n \"def initBrowser(browserConfig, isUseSeleniumwire=False):\\n webdriver = getWebDirver(isUseSeleniumwire=isUseSeleniumwire)\\n chromeOptions = webdriver.ChromeOptions()\\n\\n if \\\"headless\\\" in browserConfig:\\n isCurHeadless = browserConfig[\\\"headless\\\"]\\n if isCurHeadless:\\n chromeOptions.add_argument('--headless')\\n\\n if \\\"disableGpu\\\" in browserConfig:\\n isDisableGpu = browserConfig[\\\"disableGpu\\\"]\\n if isDisableGpu:\\n chromeOptions.add_argument('--disable-gpu')\\n\\n # for debug\\n # chromeOptions.add_experimental_option(\\\"excludeSwitches\\\", [\\\"enable-automation\\\"])\\n # chromeOptions.add_experimental_option('useAutomationExtension', False)\\n # chromeOptions.add_argument('window-size=1920x1080')\\n # chromeOptions.add_argument('--window-size=1920x1080')\\n\\n driverConfigDict = {\\n \\\"options\\\": chromeOptions\\n }\\n\\n if \\\"seleniumwire\\\" in browserConfig:\\n if isUseSeleniumwire:\\n driverConfigDict[\\\"seleniumwire_options\\\"] = browserConfig[\\\"seleniumwire\\\"]\\n else:\\n del browserConfig[\\\"seleniumwire\\\"]\\n\\n driver = webdriver.Chrome(**driverConfigDict)\\n # driver = webdriver.Chrome(options=chromeOptions)\\n\\n # # for debug\\n # driver.set_window_size(1920, 1080)\\n\\n if \\\"pageLoadTimeout\\\" in browserConfig:\\n curPageLoadTimeout = browserConfig[\\\"pageLoadTimeout\\\"]\\n driver.set_page_load_timeout(curPageLoadTimeout)\\n\\n return driver\",\n \"def sleep(timeout=1):\\n if os.environ.get('JS9_TEST_TIMEOUT'):\\n timeout = int(os.environ.get('JS9_TEST_TIMEOUT'));\\n time.sleep(timeout)\",\n \"def setup_driver():\\n os.environ[\\\"webdriver.chrome.driver\\\"] = chrome_driver_location\\n driver = webdriver.Chrome(chrome_driver_location)\\n driver.set_window_size(1280, 800)\\n return driver\",\n \"def execute_driver(self, script: str, script_type: str = 'webdriverio', timeout_ms: Optional[int] = None) -> Any:\\n\\n class Result:\\n def __init__(self, res: Dict):\\n self.result = res['result']\\n self.logs = res['logs']\\n\\n option: Dict[str, Union[str, int]] = {'script': script, 'type': script_type}\\n if timeout_ms is not None:\\n option['timeout'] = timeout_ms\\n\\n response = self.execute(Command.EXECUTE_DRIVER, option)['value']\\n return Result(response)\",\n \"def setUpClass(cls):\\n\\n super().setUpClass()\\n cls.selenium = WebDriver(executable_path=\\\"C:\\\\Program Files (x86)\\\\chromedriver.exe\\\")\\n cls.selenium.implicitly_wait(10)\",\n \"def create_browser():\\n browser = selenium.webdriver.Chrome()\\n return browser\",\n \"def connect(\\n servers=None, timeout=None, retry_time=10, connection=None, *args, **kwargs\\n):\\n if not connection:\\n connection = connection_http.HTTPConnection()\\n\\n verify.verifyObject(interfaces.IConnection, connection)\\n connection.connect(\\n servers=servers, timeout=timeout,\\n retry_time=retry_time, *args, **kwargs)\\n return connection\",\n \"async def main():\\n # Create the queue of work\\n work_queue = asyncio.Queue()\\n\\n # Put some work in the queue\\n for url in [\\n \\\"http://google.com\\\",\\n \\\"http://yahoo.com\\\",\\n \\\"http://linkedin.com\\\",\\n \\\"http://apple.com\\\",\\n \\\"http://microsoft.com\\\",\\n \\\"http://facebook.com\\\",\\n \\\"http://twitter.com\\\",\\n ]:\\n await work_queue.put(url)\\n\\n browser = HTTPBrowser(2,\\n work_queue.qsize(),\\n LoadBalancing()\\n )\\n\\n await browser.browser_session(work_queue)\",\n \"def create_connection(url, timeout=None, **options):\\r\\n websock = WebSocket()\\r\\n websock.settimeout(timeout != None and timeout or default_timeout)\\r\\n websock.connect(url, **options)\\r\\n return websock\",\n \"def __init__(self, timeout=0.1):\\n self.poller = select.epoll()\\n self.timeout = timeout\",\n \"def __init__(self, timeout=0.1):\\n self.poller = select.epoll()\\n self.timeout = timeout\",\n \"def load_script(browser, url):\\r\\n if browser.current_url.startswith('file:'):\\r\\n url = 'https:' + url\\r\\n browser.execute_script(\\\"\\\"\\\"\\r\\n var script_tag = document.createElement(\\\"script\\\");\\r\\n script_tag.setAttribute(\\\"type\\\", \\\"text/javascript\\\");\\r\\n script_tag.setAttribute(\\\"src\\\", arguments[0]);\\r\\n document.getElementsByTagName(\\\"head\\\")[0].appendChild(script_tag);\\r\\n \\\"\\\"\\\", url)\",\n \"def runBrowser(driver, url):\\n\\tdriver.get(url)\\n\\ttime.sleep(3) #REACT app need to sleep and wait app load.\\n\\tall_links=driver.execute_script('all_links = []; links = document.querySelectorAll(\\\".style-module--action--1Avvt>a\\\"); links.forEach(url => all_links.push(url.href)); return all_links');\\n\\tbar = IncrementalBar('📥 Icons Downloaded', max = len(all_links))\\n\\t\\n\\tfor i, link in enumerate(all_links):\\n\\t\\tdriver.execute_script('''window.open(\\\"'''+link+'''\\\",\\\"_blank\\\");''')\\n\\t\\tbar.next()\\n\\tprint('\\\\n')\\n\\tdriver.close()\\n\\tMessage.success('🎉 Download done!')\",\n \"def __init__(self, **kwargs):\\n super(DesktopInternetExplorerWebDriver, self).__init__(\\n default_capabilities=False, # ensure that HackedWebDriver doesn't mess with the capabilities\\n **kwargs\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5883255","0.5759221","0.57567716","0.5650392","0.5649762","0.55207306","0.5444826","0.53997815","0.535544","0.5268799","0.5228582","0.5209584","0.5167454","0.5134206","0.50916547","0.50906485","0.505967","0.5057035","0.50250274","0.49927777","0.49799502","0.4977438","0.49724478","0.492419","0.49237722","0.48724273","0.4863387","0.4861319","0.4853867","0.4823819","0.4803556","0.4802532","0.47984594","0.47830924","0.47800517","0.47733983","0.47717866","0.47676754","0.47660604","0.47575408","0.4744593","0.47317925","0.47317925","0.4715415","0.46916774","0.46829966","0.46793836","0.46594167","0.46437323","0.46385777","0.46381527","0.46380997","0.46376854","0.46376178","0.4628073","0.46263877","0.46190944","0.46177074","0.461361","0.46061748","0.46059722","0.46030337","0.4597","0.4583337","0.45774192","0.45561785","0.45524514","0.4552403","0.4547242","0.45432034","0.45419198","0.4535384","0.45307398","0.4523237","0.45164","0.4503652","0.4483908","0.44824687","0.44766843","0.44733208","0.44640437","0.4453994","0.44525713","0.44500253","0.444878","0.4434335","0.44329312","0.4432768","0.44256854","0.4423565","0.44223312","0.44023404","0.4381674","0.4381352","0.43756878","0.43672502","0.43672502","0.4366973","0.43613297","0.4354078"],"string":"[\n \"0.5883255\",\n \"0.5759221\",\n \"0.57567716\",\n \"0.5650392\",\n \"0.5649762\",\n \"0.55207306\",\n \"0.5444826\",\n \"0.53997815\",\n \"0.535544\",\n \"0.5268799\",\n \"0.5228582\",\n \"0.5209584\",\n \"0.5167454\",\n \"0.5134206\",\n \"0.50916547\",\n \"0.50906485\",\n \"0.505967\",\n \"0.5057035\",\n \"0.50250274\",\n \"0.49927777\",\n \"0.49799502\",\n \"0.4977438\",\n \"0.49724478\",\n \"0.492419\",\n \"0.49237722\",\n \"0.48724273\",\n \"0.4863387\",\n \"0.4861319\",\n \"0.4853867\",\n \"0.4823819\",\n \"0.4803556\",\n \"0.4802532\",\n \"0.47984594\",\n \"0.47830924\",\n \"0.47800517\",\n \"0.47733983\",\n \"0.47717866\",\n \"0.47676754\",\n \"0.47660604\",\n \"0.47575408\",\n \"0.4744593\",\n \"0.47317925\",\n \"0.47317925\",\n \"0.4715415\",\n \"0.46916774\",\n \"0.46829966\",\n \"0.46793836\",\n \"0.46594167\",\n \"0.46437323\",\n \"0.46385777\",\n \"0.46381527\",\n \"0.46380997\",\n \"0.46376854\",\n \"0.46376178\",\n \"0.4628073\",\n \"0.46263877\",\n \"0.46190944\",\n \"0.46177074\",\n \"0.461361\",\n \"0.46061748\",\n \"0.46059722\",\n \"0.46030337\",\n \"0.4597\",\n \"0.4583337\",\n \"0.45774192\",\n \"0.45561785\",\n \"0.45524514\",\n \"0.4552403\",\n \"0.4547242\",\n \"0.45432034\",\n \"0.45419198\",\n \"0.4535384\",\n \"0.45307398\",\n \"0.4523237\",\n \"0.45164\",\n \"0.4503652\",\n \"0.4483908\",\n \"0.44824687\",\n \"0.44766843\",\n \"0.44733208\",\n \"0.44640437\",\n \"0.4453994\",\n \"0.44525713\",\n \"0.44500253\",\n \"0.444878\",\n \"0.4434335\",\n \"0.44329312\",\n \"0.4432768\",\n \"0.44256854\",\n \"0.4423565\",\n \"0.44223312\",\n \"0.44023404\",\n \"0.4381674\",\n \"0.4381352\",\n \"0.43756878\",\n \"0.43672502\",\n \"0.43672502\",\n \"0.4366973\",\n \"0.43613297\",\n \"0.4354078\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5961083"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88379,"cells":{"query":{"kind":"string","value":"The selenium remote control instance of currently active browser."},"document":{"kind":"string","value":"def selenium(self):\n return self._selenium"},"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 get_webdriver_instance():\n return selenium._current_browser()\n # return PageBase.get_selenium2library_instance()._current_browser()","def remote_control(self) -> interface.RemoteControl:\n return cast(interface.RemoteControl, self._interfaces[interface.RemoteControl])","def get_instance():\n if ChromeDriverSession.__instance is None:\n ChromeDriverSession()\n return ChromeDriverSession.__instance","def _browser(self):\n RemoteConnection.set_timeout(CONNECTION_TIMEOUT)\n\n profile = webdriver.FirefoxProfile()\n preferences = self.config.get('preferences', {})\n for key, value in preferences.items():\n profile.set_preference(key, value)\n\n driver = webdriver.Firefox(profile)\n # Wait for UI events to complete before failing to find an element.\n driver.implicitly_wait(IMPLICIT_TIMEOUT)\n\n return driver","def get_control(self):\n return self.control","def get_instance(driver_info: DriverInfo) -> webdriver:\n if driver_info.get_driver_type() == \"chrome\":\n options = webdriver.ChromeOptions()\n options.add_argument(\"--start-maximized\")\n return webdriver.Chrome(\n executable_path=os.path.join(\n driver_info.get_driver_path(),\n \"chromedriver\"\n ),\n chrome_options=options\n )","def control(self):\n return self._control","def selenium(self):\n return self.builtin.get_library_instance(\"SeleniumLibrary\")","def isolate_server(self):\n return self._isolate_server","def getControl(self):\n return self._Control","def smartctl(self) -> SmartNvmeSmartctl:\n return self._smartctl","def getWebDriverInstance(self):\n #baseURL = \"https://qa-test.avenuecode.com/\"\n if self.device == \"ios_mobile\":\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\n self.driver.implicitly_wait(10)\n #return driver\n #driver.get(baseURL)\n\n else:\n print(\"Hello\")\n # Setting Driver Implicit Time out for An Element\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\n self.driver.implicitly_wait(10)\n return self.driver\n # Maximize the window\n #driver.maximize_window()\n # Loading browser with App URL\n #driver.get(baseURL)\n #return driver","def _get_browser(self):\n # Create a new Firefox instance if there is none exists yet.\n if not self.browser:\n self.browser = self.guest.application(\"webBrowserFirefox\", {'webBrowser': \"firefox\"})\n\n # Wait for Firefox to start.\n while self.browser.is_busy is True:\n self._logger.debug(\"[~] Firefox is starting. Waiting.\")\n time.sleep(1)\n\n # Return the browser.\n return self.browser","def aisappium_get_driver_instance(self):\n return self._current_application()","def browser(self):\n return","def open(self):\n self.browser = self._browser()\n\n return self.browser","def current_ssh_connection(self):\n return self._current","def browser(self):\n # type: () -> string_types\n return self._browser","def controller(self):\n return self._controller","def get_active(cls):\n\n\t\tif cls._interface:\n\t\t\twindow = cls._interface.get_active()\n\t\t\tif window:\n\t\t\t\treturn cls(window)\n\t\t\telse:\n\t\t\t\treturn None\n\t\telse:\n\t\t\traise NotImplementedError('Unsupported platform')","def __get_browser(self):\n print(\"Setting WebDriver Chrome as headless mode\")\n options = chromeOptions()\n options.set_headless(headless=True)\n chrome = webdriver.Chrome(ChromeDriverManager().install(),\n chrome_options=options)\n return chrome","def choose_driver(is_remote, t_browser):\n if is_remote:\n return remote_driver(t_browser)\n return custom_driver(t_browser)","def client(self):\n return self._thread._client","def _get_webdriver(self):\n driver = webdriver.Chrome(self.CHROME_DRIVER_PATH, options=self.CHROME_DRIVER_OPTIONS)\n driver.implicitly_wait(1)\n driver.set_window_size(1024, 768)\n\n return driver","def get_selenium2libraryExtend_instance():\n\n # selenium = BuiltIn().get_library_instance('Selenium2Library')\n return selenium","def create_browser_instance():\n cmd = [browser_sync_path, 'start', '--proxy=localhost:8000']\n check_output(cmd)","def current_gui(self):\n return self._current_gui","def current_control(self):\n return self.layout.current_control","def get_agent(self):\n servers = self.get_agents()\n assert servers, \"starter: have no instances!\"\n return servers[0]","def control(self):\n lpdwRevision = gdef.DWORD()\n control = gdef.SECURITY_DESCRIPTOR_CONTROL()\n winproxy.GetSecurityDescriptorControl(self, control, lpdwRevision)\n return control.value","def isolate_server(self):\n assert self._server\n return self._server","def _get_controller(self):\n return self.__controller","def instance(self):\n return self._instance","def instance(self):\n return self.__instance","def host_status_control(self):\n return self._host_status_control","def get_instance(cls):\n if cls.__instance is None:\n cls.__guard = False\n cls.__instance = PvMonitors()\n cls.__guard = True\n return PvMonitors.__instance","def index(self):\n return self._browser.driver.window_handles.index(self.name)","def _instantiate_driver(self) -> webdriver:\n\n if self.driver is None: return Browser.run_chromedriver()\n\n return self.driver","def controller(self): # type: () -> ControllerHostConfig\n return self.host_settings.controller","def current_window(self):\n return self._impl.get_current_window().interface","def get_web_browser(self, settings=None):\n browser = SeleniumBrowser(self.get_wsgi_application())\n if settings is not None:\n settings(browser)\n self._browsers.append(browser)\n return browser","def get_window(self):\n \n # get window from browser\n return self.browser.get_window()","def controller(self) -> Optional['outputs.CSIPowerMaxSpecDriverController']:\n return pulumi.get(self, \"controller\")","def become_controller(self):\n return self._send_command('control')","def getinstance() :\n\t\treturn Jikji.instance","def _browser(self):\n name = self.arg.browser\n if 'phantomjs' in name:\n return self._phantomjs()\n elif 'firefox' in name:\n return self._firefox()\n elif 'chrome' in name:\n return self._chrome()","def getController(self):\n return self.__controller","def instance_proxy(self):\r\n return self._proxyClient['clientName']","def remote_container(self):\n return pn_connection_remote_container(self._impl)","def ion_instance(self):\n return self._ion_instance","def controller(self) -> Optional['outputs.CSIPowerStoreSpecDriverController']:\n return pulumi.get(self, \"controller\")","def vserver(self):\n return self._vserver","def vserver(self):\n return self._vserver","def vserver(self):\n return self._vserver","def _get_selenium_browser(navigator, fLOG=noLOG):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n from selenium import webdriver\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\n\n fLOG(\"[webshot] navigator=\", navigator)\n if navigator == \"firefox\":\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\n firefox_capabilities['marionette'] = True\n firefox_capabilities[\n 'binary'] = r\"C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe\"\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\n elif navigator == \"chrome\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n install_chromedriver(fLOG=fLOG)\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install 'chromedriver.exe'\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'chromedriver'\n\n start_navi = True\n if start_navi:\n fLOG(\"[_get_selenium_browser] start\", navigator)\n chrome_options = webdriver.ChromeOptions()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--verbose')\n browser = webdriver.Chrome(executable_path=chromed,\n chrome_options=chrome_options)\n else:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n import selenium.webdriver.chrome.service as wservice\n fLOG(\"[_get_selenium_browser] create service\")\n service = wservice.Service(chromed)\n fLOG(\"[_get_selenium_browser] start service\")\n service.start()\n fLOG(\"[_get_selenium_browser] declare remote\")\n capabilities = {'chrome.binary': chromed}\n browser = webdriver.Remote(service.service_url, capabilities)\n elif navigator == \"ie\":\n browser = webdriver.Ie()\n elif navigator == \"opera\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n install_operadriver(fLOG=fLOG)\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install operadriver.exe\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'operadriver'\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\n elif navigator == \"edge\":\n browser = webdriver.Edge()\n else:\n raise RuntimeError(\n f\"unable to interpret the navigator '{navigator}'\")\n fLOG(\"[_get_selenium_browser] navigator is started\")\n return browser","def current_process(self):\n return self._current_process","def controller( self ):\n\t\ttry:\n\t\t\treturn self._controller\n\t\texcept Exception as e:\n\t\t\tself.logToConsole( \"controller: %s\" % str(e) )","def controller(self) -> Optional['outputs.CSIUnitySpecDriverController']:\n return pulumi.get(self, \"controller\")","def current_browser_proxy(self, browser: Browser) -> Union[str, None]:\r\n if browser in self.browsers:\r\n return self.browsers[browser]['launch_options'].get('proxy')","def controller(self) -> Optional['outputs.CSIIsilonSpecDriverController']:\n return pulumi.get(self, \"controller\")","def _browser(wh_conn):\n util = Utility()\n config = util.CONFIG\n br = util.get_plugin(config.PATH_BROWSER)\n br.connect(wh_conn)\n return br","def get_connection(self):\n\n return self.REMOTE_CONNECTION","def process_control(self):\n return self._process_control","def gui(self):\n return gui","def current_server():\n if not _current_server:\n create_server()\n return _current_server","def get_object(self):\n if getattr(self, 'current_instance', None):\n ret = self.current_instance\n else:\n ret = super().get_object()\n return ret","def GetCurrentInterface(self):\n return self.current_interface","def driver(self):\n \n return self.__driver","def browser_chrome(context, timeout=30, **kwargs):\n if settings.BROWSER == 'remote':\n browser = splinter.Browser(\n driver_name='remote',\n browser='chrome',\n url=settings.SELENIUM_URL,\n )\n else:\n browser = splinter.Browser(\n driver_name=settings.BROWSER,\n headless=settings.RUN_HEADLESS,\n )\n context.browser = browser\n context.add_cleanup(browser.quit)\n return browser","def cntrl(self):\n return self._cntrl","def get_random_controller_ssh_client():\n nodes = topology.list_openstack_nodes(group='controller')\n controller_node = nodes[0]\n return controller_node.ssh_client","def controller(self) -> Optional['outputs.CSIVXFlexOSSpecDriverController']:\n return pulumi.get(self, \"controller\")","def ui(self):\n return self._ui","def instance():\n\n if Controller._instance == None:\n Controller._instance = Controller()\n return Controller._instance","def client(self):\n\t\t# pylint: disable=invalid-name\n\t\treturn self._client","def get_driver(self):\n return self.driver","def _get_session(self):\n if current_uow and not self._outside_uow:\n return current_uow.get_session(self.provider.name)\n else:\n new_connection = self.provider.get_connection()\n if not new_connection.is_active:\n new_connection.begin()\n return new_connection","def get_control(self):\n return self.o.read_register(self.dev_id, CONTROL)","def get_browser(self, settings=None):\n browser = Browser(self.get_wsgi_application())\n if settings is not None:\n settings(browser)\n self._browsers.append(browser)\n return browser","def test_webuidriver_remote(self):\n\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\n hub.start_server()\n\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\"localhost\", 4444))\n node.start_server()\n executors = SeleniumHatch.get_remote_executors(\"localhost\", 4444)\n\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\n\n self.driver.get('http://www.baidu.com')\n time.sleep(1)\n\n # webuidriver.Remote 是 webdriver.Chrome 的子类\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\n self.assertIsInstance(self.driver, webdriver.Remote)\n\n self.driver.close()\n self.driver.quit()\n\n hub.stop_server()\n node.stop_server()","def service(self):\n return self.__stackdriver","def create_browser():\n browser = selenium.webdriver.Chrome()\n return browser","def remote_desired_capabilities(self):\n return dat2obj(pn_connection_remote_desired_capabilities(self._impl))","def FindControl(self, id):\r\n \r\n wnd = self.FindWindow(id)\r\n return wnd","def get_session(self):\n return ESSession(self)","def client(self):\n return self._client","def getCurrentNodeEditorWidget(self):\n activeSubWindow = self.mdiArea.activeSubWindow()\n if activeSubWindow:\n return activeSubWindow.widget()\n return None","def getCurrentNodeEditorWidget(self):\n activeSubWindow = self.mdiArea.activeSubWindow()\n if activeSubWindow:\n return activeSubWindow.widget()\n return None","def driver(self):\n from dallinger.config import get_config\n\n config = get_config()\n if not config.ready:\n config.load()\n driver_url = config.get(\"webdriver_url\", None)\n driver_type = config.get(\"webdriver_type\")\n driver = None\n\n if driver_url:\n capabilities = CAPABILITY_MAP.get(driver_type.lower())\n if capabilities is None:\n raise ValueError(\n \"Unsupported remote webdriver_type: {}\".format(driver_type)\n )\n driver = webdriver.Remote(\n desired_capabilities=capabilities, command_executor=driver_url\n )\n else:\n driver_class = DRIVER_MAP.get(driver_type.lower())\n if driver_class is not None:\n kwargs = {}\n if driver_type.lower() == \"chrome_headless\":\n from selenium.webdriver.chrome.options import Options\n\n chrome_options = Options()\n chrome_options.add_argument(\"--headless\")\n kwargs = {\"options\": chrome_options}\n driver = driver_class(**kwargs)\n\n if driver is None:\n raise ValueError(\"Unsupported webdriver_type: {}\".format(driver_type))\n\n driver.set_window_size(1024, 768)\n logger.info(\"Created {} webdriver.\".format(driver_type))\n return driver","def _get_browser(self, webpage):\n options = self._build_options()\n\n chrome_path = 'C:/Users/jorda/.wdm/drivers/chromedriver/81/win32/chromedriver.exe'\n browser = webdriver.Chrome(executable_path = chrome_path, options=options)\n\n# browser = webdriver.Chrome(ChromeDriverManager().install(), options=options)\n browser.get(webpage)\n wait = WebDriverWait(browser, 20) # maximum wait time is 20 seconds \n return browser, wait","def plugin_instance(self):\n return self.__plugin_instance","def get_instance(self, name):\n return self.website.instance.id","def get_dv_switch_manager(vim):\n return vim.service_content.dvSwitchManager","def get_worker(self):\n return self.worker","def instance(self) -> str:\n return pulumi.get(self, \"instance\")","def instance(self) -> str:\n return pulumi.get(self, \"instance\")","def launch_browser2(self, clean_session=False):\n try:\n if self._browserName[0:2] == \"IE\":\n if clean_session:\n self._browser = webdriver.Ie(log_level=\"TRACE\", log_file=\"iedriver_stdout.log\",\n capabilities={'ie.ensureCleanSession': True})\n else:\n self._browser = webdriver.Ie(log_level=\"TRACE\", log_file=\"iedriver_stdout.log\")\n elif self._browserName == \"RemoteIE\":\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\n desired_capabilities={'browserName': 'internet explorer'})\n elif self._browserName == \"RemoteFF\":\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\n desired_capabilities={'browserName': 'firefox'})\n \n elif self._browserName == \"Firefox\":\n fp = webdriver.FirefoxProfile()\n fp.set_preference('app.update.auto', False)\n fp.set_preference('app.update.enabled', False)\n fp.native_events_enabled = False\n proxy = None\n if self._configuration.security:\n self.logger.info(\"we use a proxy\")\n fp.accept_untrusted_certs = True\n proxy = webdriver.Proxy()\n proxy.http_proxy = \"localhost:9080\"\n proxy.ssl_proxy = \"localhost:9080\"\n self._browser = webdriver.Firefox(firefox_profile=fp, proxy=proxy)\n elif self._browserName == \"Chrome\":\n # dirty way to launch chromedriver as the current webdriver fail after the xth command\n import subprocess\n\n self._chrome_log_file_stdout = open('chromedriver_stdout.log', 'w')\n self._chrome_log_file_stderr = open('chromedriver_stderr.log', 'w')\n subprocess.Popen(\"chromedriver\", stdout=self._chrome_log_file_stdout,\n stderr=self._chrome_log_file_stderr)\n time.sleep(2)\n self._browser = webdriver.Remote('http://localhost:9515', {\"nativeEvents\": False,\n \"javascriptEnabled\": True})\n else:\n raise NotKnown(\"Unknown browser : \" + self._browserName)\n self.set_implicit_wait_default()\n self._browser.maximize_window()\n self._currentFrame = \"main\"\n self.logger.info(\"Launching : \" + str(self._browserName))\n except Exception as e:\n self.logger.error(\"Error launching browser : \" + str(e))\n raise","def remote(self, *args, **kwargs):\n return self.api.remote(*args, **kwargs)","def GetInstance():\n pass","def bot(self):\n return self._bot"],"string":"[\n \"def get_webdriver_instance():\\n return selenium._current_browser()\\n # return PageBase.get_selenium2library_instance()._current_browser()\",\n \"def remote_control(self) -> interface.RemoteControl:\\n return cast(interface.RemoteControl, self._interfaces[interface.RemoteControl])\",\n \"def get_instance():\\n if ChromeDriverSession.__instance is None:\\n ChromeDriverSession()\\n return ChromeDriverSession.__instance\",\n \"def _browser(self):\\n RemoteConnection.set_timeout(CONNECTION_TIMEOUT)\\n\\n profile = webdriver.FirefoxProfile()\\n preferences = self.config.get('preferences', {})\\n for key, value in preferences.items():\\n profile.set_preference(key, value)\\n\\n driver = webdriver.Firefox(profile)\\n # Wait for UI events to complete before failing to find an element.\\n driver.implicitly_wait(IMPLICIT_TIMEOUT)\\n\\n return driver\",\n \"def get_control(self):\\n return self.control\",\n \"def get_instance(driver_info: DriverInfo) -> webdriver:\\n if driver_info.get_driver_type() == \\\"chrome\\\":\\n options = webdriver.ChromeOptions()\\n options.add_argument(\\\"--start-maximized\\\")\\n return webdriver.Chrome(\\n executable_path=os.path.join(\\n driver_info.get_driver_path(),\\n \\\"chromedriver\\\"\\n ),\\n chrome_options=options\\n )\",\n \"def control(self):\\n return self._control\",\n \"def selenium(self):\\n return self.builtin.get_library_instance(\\\"SeleniumLibrary\\\")\",\n \"def isolate_server(self):\\n return self._isolate_server\",\n \"def getControl(self):\\n return self._Control\",\n \"def smartctl(self) -> SmartNvmeSmartctl:\\n return self._smartctl\",\n \"def getWebDriverInstance(self):\\n #baseURL = \\\"https://qa-test.avenuecode.com/\\\"\\n if self.device == \\\"ios_mobile\\\":\\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\\n self.driver.implicitly_wait(10)\\n #return driver\\n #driver.get(baseURL)\\n\\n else:\\n print(\\\"Hello\\\")\\n # Setting Driver Implicit Time out for An Element\\n self.driver = appiumdriver.Remote('http://localhost:4723/wd/hub', self.capabilities)\\n self.driver.implicitly_wait(10)\\n return self.driver\\n # Maximize the window\\n #driver.maximize_window()\\n # Loading browser with App URL\\n #driver.get(baseURL)\\n #return driver\",\n \"def _get_browser(self):\\n # Create a new Firefox instance if there is none exists yet.\\n if not self.browser:\\n self.browser = self.guest.application(\\\"webBrowserFirefox\\\", {'webBrowser': \\\"firefox\\\"})\\n\\n # Wait for Firefox to start.\\n while self.browser.is_busy is True:\\n self._logger.debug(\\\"[~] Firefox is starting. Waiting.\\\")\\n time.sleep(1)\\n\\n # Return the browser.\\n return self.browser\",\n \"def aisappium_get_driver_instance(self):\\n return self._current_application()\",\n \"def browser(self):\\n return\",\n \"def open(self):\\n self.browser = self._browser()\\n\\n return self.browser\",\n \"def current_ssh_connection(self):\\n return self._current\",\n \"def browser(self):\\n # type: () -> string_types\\n return self._browser\",\n \"def controller(self):\\n return self._controller\",\n \"def get_active(cls):\\n\\n\\t\\tif cls._interface:\\n\\t\\t\\twindow = cls._interface.get_active()\\n\\t\\t\\tif window:\\n\\t\\t\\t\\treturn cls(window)\\n\\t\\t\\telse:\\n\\t\\t\\t\\treturn None\\n\\t\\telse:\\n\\t\\t\\traise NotImplementedError('Unsupported platform')\",\n \"def __get_browser(self):\\n print(\\\"Setting WebDriver Chrome as headless mode\\\")\\n options = chromeOptions()\\n options.set_headless(headless=True)\\n chrome = webdriver.Chrome(ChromeDriverManager().install(),\\n chrome_options=options)\\n return chrome\",\n \"def choose_driver(is_remote, t_browser):\\n if is_remote:\\n return remote_driver(t_browser)\\n return custom_driver(t_browser)\",\n \"def client(self):\\n return self._thread._client\",\n \"def _get_webdriver(self):\\n driver = webdriver.Chrome(self.CHROME_DRIVER_PATH, options=self.CHROME_DRIVER_OPTIONS)\\n driver.implicitly_wait(1)\\n driver.set_window_size(1024, 768)\\n\\n return driver\",\n \"def get_selenium2libraryExtend_instance():\\n\\n # selenium = BuiltIn().get_library_instance('Selenium2Library')\\n return selenium\",\n \"def create_browser_instance():\\n cmd = [browser_sync_path, 'start', '--proxy=localhost:8000']\\n check_output(cmd)\",\n \"def current_gui(self):\\n return self._current_gui\",\n \"def current_control(self):\\n return self.layout.current_control\",\n \"def get_agent(self):\\n servers = self.get_agents()\\n assert servers, \\\"starter: have no instances!\\\"\\n return servers[0]\",\n \"def control(self):\\n lpdwRevision = gdef.DWORD()\\n control = gdef.SECURITY_DESCRIPTOR_CONTROL()\\n winproxy.GetSecurityDescriptorControl(self, control, lpdwRevision)\\n return control.value\",\n \"def isolate_server(self):\\n assert self._server\\n return self._server\",\n \"def _get_controller(self):\\n return self.__controller\",\n \"def instance(self):\\n return self._instance\",\n \"def instance(self):\\n return self.__instance\",\n \"def host_status_control(self):\\n return self._host_status_control\",\n \"def get_instance(cls):\\n if cls.__instance is None:\\n cls.__guard = False\\n cls.__instance = PvMonitors()\\n cls.__guard = True\\n return PvMonitors.__instance\",\n \"def index(self):\\n return self._browser.driver.window_handles.index(self.name)\",\n \"def _instantiate_driver(self) -> webdriver:\\n\\n if self.driver is None: return Browser.run_chromedriver()\\n\\n return self.driver\",\n \"def controller(self): # type: () -> ControllerHostConfig\\n return self.host_settings.controller\",\n \"def current_window(self):\\n return self._impl.get_current_window().interface\",\n \"def get_web_browser(self, settings=None):\\n browser = SeleniumBrowser(self.get_wsgi_application())\\n if settings is not None:\\n settings(browser)\\n self._browsers.append(browser)\\n return browser\",\n \"def get_window(self):\\n \\n # get window from browser\\n return self.browser.get_window()\",\n \"def controller(self) -> Optional['outputs.CSIPowerMaxSpecDriverController']:\\n return pulumi.get(self, \\\"controller\\\")\",\n \"def become_controller(self):\\n return self._send_command('control')\",\n \"def getinstance() :\\n\\t\\treturn Jikji.instance\",\n \"def _browser(self):\\n name = self.arg.browser\\n if 'phantomjs' in name:\\n return self._phantomjs()\\n elif 'firefox' in name:\\n return self._firefox()\\n elif 'chrome' in name:\\n return self._chrome()\",\n \"def getController(self):\\n return self.__controller\",\n \"def instance_proxy(self):\\r\\n return self._proxyClient['clientName']\",\n \"def remote_container(self):\\n return pn_connection_remote_container(self._impl)\",\n \"def ion_instance(self):\\n return self._ion_instance\",\n \"def controller(self) -> Optional['outputs.CSIPowerStoreSpecDriverController']:\\n return pulumi.get(self, \\\"controller\\\")\",\n \"def vserver(self):\\n return self._vserver\",\n \"def vserver(self):\\n return self._vserver\",\n \"def vserver(self):\\n return self._vserver\",\n \"def _get_selenium_browser(navigator, fLOG=noLOG):\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n from selenium import webdriver\\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\\n\\n fLOG(\\\"[webshot] navigator=\\\", navigator)\\n if navigator == \\\"firefox\\\":\\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\\n firefox_capabilities['marionette'] = True\\n firefox_capabilities[\\n 'binary'] = r\\\"C:\\\\Program Files (x86)\\\\Mozilla Firefox\\\\firefox.exe\\\"\\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\\n elif navigator == \\\"chrome\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n install_chromedriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install 'chromedriver.exe'\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'chromedriver'\\n\\n start_navi = True\\n if start_navi:\\n fLOG(\\\"[_get_selenium_browser] start\\\", navigator)\\n chrome_options = webdriver.ChromeOptions()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--verbose')\\n browser = webdriver.Chrome(executable_path=chromed,\\n chrome_options=chrome_options)\\n else:\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n import selenium.webdriver.chrome.service as wservice\\n fLOG(\\\"[_get_selenium_browser] create service\\\")\\n service = wservice.Service(chromed)\\n fLOG(\\\"[_get_selenium_browser] start service\\\")\\n service.start()\\n fLOG(\\\"[_get_selenium_browser] declare remote\\\")\\n capabilities = {'chrome.binary': chromed}\\n browser = webdriver.Remote(service.service_url, capabilities)\\n elif navigator == \\\"ie\\\":\\n browser = webdriver.Ie()\\n elif navigator == \\\"opera\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n install_operadriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install operadriver.exe\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'operadriver'\\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\\n elif navigator == \\\"edge\\\":\\n browser = webdriver.Edge()\\n else:\\n raise RuntimeError(\\n f\\\"unable to interpret the navigator '{navigator}'\\\")\\n fLOG(\\\"[_get_selenium_browser] navigator is started\\\")\\n return browser\",\n \"def current_process(self):\\n return self._current_process\",\n \"def controller( self ):\\n\\t\\ttry:\\n\\t\\t\\treturn self._controller\\n\\t\\texcept Exception as e:\\n\\t\\t\\tself.logToConsole( \\\"controller: %s\\\" % str(e) )\",\n \"def controller(self) -> Optional['outputs.CSIUnitySpecDriverController']:\\n return pulumi.get(self, \\\"controller\\\")\",\n \"def current_browser_proxy(self, browser: Browser) -> Union[str, None]:\\r\\n if browser in self.browsers:\\r\\n return self.browsers[browser]['launch_options'].get('proxy')\",\n \"def controller(self) -> Optional['outputs.CSIIsilonSpecDriverController']:\\n return pulumi.get(self, \\\"controller\\\")\",\n \"def _browser(wh_conn):\\n util = Utility()\\n config = util.CONFIG\\n br = util.get_plugin(config.PATH_BROWSER)\\n br.connect(wh_conn)\\n return br\",\n \"def get_connection(self):\\n\\n return self.REMOTE_CONNECTION\",\n \"def process_control(self):\\n return self._process_control\",\n \"def gui(self):\\n return gui\",\n \"def current_server():\\n if not _current_server:\\n create_server()\\n return _current_server\",\n \"def get_object(self):\\n if getattr(self, 'current_instance', None):\\n ret = self.current_instance\\n else:\\n ret = super().get_object()\\n return ret\",\n \"def GetCurrentInterface(self):\\n return self.current_interface\",\n \"def driver(self):\\n \\n return self.__driver\",\n \"def browser_chrome(context, timeout=30, **kwargs):\\n if settings.BROWSER == 'remote':\\n browser = splinter.Browser(\\n driver_name='remote',\\n browser='chrome',\\n url=settings.SELENIUM_URL,\\n )\\n else:\\n browser = splinter.Browser(\\n driver_name=settings.BROWSER,\\n headless=settings.RUN_HEADLESS,\\n )\\n context.browser = browser\\n context.add_cleanup(browser.quit)\\n return browser\",\n \"def cntrl(self):\\n return self._cntrl\",\n \"def get_random_controller_ssh_client():\\n nodes = topology.list_openstack_nodes(group='controller')\\n controller_node = nodes[0]\\n return controller_node.ssh_client\",\n \"def controller(self) -> Optional['outputs.CSIVXFlexOSSpecDriverController']:\\n return pulumi.get(self, \\\"controller\\\")\",\n \"def ui(self):\\n return self._ui\",\n \"def instance():\\n\\n if Controller._instance == None:\\n Controller._instance = Controller()\\n return Controller._instance\",\n \"def client(self):\\n\\t\\t# pylint: disable=invalid-name\\n\\t\\treturn self._client\",\n \"def get_driver(self):\\n return self.driver\",\n \"def _get_session(self):\\n if current_uow and not self._outside_uow:\\n return current_uow.get_session(self.provider.name)\\n else:\\n new_connection = self.provider.get_connection()\\n if not new_connection.is_active:\\n new_connection.begin()\\n return new_connection\",\n \"def get_control(self):\\n return self.o.read_register(self.dev_id, CONTROL)\",\n \"def get_browser(self, settings=None):\\n browser = Browser(self.get_wsgi_application())\\n if settings is not None:\\n settings(browser)\\n self._browsers.append(browser)\\n return browser\",\n \"def test_webuidriver_remote(self):\\n\\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\\n hub.start_server()\\n\\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\\\"localhost\\\", 4444))\\n node.start_server()\\n executors = SeleniumHatch.get_remote_executors(\\\"localhost\\\", 4444)\\n\\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\\n\\n self.driver.get('http://www.baidu.com')\\n time.sleep(1)\\n\\n # webuidriver.Remote 是 webdriver.Chrome 的子类\\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\\n self.assertIsInstance(self.driver, webdriver.Remote)\\n\\n self.driver.close()\\n self.driver.quit()\\n\\n hub.stop_server()\\n node.stop_server()\",\n \"def service(self):\\n return self.__stackdriver\",\n \"def create_browser():\\n browser = selenium.webdriver.Chrome()\\n return browser\",\n \"def remote_desired_capabilities(self):\\n return dat2obj(pn_connection_remote_desired_capabilities(self._impl))\",\n \"def FindControl(self, id):\\r\\n \\r\\n wnd = self.FindWindow(id)\\r\\n return wnd\",\n \"def get_session(self):\\n return ESSession(self)\",\n \"def client(self):\\n return self._client\",\n \"def getCurrentNodeEditorWidget(self):\\n activeSubWindow = self.mdiArea.activeSubWindow()\\n if activeSubWindow:\\n return activeSubWindow.widget()\\n return None\",\n \"def getCurrentNodeEditorWidget(self):\\n activeSubWindow = self.mdiArea.activeSubWindow()\\n if activeSubWindow:\\n return activeSubWindow.widget()\\n return None\",\n \"def driver(self):\\n from dallinger.config import get_config\\n\\n config = get_config()\\n if not config.ready:\\n config.load()\\n driver_url = config.get(\\\"webdriver_url\\\", None)\\n driver_type = config.get(\\\"webdriver_type\\\")\\n driver = None\\n\\n if driver_url:\\n capabilities = CAPABILITY_MAP.get(driver_type.lower())\\n if capabilities is None:\\n raise ValueError(\\n \\\"Unsupported remote webdriver_type: {}\\\".format(driver_type)\\n )\\n driver = webdriver.Remote(\\n desired_capabilities=capabilities, command_executor=driver_url\\n )\\n else:\\n driver_class = DRIVER_MAP.get(driver_type.lower())\\n if driver_class is not None:\\n kwargs = {}\\n if driver_type.lower() == \\\"chrome_headless\\\":\\n from selenium.webdriver.chrome.options import Options\\n\\n chrome_options = Options()\\n chrome_options.add_argument(\\\"--headless\\\")\\n kwargs = {\\\"options\\\": chrome_options}\\n driver = driver_class(**kwargs)\\n\\n if driver is None:\\n raise ValueError(\\\"Unsupported webdriver_type: {}\\\".format(driver_type))\\n\\n driver.set_window_size(1024, 768)\\n logger.info(\\\"Created {} webdriver.\\\".format(driver_type))\\n return driver\",\n \"def _get_browser(self, webpage):\\n options = self._build_options()\\n\\n chrome_path = 'C:/Users/jorda/.wdm/drivers/chromedriver/81/win32/chromedriver.exe'\\n browser = webdriver.Chrome(executable_path = chrome_path, options=options)\\n\\n# browser = webdriver.Chrome(ChromeDriverManager().install(), options=options)\\n browser.get(webpage)\\n wait = WebDriverWait(browser, 20) # maximum wait time is 20 seconds \\n return browser, wait\",\n \"def plugin_instance(self):\\n return self.__plugin_instance\",\n \"def get_instance(self, name):\\n return self.website.instance.id\",\n \"def get_dv_switch_manager(vim):\\n return vim.service_content.dvSwitchManager\",\n \"def get_worker(self):\\n return self.worker\",\n \"def instance(self) -> str:\\n return pulumi.get(self, \\\"instance\\\")\",\n \"def instance(self) -> str:\\n return pulumi.get(self, \\\"instance\\\")\",\n \"def launch_browser2(self, clean_session=False):\\n try:\\n if self._browserName[0:2] == \\\"IE\\\":\\n if clean_session:\\n self._browser = webdriver.Ie(log_level=\\\"TRACE\\\", log_file=\\\"iedriver_stdout.log\\\",\\n capabilities={'ie.ensureCleanSession': True})\\n else:\\n self._browser = webdriver.Ie(log_level=\\\"TRACE\\\", log_file=\\\"iedriver_stdout.log\\\")\\n elif self._browserName == \\\"RemoteIE\\\":\\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\\n desired_capabilities={'browserName': 'internet explorer'})\\n elif self._browserName == \\\"RemoteFF\\\":\\n self._browser = webdriver.Remote(command_executor='http://127.0.0.1:4444/wd/hub',\\n desired_capabilities={'browserName': 'firefox'})\\n \\n elif self._browserName == \\\"Firefox\\\":\\n fp = webdriver.FirefoxProfile()\\n fp.set_preference('app.update.auto', False)\\n fp.set_preference('app.update.enabled', False)\\n fp.native_events_enabled = False\\n proxy = None\\n if self._configuration.security:\\n self.logger.info(\\\"we use a proxy\\\")\\n fp.accept_untrusted_certs = True\\n proxy = webdriver.Proxy()\\n proxy.http_proxy = \\\"localhost:9080\\\"\\n proxy.ssl_proxy = \\\"localhost:9080\\\"\\n self._browser = webdriver.Firefox(firefox_profile=fp, proxy=proxy)\\n elif self._browserName == \\\"Chrome\\\":\\n # dirty way to launch chromedriver as the current webdriver fail after the xth command\\n import subprocess\\n\\n self._chrome_log_file_stdout = open('chromedriver_stdout.log', 'w')\\n self._chrome_log_file_stderr = open('chromedriver_stderr.log', 'w')\\n subprocess.Popen(\\\"chromedriver\\\", stdout=self._chrome_log_file_stdout,\\n stderr=self._chrome_log_file_stderr)\\n time.sleep(2)\\n self._browser = webdriver.Remote('http://localhost:9515', {\\\"nativeEvents\\\": False,\\n \\\"javascriptEnabled\\\": True})\\n else:\\n raise NotKnown(\\\"Unknown browser : \\\" + self._browserName)\\n self.set_implicit_wait_default()\\n self._browser.maximize_window()\\n self._currentFrame = \\\"main\\\"\\n self.logger.info(\\\"Launching : \\\" + str(self._browserName))\\n except Exception as e:\\n self.logger.error(\\\"Error launching browser : \\\" + str(e))\\n raise\",\n \"def remote(self, *args, **kwargs):\\n return self.api.remote(*args, **kwargs)\",\n \"def GetInstance():\\n pass\",\n \"def bot(self):\\n return self._bot\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.71983075","0.6925138","0.64066046","0.6203262","0.6168742","0.5982635","0.5981238","0.5977537","0.58916575","0.5799441","0.57358706","0.572651","0.57153845","0.5688557","0.5687891","0.56801546","0.56783015","0.5634735","0.5615675","0.5575124","0.55226266","0.55159634","0.5482795","0.54724836","0.54551005","0.5427612","0.5414991","0.5407184","0.53872156","0.53818244","0.53782576","0.53769696","0.53751504","0.53620726","0.5355761","0.5325902","0.5324589","0.5317523","0.5294592","0.5282534","0.52816516","0.5278394","0.52485025","0.5241186","0.5231728","0.52167314","0.5203451","0.5191096","0.51886183","0.5185795","0.5180684","0.51636904","0.51636904","0.51636904","0.5158311","0.5144289","0.5144013","0.51429826","0.5140698","0.51404244","0.51364183","0.5131676","0.5127149","0.51086885","0.5105873","0.5098631","0.5091997","0.5089115","0.5087931","0.50874597","0.5085145","0.50700873","0.5063104","0.50568926","0.50539607","0.5052707","0.5046277","0.50423515","0.50414777","0.5038636","0.50272065","0.5022677","0.50219184","0.50148976","0.5013868","0.50042397","0.49995407","0.49995407","0.4995901","0.4989731","0.49887758","0.49765906","0.4976485","0.49752522","0.49724823","0.49724823","0.49661756","0.49660796","0.49541545","0.49389824"],"string":"[\n \"0.71983075\",\n \"0.6925138\",\n \"0.64066046\",\n \"0.6203262\",\n \"0.6168742\",\n \"0.5982635\",\n \"0.5981238\",\n \"0.5977537\",\n \"0.58916575\",\n \"0.5799441\",\n \"0.57358706\",\n \"0.572651\",\n \"0.57153845\",\n \"0.5688557\",\n \"0.5687891\",\n \"0.56801546\",\n \"0.56783015\",\n \"0.5634735\",\n \"0.5615675\",\n \"0.5575124\",\n \"0.55226266\",\n \"0.55159634\",\n \"0.5482795\",\n \"0.54724836\",\n \"0.54551005\",\n \"0.5427612\",\n \"0.5414991\",\n \"0.5407184\",\n \"0.53872156\",\n \"0.53818244\",\n \"0.53782576\",\n \"0.53769696\",\n \"0.53751504\",\n \"0.53620726\",\n \"0.5355761\",\n \"0.5325902\",\n \"0.5324589\",\n \"0.5317523\",\n \"0.5294592\",\n \"0.5282534\",\n \"0.52816516\",\n \"0.5278394\",\n \"0.52485025\",\n \"0.5241186\",\n \"0.5231728\",\n \"0.52167314\",\n \"0.5203451\",\n \"0.5191096\",\n \"0.51886183\",\n \"0.5185795\",\n \"0.5180684\",\n \"0.51636904\",\n \"0.51636904\",\n \"0.51636904\",\n \"0.5158311\",\n \"0.5144289\",\n \"0.5144013\",\n \"0.51429826\",\n \"0.5140698\",\n \"0.51404244\",\n \"0.51364183\",\n \"0.5131676\",\n \"0.5127149\",\n \"0.51086885\",\n \"0.5105873\",\n \"0.5098631\",\n \"0.5091997\",\n \"0.5089115\",\n \"0.5087931\",\n \"0.50874597\",\n \"0.5085145\",\n \"0.50700873\",\n \"0.5063104\",\n \"0.50568926\",\n \"0.50539607\",\n \"0.5052707\",\n \"0.5046277\",\n \"0.50423515\",\n \"0.50414777\",\n \"0.5038636\",\n \"0.50272065\",\n \"0.5022677\",\n \"0.50219184\",\n \"0.50148976\",\n \"0.5013868\",\n \"0.50042397\",\n \"0.49995407\",\n \"0.49995407\",\n \"0.4995901\",\n \"0.4989731\",\n \"0.49887758\",\n \"0.49765906\",\n \"0.4976485\",\n \"0.49752522\",\n \"0.49724823\",\n \"0.49724823\",\n \"0.49661756\",\n \"0.49660796\",\n \"0.49541545\",\n \"0.49389824\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62758404"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":88380,"cells":{"query":{"kind":"string","value":"Starts the Selenium Server provided with SeleniumLibrary. `params` can contain additional command line options given to the Selenium Server. This keyword uses some command line options"},"document":{"kind":"string","value":"def start_selenium_server(self, *params):\n params = ('-port', str(self._server_port)) + params\n logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')\n self._selenium_log = open(logpath, 'w')\n start_selenium_server(self._selenium_log, self._jar_path, *params)\n self._html('Selenium server log is written to <a href=\"file://%s\">%s</a>.'\n % (logpath.replace('\\\\', '/'), logpath))"},"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 start_selenium_server(logfile=None, jarpath=None, *params):\n if not subprocess:\n raise RuntimeError('This function requires `subprocess` module which '\n 'is available on Python/Jython 2.5 or newer.')\n cmd = _server_startup_command(jarpath, *params)\n try:\n subprocess.Popen(cmd, stdout=logfile, stderr=subprocess.STDOUT)\n except OSError:\n raise RuntimeError('Starting Selenium Server failed. Check that you '\n 'have Java 1.5 or newer installed by running '\n '`java -version` on the command prompt.')\n print 'Selenium Server started with command \"%s\" ' % ' '.join(cmd)","def start(self):\r\n if platform.system() == \"Windows\":\r\n # Use a local GeckoDriver on Windows\r\n ffo = Options()\r\n ffo.headless = self.state\r\n gecko = \"dependencies/geckodriver.exe\"\r\n full_gecko = os.path.abspath(gecko)\r\n self.web_driver = webdriver.Firefox(executable_path=full_gecko, options=ffo)\r\n else:\r\n # Use a remote server if testing on Travis\r\n username = os.environ[\"SAUCE_USERNAME\"]\r\n access_key = os.environ[\"SAUCE_ACCESS_KEY\"]\r\n capabilities = {}\r\n capabilities[\"tunnel-identifier\"] = os.environ[\"TRAVIS_JOB_NUMBER\"]\r\n capabilities['version'] = \"45.0\"\r\n capabilities['browserName'] = \"firefox\"\r\n hub_url = \"%s:%s@localhost:4445\" % (username, access_key)\r\n self.web_driver = webdriver.Remote(\r\n desired_capabilities=capabilities,\r\n command_executor=\"http://%s/wd/hub\" % hub_url)","def start_server_and_driver(path_to_driver, path_to_browser):\n \n server = service.Service(path_to_driver)\n server.start()\n\n capabilities = {'chrome.binary': path_to_browser}\n driver = webdriver.Remote(server.service_url, capabilities)\n \n return server, driver","def main():\n driver = Driver()\n driver.start()","def start(params) -> None:\n check_root()\n start_microservice(params)\n load_kernel_module(params)\n start_streamer(params)","def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver","def start(self):\n # iPhone\n #driver = webdriver.Remote(browser_name=\"iphone\", command_executor='http://172.24.101.36:3001/hub')\n # Android\n #driver = webdriver.Remote(browser_name=\"android\", command_executor='http://127.0.0.1:8080/hub')\n # Google Chrome \n #driver = webdriver.Chrome()\n # Firefox \n #FirefoxProfile fp = new FirefoxProfile();\n #fp.setPreference(\"webdriver.load.strategy\", \"unstable\");\n #WebDriver driver = new FirefoxDriver(fp);\n \n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\n driver = webdriver.Firefox()\n \n self.driver = driver","def __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\n\n # selecting driver\n if not driver_path:\n driver = webdriver.Firefox\n driver_options = FireFoxOptions()\n else:\n driver = webdriver.Chrome\n driver_options = ChromeOptions()\n\n # add config\n if options:\n for option in options:\n driver_options.add_argument(option)\n\n self.driver = driver(driver_path, options=driver_options)\n self.waiter = WebDriverWait(self.driver, waiter_timeout)","def start_selenium(site, headless=True):\n global DRIVER\n global PATH_DRIVER\n options = selenium.webdriver.ChromeOptions()\n prefs = {'profile.managed_default_content_settings.images': 2, 'disk-cache-size': 4096}\n options.add_argument('log-level=3')\n options.add_experimental_option(\"prefs\", prefs)\n if headless:\n options.add_argument(\"--headless\")\n options.add_argument(\"--disable-extensions\")\n print(PATH_DRIVER)\n DRIVER[site] = selenium.webdriver.Chrome(options=options)\n colorama.init()\n print(termcolor.colored('Driver started for {}'.format(site), 'green'))\n colorama.Style.RESET_ALL\n colorama.deinit()","def start_server():\n if not os.path.exists(cf.get(\"Selenium\", \"server_path\")):\n jar_name = \"selenium-server-standalone-2.25.0.jar\"\n server_jar = os.path.join(tempfile.gettempdir(), jar_name)\n if not os.path.exists(server_jar):\n r = requests.get(\"http://selenium.googlecode.com/files/%s\" % jar_name)\n jar_on_disk = open(server_jar, \"wb\")\n jar_on_disk.write(r.content)\n jar_on_disk.close()\n else:\n server_jar = cf.get(\"Selenium\", \"server_path\")\n \n s = subprocess.Popen(['java', '-jar', server_jar], \n stdout=tempfile.TemporaryFile(), \n stderr=tempfile.TemporaryFile()).pid\n pidfile = open(pid_file_path, \"w\")\n pidfile.write(str(s))\n pidfile.close()\n\n # make sure the server is actually up\n server_up = False\n waiting = 0\n while server_up == False and waiting < 60:\n try:\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\n s.connect((\"localhost\", 4444))\n s.close()\n server_up = True\n except socket.error:\n time.sleep(1)\n waiting = waiting + 1\n server_up = False\n\n return server_up","def _runner(self, classpath, main, jvm_options, args):","def setUpClass(cls) -> None:\n desired_caps: dict[str, Any] = {}\n desired_caps[\"app\"] = \"plasmawindowed -p org.kde.plasma.nano org.kde.plasma.systemtray\"\n desired_caps[\"timeouts\"] = {'implicit': 10000}\n cls.driver = webdriver.Remote(command_executor='http://127.0.0.1:4723', desired_capabilities=desired_caps)\n cls.driver.implicitly_wait = 10","def test_webuidriver_remote(self):\n\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\n hub.start_server()\n\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\"localhost\", 4444))\n node.start_server()\n executors = SeleniumHatch.get_remote_executors(\"localhost\", 4444)\n\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\n\n self.driver.get('http://www.baidu.com')\n time.sleep(1)\n\n # webuidriver.Remote 是 webdriver.Chrome 的子类\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\n self.assertIsInstance(self.driver, webdriver.Remote)\n\n self.driver.close()\n self.driver.quit()\n\n hub.stop_server()\n node.stop_server()","def launch_browser(option):\n if not option:\n chrome_options = Options()\n chrome_options.add_argument(\"--headless\")\n return webdriver.Chrome(\"/usr/bin/chromedriver\",\n chrome_options=chrome_options)\n else:\n return webdriver.Chrome(\"/usr/bin/chromedriver\")","def setup_selenium():\n # Define the options to run with headless mode enabled\n options = Options()\n options.headless = True\n\n # Instatiate the browser object here, pointing at an exectable location which should be located in the same\n # base directory as the script\n driver = webdriver.Firefox(options=options, executable_path='./geckodriver')\n\n # Impicit wait tell the browser to wait up to 30s for an object to appear, this helps if the connection is slow.\n driver.implicitly_wait(30)\n return driver","def setup_selenium():\n options = webdriver.FirefoxOptions()\n options.add_argument('--ignore-certificate-errors')\n options.add_argument('--incognito')\n options.add_argument('--headless')\n\n return webdriver.Firefox(\n # UNCOMMENT WHEN IN LINUX executable_path=\"drivers/geckodriver-linux\",\n executable_path=\"drivers/geckodriver-macos\",\n firefox_options=options\n )","def start_streamer(params) -> None:\n print(\"Starting streamer...\")\n time.sleep(5)\n cmd = \"./streamer/fakewebcam.py -c \" + params[\"config_file\"] + \" >/dev/null 2>&1\"\n if os.system(cmd) == 0:\n print(\" Success !\")\n else:\n print(\" Failure !\")","def _run_launch(cls, params):\n assert cls.compose_file is not None, \"compose_file file must be set by subclass\"\n assert cls.testname is not None, \"testname file must be set by subclass\"\n\n test_path = dirname(realpath(sys.argv[0]))\n vmnet_path = dirname(vmnet.__file__) if hasattr(vmnet, '__file__') else vmnet.__path__._path[0]\n local_path = abspath(os.getenv('LOCAL_PATH', '.'))\n compose_path = '{}/compose_files/{}'.format(test_path, cls.compose_file)\n docker_dir_path = '{}/docker_dir'.format(test_path)\n launch_path = '{}/launch.py'.format(vmnet_path)\n if not hasattr(cls, 'docker_dir'): cls.docker_dir = docker_dir_path\n cls.launch_path = launch_path\n\n exc_str = 'python {} --compose_file {} --docker_dir {} --local_path {} {}'.format(\n launch_path,\n cls.compose_file if exists(cls.compose_file) else compose_path,\n cls.docker_dir if exists(cls.docker_dir) else docker_dir_path,\n cls.local_path if hasattr(cls, 'local_path') else local_path,\n params\n )\n os.system(exc_str)","def setUp(self):\r\n self.verificationErrors = []\r\n self.selenium = (selenium(selvars.set_localhost(), selvars.set_port(), selvars.set_browser(self.id(),self.shortDescription()), selvars.set_site()))\r\n self.selenium.start()\r\n self.session = self.selenium.sessionId\r\n self.selenium.set_timeout(testvars.timeout)","def setUp(self):\n\n self.driver = WebDriver(\n \"http://{0}:{1}/wd/hub\".format(swt.config.ADDRESS, swt.config.SELENIUM_SERVER_PORT),\n self._browser_capabilities,\n proxy=self.proxy.selenium_proxy()\n )\n swt.active_driver = self.driver","def init_driver(driver_path):\n # user_agent = user_agent_rotator.get_random_user_agent()\n try:\n if driver_path != \"\":\n chrome_options = Options()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--disable-dev-shm-usage')\n chrome_options.add_argument('--window-size=1420,1080')\n chrome_options.add_argument('--disable-gpu')\n chrome_options.add_argument(f'user-agent={USER_AGENT}')\n Driver._driver = webdriver.Chrome(executable_path=driver_path, chrome_options=chrome_options)\n else:\n raise Exception(\"Please provide a path to the chromedriver\")\n except Exception as e:\n logging.error(f\"Driver cannot be found. Path entered: {driver_path}\")\n raise FileNotFoundError(\"Could not execute webdriver. Make sure you provided the correct path to the \"\n \"chromedriver\", e)","def run(options, executable, datadir, parameters):\n if options['pbs']:\n common.pbs.run(options, executable, datadir, parameters)\n else:\n runNode(options, executable, datadir, parameters)","def run_script(self, params, config_no):\n raise NotImplementedError()","def initial_setup(server):\r\n world.absorb(settings.LETTUCE_SELENIUM_CLIENT, 'LETTUCE_SELENIUM_CLIENT')\r\n\r\n if world.LETTUCE_SELENIUM_CLIENT == 'local':\r\n browser_driver = getattr(settings, 'LETTUCE_BROWSER', 'chrome')\r\n\r\n # There is an issue with ChromeDriver2 r195627 on Ubuntu\r\n # in which we sometimes get an invalid browser session.\r\n # This is a work-around to ensure that we get a valid session.\r\n success = False\r\n num_attempts = 0\r\n while (not success) and num_attempts < MAX_VALID_BROWSER_ATTEMPTS:\r\n\r\n # Load the browser and try to visit the main page\r\n # If the browser couldn't be reached or\r\n # the browser session is invalid, this will\r\n # raise a WebDriverException\r\n try:\r\n world.browser = Browser(browser_driver)\r\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\r\n world.visit('/')\r\n\r\n except WebDriverException:\r\n if hasattr(world, 'browser'):\r\n world.browser.quit()\r\n num_attempts += 1\r\n\r\n else:\r\n success = True\r\n\r\n # If we were unable to get a valid session within the limit of attempts,\r\n # then we cannot run the tests.\r\n if not success:\r\n raise IOError(\"Could not acquire valid {driver} browser session.\".format(driver=browser_driver))\r\n\r\n world.absorb(0, 'IMPLICIT_WAIT')\r\n world.browser.driver.set_window_size(1280, 1024)\r\n\r\n elif world.LETTUCE_SELENIUM_CLIENT == 'saucelabs':\r\n config = get_saucelabs_username_and_key()\r\n world.browser = Browser(\r\n 'remote',\r\n url=\"http://{}:{}@ondemand.saucelabs.com:80/wd/hub\".format(config['username'], config['access-key']),\r\n **make_saucelabs_desired_capabilities()\r\n )\r\n world.absorb(30, 'IMPLICIT_WAIT')\r\n world.browser.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\r\n\r\n elif world.LETTUCE_SELENIUM_CLIENT == 'grid':\r\n world.browser = Browser(\r\n 'remote',\r\n url=settings.SELENIUM_GRID.get('URL'),\r\n browser=settings.SELENIUM_GRID.get('BROWSER'),\r\n )\r\n world.absorb(30, 'IMPLICIT_WAIT')\r\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\r\n\r\n else:\r\n raise Exception(\"Unknown selenium client '{}'\".format(world.LETTUCE_SELENIUM_CLIENT))\r\n\r\n world.browser.driver.implicitly_wait(world.IMPLICIT_WAIT)\r\n world.absorb(world.browser.driver.session_id, 'jobid')","def LaunchChromium(chrome_exe, chromium_paths, test_name,\n is_dns_forwarded, use_auto):\n REPLAY_HOST='127.0.0.1'\n user_data_dir = USER_DATA_DIR.format(**{'TEMP': tempfile.gettempdir()})\n chromium_args = [\n chrome_exe,\n '--load-extension=%s' % chromium_paths['extension'],\n '--testing-fixed-http-port=%s' % HTTP_PORT,\n '--testing-fixed-https-port=%s' % HTTPS_PORT,\n '--disable-background-networking',\n '--enable-experimental-extension-apis',\n '--enable-file-cookies',\n '--enable-logging',\n '--log-level=0',\n '--enable-stats-table',\n '--enable-benchmarking',\n '--ignore-certificate-errors',\n '--metrics-recording-only',\n '--activate-on-launch',\n '--no-first-run',\n '--no-proxy-server',\n '--user-data-dir=%s' % user_data_dir,\n '--window-size=1280,1024',\n ]\n if not is_dns_forwarded:\n chromium_args.append('--host-resolver-rules=MAP * %s' % REPLAY_HOST)\n start_url = 'file://%s?test=%s' % (chromium_paths['start.html'], test_name)\n if use_auto:\n start_url += '&auto=1'\n chromium_args.append(start_url)\n if os.path.exists(user_data_dir):\n shutil.rmtree(user_data_dir)\n os.makedirs(user_data_dir)\n try:\n logging.debug('Starting Chrome: %s', chromium_args)\n retval = subprocess.call(chromium_args)\n finally:\n shutil.rmtree(user_data_dir)","def setUp(self):\n options = webdriver.ChromeOptions()\n\n # Define a custom User Agent\n user_agent = '--user-agent=\"' + CFG['user_agent'] + '\"'\n options.add_argument(user_agent)\n\n # Setup the full screen kiosk\n if CFG['kiosk']:\n options.add_argument('--kiosk')\n\n # Alternatively launch the webdriver Firefox browser\n # test whether Firefox loads the videos better\n\n # Launch a Chrome instance with the appropriate options\n chrome_paths = ('c:\\Program Files\\chromedriver.exe',\n 'c:\\Program Files (x86)\\chromedriver.exe')\n # Try to launch the Chrome driver without any path details\n try:\n self.driver = webdriver.Chrome(chrome_options=options)\n # If it raises an exception try looping through the path options\n except webdriver.chrome.webdriver.WebDriverException:\n for chrome_path in chrome_paths:\n try:\n self.driver = webdriver.Chrome(chrome_path,\n chrome_options=options)\n except webdriver.chrome.webdriver.WebDriverException:\n pass\n else:\n break","def before_productline_steps():\n cmd = ['phantomjs', '--webdriver', '4444']\n click.echo(\"Running command\" + subprocess.list2cmdline(cmd))\n process = subprocess.Popen(cmd)\n RUNNING_TEST_PROCESSES.append(process)","def initBrowser(browserConfig, isUseSeleniumwire=False):\n webdriver = getWebDirver(isUseSeleniumwire=isUseSeleniumwire)\n chromeOptions = webdriver.ChromeOptions()\n\n if \"headless\" in browserConfig:\n isCurHeadless = browserConfig[\"headless\"]\n if isCurHeadless:\n chromeOptions.add_argument('--headless')\n\n if \"disableGpu\" in browserConfig:\n isDisableGpu = browserConfig[\"disableGpu\"]\n if isDisableGpu:\n chromeOptions.add_argument('--disable-gpu')\n\n # for debug\n # chromeOptions.add_experimental_option(\"excludeSwitches\", [\"enable-automation\"])\n # chromeOptions.add_experimental_option('useAutomationExtension', False)\n # chromeOptions.add_argument('window-size=1920x1080')\n # chromeOptions.add_argument('--window-size=1920x1080')\n\n driverConfigDict = {\n \"options\": chromeOptions\n }\n\n if \"seleniumwire\" in browserConfig:\n if isUseSeleniumwire:\n driverConfigDict[\"seleniumwire_options\"] = browserConfig[\"seleniumwire\"]\n else:\n del browserConfig[\"seleniumwire\"]\n\n driver = webdriver.Chrome(**driverConfigDict)\n # driver = webdriver.Chrome(options=chromeOptions)\n\n # # for debug\n # driver.set_window_size(1920, 1080)\n\n if \"pageLoadTimeout\" in browserConfig:\n curPageLoadTimeout = browserConfig[\"pageLoadTimeout\"]\n driver.set_page_load_timeout(curPageLoadTimeout)\n\n return driver","def test_explicit_start_stop(self, runpath):\n driver = self.MyDriver(name=\"MyDriver\", runpath=runpath)\n\n assert not driver.pre_start_called\n assert not driver.post_start_called\n\n driver.start()\n\n assert driver.pre_start_called\n assert not driver.post_start_called\n\n driver.wait(driver.STATUS.STARTED)\n\n assert driver.post_start_called\n assert not driver.pre_stop_called\n assert not driver.post_stop_called\n\n driver.stop()\n\n assert driver.pre_stop_called\n assert not driver.post_stop_called\n\n driver.wait(driver.STATUS.STOPPED)\n\n assert driver.post_stop_called","def start_browser_with(self, browser: 'Browserify', url: 'Url') -> 'StartableClient':","def startBrowser(self):\n if 'TRAVIS' in os.environ:\n # Initialize hidden display for Firefox.\n # Less annoying and allows remote execution.\n display = Display(visible=0, size=(800, 600))\n display.start()\n\n self.browser = webdriver.Firefox()\n self.browser.implicitly_wait(3)","def setup(setup_filenames, loop_filename, chromedriver_path=None,\n log_path=\"/tmp/BrowserAutomator.log\",\n log_level=\"ERROR\"):\n logging_setup(log_path, log_level)\n driver = selenium_setup(chromedriver_path)\n if action_runner(driver, setup_filenames) == 1:\n driver.quit()\n return 1\n out = loop_runner(driver, loop_filename, setup_filenames)\n driver.quit()\n return out","def RunCommand(self, params):\n prefix = ['container', 'hub', 'memberships', 'register']\n return self.Run(prefix + params)","def main():\r\n args = getargs()\r\n testng_file = args.testng_file\r\n url = args.url\r\n fetch_testng(testng_file, url)","def run():\n import argparse\n\n parser = argparse.ArgumentParser(description='Phovea Server')\n parser.add_argument('--use_reloader', action='store_true', help='whether to automatically reload the server')\n parser.add_argument('--env', default=cc.get('env'), help='environment mode (dev or prod)')\n\n # parse before to enable correct plugin discovery\n args = parser.parse_known_args()[0]\n if args.env.startswith('dev'):\n enable_dev_mode()\n else:\n enable_prod_mode()\n\n # resolve the default command to decide which application to launch\n default_command = _resolve_commands(parser)\n if default_command is not None:\n # set a default subparse to extract the defined arguments from the instance to the main arguments (?)\n set_default_subparser(parser, default_command)\n\n args = parser.parse_args()\n\n _set_runtime_infos(args)\n\n main = args.launcher(args) # execute the launcher function, which returns another function\n\n if args.use_reloader:\n _log.info('start application using reloader...')\n run_with_reloader(main, extra_files=_config_files())\n else:\n _log.info('start application...')\n main()","def start_chrome():\n os.system(\"start {CHROME_PATH} --remote-debugging-port={CHROME_DEBUG_PORT} --user-data-dir=\\\"{CHROME_USERDATA_PATH}\\\" --lang=zh-CN\".format(\n CHROME_PATH=CHROME_PATH, CHROME_DEBUG_PORT=CHROME_DEBUG_PORT, CHROME_USERDATA_PATH=CHROME_USERDATA_PATH))\n\n chrome_options = Options()\n chrome_options.add_experimental_option(\"debuggerAddress\", \"127.0.0.1:9222\")\n driver = webdriver.Chrome(\n CHROME_DRIVER_PATH, chrome_options=chrome_options)\n time.sleep(2)\n\n return driver","def run(parameters=None, silent=False):\n return _proc_exec_wait(\"{0} {1}\".format(_config.command, parameters), silent)","def _SetRunParameters(self, params: Mapping[str, Any]) -> None:\n # Ideally YCSB should be refactored to include a function that just takes\n # commands for a run, but that will be a large refactor.\n FLAGS['ycsb_run_parameters'].unparse()\n FLAGS['ycsb_run_parameters'].parse([f'{k}={v}' for k, v in params.items()])","def main(args=None):\n args = args or sys.argv[1:]\n parser = parse_options()\n common.main_cli(experiment_parse_and_run, parser, args)","def init_webdriver(driver_name=None, headless=False):\n\n if driver_name == \"chrome\":\n try:\n #try to connect with chrome driver\n driver = connect_chrome_driver(headless)\n except:\n print_pretty(\"Sorry, you can't use chrome driver, please try another driver!\")\n sys.exit(0)\n elif driver_name == \"ie\":\n try:\n #try to connect with ie driver\n driver = connect_ie_driver(headless)\n except:\n print_pretty(\"Sorry, you can't use internet explorer driver, please try another driver!\")\n sys.exit(0)\n elif driver_name == \"firefox\":\n try:\n #try to connect with firefox driver\n driver = connect_firefox_driver(headless)\n except:\n print_pretty(\"sorry, you can't use firefox driver, please try another driver!\")\n sys.exit(0)\n else:\n print_pretty(\"No browser selected, please choose 'chrome', 'ie' or 'firefox'\")\n return None\n\n print_pretty(\"Selenium driver\", driver_name, \"sucessfully initialised\")\n return driver","def __init__(self, BrowserType=\"Chrome\", Remote=False, Headless=False, BrowserWidth=1920,\n BrowserHeight=1080, SeleniumGridHost=\"\", SeleniumGridPort=4444, Options=[], DesiredCapabilities={}):\n self.BrowserType = BrowserType\n self.Remote = Remote\n self.Headless = Headless\n self.BrowserWidth = BrowserWidth\n self.BrowserHeight = BrowserHeight\n self.SeleniumGridHost = SeleniumGridHost\n self.SeleniumGridPort = SeleniumGridPort\n self.Options = Options\n self.DesiredCapabilities = DesiredCapabilities","def launch(\n click_context: click.Context,\n agents: List[str],\n password: Optional[str],\n multithreaded: bool,\n) -> None:\n _launch_agents(click_context, agents, multithreaded, password)","def setup_driver():\n os.environ[\"webdriver.chrome.driver\"] = chrome_driver_location\n driver = webdriver.Chrome(chrome_driver_location)\n driver.set_window_size(1280, 800)\n return driver","def call(self, **params):\n # NOTE - use __call__??\n # TODO - move exec_script here?\n # TODO - call should handle param defaults\n from datapane.runner.exec_script import run\n\n run(self, params)","def __init__(self, driver_path=None):\n\n if driver_path is None:\n self.driver = webdriver.Firefox()\n else:\n print(\"Alter gecko path\")\n self.driver = webdriver.Firefox(executable_path=driver_path)","def seleniumDriver():\n chrome_options = Options()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--disable-dev-shm-usage')\n driver = webdriver.Chrome(\"/usr/bin/chromedriver\",\n options=chrome_options\n )\n driver.set_page_load_timeout(10)\n return driver","def start(coordinator_url: str, use_case: UseCase):\n\n raise NotImplementedError","def initDriver(browser):\n if browser == \"firefox\":\n opts = Options()\n opts.log.level = \"trace\"\n driver = webdriver.Firefox(options=opts)\n return driver\n elif browser == \"chrome\":\n options = webdriver.ChromeOptions()\n options.add_argument(\"start-maximized\")\n #d = DesiredCapabilities.CHROME\n d = options.to_capabilities()\n d['loggingPrefs'] = { 'browser':'ALL'}\n driver = webdriver.Chrome('../Data/chromedriver_linux64/chromedriver',desired_capabilities=d)\n return driver\n else:\n print(\"------- Navegador no compatible ---------\")\n return null","def main(aArgs, aTransmitToTaskHandler):\n\n global TASK_HANDLER_HOST\n global TASK_HANDLER_PORT\n\n # if the option --printList is passed, only generate the file\n # reftestList.txt\n if hasattr(aArgs, \"printList\"):\n printReftestList()\n exit(0)\n\n # if the option --printNotes is passed, only generate the\n # testsuiteNotes html page.\n if hasattr(aArgs, \"printNotes\"):\n printNotes()\n exit(0)\n\n # if the option --printListOfTests is passed, only generate a ListOfTests\n # from a file containing test URIs\n if hasattr(aArgs, \"printListOfTests\"):\n if not aArgs.printListOfTests:\n print(\"No input file!\", file=sys.stderr)\n exit(0)\n printListOfTests(aArgs.printListOfTests)\n exit(0)\n\n # create the date directory\n now = datetime.utcnow();\n directory = MATHJAX_WEB_PATH + \"results/\"\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # create the subdirectory\n if aArgs.output and re.match(\"^([0-9]|[a-z]|[A-Z]|-|/){1,50}/$\",\n aArgs.output):\n directory += aArgs.output\n else:\n directory += now.strftime(\"%Y-%m-%d/%H-%M-%S/\")\n\n if not os.path.exists(directory):\n os.makedirs(directory)\n\n # execute testing instances for all the config files\n configFileList = aArgs.config.split(\",\")\n\n for configFile in configFileList:\n\n configFile = configFile\n\n if (not os.path.isfile(configFile)):\n print(\"Warning: config file \" + configFile + \" not found!\",\n file=sys.stderr)\n continue\n\n # Load configuration file\n config = ConfigParser.ConfigParser()\n config.readfp(open(configFile))\n\n # framework section\n section = \"framework\"\n useGrid = getBooleanOption(config, section, \"useGrid\")\n host = config.get(section, \"host\")\n # host == \"default\" is handled below\n port = config.getint(section, \"port\")\n if (port == -1):\n port = SELENIUM_SERVER_PORT\n mathJaxPath = config.get(section, \"mathJaxPath\")\n if (mathJaxPath == \"default\"):\n mathJaxPath = DEFAULT_MATHJAX_PATH\n mathJaxTestPath = config.get(section, \"mathJaxTestPath\")\n if (mathJaxTestPath == \"default\"):\n mathJaxTestPath = MATHJAX_TEST_LOCAL_URI + \"testsuite/\"\n timeOut = config.getint(section, \"timeOut\")\n if (timeOut == -1):\n timeOut = DEFAULT_TIMEOUT\n timeOut = timeOut * 1000 # convert in ms\n useWebDriver = getBooleanOption(config, section, \"useWebDriver\")\n fullScreenMode = getBooleanOption(config, section, \"fullScreenMode\")\n formatOutput = getBooleanOption(config, section, \"formatOutput\")\n compressOutput = getBooleanOption(config, section, \"compressOutput\")\n\n # platform section\n section = \"platform\"\n operatingSystem = config.get(section, \"operatingSystem\")\n if (operatingSystem == \"default\"):\n operatingSystem = OS_LIST[0]\n if (host == \"default\"):\n host = HOST_LIST[HOST_LIST_OS.index(OS_LIST.index(operatingSystem))]\n browserList = config.get(section, \"browser\").split()\n browserVersionList = config.get(section, \"browserVersion\").split()\n browserModeList = config.get(section, \"browserMode\").split()\n browserPath = config.get(section, \"browserPath\")\n fontList = config.get(section, \"font\").split()\n outputJaxList = config.get(section, \"outputJax\").split()\n \n # testsuite section\n section = \"testsuite\"\n runSlowTests = getBooleanOption(config, section, \"runSlowTests\")\n runSkipTests = getBooleanOption(config, section, \"runSkipTests\")\n listOfTests = config.get(section, \"listOfTests\")\n startID = config.get(section, \"startID\")\n if (startID == \"default\"):\n startID = \"\"\n \n # When more than one browser is specified, browserPath is ignored.\n if (len(browserList) > 1 and browserPath != \"default\"):\n print(\"Warning: browserPath ignored\", file=sys.stderr)\n browserPath = \"default\"\n\n for browser in browserList:\n\n if (browser == \"default\"):\n browser = BROWSER_LIST[0]\n\n for font in fontList:\n\n if (font == \"default\"):\n font = FONT_LIST[0]\n\n for outputJax in outputJaxList:\n\n if (outputJax == \"default\"):\n outputJax = OUTPUT_JAX_LIST[0]\n\n for browserVersion in browserVersionList:\n\n # browserModeList is only relevant for MSIE\n if not(browser == \"MSIE\"):\n browserModeList2 = [\"default\"]\n else:\n browserModeList2 = browserModeList\n \n for browserMode in browserModeList2:\n \n # Create a Selenium instance\n selenium = \\\n seleniumMathJax.seleniumMathJax(useWebDriver,\n useGrid,\n host,\n port,\n mathJaxPath,\n mathJaxTestPath,\n operatingSystem,\n browser,\n browserVersion,\n browserMode,\n browserPath,\n font,\n outputJax,\n timeOut,\n fullScreenMode)\n \n if aTransmitToTaskHandler:\n taskHandler = [TASK_HANDLER_HOST,\n TASK_HANDLER_PORT,\n str(os.getpid())]\n else:\n taskHandler = None\n\n # Create the test suite\n suite = reftest.reftestSuite(taskHandler,\n runSlowTests,\n runSkipTests,\n listOfTests,\n startID)\n # use the specified file name\n if hasattr(aArgs, \"filename\"):\n filename = aArgs.filename\n else:\n filename = getOutputFileName(directory,\n selenium,\n suite)\n runTestingInstance(directory, selenium, suite,\n formatOutput, compressOutput,\n filename)\n # end browserMode\n # end browserVersion\n #end outputJax\n # end for font\n # end browser","def launch_tool(https_authority,username,password,browser,catalog,utils,tool_name,\n tool_revision,parameters_text,add_empty_params=False):\n\n # login to the hub\n utils.account.login_as(username,password)\n\n # go to the page to launch the tool\n # with the parameters encoded in the url\n GenericPage = catalog.load('GenericPage')\n po = GenericPage(browser,catalog)\n\n # quote() is for escaping the path portion of the url\n # quote_plus() is for escaping the query portion of the url\n # and handles escaping / to %2F, but turns spaces into +'s\n encoded_parameters = urllib.quote_plus(parameters_text.encode('utf8'))\n\n url = \"%(https_authority)s/tools/%(toolname)s/invoke/%(toolrev)s\"\n\n if encoded_parameters != '' or add_empty_params:\n url += \"?params=%(params)s\"\n\n # hard code tool revision to test so we don't have to publish the tool\n tool_revision = 'test'\n\n url = url % {'https_authority' : https_authority,\n 'toolname' : tool_name,\n 'toolrev' : tool_revision,\n 'params' : encoded_parameters,}\n\n # print \"parameters_text = %s\" % (parameters_text)\n # print \"url = %s\" % (url)\n\n # launch the tool\n browser.proxy_client.new_har(\"page link\")\n po.goto_page(url)\n har_entry = browser.page_load_details()\n\n if browser.error_loading_page(har_entry):\n # the tool session container may still start,\n # even if the har status is not 200 level\n # try to close it before raising the error\n\n har_status = har_entry['response']['status']\n # print har_status\n raise HarStatusError(\"unexpected error while launching tool: %s\" % (har_status))\n\n # include a check for 'Bad Parameters' error box in html\n # because the error page returns status of 200\n for msg in po.get_errorbox_info():\n if 'bad parameters' in msg.lower():\n raise BadParameterError(\n \"found a 'Bad Parameters' error box in the html of\" \\\n + \" %s while passing parameters: %s\\n%s\" \\\n % (url,parameters_text,msg))\n\n # one last check for middleware errors that take the user back to\n # the member's dashboard page. middleware can't send messages back\n # to the web server, so we get the message \"Failed to invoke session\"\n loc = 'css=dd.error'\n if po.is_displayed(loc):\n # there is an error message displayed\n e = po.find_element(loc)\n msg = e.text\n raise SessionInvokeError(msg)\n\n # get the session number from the tool session page\n ToolSessionPage = catalog.load('ToolSessionPage')\n po = ToolSessionPage(browser,catalog)\n tool_session_number = po.get_session_number()\n\n return tool_session_number","def start_server(**params):\n\n def _grpc_server_async(options):\n call_command(\"grpcserver\", **options)\n\n port = 50000 + randint(0, 10000)\n params[\"port\"] = port\n # Start grpc server\n srv = threading.Thread(\n target=_grpc_server_async, args=[params]\n )\n srv.start()\n sleep(5)\n return \"localhost:%s\" % port","def main():\n print(\"runner\")\n runner = Runner()\n stop_on_idle = True\n probes = []\n for url in urls:\n probe_cls = random.choice((HttpProbe, ThreadProbe, ShellProbe))\n runner.probes.append(probe_cls(url))\n\n runner.run()","def init_driver():\n driver = webdriver.Firefox()\n driver.wait = WebDriverWait(driver,5)\n return driver","def run_tests(params):\n default_test_params = [\n \"./tests\",\n \"-vv\",\n \"--json-report\",\n \"--key-file\",\n DEFAULT_KEY_FILE.name\n ]\n\n with DEBUG_LOG_FILE.open(\"a\") as debug_out:\n with redirect_stdout(debug_out):\n with redirect_stderr(sys.stdout):\n return pytest.main(default_test_params + params)","def __init__(self, path_to_web_driver='/usr/local/bin/chrome'):\n self.path_to_web_driver = path_to_web_driver\n options = webdriver.ChromeOptions()\n options.add_argument('headless')\n webdriver.Chrome.__init__(self, executable_path=self.path_to_web_driver, chrome_options=options)","def run_ps(self):\n config = self._estimator.config\n server = self._start_std_server(config)\n server.join()","def driver():\n driver = webdriver.Chrome(chrome_options=ChromeOptions(), project_name=\"Examples\", job_name=\"Pytest Example\")\n yield driver\n driver.quit()","def launch(**kwargs):\n logger.info('launch dream command')\n launch_gui()","def __init__(self, logger, binary, webdriver_binary=\"chromedriver\",\n adb_binary=None,\n remote_queue=None,\n device_serial=None,\n webdriver_args=None,\n stackwalk_binary=None,\n symbols_path=None):\n super().__init__(logger,\n webdriver_binary, adb_binary, remote_queue,\n device_serial, webdriver_args, stackwalk_binary,\n symbols_path)\n self.binary = binary\n self.wptserver_ports = _wptserve_ports","def runner(self, classpath, main, jvm_options=None, args=None):\r\n return self._runner(*self._scrub_args(classpath, main, jvm_options, args))","def start_collector_configure() -> WebDriver:\n exp_cap = {\n \"app\": r\"C:\\Program Files\\Centrify\\Audit\\Collector\\collector.configure.exe\",\n \"deviceName\": \"WindowsPC\"\n }\n exp_session = webdriver.Remote(\n command_executor='http://127.0.0.1:4723',\n desired_capabilities=exp_cap)\n return exp_session","def setUpClass(cls):\n super().setUpClass()\n options = Options()\n options.headless = True\n cls.selenium = WebDriver(options=options)\n cls.selenium.implicitly_wait(10)","def run_local_test_run(self, api, test_config_params,\n skip_download=False): # pragma: no cover\n if self.m.platform.is_win:\n self.m.chromium.taskkill()\n\n if skip_download:\n update_step = None\n else:\n update_step = api.bot_update.ensure_checkout(\n root_solution_revision=test_config_params['revision'])\n self.start_test_run_for_bisect(api, update_step, self.bot_db,\n test_config_params, run_locally=True,\n skip_download=skip_download)","def _start_server():\n args = [sys.executable] + sys.argv\n args.insert(args.index('wserver'), 'server')\n args.remove('wserver')\n pid = os.spawnv(os.P_NOWAIT, sys.executable, args)\n return pid","def main():\n\n run_manual_session()\n # run_automated_session()","def launch(config):\n \n launch_with_configs([config])","def browser(config, config_url, config_browser, config_wait_time):\n try:\n kwargs = {}\n if 'binary' in config:\n binary = config['binary']\n if config['selenium_grid']:\n caps = {'browserName': config_browser}\n command_executor_url = \"http://{}:4444/wd/hub\".format(config['hub_host'])\n driver = webdriver.Remote(\n command_executor=command_executor_url,\n desired_capabilities=caps\n )\n else:\n if config_browser == 'chrome':\n if binary:\n kwargs.update({'executable_path': binary})\n options = webdriver.ChromeOptions()\n options.add_argument('disable-web-security')\n options.add_argument(\"--no-sandbox\")\n options.add_argument(\"--disable-dev-shm-usage\")\n kwargs.update({'options': options})\n driver = webdriver.Chrome(**kwargs)\n elif config_browser == 'firefox':\n driver = webdriver.Firefox(**kwargs)\n else:\n raise Exception('\"{config_browser}\" is not a supported browser')\n\n # Wait implicitly for elements to be ready before attempting interactions\n driver.implicitly_wait(config_wait_time)\n driver.get(config_url)\n driver.maximize_window()\n\n # Return the driver object at the end of setup\n yield driver\n finally:\n # For cleanup, quit the driver\n driver.quit()","def main():\n args = docopt(__doc__)\n loc = \"%s/%s/dataset/%s\" % (args['--host'], args['--prefix'], args['DATASET'])\n qstr = \"staticThreshold=Infinity\"\n qstr += \"&nohitThreshold=Infinity\"\n qstr += \"&plotGraphics=svg\"\n if args['--format'] == 'svg':\n qstr += \"&svgThreshold=Infinity\"\n shape = 'square'\n for param in args['--param']:\n qstr += \"&%s\" % str(param)\n key, value = param.split('=')\n if key == 'plotShape':\n shape = value\n\n timeout = int(args['--timeout'])\n\n outdir = os.path.abspath(args['--out'])\n os.makedirs(Path(outdir), exist_ok=True)\n\n profile = webdriver.FirefoxProfile()\n profile.set_preference('browser.download.folderList', 2)\n profile.set_preference('browser.download.manager.showWhenStarting', False)\n profile.set_preference('browser.download.dir', outdir)\n profile.set_preference('browser.download.lastDir', args['--out'])\n profile.set_preference('browser.helperApps.neverAsk.saveToDisk',\n 'image/png, image/svg+xml, text/csv, text/plain, application/json')\n\n options = Options()\n options.set_headless(headless=False)\n display = Display(visible=0, size=(800, 600))\n display.start()\n driver = webdriver.Firefox(options=options, firefox_profile=profile)\n try:\n view = args['--view'][0]\n if args['--preview']:\n qstr += '#Filters'\n url = \"%s/%s?%s\" % (loc, view, qstr)\n print(\"Loading %s\" % url)\n try:\n driver.get(url)\n except Exception as err:\n print(err)\n\n for next_view in args['--view']:\n if next_view != view:\n view = next_view\n url = \"%s/%s?%s\" % (loc, view, qstr)\n print(\"Navigating to %s\" % url)\n try:\n driver.get(url)\n except Exception as err:\n print(err)\n for fmt in args['--format']:\n file = \"%s.%s\" % (args['DATASET'], view)\n if view == 'blob':\n file += \".%s\" % shape\n elif view == 'busco':\n view = \"all_%s\" % view\n if fmt not in ('csv', 'json'):\n fmt = 'json'\n file += \".%s\" % fmt\n print(\"Fetching %s\" % file)\n el_id = \"%s_save_%s\" % (view, fmt)\n print(\"waiting for element %s\" % el_id)\n unstable = True\n while unstable:\n try:\n element = WebDriverWait(driver, timeout).until(\n EC.visibility_of_element_located((By.ID, el_id))\n )\n element.click()\n unstable = False\n file_name = \"%s/%s\" % (outdir, file)\n print(\"waiting for file '%s'\" % file_name)\n file_ready(file_name)\n except Exception as err:\n time.sleep(1)\n\n for preview in args['--preview']:\n print(\"Creating %s preview\" % preview)\n for fmt in args['--format']:\n el_id = \"%s_preview_save_%s\" % (preview, fmt)\n file = \"%s.%s.preview.%s\" % (args['DATASET'], preview, fmt)\n try:\n element = WebDriverWait(driver, timeout).until(\n EC.visibility_of_element_located((By.ID, el_id))\n )\n element.click()\n file_name = \"%s/%s\" % (outdir, file)\n print(\"waiting for file '%s'\" % file_name)\n file_ready(file_name)\n except Exception as err:\n print(err)\n driver.close()\n except Exception as err:\n print(err)\n driver.close()","def launch_ec(self, argStr='', input='', flag=''):\n command = 'python tests/targets/simple.py'\n\n if flag:\n command += ' %s' % flag\n\n if argStr:\n\n command += ' %s' % argStr\n\n return shell_exec(command, input=input)","def _start(args=None):\n options = _parse_args(args)\n main(**options)","def launch_application(path) -> WebDriver:\n try:\n exp_cap = {\n \"deviceName\": \"WindowsPC\",\n \"app\": path}\n exp_session = webdriver.Remote(\n command_executor='http://127.0.0.1:4723',\n desired_capabilities=exp_cap)\n return exp_session\n except Exception as ex:\n logger.info(f':Error in launching app ERROR: {ex}')","def get_driver_with_options():\n #options = get_driver_options()\n #return webdriver.Chrome(options=options)\n return webdriver.Chrome()","def main():\n return run_server(**parse_server_args())","def setUpClass(cls):\n\n super().setUpClass()\n cls.selenium = WebDriver(executable_path=\"C:\\Program Files (x86)\\chromedriver.exe\")\n cls.selenium.implicitly_wait(10)","def launch_chrome():\r\n DRIVER_PATH = '/Users/User/Downloads/chromedriver_win32/chromedriver' #Location of chromedriver application\r\n chrome_options = webdriver.ChromeOptions()\r\n chrome_options.add_argument('--disable-blink-features=AutomationControlled') #Tells browser it is not controlled by automation\r\n driver = webdriver.Chrome(DRIVER_PATH,options = chrome_options)\r\n return driver","def setup(self, skip_start=False):\n nprev_comm = self.comm_count\n nprev_thread = self.thread_count\n nprev_fd = self.fd_count\n self.driver = self.driver_class(*self.driver_args, **self.driver_kwargs)\n if not skip_start:\n self.driver.start()\n os.environ.update(self.driver.env)\n self._skip_start = skip_start\n super(TestBase, self).setup(nprev_comm=nprev_comm,\n nprev_thread=nprev_thread,\n nprev_fd=nprev_fd)","def cli(argv):\n import getopt\n class BadUsage(Exception): pass\n\n try:\n opts, args = getopt.getopt(argv[1:], 'gp:r:h:s:', \n ['gui', 'port=', 'repository=', 'script-alias='])\n for opt, val in opts:\n if opt in ('-g', '--gui'):\n options.start_gui = 1\n elif opt in ('-r', '--repository'):\n if options.repositories: # option may be used more than once:\n num = len(options.repositories.keys())+1\n symbolic_name = \"Repository\"+str(num)\n options.repositories[symbolic_name] = val\n else:\n options.repositories[\"Development\"] = val\n elif opt in ('-p', '--port'):\n try:\n options.port = int(val)\n except ValueError:\n raise BadUsage\n elif opt in ('-h', '--host'):\n options.host = val\n elif opt in ('-s', '--script-alias'):\n options.script_alias = \\\n string.join(filter(None, string.split(val, '/')), '/')\n if options.start_gui:\n gui(options.host, options.port)\n return\n elif options.port:\n def ready(server):\n print 'server ready at %s%s' % (server.url,\n options.script_alias)\n serve(options.host, options.port, ready)\n return\n raise BadUsage\n except (getopt.error, BadUsage):\n cmd = os.path.basename(sys.argv[0])\n port = options.port\n host = options.host\n script_alias = options.script_alias\n print \"\"\"ViewVC standalone - a simple standalone HTTP-Server\n\nUsage: %(cmd)s [OPTIONS]\n\nAvailable Options:\n\n-h <host>, --host=<host>:\n Start the HTTP server listening on <host>. You need to provide\n the hostname if you want to access the standalone server from a\n remote machine. [default: %(host)s]\n\n-p <port>, --port=<port>:\n Start an HTTP server on the given port. [default: %(port)d]\n\n-r <path>, --repository=<path>:\n Specify a path for a CVS repository. Repository definitions are\n typically read from the viewvc.conf file, if available. This\n option may be used more than once.\n\n-s <path>, --script-alias=<path>:\n Specify the ScriptAlias, the artificial path location that at\n which ViewVC appears to be located. For example, if your\n ScriptAlias is \"cgi-bin/viewvc\", then ViewVC will appear to be\n accessible at the URL \"http://%(host)s:%(port)s/cgi-bin/viewvc\".\n [default: %(script_alias)s]\n \n-g, --gui:\n Pop up a graphical interface for serving and testing ViewVC.\n NOTE: this requires a valid X11 display connection.\n\"\"\" % locals()","def main():\n tester = Tester()\n # parse args, load configuration and create all required objects.\n tester.setup_experiment()\n # GO!\n tester.run_experiment()","def __init__(self, base_url=\"\",\n driver=None,\n driver_kwargs=None,\n enable_highlighting=False,\n enable_screen_shot_highlight=False,\n implicit_wait=0,\n think_time=0,\n download_folder='',\n screen_shots_folder='',\n highlighting_color='',\n highlighting_size=0,\n highlighting_time=0,\n remote_ip=None,\n remote_port=None,\n desired_capability=None,\n headless=None,\n display_width=None,\n display_height=None\n ):\n\n if isinstance(driver, str):\n driver = get_driver_from_name(driver)\n\n if driver is None:\n driver = get_driver_from_name(settings.DEFAULT_DRIVER_EXECUTABLE)\n\n self.web_driver = driver\n self._driver_kwargs = driver_kwargs or {}\n self.driver = None # type: WebDriver\n\n self.url = base_url if base_url.startswith('http') else (\"http://\" + base_url) if base_url else ''\n self.accept_next_alert = True\n\n self.download_folder = download_folder or settings.DOWNLOAD_FOLDER\n self.implicit_wait = implicit_wait or settings.IMPLICIT_WAIT\n screen_shots_folder = screen_shots_folder or os.path.join(self.download_folder, settings.SCREEN_SHOTS_FOLDER)\n self.screen_shot_folder = os.path.realpath(screen_shots_folder)\n self.think_time = think_time\n\n self._is_driver_open = False\n self._default_find_element_method = self._default_find_elements_method = None\n\n self._enable_highlighted_find_elements = enable_highlighting or settings.ENABLE_HIGHTLIGHTING\n self._screen_shot_highlights = enable_screen_shot_highlight or settings.ENABLE_SCREENSHOT_HIGHTLIGHTING\n self._highlighting_color = highlighting_color or settings.HIGHLIGHTING_COLOR\n self._highlighting_size = highlighting_size or settings.HIGHLIGHTING_SIZE\n self._highlighting_time = highlighting_time or settings.HIGHLIGHTING_TIME\n\n\n # headless vars\n self._headless = headless or settings.HEADLESS\n self._display_height = display_height\n self._display_width = display_width\n\n self._create_download_shots_folders()\n\n self._remote_ip = remote_ip\n self._remote_port = remote_port or settings.REMOTE_PORT\n self._desired_capability = desired_capability\n\n self._jquery_available = self._jquery_checked = False","def StartTestConfiguration(self, *args, **kwargs):\n # type: (*Any, **Any) -> None\n payload = {}\n for i in range(len(args)):\n payload[\"Arg%s\" % (i + 1)] = args[i]\n for item in kwargs.items():\n payload[item[0]] = item[1]\n return self._execute(\n \"startTestConfiguration\", payload=payload, response_object=None\n )","def main():\n executor(option().host)","def main():\n args = parse_command_line()\n expt_config = load_config(args.experiment_config_path)\n run_cli(RunOptions.from_dict(expt_config))","def get_driver():\n # user_agent = user_agent_rotator.get_random_user_agent()\n try:\n if len(sys.argv) > 1:\n if Driver._driver is None:\n chrome_options = Options()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--disable-extensions')\n chrome_options.add_argument('--profile-directory=Default')\n chrome_options.add_argument(\"--incognito\")\n chrome_options.add_argument(\"--disable-plugins-discovery\")\n chrome_options.add_argument(\"--start-maximized\")\n chrome_options.add_argument(f'--user-agent={USER_AGENT}')\n Driver._driver = webdriver.Chrome(executable_path=sys.argv[1], chrome_options=chrome_options)\n logging.info(f\"Driver loaded succesfully from {sys.argv[1]}\")\n return Driver._driver\n else:\n logging.error(f\"Driver cannot be found. User entered: {sys.argv[1]}\")\n raise Exception(\"Please provide a path to the chromedriver\")\n\n except Exception as e:\n logging.error(f\"Driver cannot be found. User entered: {sys.argv[1]}\")\n raise FileNotFoundError(\"Could not execute webdriver. Make sure you provided the correct path to the \"\n \"chromedriver\", e)","def main(self, params):\n raise NotImplementedError('main() must be implemented.')","def __init__(self,\n geckodriver_path = None,\n headless_browser = False,\n disable_image_load = False,\n page_delay = 10,\n logfolder = 'logs/',\n user_agent = None,\n proxy_address = None,\n proxy_port = None,\n proxy_username = None,\n proxy_password = None,\n limit_scropes = None,\n exclude_hosts = None,\n browser_profile_path = None,\n browser_executable_path = None,\n geckodriver_log_level = 'info'\n ):\n firefox_options = Firefox_Options()\n seleniumwire_options = {}\n\n if headless_browser:\n firefox_options.add_argument(\"-headless\")\n\n if browser_profile_path is not None:\n firefox_profile = webdriver.FirefoxProfile(browser_profile_path)\n else:\n firefox_profile = webdriver.FirefoxProfile()\n\n if browser_executable_path is not None:\n firefox_options.binary = browser_executable_path\n\n\n # set \"info\" by default\n # set \"trace\" for debubging, Development only\n firefox_options.log.level = geckodriver_log_level\n\n # set English language\n firefox_profile.set_preference(\"intl.accept_languages\", \"en-US\")\n\n # set User-Agent\n if user_agent is not None:\n firefox_profile.set_preference(\"general.useragent.override\", user_agent)\n\n if disable_image_load:\n # permissions.default.image = 2: Disable images load,\n # this setting can improve pageload & save bandwidth\n firefox_profile.set_preference(\"permissions.default.image\", 2)\n \n # mute audio while watching stories\n firefox_profile.set_preference(\"media.volume_scale\", \"0.0\")\n\n # prevent Hide Selenium Extension: error\n firefox_profile.set_preference(\"dom.webdriver.enabled\", False)\n firefox_profile.set_preference(\"useAutomationExtension\", False)\n firefox_profile.set_preference(\"general.platform.override\", \"iPhone\")\n firefox_profile.update_preferences()\n\n # geckodriver log in specific user logfolder\n geckodriver_log = \"{}geckodriver.log\".format(logfolder)\n check_and_create_file(geckodriver_log)\n\n\n # The list exclude hosts for capturing\n if exclude_hosts:\n seleniumwire_options['exclude_hosts'] = exclude_hosts\n\n # Add proxy with username and password authentication\n if proxy_address and proxy_port:\n if proxy_username and proxy_password:\n seleniumwire_options['proxy'] = {\n 'http': f'http://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\n 'https': f'https://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\n 'no_proxy': 'localhost,127.0.0.1'\n }\n else:\n seleniumwire_options['proxy'] = {\n 'http': f'http://{proxy_address}:{proxy_port}',\n 'https': f'https://{proxy_address}:{proxy_port}',\n 'no_proxy': 'localhost,127.0.0.1'\n }\n\n\n\n self.driver = webdriver.Firefox(\n firefox_profile=firefox_profile,\n executable_path=geckodriver_path,\n log_path=geckodriver_log,\n options=firefox_options,\n seleniumwire_options=seleniumwire_options\n )\n # Limit capture urls with regulater expression\n if limit_scropes:\n self.driver.scopes = limit_scropes\n\n # Set implicitly wait\n self.driver.implicitly_wait(page_delay)\n\n # Set maximum windows\n self.driver.maximize_window()","def connect(self, params={}):\n self.params = params\n return None","def __init__(self, **kwargs):\n super(DesktopInternetExplorerWebDriver, self).__init__(\n default_capabilities=False, # ensure that HackedWebDriver doesn't mess with the capabilities\n **kwargs\n )","def launch(self, user_data_dir=None):\n if self.custom_driver:\n return self.custom_driver\n\n options = self.driver_options()\n\n return webdriver.Chrome(options=options)","def connect():\n\n driver = webdriver.Chrome(driver_exe) # Run the simulated chrome driver\n driver.get(url) # go to the whatsapp web page\n driver.implicitly_wait(10) # wait a little to make sure the page loads\n return driver","def main(self):\n self.parse_option()\n self.set_option()\n\n r = Bootscripts()\n reactor.listenTCP(8009, server.Site(r))\n reactor.run()","def launch(click_context, agents: List[str], multithreaded: bool):\n agents_directories = list(map(Path, list(OrderedDict.fromkeys(agents))))\n if multithreaded:\n failed = _launch_threads(click_context, agents_directories)\n else:\n failed = _launch_subprocesses(click_context, agents_directories)\n logger.debug(f\"Exit cli. code: {failed}\")\n sys.exit(failed)","def startup(self, override_args=None):\n self._app_name = sys.argv[0]\n if override_args:\n my_args = [self._app_name]\n my_args = my_args + override_args\n else:\n my_args = sys.argv[:]\n\n if len(my_args) != 2:\n print(\"\"\"Usage:\n\n {0} sitl\n run with built-in SITL simulator\n {0} render\n just render the behaviour tree\n {0} <connection string>\n connect as prescribed and fly the mission\"\"\".format((self._app_name)))\n elif my_args[1] == 'sitl':\n self._sitl = dronekit_sitl.start_default(lat=self._sitl_lat,\n lon=self._sitl_lon)\n self._connection_string = self._sitl.connection_string()\n print(\"Using SITL via {}\".format(self._connection_string))\n self.connect()\n elif my_args[1] == 'render':\n print(\"Rendering only\")\n self.render()\n else:\n self._connection_string = my_args[1]\n print(f\"Attempting to connect via {self._connection_string}\")\n self.connect()","def __init__(self, base_url=None):\n self.driver = webdriver.Chrome()\n if base_url:\n self.base_url = base_url","def _get_selenium_browser(navigator, fLOG=noLOG):\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n from selenium import webdriver\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\n\n fLOG(\"[webshot] navigator=\", navigator)\n if navigator == \"firefox\":\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\n firefox_capabilities['marionette'] = True\n firefox_capabilities[\n 'binary'] = r\"C:\\Program Files (x86)\\Mozilla Firefox\\firefox.exe\"\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\n elif navigator == \"chrome\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n install_chromedriver(fLOG=fLOG)\n chromed = where_in_path(\"chromedriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install 'chromedriver.exe'\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'chromedriver'\n\n start_navi = True\n if start_navi:\n fLOG(\"[_get_selenium_browser] start\", navigator)\n chrome_options = webdriver.ChromeOptions()\n chrome_options.add_argument('--headless')\n chrome_options.add_argument('--no-sandbox')\n chrome_options.add_argument('--verbose')\n browser = webdriver.Chrome(executable_path=chromed,\n chrome_options=chrome_options)\n else:\n with warnings.catch_warnings():\n warnings.simplefilter(\"ignore\", ImportWarning)\n import selenium.webdriver.chrome.service as wservice\n fLOG(\"[_get_selenium_browser] create service\")\n service = wservice.Service(chromed)\n fLOG(\"[_get_selenium_browser] start service\")\n service.start()\n fLOG(\"[_get_selenium_browser] declare remote\")\n capabilities = {'chrome.binary': chromed}\n browser = webdriver.Remote(service.service_url, capabilities)\n elif navigator == \"ie\":\n browser = webdriver.Ie()\n elif navigator == \"opera\":\n if sys.platform.startswith(\"win\"):\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n install_operadriver(fLOG=fLOG)\n chromed = where_in_path(\"operadriver.exe\")\n if chromed is None:\n raise FileNotFoundError(\n \"unable to install operadriver.exe\")\n else:\n fLOG(\"[_get_selenium_browser] found chromedriver:\", chromed)\n else:\n chromed = 'operadriver'\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\n elif navigator == \"edge\":\n browser = webdriver.Edge()\n else:\n raise RuntimeError(\n f\"unable to interpret the navigator '{navigator}'\")\n fLOG(\"[_get_selenium_browser] navigator is started\")\n return browser","def start_chrome_browser(options_list, headless_mode, desired_capab= None, my_queue = None):\r\n\r\n driver = None\r\n chrome_options = Options()\r\n for option in options_list:\r\n chrome_options.add_argument(option) \r\n \r\n # suppress chrome log info\r\n chrome_options.add_argument('--log-level=3') \r\n chrome_options.add_argument('--disable-dev-shm-usage') \r\n chrome_options.add_argument(\"--no-sandbox\")\r\n chrome_options.add_argument(\"--disable-extensions\")\r\n chrome_options.add_argument(\"--disable-notifications\")\r\n chrome_options.add_argument(\"--enable-automation\")\r\n\r\n chrome_options.add_experimental_option('excludeSwitches', ['enable-logging'])\r\n\r\n if headless_mode:\r\n print('Starting Chrome browser without the graphical user interface ...')\r\n chrome_options.add_argument(\"--headless\") \r\n else:\r\n printY('DO NOT INTERACT WITH THE CHROME BROWSER. IT IS CONTROLLED BY THE SCRIPT AND WILL BE CLOSED WHEN THE TASK FINISHES')\r\n #chrome_options.add_argument(\"--window-size=900,1200\")\r\n\r\n if desired_capab:\r\n driver = webdriver.Chrome(options=chrome_options, desired_capabilities= desired_capab)\r\n else:\r\n driver = webdriver.Chrome(options=chrome_options)\r\n\r\n if my_queue:\r\n my_queue.put(driver)\r\n\r\n return driver","def start_test_instance(test_name=None):\n env.warn_only = True\n if test_name is not None:\n instances = [test_name]\n else:\n output = run('ls -1 %s' % env.site_root)\n instances = [x.strip() for x in output.split(\"\\n\")]\n for item in instances:\n sudo(\"start %s\" % item.strip())","def main(_):\n description = xm.ExperimentDescription(\n FLAGS.exp_name, tags=[\n FLAGS.env_name,\n ])\n experiment = build_experiment()\n xm.launch_experiment(description, experiment)","def test_executable():\n arg1 = get_args(driver=\"chrome\", executable=\"/tmp\")\n assert arg1[\"executable_path\"] == \"/tmp\"","def start_microservice(params) -> None:\n print(\"Starting microservice...\")\n cmd = \"docker run --rm --publish \" + params['microservice_port'] + \":\" + \\\n params['microservice_port'] + \" --detach --name bg_changer \" + \\\n \"--mount type=bind,source=\" + params['config_file'] + \\\n \",destination=/fakewebcam.ini bg_changer >/dev/null 2>&1\"\n if os.system(cmd) == 0:\n print(\" Success !\")\n else:\n print(\" Failure !\")","def init_driver(self):\n # Set UserAgent to prevent issues with blocking bot\n self.chrome_options.add_argument(\n \"user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36\")\n # Set headless\n if self.headless:\n self.chrome_options.add_argument('headless')\n # Initiate driver\n driver = webdriver.Chrome(\n self.chromedriver_path + \"/chromedriver\", options=self.chrome_options)\n self.driver = driver\n self.wait = WebDriverWait(self.driver, 20)\n return self.driver"],"string":"[\n \"def start_selenium_server(logfile=None, jarpath=None, *params):\\n if not subprocess:\\n raise RuntimeError('This function requires `subprocess` module which '\\n 'is available on Python/Jython 2.5 or newer.')\\n cmd = _server_startup_command(jarpath, *params)\\n try:\\n subprocess.Popen(cmd, stdout=logfile, stderr=subprocess.STDOUT)\\n except OSError:\\n raise RuntimeError('Starting Selenium Server failed. Check that you '\\n 'have Java 1.5 or newer installed by running '\\n '`java -version` on the command prompt.')\\n print 'Selenium Server started with command \\\"%s\\\" ' % ' '.join(cmd)\",\n \"def start(self):\\r\\n if platform.system() == \\\"Windows\\\":\\r\\n # Use a local GeckoDriver on Windows\\r\\n ffo = Options()\\r\\n ffo.headless = self.state\\r\\n gecko = \\\"dependencies/geckodriver.exe\\\"\\r\\n full_gecko = os.path.abspath(gecko)\\r\\n self.web_driver = webdriver.Firefox(executable_path=full_gecko, options=ffo)\\r\\n else:\\r\\n # Use a remote server if testing on Travis\\r\\n username = os.environ[\\\"SAUCE_USERNAME\\\"]\\r\\n access_key = os.environ[\\\"SAUCE_ACCESS_KEY\\\"]\\r\\n capabilities = {}\\r\\n capabilities[\\\"tunnel-identifier\\\"] = os.environ[\\\"TRAVIS_JOB_NUMBER\\\"]\\r\\n capabilities['version'] = \\\"45.0\\\"\\r\\n capabilities['browserName'] = \\\"firefox\\\"\\r\\n hub_url = \\\"%s:%s@localhost:4445\\\" % (username, access_key)\\r\\n self.web_driver = webdriver.Remote(\\r\\n desired_capabilities=capabilities,\\r\\n command_executor=\\\"http://%s/wd/hub\\\" % hub_url)\",\n \"def start_server_and_driver(path_to_driver, path_to_browser):\\n \\n server = service.Service(path_to_driver)\\n server.start()\\n\\n capabilities = {'chrome.binary': path_to_browser}\\n driver = webdriver.Remote(server.service_url, capabilities)\\n \\n return server, driver\",\n \"def main():\\n driver = Driver()\\n driver.start()\",\n \"def start(params) -> None:\\n check_root()\\n start_microservice(params)\\n load_kernel_module(params)\\n start_streamer(params)\",\n \"def start(self):\\n # iPhone\\n #driver = webdriver.Remote(browser_name=\\\"iphone\\\", command_executor='http://172.24.101.36:3001/hub')\\n # Android\\n #driver = webdriver.Remote(browser_name=\\\"android\\\", command_executor='http://127.0.0.1:8080/hub')\\n # Google Chrome \\n #driver = webdriver.Chrome()\\n # Firefox \\n #FirefoxProfile fp = new FirefoxProfile();\\n #fp.setPreference(\\\"webdriver.load.strategy\\\", \\\"unstable\\\");\\n #WebDriver driver = new FirefoxDriver(fp);\\n \\n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\\n driver = webdriver.Firefox()\\n \\n self.driver = driver\",\n \"def start(self):\\n # iPhone\\n #driver = webdriver.Remote(browser_name=\\\"iphone\\\", command_executor='http://172.24.101.36:3001/hub')\\n # Android\\n #driver = webdriver.Remote(browser_name=\\\"android\\\", command_executor='http://127.0.0.1:8080/hub')\\n # Google Chrome \\n #driver = webdriver.Chrome()\\n # Firefox \\n #FirefoxProfile fp = new FirefoxProfile();\\n #fp.setPreference(\\\"webdriver.load.strategy\\\", \\\"unstable\\\");\\n #WebDriver driver = new FirefoxDriver(fp);\\n \\n #driver = webdriver.Firefox(firefox_profile=self.disableImages())\\n driver = webdriver.Firefox()\\n \\n self.driver = driver\",\n \"def __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\\n\\n # selecting driver\\n if not driver_path:\\n driver = webdriver.Firefox\\n driver_options = FireFoxOptions()\\n else:\\n driver = webdriver.Chrome\\n driver_options = ChromeOptions()\\n\\n # add config\\n if options:\\n for option in options:\\n driver_options.add_argument(option)\\n\\n self.driver = driver(driver_path, options=driver_options)\\n self.waiter = WebDriverWait(self.driver, waiter_timeout)\",\n \"def start_selenium(site, headless=True):\\n global DRIVER\\n global PATH_DRIVER\\n options = selenium.webdriver.ChromeOptions()\\n prefs = {'profile.managed_default_content_settings.images': 2, 'disk-cache-size': 4096}\\n options.add_argument('log-level=3')\\n options.add_experimental_option(\\\"prefs\\\", prefs)\\n if headless:\\n options.add_argument(\\\"--headless\\\")\\n options.add_argument(\\\"--disable-extensions\\\")\\n print(PATH_DRIVER)\\n DRIVER[site] = selenium.webdriver.Chrome(options=options)\\n colorama.init()\\n print(termcolor.colored('Driver started for {}'.format(site), 'green'))\\n colorama.Style.RESET_ALL\\n colorama.deinit()\",\n \"def start_server():\\n if not os.path.exists(cf.get(\\\"Selenium\\\", \\\"server_path\\\")):\\n jar_name = \\\"selenium-server-standalone-2.25.0.jar\\\"\\n server_jar = os.path.join(tempfile.gettempdir(), jar_name)\\n if not os.path.exists(server_jar):\\n r = requests.get(\\\"http://selenium.googlecode.com/files/%s\\\" % jar_name)\\n jar_on_disk = open(server_jar, \\\"wb\\\")\\n jar_on_disk.write(r.content)\\n jar_on_disk.close()\\n else:\\n server_jar = cf.get(\\\"Selenium\\\", \\\"server_path\\\")\\n \\n s = subprocess.Popen(['java', '-jar', server_jar], \\n stdout=tempfile.TemporaryFile(), \\n stderr=tempfile.TemporaryFile()).pid\\n pidfile = open(pid_file_path, \\\"w\\\")\\n pidfile.write(str(s))\\n pidfile.close()\\n\\n # make sure the server is actually up\\n server_up = False\\n waiting = 0\\n while server_up == False and waiting < 60:\\n try:\\n s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)\\n s.connect((\\\"localhost\\\", 4444))\\n s.close()\\n server_up = True\\n except socket.error:\\n time.sleep(1)\\n waiting = waiting + 1\\n server_up = False\\n\\n return server_up\",\n \"def _runner(self, classpath, main, jvm_options, args):\",\n \"def setUpClass(cls) -> None:\\n desired_caps: dict[str, Any] = {}\\n desired_caps[\\\"app\\\"] = \\\"plasmawindowed -p org.kde.plasma.nano org.kde.plasma.systemtray\\\"\\n desired_caps[\\\"timeouts\\\"] = {'implicit': 10000}\\n cls.driver = webdriver.Remote(command_executor='http://127.0.0.1:4723', desired_capabilities=desired_caps)\\n cls.driver.implicitly_wait = 10\",\n \"def test_webuidriver_remote(self):\\n\\n hub = SeleniumJar(self.jar_path, self.java_path).hub(4444)\\n hub.start_server()\\n\\n node = SeleniumJar(self.jar_path, self.java_path).node(5555, (\\\"localhost\\\", 4444))\\n node.start_server()\\n executors = SeleniumHatch.get_remote_executors(\\\"localhost\\\", 4444)\\n\\n # self.driver = webuidriver.Remote(executor, options=self.opt) 与下面语句效果是一样的\\n self.driver = webuidriver.Remote(executors[0], desired_capabilities=self.opt.to_capabilities())\\n\\n self.driver.get('http://www.baidu.com')\\n time.sleep(1)\\n\\n # webuidriver.Remote 是 webdriver.Chrome 的子类\\n self.assertTrue(issubclass(webuidriver.Chrome, webdriver.Remote))\\n self.assertIsInstance(self.driver, webdriver.Remote)\\n\\n self.driver.close()\\n self.driver.quit()\\n\\n hub.stop_server()\\n node.stop_server()\",\n \"def launch_browser(option):\\n if not option:\\n chrome_options = Options()\\n chrome_options.add_argument(\\\"--headless\\\")\\n return webdriver.Chrome(\\\"/usr/bin/chromedriver\\\",\\n chrome_options=chrome_options)\\n else:\\n return webdriver.Chrome(\\\"/usr/bin/chromedriver\\\")\",\n \"def setup_selenium():\\n # Define the options to run with headless mode enabled\\n options = Options()\\n options.headless = True\\n\\n # Instatiate the browser object here, pointing at an exectable location which should be located in the same\\n # base directory as the script\\n driver = webdriver.Firefox(options=options, executable_path='./geckodriver')\\n\\n # Impicit wait tell the browser to wait up to 30s for an object to appear, this helps if the connection is slow.\\n driver.implicitly_wait(30)\\n return driver\",\n \"def setup_selenium():\\n options = webdriver.FirefoxOptions()\\n options.add_argument('--ignore-certificate-errors')\\n options.add_argument('--incognito')\\n options.add_argument('--headless')\\n\\n return webdriver.Firefox(\\n # UNCOMMENT WHEN IN LINUX executable_path=\\\"drivers/geckodriver-linux\\\",\\n executable_path=\\\"drivers/geckodriver-macos\\\",\\n firefox_options=options\\n )\",\n \"def start_streamer(params) -> None:\\n print(\\\"Starting streamer...\\\")\\n time.sleep(5)\\n cmd = \\\"./streamer/fakewebcam.py -c \\\" + params[\\\"config_file\\\"] + \\\" >/dev/null 2>&1\\\"\\n if os.system(cmd) == 0:\\n print(\\\" Success !\\\")\\n else:\\n print(\\\" Failure !\\\")\",\n \"def _run_launch(cls, params):\\n assert cls.compose_file is not None, \\\"compose_file file must be set by subclass\\\"\\n assert cls.testname is not None, \\\"testname file must be set by subclass\\\"\\n\\n test_path = dirname(realpath(sys.argv[0]))\\n vmnet_path = dirname(vmnet.__file__) if hasattr(vmnet, '__file__') else vmnet.__path__._path[0]\\n local_path = abspath(os.getenv('LOCAL_PATH', '.'))\\n compose_path = '{}/compose_files/{}'.format(test_path, cls.compose_file)\\n docker_dir_path = '{}/docker_dir'.format(test_path)\\n launch_path = '{}/launch.py'.format(vmnet_path)\\n if not hasattr(cls, 'docker_dir'): cls.docker_dir = docker_dir_path\\n cls.launch_path = launch_path\\n\\n exc_str = 'python {} --compose_file {} --docker_dir {} --local_path {} {}'.format(\\n launch_path,\\n cls.compose_file if exists(cls.compose_file) else compose_path,\\n cls.docker_dir if exists(cls.docker_dir) else docker_dir_path,\\n cls.local_path if hasattr(cls, 'local_path') else local_path,\\n params\\n )\\n os.system(exc_str)\",\n \"def setUp(self):\\r\\n self.verificationErrors = []\\r\\n self.selenium = (selenium(selvars.set_localhost(), selvars.set_port(), selvars.set_browser(self.id(),self.shortDescription()), selvars.set_site()))\\r\\n self.selenium.start()\\r\\n self.session = self.selenium.sessionId\\r\\n self.selenium.set_timeout(testvars.timeout)\",\n \"def setUp(self):\\n\\n self.driver = WebDriver(\\n \\\"http://{0}:{1}/wd/hub\\\".format(swt.config.ADDRESS, swt.config.SELENIUM_SERVER_PORT),\\n self._browser_capabilities,\\n proxy=self.proxy.selenium_proxy()\\n )\\n swt.active_driver = self.driver\",\n \"def init_driver(driver_path):\\n # user_agent = user_agent_rotator.get_random_user_agent()\\n try:\\n if driver_path != \\\"\\\":\\n chrome_options = Options()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--disable-dev-shm-usage')\\n chrome_options.add_argument('--window-size=1420,1080')\\n chrome_options.add_argument('--disable-gpu')\\n chrome_options.add_argument(f'user-agent={USER_AGENT}')\\n Driver._driver = webdriver.Chrome(executable_path=driver_path, chrome_options=chrome_options)\\n else:\\n raise Exception(\\\"Please provide a path to the chromedriver\\\")\\n except Exception as e:\\n logging.error(f\\\"Driver cannot be found. Path entered: {driver_path}\\\")\\n raise FileNotFoundError(\\\"Could not execute webdriver. Make sure you provided the correct path to the \\\"\\n \\\"chromedriver\\\", e)\",\n \"def run(options, executable, datadir, parameters):\\n if options['pbs']:\\n common.pbs.run(options, executable, datadir, parameters)\\n else:\\n runNode(options, executable, datadir, parameters)\",\n \"def run_script(self, params, config_no):\\n raise NotImplementedError()\",\n \"def initial_setup(server):\\r\\n world.absorb(settings.LETTUCE_SELENIUM_CLIENT, 'LETTUCE_SELENIUM_CLIENT')\\r\\n\\r\\n if world.LETTUCE_SELENIUM_CLIENT == 'local':\\r\\n browser_driver = getattr(settings, 'LETTUCE_BROWSER', 'chrome')\\r\\n\\r\\n # There is an issue with ChromeDriver2 r195627 on Ubuntu\\r\\n # in which we sometimes get an invalid browser session.\\r\\n # This is a work-around to ensure that we get a valid session.\\r\\n success = False\\r\\n num_attempts = 0\\r\\n while (not success) and num_attempts < MAX_VALID_BROWSER_ATTEMPTS:\\r\\n\\r\\n # Load the browser and try to visit the main page\\r\\n # If the browser couldn't be reached or\\r\\n # the browser session is invalid, this will\\r\\n # raise a WebDriverException\\r\\n try:\\r\\n world.browser = Browser(browser_driver)\\r\\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\\r\\n world.visit('/')\\r\\n\\r\\n except WebDriverException:\\r\\n if hasattr(world, 'browser'):\\r\\n world.browser.quit()\\r\\n num_attempts += 1\\r\\n\\r\\n else:\\r\\n success = True\\r\\n\\r\\n # If we were unable to get a valid session within the limit of attempts,\\r\\n # then we cannot run the tests.\\r\\n if not success:\\r\\n raise IOError(\\\"Could not acquire valid {driver} browser session.\\\".format(driver=browser_driver))\\r\\n\\r\\n world.absorb(0, 'IMPLICIT_WAIT')\\r\\n world.browser.driver.set_window_size(1280, 1024)\\r\\n\\r\\n elif world.LETTUCE_SELENIUM_CLIENT == 'saucelabs':\\r\\n config = get_saucelabs_username_and_key()\\r\\n world.browser = Browser(\\r\\n 'remote',\\r\\n url=\\\"http://{}:{}@ondemand.saucelabs.com:80/wd/hub\\\".format(config['username'], config['access-key']),\\r\\n **make_saucelabs_desired_capabilities()\\r\\n )\\r\\n world.absorb(30, 'IMPLICIT_WAIT')\\r\\n world.browser.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\\r\\n\\r\\n elif world.LETTUCE_SELENIUM_CLIENT == 'grid':\\r\\n world.browser = Browser(\\r\\n 'remote',\\r\\n url=settings.SELENIUM_GRID.get('URL'),\\r\\n browser=settings.SELENIUM_GRID.get('BROWSER'),\\r\\n )\\r\\n world.absorb(30, 'IMPLICIT_WAIT')\\r\\n world.browser.driver.set_script_timeout(GLOBAL_SCRIPT_TIMEOUT)\\r\\n\\r\\n else:\\r\\n raise Exception(\\\"Unknown selenium client '{}'\\\".format(world.LETTUCE_SELENIUM_CLIENT))\\r\\n\\r\\n world.browser.driver.implicitly_wait(world.IMPLICIT_WAIT)\\r\\n world.absorb(world.browser.driver.session_id, 'jobid')\",\n \"def LaunchChromium(chrome_exe, chromium_paths, test_name,\\n is_dns_forwarded, use_auto):\\n REPLAY_HOST='127.0.0.1'\\n user_data_dir = USER_DATA_DIR.format(**{'TEMP': tempfile.gettempdir()})\\n chromium_args = [\\n chrome_exe,\\n '--load-extension=%s' % chromium_paths['extension'],\\n '--testing-fixed-http-port=%s' % HTTP_PORT,\\n '--testing-fixed-https-port=%s' % HTTPS_PORT,\\n '--disable-background-networking',\\n '--enable-experimental-extension-apis',\\n '--enable-file-cookies',\\n '--enable-logging',\\n '--log-level=0',\\n '--enable-stats-table',\\n '--enable-benchmarking',\\n '--ignore-certificate-errors',\\n '--metrics-recording-only',\\n '--activate-on-launch',\\n '--no-first-run',\\n '--no-proxy-server',\\n '--user-data-dir=%s' % user_data_dir,\\n '--window-size=1280,1024',\\n ]\\n if not is_dns_forwarded:\\n chromium_args.append('--host-resolver-rules=MAP * %s' % REPLAY_HOST)\\n start_url = 'file://%s?test=%s' % (chromium_paths['start.html'], test_name)\\n if use_auto:\\n start_url += '&auto=1'\\n chromium_args.append(start_url)\\n if os.path.exists(user_data_dir):\\n shutil.rmtree(user_data_dir)\\n os.makedirs(user_data_dir)\\n try:\\n logging.debug('Starting Chrome: %s', chromium_args)\\n retval = subprocess.call(chromium_args)\\n finally:\\n shutil.rmtree(user_data_dir)\",\n \"def setUp(self):\\n options = webdriver.ChromeOptions()\\n\\n # Define a custom User Agent\\n user_agent = '--user-agent=\\\"' + CFG['user_agent'] + '\\\"'\\n options.add_argument(user_agent)\\n\\n # Setup the full screen kiosk\\n if CFG['kiosk']:\\n options.add_argument('--kiosk')\\n\\n # Alternatively launch the webdriver Firefox browser\\n # test whether Firefox loads the videos better\\n\\n # Launch a Chrome instance with the appropriate options\\n chrome_paths = ('c:\\\\Program Files\\\\chromedriver.exe',\\n 'c:\\\\Program Files (x86)\\\\chromedriver.exe')\\n # Try to launch the Chrome driver without any path details\\n try:\\n self.driver = webdriver.Chrome(chrome_options=options)\\n # If it raises an exception try looping through the path options\\n except webdriver.chrome.webdriver.WebDriverException:\\n for chrome_path in chrome_paths:\\n try:\\n self.driver = webdriver.Chrome(chrome_path,\\n chrome_options=options)\\n except webdriver.chrome.webdriver.WebDriverException:\\n pass\\n else:\\n break\",\n \"def before_productline_steps():\\n cmd = ['phantomjs', '--webdriver', '4444']\\n click.echo(\\\"Running command\\\" + subprocess.list2cmdline(cmd))\\n process = subprocess.Popen(cmd)\\n RUNNING_TEST_PROCESSES.append(process)\",\n \"def initBrowser(browserConfig, isUseSeleniumwire=False):\\n webdriver = getWebDirver(isUseSeleniumwire=isUseSeleniumwire)\\n chromeOptions = webdriver.ChromeOptions()\\n\\n if \\\"headless\\\" in browserConfig:\\n isCurHeadless = browserConfig[\\\"headless\\\"]\\n if isCurHeadless:\\n chromeOptions.add_argument('--headless')\\n\\n if \\\"disableGpu\\\" in browserConfig:\\n isDisableGpu = browserConfig[\\\"disableGpu\\\"]\\n if isDisableGpu:\\n chromeOptions.add_argument('--disable-gpu')\\n\\n # for debug\\n # chromeOptions.add_experimental_option(\\\"excludeSwitches\\\", [\\\"enable-automation\\\"])\\n # chromeOptions.add_experimental_option('useAutomationExtension', False)\\n # chromeOptions.add_argument('window-size=1920x1080')\\n # chromeOptions.add_argument('--window-size=1920x1080')\\n\\n driverConfigDict = {\\n \\\"options\\\": chromeOptions\\n }\\n\\n if \\\"seleniumwire\\\" in browserConfig:\\n if isUseSeleniumwire:\\n driverConfigDict[\\\"seleniumwire_options\\\"] = browserConfig[\\\"seleniumwire\\\"]\\n else:\\n del browserConfig[\\\"seleniumwire\\\"]\\n\\n driver = webdriver.Chrome(**driverConfigDict)\\n # driver = webdriver.Chrome(options=chromeOptions)\\n\\n # # for debug\\n # driver.set_window_size(1920, 1080)\\n\\n if \\\"pageLoadTimeout\\\" in browserConfig:\\n curPageLoadTimeout = browserConfig[\\\"pageLoadTimeout\\\"]\\n driver.set_page_load_timeout(curPageLoadTimeout)\\n\\n return driver\",\n \"def test_explicit_start_stop(self, runpath):\\n driver = self.MyDriver(name=\\\"MyDriver\\\", runpath=runpath)\\n\\n assert not driver.pre_start_called\\n assert not driver.post_start_called\\n\\n driver.start()\\n\\n assert driver.pre_start_called\\n assert not driver.post_start_called\\n\\n driver.wait(driver.STATUS.STARTED)\\n\\n assert driver.post_start_called\\n assert not driver.pre_stop_called\\n assert not driver.post_stop_called\\n\\n driver.stop()\\n\\n assert driver.pre_stop_called\\n assert not driver.post_stop_called\\n\\n driver.wait(driver.STATUS.STOPPED)\\n\\n assert driver.post_stop_called\",\n \"def start_browser_with(self, browser: 'Browserify', url: 'Url') -> 'StartableClient':\",\n \"def startBrowser(self):\\n if 'TRAVIS' in os.environ:\\n # Initialize hidden display for Firefox.\\n # Less annoying and allows remote execution.\\n display = Display(visible=0, size=(800, 600))\\n display.start()\\n\\n self.browser = webdriver.Firefox()\\n self.browser.implicitly_wait(3)\",\n \"def setup(setup_filenames, loop_filename, chromedriver_path=None,\\n log_path=\\\"/tmp/BrowserAutomator.log\\\",\\n log_level=\\\"ERROR\\\"):\\n logging_setup(log_path, log_level)\\n driver = selenium_setup(chromedriver_path)\\n if action_runner(driver, setup_filenames) == 1:\\n driver.quit()\\n return 1\\n out = loop_runner(driver, loop_filename, setup_filenames)\\n driver.quit()\\n return out\",\n \"def RunCommand(self, params):\\n prefix = ['container', 'hub', 'memberships', 'register']\\n return self.Run(prefix + params)\",\n \"def main():\\r\\n args = getargs()\\r\\n testng_file = args.testng_file\\r\\n url = args.url\\r\\n fetch_testng(testng_file, url)\",\n \"def run():\\n import argparse\\n\\n parser = argparse.ArgumentParser(description='Phovea Server')\\n parser.add_argument('--use_reloader', action='store_true', help='whether to automatically reload the server')\\n parser.add_argument('--env', default=cc.get('env'), help='environment mode (dev or prod)')\\n\\n # parse before to enable correct plugin discovery\\n args = parser.parse_known_args()[0]\\n if args.env.startswith('dev'):\\n enable_dev_mode()\\n else:\\n enable_prod_mode()\\n\\n # resolve the default command to decide which application to launch\\n default_command = _resolve_commands(parser)\\n if default_command is not None:\\n # set a default subparse to extract the defined arguments from the instance to the main arguments (?)\\n set_default_subparser(parser, default_command)\\n\\n args = parser.parse_args()\\n\\n _set_runtime_infos(args)\\n\\n main = args.launcher(args) # execute the launcher function, which returns another function\\n\\n if args.use_reloader:\\n _log.info('start application using reloader...')\\n run_with_reloader(main, extra_files=_config_files())\\n else:\\n _log.info('start application...')\\n main()\",\n \"def start_chrome():\\n os.system(\\\"start {CHROME_PATH} --remote-debugging-port={CHROME_DEBUG_PORT} --user-data-dir=\\\\\\\"{CHROME_USERDATA_PATH}\\\\\\\" --lang=zh-CN\\\".format(\\n CHROME_PATH=CHROME_PATH, CHROME_DEBUG_PORT=CHROME_DEBUG_PORT, CHROME_USERDATA_PATH=CHROME_USERDATA_PATH))\\n\\n chrome_options = Options()\\n chrome_options.add_experimental_option(\\\"debuggerAddress\\\", \\\"127.0.0.1:9222\\\")\\n driver = webdriver.Chrome(\\n CHROME_DRIVER_PATH, chrome_options=chrome_options)\\n time.sleep(2)\\n\\n return driver\",\n \"def run(parameters=None, silent=False):\\n return _proc_exec_wait(\\\"{0} {1}\\\".format(_config.command, parameters), silent)\",\n \"def _SetRunParameters(self, params: Mapping[str, Any]) -> None:\\n # Ideally YCSB should be refactored to include a function that just takes\\n # commands for a run, but that will be a large refactor.\\n FLAGS['ycsb_run_parameters'].unparse()\\n FLAGS['ycsb_run_parameters'].parse([f'{k}={v}' for k, v in params.items()])\",\n \"def main(args=None):\\n args = args or sys.argv[1:]\\n parser = parse_options()\\n common.main_cli(experiment_parse_and_run, parser, args)\",\n \"def init_webdriver(driver_name=None, headless=False):\\n\\n if driver_name == \\\"chrome\\\":\\n try:\\n #try to connect with chrome driver\\n driver = connect_chrome_driver(headless)\\n except:\\n print_pretty(\\\"Sorry, you can't use chrome driver, please try another driver!\\\")\\n sys.exit(0)\\n elif driver_name == \\\"ie\\\":\\n try:\\n #try to connect with ie driver\\n driver = connect_ie_driver(headless)\\n except:\\n print_pretty(\\\"Sorry, you can't use internet explorer driver, please try another driver!\\\")\\n sys.exit(0)\\n elif driver_name == \\\"firefox\\\":\\n try:\\n #try to connect with firefox driver\\n driver = connect_firefox_driver(headless)\\n except:\\n print_pretty(\\\"sorry, you can't use firefox driver, please try another driver!\\\")\\n sys.exit(0)\\n else:\\n print_pretty(\\\"No browser selected, please choose 'chrome', 'ie' or 'firefox'\\\")\\n return None\\n\\n print_pretty(\\\"Selenium driver\\\", driver_name, \\\"sucessfully initialised\\\")\\n return driver\",\n \"def __init__(self, BrowserType=\\\"Chrome\\\", Remote=False, Headless=False, BrowserWidth=1920,\\n BrowserHeight=1080, SeleniumGridHost=\\\"\\\", SeleniumGridPort=4444, Options=[], DesiredCapabilities={}):\\n self.BrowserType = BrowserType\\n self.Remote = Remote\\n self.Headless = Headless\\n self.BrowserWidth = BrowserWidth\\n self.BrowserHeight = BrowserHeight\\n self.SeleniumGridHost = SeleniumGridHost\\n self.SeleniumGridPort = SeleniumGridPort\\n self.Options = Options\\n self.DesiredCapabilities = DesiredCapabilities\",\n \"def launch(\\n click_context: click.Context,\\n agents: List[str],\\n password: Optional[str],\\n multithreaded: bool,\\n) -> None:\\n _launch_agents(click_context, agents, multithreaded, password)\",\n \"def setup_driver():\\n os.environ[\\\"webdriver.chrome.driver\\\"] = chrome_driver_location\\n driver = webdriver.Chrome(chrome_driver_location)\\n driver.set_window_size(1280, 800)\\n return driver\",\n \"def call(self, **params):\\n # NOTE - use __call__??\\n # TODO - move exec_script here?\\n # TODO - call should handle param defaults\\n from datapane.runner.exec_script import run\\n\\n run(self, params)\",\n \"def __init__(self, driver_path=None):\\n\\n if driver_path is None:\\n self.driver = webdriver.Firefox()\\n else:\\n print(\\\"Alter gecko path\\\")\\n self.driver = webdriver.Firefox(executable_path=driver_path)\",\n \"def seleniumDriver():\\n chrome_options = Options()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--disable-dev-shm-usage')\\n driver = webdriver.Chrome(\\\"/usr/bin/chromedriver\\\",\\n options=chrome_options\\n )\\n driver.set_page_load_timeout(10)\\n return driver\",\n \"def start(coordinator_url: str, use_case: UseCase):\\n\\n raise NotImplementedError\",\n \"def initDriver(browser):\\n if browser == \\\"firefox\\\":\\n opts = Options()\\n opts.log.level = \\\"trace\\\"\\n driver = webdriver.Firefox(options=opts)\\n return driver\\n elif browser == \\\"chrome\\\":\\n options = webdriver.ChromeOptions()\\n options.add_argument(\\\"start-maximized\\\")\\n #d = DesiredCapabilities.CHROME\\n d = options.to_capabilities()\\n d['loggingPrefs'] = { 'browser':'ALL'}\\n driver = webdriver.Chrome('../Data/chromedriver_linux64/chromedriver',desired_capabilities=d)\\n return driver\\n else:\\n print(\\\"------- Navegador no compatible ---------\\\")\\n return null\",\n \"def main(aArgs, aTransmitToTaskHandler):\\n\\n global TASK_HANDLER_HOST\\n global TASK_HANDLER_PORT\\n\\n # if the option --printList is passed, only generate the file\\n # reftestList.txt\\n if hasattr(aArgs, \\\"printList\\\"):\\n printReftestList()\\n exit(0)\\n\\n # if the option --printNotes is passed, only generate the\\n # testsuiteNotes html page.\\n if hasattr(aArgs, \\\"printNotes\\\"):\\n printNotes()\\n exit(0)\\n\\n # if the option --printListOfTests is passed, only generate a ListOfTests\\n # from a file containing test URIs\\n if hasattr(aArgs, \\\"printListOfTests\\\"):\\n if not aArgs.printListOfTests:\\n print(\\\"No input file!\\\", file=sys.stderr)\\n exit(0)\\n printListOfTests(aArgs.printListOfTests)\\n exit(0)\\n\\n # create the date directory\\n now = datetime.utcnow();\\n directory = MATHJAX_WEB_PATH + \\\"results/\\\"\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # create the subdirectory\\n if aArgs.output and re.match(\\\"^([0-9]|[a-z]|[A-Z]|-|/){1,50}/$\\\",\\n aArgs.output):\\n directory += aArgs.output\\n else:\\n directory += now.strftime(\\\"%Y-%m-%d/%H-%M-%S/\\\")\\n\\n if not os.path.exists(directory):\\n os.makedirs(directory)\\n\\n # execute testing instances for all the config files\\n configFileList = aArgs.config.split(\\\",\\\")\\n\\n for configFile in configFileList:\\n\\n configFile = configFile\\n\\n if (not os.path.isfile(configFile)):\\n print(\\\"Warning: config file \\\" + configFile + \\\" not found!\\\",\\n file=sys.stderr)\\n continue\\n\\n # Load configuration file\\n config = ConfigParser.ConfigParser()\\n config.readfp(open(configFile))\\n\\n # framework section\\n section = \\\"framework\\\"\\n useGrid = getBooleanOption(config, section, \\\"useGrid\\\")\\n host = config.get(section, \\\"host\\\")\\n # host == \\\"default\\\" is handled below\\n port = config.getint(section, \\\"port\\\")\\n if (port == -1):\\n port = SELENIUM_SERVER_PORT\\n mathJaxPath = config.get(section, \\\"mathJaxPath\\\")\\n if (mathJaxPath == \\\"default\\\"):\\n mathJaxPath = DEFAULT_MATHJAX_PATH\\n mathJaxTestPath = config.get(section, \\\"mathJaxTestPath\\\")\\n if (mathJaxTestPath == \\\"default\\\"):\\n mathJaxTestPath = MATHJAX_TEST_LOCAL_URI + \\\"testsuite/\\\"\\n timeOut = config.getint(section, \\\"timeOut\\\")\\n if (timeOut == -1):\\n timeOut = DEFAULT_TIMEOUT\\n timeOut = timeOut * 1000 # convert in ms\\n useWebDriver = getBooleanOption(config, section, \\\"useWebDriver\\\")\\n fullScreenMode = getBooleanOption(config, section, \\\"fullScreenMode\\\")\\n formatOutput = getBooleanOption(config, section, \\\"formatOutput\\\")\\n compressOutput = getBooleanOption(config, section, \\\"compressOutput\\\")\\n\\n # platform section\\n section = \\\"platform\\\"\\n operatingSystem = config.get(section, \\\"operatingSystem\\\")\\n if (operatingSystem == \\\"default\\\"):\\n operatingSystem = OS_LIST[0]\\n if (host == \\\"default\\\"):\\n host = HOST_LIST[HOST_LIST_OS.index(OS_LIST.index(operatingSystem))]\\n browserList = config.get(section, \\\"browser\\\").split()\\n browserVersionList = config.get(section, \\\"browserVersion\\\").split()\\n browserModeList = config.get(section, \\\"browserMode\\\").split()\\n browserPath = config.get(section, \\\"browserPath\\\")\\n fontList = config.get(section, \\\"font\\\").split()\\n outputJaxList = config.get(section, \\\"outputJax\\\").split()\\n \\n # testsuite section\\n section = \\\"testsuite\\\"\\n runSlowTests = getBooleanOption(config, section, \\\"runSlowTests\\\")\\n runSkipTests = getBooleanOption(config, section, \\\"runSkipTests\\\")\\n listOfTests = config.get(section, \\\"listOfTests\\\")\\n startID = config.get(section, \\\"startID\\\")\\n if (startID == \\\"default\\\"):\\n startID = \\\"\\\"\\n \\n # When more than one browser is specified, browserPath is ignored.\\n if (len(browserList) > 1 and browserPath != \\\"default\\\"):\\n print(\\\"Warning: browserPath ignored\\\", file=sys.stderr)\\n browserPath = \\\"default\\\"\\n\\n for browser in browserList:\\n\\n if (browser == \\\"default\\\"):\\n browser = BROWSER_LIST[0]\\n\\n for font in fontList:\\n\\n if (font == \\\"default\\\"):\\n font = FONT_LIST[0]\\n\\n for outputJax in outputJaxList:\\n\\n if (outputJax == \\\"default\\\"):\\n outputJax = OUTPUT_JAX_LIST[0]\\n\\n for browserVersion in browserVersionList:\\n\\n # browserModeList is only relevant for MSIE\\n if not(browser == \\\"MSIE\\\"):\\n browserModeList2 = [\\\"default\\\"]\\n else:\\n browserModeList2 = browserModeList\\n \\n for browserMode in browserModeList2:\\n \\n # Create a Selenium instance\\n selenium = \\\\\\n seleniumMathJax.seleniumMathJax(useWebDriver,\\n useGrid,\\n host,\\n port,\\n mathJaxPath,\\n mathJaxTestPath,\\n operatingSystem,\\n browser,\\n browserVersion,\\n browserMode,\\n browserPath,\\n font,\\n outputJax,\\n timeOut,\\n fullScreenMode)\\n \\n if aTransmitToTaskHandler:\\n taskHandler = [TASK_HANDLER_HOST,\\n TASK_HANDLER_PORT,\\n str(os.getpid())]\\n else:\\n taskHandler = None\\n\\n # Create the test suite\\n suite = reftest.reftestSuite(taskHandler,\\n runSlowTests,\\n runSkipTests,\\n listOfTests,\\n startID)\\n # use the specified file name\\n if hasattr(aArgs, \\\"filename\\\"):\\n filename = aArgs.filename\\n else:\\n filename = getOutputFileName(directory,\\n selenium,\\n suite)\\n runTestingInstance(directory, selenium, suite,\\n formatOutput, compressOutput,\\n filename)\\n # end browserMode\\n # end browserVersion\\n #end outputJax\\n # end for font\\n # end browser\",\n \"def launch_tool(https_authority,username,password,browser,catalog,utils,tool_name,\\n tool_revision,parameters_text,add_empty_params=False):\\n\\n # login to the hub\\n utils.account.login_as(username,password)\\n\\n # go to the page to launch the tool\\n # with the parameters encoded in the url\\n GenericPage = catalog.load('GenericPage')\\n po = GenericPage(browser,catalog)\\n\\n # quote() is for escaping the path portion of the url\\n # quote_plus() is for escaping the query portion of the url\\n # and handles escaping / to %2F, but turns spaces into +'s\\n encoded_parameters = urllib.quote_plus(parameters_text.encode('utf8'))\\n\\n url = \\\"%(https_authority)s/tools/%(toolname)s/invoke/%(toolrev)s\\\"\\n\\n if encoded_parameters != '' or add_empty_params:\\n url += \\\"?params=%(params)s\\\"\\n\\n # hard code tool revision to test so we don't have to publish the tool\\n tool_revision = 'test'\\n\\n url = url % {'https_authority' : https_authority,\\n 'toolname' : tool_name,\\n 'toolrev' : tool_revision,\\n 'params' : encoded_parameters,}\\n\\n # print \\\"parameters_text = %s\\\" % (parameters_text)\\n # print \\\"url = %s\\\" % (url)\\n\\n # launch the tool\\n browser.proxy_client.new_har(\\\"page link\\\")\\n po.goto_page(url)\\n har_entry = browser.page_load_details()\\n\\n if browser.error_loading_page(har_entry):\\n # the tool session container may still start,\\n # even if the har status is not 200 level\\n # try to close it before raising the error\\n\\n har_status = har_entry['response']['status']\\n # print har_status\\n raise HarStatusError(\\\"unexpected error while launching tool: %s\\\" % (har_status))\\n\\n # include a check for 'Bad Parameters' error box in html\\n # because the error page returns status of 200\\n for msg in po.get_errorbox_info():\\n if 'bad parameters' in msg.lower():\\n raise BadParameterError(\\n \\\"found a 'Bad Parameters' error box in the html of\\\" \\\\\\n + \\\" %s while passing parameters: %s\\\\n%s\\\" \\\\\\n % (url,parameters_text,msg))\\n\\n # one last check for middleware errors that take the user back to\\n # the member's dashboard page. middleware can't send messages back\\n # to the web server, so we get the message \\\"Failed to invoke session\\\"\\n loc = 'css=dd.error'\\n if po.is_displayed(loc):\\n # there is an error message displayed\\n e = po.find_element(loc)\\n msg = e.text\\n raise SessionInvokeError(msg)\\n\\n # get the session number from the tool session page\\n ToolSessionPage = catalog.load('ToolSessionPage')\\n po = ToolSessionPage(browser,catalog)\\n tool_session_number = po.get_session_number()\\n\\n return tool_session_number\",\n \"def start_server(**params):\\n\\n def _grpc_server_async(options):\\n call_command(\\\"grpcserver\\\", **options)\\n\\n port = 50000 + randint(0, 10000)\\n params[\\\"port\\\"] = port\\n # Start grpc server\\n srv = threading.Thread(\\n target=_grpc_server_async, args=[params]\\n )\\n srv.start()\\n sleep(5)\\n return \\\"localhost:%s\\\" % port\",\n \"def main():\\n print(\\\"runner\\\")\\n runner = Runner()\\n stop_on_idle = True\\n probes = []\\n for url in urls:\\n probe_cls = random.choice((HttpProbe, ThreadProbe, ShellProbe))\\n runner.probes.append(probe_cls(url))\\n\\n runner.run()\",\n \"def init_driver():\\n driver = webdriver.Firefox()\\n driver.wait = WebDriverWait(driver,5)\\n return driver\",\n \"def run_tests(params):\\n default_test_params = [\\n \\\"./tests\\\",\\n \\\"-vv\\\",\\n \\\"--json-report\\\",\\n \\\"--key-file\\\",\\n DEFAULT_KEY_FILE.name\\n ]\\n\\n with DEBUG_LOG_FILE.open(\\\"a\\\") as debug_out:\\n with redirect_stdout(debug_out):\\n with redirect_stderr(sys.stdout):\\n return pytest.main(default_test_params + params)\",\n \"def __init__(self, path_to_web_driver='/usr/local/bin/chrome'):\\n self.path_to_web_driver = path_to_web_driver\\n options = webdriver.ChromeOptions()\\n options.add_argument('headless')\\n webdriver.Chrome.__init__(self, executable_path=self.path_to_web_driver, chrome_options=options)\",\n \"def run_ps(self):\\n config = self._estimator.config\\n server = self._start_std_server(config)\\n server.join()\",\n \"def driver():\\n driver = webdriver.Chrome(chrome_options=ChromeOptions(), project_name=\\\"Examples\\\", job_name=\\\"Pytest Example\\\")\\n yield driver\\n driver.quit()\",\n \"def launch(**kwargs):\\n logger.info('launch dream command')\\n launch_gui()\",\n \"def __init__(self, logger, binary, webdriver_binary=\\\"chromedriver\\\",\\n adb_binary=None,\\n remote_queue=None,\\n device_serial=None,\\n webdriver_args=None,\\n stackwalk_binary=None,\\n symbols_path=None):\\n super().__init__(logger,\\n webdriver_binary, adb_binary, remote_queue,\\n device_serial, webdriver_args, stackwalk_binary,\\n symbols_path)\\n self.binary = binary\\n self.wptserver_ports = _wptserve_ports\",\n \"def runner(self, classpath, main, jvm_options=None, args=None):\\r\\n return self._runner(*self._scrub_args(classpath, main, jvm_options, args))\",\n \"def start_collector_configure() -> WebDriver:\\n exp_cap = {\\n \\\"app\\\": r\\\"C:\\\\Program Files\\\\Centrify\\\\Audit\\\\Collector\\\\collector.configure.exe\\\",\\n \\\"deviceName\\\": \\\"WindowsPC\\\"\\n }\\n exp_session = webdriver.Remote(\\n command_executor='http://127.0.0.1:4723',\\n desired_capabilities=exp_cap)\\n return exp_session\",\n \"def setUpClass(cls):\\n super().setUpClass()\\n options = Options()\\n options.headless = True\\n cls.selenium = WebDriver(options=options)\\n cls.selenium.implicitly_wait(10)\",\n \"def run_local_test_run(self, api, test_config_params,\\n skip_download=False): # pragma: no cover\\n if self.m.platform.is_win:\\n self.m.chromium.taskkill()\\n\\n if skip_download:\\n update_step = None\\n else:\\n update_step = api.bot_update.ensure_checkout(\\n root_solution_revision=test_config_params['revision'])\\n self.start_test_run_for_bisect(api, update_step, self.bot_db,\\n test_config_params, run_locally=True,\\n skip_download=skip_download)\",\n \"def _start_server():\\n args = [sys.executable] + sys.argv\\n args.insert(args.index('wserver'), 'server')\\n args.remove('wserver')\\n pid = os.spawnv(os.P_NOWAIT, sys.executable, args)\\n return pid\",\n \"def main():\\n\\n run_manual_session()\\n # run_automated_session()\",\n \"def launch(config):\\n \\n launch_with_configs([config])\",\n \"def browser(config, config_url, config_browser, config_wait_time):\\n try:\\n kwargs = {}\\n if 'binary' in config:\\n binary = config['binary']\\n if config['selenium_grid']:\\n caps = {'browserName': config_browser}\\n command_executor_url = \\\"http://{}:4444/wd/hub\\\".format(config['hub_host'])\\n driver = webdriver.Remote(\\n command_executor=command_executor_url,\\n desired_capabilities=caps\\n )\\n else:\\n if config_browser == 'chrome':\\n if binary:\\n kwargs.update({'executable_path': binary})\\n options = webdriver.ChromeOptions()\\n options.add_argument('disable-web-security')\\n options.add_argument(\\\"--no-sandbox\\\")\\n options.add_argument(\\\"--disable-dev-shm-usage\\\")\\n kwargs.update({'options': options})\\n driver = webdriver.Chrome(**kwargs)\\n elif config_browser == 'firefox':\\n driver = webdriver.Firefox(**kwargs)\\n else:\\n raise Exception('\\\"{config_browser}\\\" is not a supported browser')\\n\\n # Wait implicitly for elements to be ready before attempting interactions\\n driver.implicitly_wait(config_wait_time)\\n driver.get(config_url)\\n driver.maximize_window()\\n\\n # Return the driver object at the end of setup\\n yield driver\\n finally:\\n # For cleanup, quit the driver\\n driver.quit()\",\n \"def main():\\n args = docopt(__doc__)\\n loc = \\\"%s/%s/dataset/%s\\\" % (args['--host'], args['--prefix'], args['DATASET'])\\n qstr = \\\"staticThreshold=Infinity\\\"\\n qstr += \\\"&nohitThreshold=Infinity\\\"\\n qstr += \\\"&plotGraphics=svg\\\"\\n if args['--format'] == 'svg':\\n qstr += \\\"&svgThreshold=Infinity\\\"\\n shape = 'square'\\n for param in args['--param']:\\n qstr += \\\"&%s\\\" % str(param)\\n key, value = param.split('=')\\n if key == 'plotShape':\\n shape = value\\n\\n timeout = int(args['--timeout'])\\n\\n outdir = os.path.abspath(args['--out'])\\n os.makedirs(Path(outdir), exist_ok=True)\\n\\n profile = webdriver.FirefoxProfile()\\n profile.set_preference('browser.download.folderList', 2)\\n profile.set_preference('browser.download.manager.showWhenStarting', False)\\n profile.set_preference('browser.download.dir', outdir)\\n profile.set_preference('browser.download.lastDir', args['--out'])\\n profile.set_preference('browser.helperApps.neverAsk.saveToDisk',\\n 'image/png, image/svg+xml, text/csv, text/plain, application/json')\\n\\n options = Options()\\n options.set_headless(headless=False)\\n display = Display(visible=0, size=(800, 600))\\n display.start()\\n driver = webdriver.Firefox(options=options, firefox_profile=profile)\\n try:\\n view = args['--view'][0]\\n if args['--preview']:\\n qstr += '#Filters'\\n url = \\\"%s/%s?%s\\\" % (loc, view, qstr)\\n print(\\\"Loading %s\\\" % url)\\n try:\\n driver.get(url)\\n except Exception as err:\\n print(err)\\n\\n for next_view in args['--view']:\\n if next_view != view:\\n view = next_view\\n url = \\\"%s/%s?%s\\\" % (loc, view, qstr)\\n print(\\\"Navigating to %s\\\" % url)\\n try:\\n driver.get(url)\\n except Exception as err:\\n print(err)\\n for fmt in args['--format']:\\n file = \\\"%s.%s\\\" % (args['DATASET'], view)\\n if view == 'blob':\\n file += \\\".%s\\\" % shape\\n elif view == 'busco':\\n view = \\\"all_%s\\\" % view\\n if fmt not in ('csv', 'json'):\\n fmt = 'json'\\n file += \\\".%s\\\" % fmt\\n print(\\\"Fetching %s\\\" % file)\\n el_id = \\\"%s_save_%s\\\" % (view, fmt)\\n print(\\\"waiting for element %s\\\" % el_id)\\n unstable = True\\n while unstable:\\n try:\\n element = WebDriverWait(driver, timeout).until(\\n EC.visibility_of_element_located((By.ID, el_id))\\n )\\n element.click()\\n unstable = False\\n file_name = \\\"%s/%s\\\" % (outdir, file)\\n print(\\\"waiting for file '%s'\\\" % file_name)\\n file_ready(file_name)\\n except Exception as err:\\n time.sleep(1)\\n\\n for preview in args['--preview']:\\n print(\\\"Creating %s preview\\\" % preview)\\n for fmt in args['--format']:\\n el_id = \\\"%s_preview_save_%s\\\" % (preview, fmt)\\n file = \\\"%s.%s.preview.%s\\\" % (args['DATASET'], preview, fmt)\\n try:\\n element = WebDriverWait(driver, timeout).until(\\n EC.visibility_of_element_located((By.ID, el_id))\\n )\\n element.click()\\n file_name = \\\"%s/%s\\\" % (outdir, file)\\n print(\\\"waiting for file '%s'\\\" % file_name)\\n file_ready(file_name)\\n except Exception as err:\\n print(err)\\n driver.close()\\n except Exception as err:\\n print(err)\\n driver.close()\",\n \"def launch_ec(self, argStr='', input='', flag=''):\\n command = 'python tests/targets/simple.py'\\n\\n if flag:\\n command += ' %s' % flag\\n\\n if argStr:\\n\\n command += ' %s' % argStr\\n\\n return shell_exec(command, input=input)\",\n \"def _start(args=None):\\n options = _parse_args(args)\\n main(**options)\",\n \"def launch_application(path) -> WebDriver:\\n try:\\n exp_cap = {\\n \\\"deviceName\\\": \\\"WindowsPC\\\",\\n \\\"app\\\": path}\\n exp_session = webdriver.Remote(\\n command_executor='http://127.0.0.1:4723',\\n desired_capabilities=exp_cap)\\n return exp_session\\n except Exception as ex:\\n logger.info(f':Error in launching app ERROR: {ex}')\",\n \"def get_driver_with_options():\\n #options = get_driver_options()\\n #return webdriver.Chrome(options=options)\\n return webdriver.Chrome()\",\n \"def main():\\n return run_server(**parse_server_args())\",\n \"def setUpClass(cls):\\n\\n super().setUpClass()\\n cls.selenium = WebDriver(executable_path=\\\"C:\\\\Program Files (x86)\\\\chromedriver.exe\\\")\\n cls.selenium.implicitly_wait(10)\",\n \"def launch_chrome():\\r\\n DRIVER_PATH = '/Users/User/Downloads/chromedriver_win32/chromedriver' #Location of chromedriver application\\r\\n chrome_options = webdriver.ChromeOptions()\\r\\n chrome_options.add_argument('--disable-blink-features=AutomationControlled') #Tells browser it is not controlled by automation\\r\\n driver = webdriver.Chrome(DRIVER_PATH,options = chrome_options)\\r\\n return driver\",\n \"def setup(self, skip_start=False):\\n nprev_comm = self.comm_count\\n nprev_thread = self.thread_count\\n nprev_fd = self.fd_count\\n self.driver = self.driver_class(*self.driver_args, **self.driver_kwargs)\\n if not skip_start:\\n self.driver.start()\\n os.environ.update(self.driver.env)\\n self._skip_start = skip_start\\n super(TestBase, self).setup(nprev_comm=nprev_comm,\\n nprev_thread=nprev_thread,\\n nprev_fd=nprev_fd)\",\n \"def cli(argv):\\n import getopt\\n class BadUsage(Exception): pass\\n\\n try:\\n opts, args = getopt.getopt(argv[1:], 'gp:r:h:s:', \\n ['gui', 'port=', 'repository=', 'script-alias='])\\n for opt, val in opts:\\n if opt in ('-g', '--gui'):\\n options.start_gui = 1\\n elif opt in ('-r', '--repository'):\\n if options.repositories: # option may be used more than once:\\n num = len(options.repositories.keys())+1\\n symbolic_name = \\\"Repository\\\"+str(num)\\n options.repositories[symbolic_name] = val\\n else:\\n options.repositories[\\\"Development\\\"] = val\\n elif opt in ('-p', '--port'):\\n try:\\n options.port = int(val)\\n except ValueError:\\n raise BadUsage\\n elif opt in ('-h', '--host'):\\n options.host = val\\n elif opt in ('-s', '--script-alias'):\\n options.script_alias = \\\\\\n string.join(filter(None, string.split(val, '/')), '/')\\n if options.start_gui:\\n gui(options.host, options.port)\\n return\\n elif options.port:\\n def ready(server):\\n print 'server ready at %s%s' % (server.url,\\n options.script_alias)\\n serve(options.host, options.port, ready)\\n return\\n raise BadUsage\\n except (getopt.error, BadUsage):\\n cmd = os.path.basename(sys.argv[0])\\n port = options.port\\n host = options.host\\n script_alias = options.script_alias\\n print \\\"\\\"\\\"ViewVC standalone - a simple standalone HTTP-Server\\n\\nUsage: %(cmd)s [OPTIONS]\\n\\nAvailable Options:\\n\\n-h <host>, --host=<host>:\\n Start the HTTP server listening on <host>. You need to provide\\n the hostname if you want to access the standalone server from a\\n remote machine. [default: %(host)s]\\n\\n-p <port>, --port=<port>:\\n Start an HTTP server on the given port. [default: %(port)d]\\n\\n-r <path>, --repository=<path>:\\n Specify a path for a CVS repository. Repository definitions are\\n typically read from the viewvc.conf file, if available. This\\n option may be used more than once.\\n\\n-s <path>, --script-alias=<path>:\\n Specify the ScriptAlias, the artificial path location that at\\n which ViewVC appears to be located. For example, if your\\n ScriptAlias is \\\"cgi-bin/viewvc\\\", then ViewVC will appear to be\\n accessible at the URL \\\"http://%(host)s:%(port)s/cgi-bin/viewvc\\\".\\n [default: %(script_alias)s]\\n \\n-g, --gui:\\n Pop up a graphical interface for serving and testing ViewVC.\\n NOTE: this requires a valid X11 display connection.\\n\\\"\\\"\\\" % locals()\",\n \"def main():\\n tester = Tester()\\n # parse args, load configuration and create all required objects.\\n tester.setup_experiment()\\n # GO!\\n tester.run_experiment()\",\n \"def __init__(self, base_url=\\\"\\\",\\n driver=None,\\n driver_kwargs=None,\\n enable_highlighting=False,\\n enable_screen_shot_highlight=False,\\n implicit_wait=0,\\n think_time=0,\\n download_folder='',\\n screen_shots_folder='',\\n highlighting_color='',\\n highlighting_size=0,\\n highlighting_time=0,\\n remote_ip=None,\\n remote_port=None,\\n desired_capability=None,\\n headless=None,\\n display_width=None,\\n display_height=None\\n ):\\n\\n if isinstance(driver, str):\\n driver = get_driver_from_name(driver)\\n\\n if driver is None:\\n driver = get_driver_from_name(settings.DEFAULT_DRIVER_EXECUTABLE)\\n\\n self.web_driver = driver\\n self._driver_kwargs = driver_kwargs or {}\\n self.driver = None # type: WebDriver\\n\\n self.url = base_url if base_url.startswith('http') else (\\\"http://\\\" + base_url) if base_url else ''\\n self.accept_next_alert = True\\n\\n self.download_folder = download_folder or settings.DOWNLOAD_FOLDER\\n self.implicit_wait = implicit_wait or settings.IMPLICIT_WAIT\\n screen_shots_folder = screen_shots_folder or os.path.join(self.download_folder, settings.SCREEN_SHOTS_FOLDER)\\n self.screen_shot_folder = os.path.realpath(screen_shots_folder)\\n self.think_time = think_time\\n\\n self._is_driver_open = False\\n self._default_find_element_method = self._default_find_elements_method = None\\n\\n self._enable_highlighted_find_elements = enable_highlighting or settings.ENABLE_HIGHTLIGHTING\\n self._screen_shot_highlights = enable_screen_shot_highlight or settings.ENABLE_SCREENSHOT_HIGHTLIGHTING\\n self._highlighting_color = highlighting_color or settings.HIGHLIGHTING_COLOR\\n self._highlighting_size = highlighting_size or settings.HIGHLIGHTING_SIZE\\n self._highlighting_time = highlighting_time or settings.HIGHLIGHTING_TIME\\n\\n\\n # headless vars\\n self._headless = headless or settings.HEADLESS\\n self._display_height = display_height\\n self._display_width = display_width\\n\\n self._create_download_shots_folders()\\n\\n self._remote_ip = remote_ip\\n self._remote_port = remote_port or settings.REMOTE_PORT\\n self._desired_capability = desired_capability\\n\\n self._jquery_available = self._jquery_checked = False\",\n \"def StartTestConfiguration(self, *args, **kwargs):\\n # type: (*Any, **Any) -> None\\n payload = {}\\n for i in range(len(args)):\\n payload[\\\"Arg%s\\\" % (i + 1)] = args[i]\\n for item in kwargs.items():\\n payload[item[0]] = item[1]\\n return self._execute(\\n \\\"startTestConfiguration\\\", payload=payload, response_object=None\\n )\",\n \"def main():\\n executor(option().host)\",\n \"def main():\\n args = parse_command_line()\\n expt_config = load_config(args.experiment_config_path)\\n run_cli(RunOptions.from_dict(expt_config))\",\n \"def get_driver():\\n # user_agent = user_agent_rotator.get_random_user_agent()\\n try:\\n if len(sys.argv) > 1:\\n if Driver._driver is None:\\n chrome_options = Options()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--disable-extensions')\\n chrome_options.add_argument('--profile-directory=Default')\\n chrome_options.add_argument(\\\"--incognito\\\")\\n chrome_options.add_argument(\\\"--disable-plugins-discovery\\\")\\n chrome_options.add_argument(\\\"--start-maximized\\\")\\n chrome_options.add_argument(f'--user-agent={USER_AGENT}')\\n Driver._driver = webdriver.Chrome(executable_path=sys.argv[1], chrome_options=chrome_options)\\n logging.info(f\\\"Driver loaded succesfully from {sys.argv[1]}\\\")\\n return Driver._driver\\n else:\\n logging.error(f\\\"Driver cannot be found. User entered: {sys.argv[1]}\\\")\\n raise Exception(\\\"Please provide a path to the chromedriver\\\")\\n\\n except Exception as e:\\n logging.error(f\\\"Driver cannot be found. User entered: {sys.argv[1]}\\\")\\n raise FileNotFoundError(\\\"Could not execute webdriver. Make sure you provided the correct path to the \\\"\\n \\\"chromedriver\\\", e)\",\n \"def main(self, params):\\n raise NotImplementedError('main() must be implemented.')\",\n \"def __init__(self,\\n geckodriver_path = None,\\n headless_browser = False,\\n disable_image_load = False,\\n page_delay = 10,\\n logfolder = 'logs/',\\n user_agent = None,\\n proxy_address = None,\\n proxy_port = None,\\n proxy_username = None,\\n proxy_password = None,\\n limit_scropes = None,\\n exclude_hosts = None,\\n browser_profile_path = None,\\n browser_executable_path = None,\\n geckodriver_log_level = 'info'\\n ):\\n firefox_options = Firefox_Options()\\n seleniumwire_options = {}\\n\\n if headless_browser:\\n firefox_options.add_argument(\\\"-headless\\\")\\n\\n if browser_profile_path is not None:\\n firefox_profile = webdriver.FirefoxProfile(browser_profile_path)\\n else:\\n firefox_profile = webdriver.FirefoxProfile()\\n\\n if browser_executable_path is not None:\\n firefox_options.binary = browser_executable_path\\n\\n\\n # set \\\"info\\\" by default\\n # set \\\"trace\\\" for debubging, Development only\\n firefox_options.log.level = geckodriver_log_level\\n\\n # set English language\\n firefox_profile.set_preference(\\\"intl.accept_languages\\\", \\\"en-US\\\")\\n\\n # set User-Agent\\n if user_agent is not None:\\n firefox_profile.set_preference(\\\"general.useragent.override\\\", user_agent)\\n\\n if disable_image_load:\\n # permissions.default.image = 2: Disable images load,\\n # this setting can improve pageload & save bandwidth\\n firefox_profile.set_preference(\\\"permissions.default.image\\\", 2)\\n \\n # mute audio while watching stories\\n firefox_profile.set_preference(\\\"media.volume_scale\\\", \\\"0.0\\\")\\n\\n # prevent Hide Selenium Extension: error\\n firefox_profile.set_preference(\\\"dom.webdriver.enabled\\\", False)\\n firefox_profile.set_preference(\\\"useAutomationExtension\\\", False)\\n firefox_profile.set_preference(\\\"general.platform.override\\\", \\\"iPhone\\\")\\n firefox_profile.update_preferences()\\n\\n # geckodriver log in specific user logfolder\\n geckodriver_log = \\\"{}geckodriver.log\\\".format(logfolder)\\n check_and_create_file(geckodriver_log)\\n\\n\\n # The list exclude hosts for capturing\\n if exclude_hosts:\\n seleniumwire_options['exclude_hosts'] = exclude_hosts\\n\\n # Add proxy with username and password authentication\\n if proxy_address and proxy_port:\\n if proxy_username and proxy_password:\\n seleniumwire_options['proxy'] = {\\n 'http': f'http://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\\n 'https': f'https://{proxy_username}:{proxy_password}@{proxy_address}:{proxy_port}',\\n 'no_proxy': 'localhost,127.0.0.1'\\n }\\n else:\\n seleniumwire_options['proxy'] = {\\n 'http': f'http://{proxy_address}:{proxy_port}',\\n 'https': f'https://{proxy_address}:{proxy_port}',\\n 'no_proxy': 'localhost,127.0.0.1'\\n }\\n\\n\\n\\n self.driver = webdriver.Firefox(\\n firefox_profile=firefox_profile,\\n executable_path=geckodriver_path,\\n log_path=geckodriver_log,\\n options=firefox_options,\\n seleniumwire_options=seleniumwire_options\\n )\\n # Limit capture urls with regulater expression\\n if limit_scropes:\\n self.driver.scopes = limit_scropes\\n\\n # Set implicitly wait\\n self.driver.implicitly_wait(page_delay)\\n\\n # Set maximum windows\\n self.driver.maximize_window()\",\n \"def connect(self, params={}):\\n self.params = params\\n return None\",\n \"def __init__(self, **kwargs):\\n super(DesktopInternetExplorerWebDriver, self).__init__(\\n default_capabilities=False, # ensure that HackedWebDriver doesn't mess with the capabilities\\n **kwargs\\n )\",\n \"def launch(self, user_data_dir=None):\\n if self.custom_driver:\\n return self.custom_driver\\n\\n options = self.driver_options()\\n\\n return webdriver.Chrome(options=options)\",\n \"def connect():\\n\\n driver = webdriver.Chrome(driver_exe) # Run the simulated chrome driver\\n driver.get(url) # go to the whatsapp web page\\n driver.implicitly_wait(10) # wait a little to make sure the page loads\\n return driver\",\n \"def main(self):\\n self.parse_option()\\n self.set_option()\\n\\n r = Bootscripts()\\n reactor.listenTCP(8009, server.Site(r))\\n reactor.run()\",\n \"def launch(click_context, agents: List[str], multithreaded: bool):\\n agents_directories = list(map(Path, list(OrderedDict.fromkeys(agents))))\\n if multithreaded:\\n failed = _launch_threads(click_context, agents_directories)\\n else:\\n failed = _launch_subprocesses(click_context, agents_directories)\\n logger.debug(f\\\"Exit cli. code: {failed}\\\")\\n sys.exit(failed)\",\n \"def startup(self, override_args=None):\\n self._app_name = sys.argv[0]\\n if override_args:\\n my_args = [self._app_name]\\n my_args = my_args + override_args\\n else:\\n my_args = sys.argv[:]\\n\\n if len(my_args) != 2:\\n print(\\\"\\\"\\\"Usage:\\n\\n {0} sitl\\n run with built-in SITL simulator\\n {0} render\\n just render the behaviour tree\\n {0} <connection string>\\n connect as prescribed and fly the mission\\\"\\\"\\\".format((self._app_name)))\\n elif my_args[1] == 'sitl':\\n self._sitl = dronekit_sitl.start_default(lat=self._sitl_lat,\\n lon=self._sitl_lon)\\n self._connection_string = self._sitl.connection_string()\\n print(\\\"Using SITL via {}\\\".format(self._connection_string))\\n self.connect()\\n elif my_args[1] == 'render':\\n print(\\\"Rendering only\\\")\\n self.render()\\n else:\\n self._connection_string = my_args[1]\\n print(f\\\"Attempting to connect via {self._connection_string}\\\")\\n self.connect()\",\n \"def __init__(self, base_url=None):\\n self.driver = webdriver.Chrome()\\n if base_url:\\n self.base_url = base_url\",\n \"def _get_selenium_browser(navigator, fLOG=noLOG):\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n from selenium import webdriver\\n from selenium.webdriver.common.desired_capabilities import DesiredCapabilities\\n\\n fLOG(\\\"[webshot] navigator=\\\", navigator)\\n if navigator == \\\"firefox\\\":\\n firefox_capabilities = DesiredCapabilities.FIREFOX.copy()\\n firefox_capabilities['marionette'] = True\\n firefox_capabilities[\\n 'binary'] = r\\\"C:\\\\Program Files (x86)\\\\Mozilla Firefox\\\\firefox.exe\\\"\\n browser = webdriver.Firefox(capabilities=firefox_capabilities)\\n elif navigator == \\\"chrome\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n install_chromedriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"chromedriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install 'chromedriver.exe'\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'chromedriver'\\n\\n start_navi = True\\n if start_navi:\\n fLOG(\\\"[_get_selenium_browser] start\\\", navigator)\\n chrome_options = webdriver.ChromeOptions()\\n chrome_options.add_argument('--headless')\\n chrome_options.add_argument('--no-sandbox')\\n chrome_options.add_argument('--verbose')\\n browser = webdriver.Chrome(executable_path=chromed,\\n chrome_options=chrome_options)\\n else:\\n with warnings.catch_warnings():\\n warnings.simplefilter(\\\"ignore\\\", ImportWarning)\\n import selenium.webdriver.chrome.service as wservice\\n fLOG(\\\"[_get_selenium_browser] create service\\\")\\n service = wservice.Service(chromed)\\n fLOG(\\\"[_get_selenium_browser] start service\\\")\\n service.start()\\n fLOG(\\\"[_get_selenium_browser] declare remote\\\")\\n capabilities = {'chrome.binary': chromed}\\n browser = webdriver.Remote(service.service_url, capabilities)\\n elif navigator == \\\"ie\\\":\\n browser = webdriver.Ie()\\n elif navigator == \\\"opera\\\":\\n if sys.platform.startswith(\\\"win\\\"):\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n install_operadriver(fLOG=fLOG)\\n chromed = where_in_path(\\\"operadriver.exe\\\")\\n if chromed is None:\\n raise FileNotFoundError(\\n \\\"unable to install operadriver.exe\\\")\\n else:\\n fLOG(\\\"[_get_selenium_browser] found chromedriver:\\\", chromed)\\n else:\\n chromed = 'operadriver'\\n browser = webdriver.Opera(chromed) # pylint: disable=E1101\\n elif navigator == \\\"edge\\\":\\n browser = webdriver.Edge()\\n else:\\n raise RuntimeError(\\n f\\\"unable to interpret the navigator '{navigator}'\\\")\\n fLOG(\\\"[_get_selenium_browser] navigator is started\\\")\\n return browser\",\n \"def start_chrome_browser(options_list, headless_mode, desired_capab= None, my_queue = None):\\r\\n\\r\\n driver = None\\r\\n chrome_options = Options()\\r\\n for option in options_list:\\r\\n chrome_options.add_argument(option) \\r\\n \\r\\n # suppress chrome log info\\r\\n chrome_options.add_argument('--log-level=3') \\r\\n chrome_options.add_argument('--disable-dev-shm-usage') \\r\\n chrome_options.add_argument(\\\"--no-sandbox\\\")\\r\\n chrome_options.add_argument(\\\"--disable-extensions\\\")\\r\\n chrome_options.add_argument(\\\"--disable-notifications\\\")\\r\\n chrome_options.add_argument(\\\"--enable-automation\\\")\\r\\n\\r\\n chrome_options.add_experimental_option('excludeSwitches', ['enable-logging'])\\r\\n\\r\\n if headless_mode:\\r\\n print('Starting Chrome browser without the graphical user interface ...')\\r\\n chrome_options.add_argument(\\\"--headless\\\") \\r\\n else:\\r\\n printY('DO NOT INTERACT WITH THE CHROME BROWSER. IT IS CONTROLLED BY THE SCRIPT AND WILL BE CLOSED WHEN THE TASK FINISHES')\\r\\n #chrome_options.add_argument(\\\"--window-size=900,1200\\\")\\r\\n\\r\\n if desired_capab:\\r\\n driver = webdriver.Chrome(options=chrome_options, desired_capabilities= desired_capab)\\r\\n else:\\r\\n driver = webdriver.Chrome(options=chrome_options)\\r\\n\\r\\n if my_queue:\\r\\n my_queue.put(driver)\\r\\n\\r\\n return driver\",\n \"def start_test_instance(test_name=None):\\n env.warn_only = True\\n if test_name is not None:\\n instances = [test_name]\\n else:\\n output = run('ls -1 %s' % env.site_root)\\n instances = [x.strip() for x in output.split(\\\"\\\\n\\\")]\\n for item in instances:\\n sudo(\\\"start %s\\\" % item.strip())\",\n \"def main(_):\\n description = xm.ExperimentDescription(\\n FLAGS.exp_name, tags=[\\n FLAGS.env_name,\\n ])\\n experiment = build_experiment()\\n xm.launch_experiment(description, experiment)\",\n \"def test_executable():\\n arg1 = get_args(driver=\\\"chrome\\\", executable=\\\"/tmp\\\")\\n assert arg1[\\\"executable_path\\\"] == \\\"/tmp\\\"\",\n \"def start_microservice(params) -> None:\\n print(\\\"Starting microservice...\\\")\\n cmd = \\\"docker run --rm --publish \\\" + params['microservice_port'] + \\\":\\\" + \\\\\\n params['microservice_port'] + \\\" --detach --name bg_changer \\\" + \\\\\\n \\\"--mount type=bind,source=\\\" + params['config_file'] + \\\\\\n \\\",destination=/fakewebcam.ini bg_changer >/dev/null 2>&1\\\"\\n if os.system(cmd) == 0:\\n print(\\\" Success !\\\")\\n else:\\n print(\\\" Failure !\\\")\",\n \"def init_driver(self):\\n # Set UserAgent to prevent issues with blocking bot\\n self.chrome_options.add_argument(\\n \\\"user-agent=Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_4) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/81.0.4044.138 Safari/537.36\\\")\\n # Set headless\\n if self.headless:\\n self.chrome_options.add_argument('headless')\\n # Initiate driver\\n driver = webdriver.Chrome(\\n self.chromedriver_path + \\\"/chromedriver\\\", options=self.chrome_options)\\n self.driver = driver\\n self.wait = WebDriverWait(self.driver, 20)\\n return self.driver\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.62242675","0.58627564","0.56516945","0.56402934","0.56345683","0.56059575","0.56059575","0.5513187","0.5233649","0.5220939","0.51877004","0.51692015","0.51691693","0.5165994","0.51010007","0.50910467","0.50774854","0.5061027","0.50559413","0.5016454","0.4973049","0.49602216","0.49595392","0.4955275","0.49543604","0.49360898","0.49337167","0.4923154","0.4894448","0.4887168","0.4885127","0.48671103","0.48645857","0.4863429","0.48551258","0.48539698","0.48491687","0.4833638","0.48278788","0.48193944","0.4811281","0.48109183","0.48093218","0.4807071","0.4791342","0.47873935","0.47848526","0.47637016","0.47520155","0.47489414","0.47424322","0.47406417","0.47348264","0.47214353","0.47097683","0.46981728","0.46807152","0.46635148","0.4650649","0.4647085","0.4640725","0.46382","0.46276468","0.46103704","0.46099424","0.45989266","0.45973653","0.45938602","0.45929492","0.4583517","0.45833164","0.4579606","0.45693174","0.45646662","0.4560036","0.45592326","0.45568237","0.45555896","0.45544994","0.4550352","0.45500088","0.45436904","0.45402083","0.45312482","0.45306095","0.45225674","0.45060062","0.44980273","0.4495361","0.4488475","0.4481257","0.44812045","0.4479995","0.4477308","0.4473378","0.4473259","0.44715276","0.44691235","0.44682246","0.44675058"],"string":"[\n \"0.62242675\",\n \"0.58627564\",\n \"0.56516945\",\n \"0.56402934\",\n \"0.56345683\",\n \"0.56059575\",\n \"0.56059575\",\n \"0.5513187\",\n \"0.5233649\",\n \"0.5220939\",\n \"0.51877004\",\n \"0.51692015\",\n \"0.51691693\",\n \"0.5165994\",\n \"0.51010007\",\n \"0.50910467\",\n \"0.50774854\",\n \"0.5061027\",\n \"0.50559413\",\n \"0.5016454\",\n \"0.4973049\",\n \"0.49602216\",\n \"0.49595392\",\n \"0.4955275\",\n \"0.49543604\",\n \"0.49360898\",\n \"0.49337167\",\n \"0.4923154\",\n \"0.4894448\",\n \"0.4887168\",\n \"0.4885127\",\n \"0.48671103\",\n \"0.48645857\",\n \"0.4863429\",\n \"0.48551258\",\n \"0.48539698\",\n \"0.48491687\",\n \"0.4833638\",\n \"0.48278788\",\n \"0.48193944\",\n \"0.4811281\",\n \"0.48109183\",\n \"0.48093218\",\n \"0.4807071\",\n \"0.4791342\",\n \"0.47873935\",\n \"0.47848526\",\n \"0.47637016\",\n \"0.47520155\",\n \"0.47489414\",\n \"0.47424322\",\n \"0.47406417\",\n \"0.47348264\",\n \"0.47214353\",\n \"0.47097683\",\n \"0.46981728\",\n \"0.46807152\",\n \"0.46635148\",\n \"0.4650649\",\n \"0.4647085\",\n \"0.4640725\",\n \"0.46382\",\n \"0.46276468\",\n \"0.46103704\",\n \"0.46099424\",\n \"0.45989266\",\n \"0.45973653\",\n \"0.45938602\",\n \"0.45929492\",\n \"0.4583517\",\n \"0.45833164\",\n \"0.4579606\",\n \"0.45693174\",\n \"0.45646662\",\n \"0.4560036\",\n \"0.45592326\",\n \"0.45568237\",\n \"0.45555896\",\n \"0.45544994\",\n \"0.4550352\",\n \"0.45500088\",\n \"0.45436904\",\n \"0.45402083\",\n \"0.45312482\",\n \"0.45306095\",\n \"0.45225674\",\n \"0.45060062\",\n \"0.44980273\",\n \"0.4495361\",\n \"0.4488475\",\n \"0.4481257\",\n \"0.44812045\",\n \"0.4479995\",\n \"0.4477308\",\n \"0.4473378\",\n \"0.4473259\",\n \"0.44715276\",\n \"0.44691235\",\n \"0.44682246\",\n \"0.44675058\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6509325"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88381,"cells":{"query":{"kind":"string","value":"Stops the selenium server (and closes all browsers)."},"document":{"kind":"string","value":"def stop_selenium_server(self):\n shut_down_selenium_server(self._server_host, self._server_port)\n self._selenium = NoBrowserOpen()\n if self._selenium_log:\n self._selenium_log.close()"},"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 stop_browser(self):\n self.driver.quit()","def shut_down_selenium_server(host='localhost', port=4444):\n try:\n selenium(host, port, '', '').shut_down_selenium_server()\n except socket.error:\n pass","def __exit__(self, exc_type, exc_val, exc_tb):\n self.server.stop()\n self.driver.quit()","def close_browser():\n driver.close()","def i_close_the_browser():\n driver.close()\n driver.quit()","def stop_server_and_driver(server, driver):\n \n driver.close()\n server.stop()","def close_and_finish_execution():\n driver.close()\n driver.quit()\n exit(0)","def close(self):\n self.m_driver.close()\n self.m_driver = None\n\n if self.m_display is not None:\n self.m_display.stop()\n self.m_display = None\n\n if self.m_vpn_handle is not None:\n self.m_vpn_handle.close()\n self.m_vpn_handle = None\n\n l_result = run(['sudo', 'killall', '-9', 'chromedriver'], stdout=PIPE, stderr=PIPE)\n self.m_logger.info('Killing chromedriver : ' + repr(l_result))\n l_result = run(['sudo', 'killall', '-9', 'chromium-browser'], stdout=PIPE, stderr=PIPE)\n self.m_logger.info('Killing Chromium : ' + repr(l_result))","def closeBrowser(driver):\n driver.quit()","def close(self):\n\n #Kill all zombie PIDs and exit gracefully\n try:\n self.webdriver.quit()\n except:\n pass\n if 'p' not in sys.argv:\n self.kill()\n sys.exit()","def stopBrowser(self):\n self.browser.quit()","def close(self):\n self.driver.quit()","def end_session(self):\r\n self.web_driver.quit()\r\n self.write_log(\"Web driver ended.\")","def stop():\n server = current_server()\n server.stop()","def stop(self):\n if self.driver:\n self.driver.stop()\n vim_session.ConnectionHandler.stop()","def close(self):\n\n self._driver.quit()","def quit(self):\n if self.webdriver is not None:\n self.webdriver.quit()\n self.webdriver = None","def teardown(self):\n self.log.info('Close browser')\n self.driver.quit()","def shutdown(self):\n self._shutdown_browser()","def quit(self):\n self.driver.close_app()\n self.driver.quit()","def stop(self):\n\n self._stop_server = True\n\n self.join()\n self.httpd.server_close()","def quit(self):\n self.driver.quit()","def __exit__(self, *args):\n self.driver.quit()","def disconnect(self) -> None:\n self.driver.quit()","def stop() -> None:\n global _server\n if _server:\n try:\n _server.shutdown()\n except Exception:\n pass","def quit(self):\n driver.quit()","def webserver_stop():\n run(\"kill $(cat %s)\" % GUNICORN_PIDFILE)\n run(\"rm %s\" % GUNICORN_PIDFILE)","def quit(self):\r\n t1 = time.time()\r\n self.driver.quit()\r\n self.my_print(\"{0} Closed all window and quit the driver, Spend {1} seconds\".format(success, time.time() - t1))","def _shutdown_browser(self):\n if self.browser:\n self.browser.close()","def tear_down(self):\n if self.driver_name != \"Firefox\":\n for window_handle in self.driver.window_handles:\n self.driver.switch_to.window(window_handle)\n self.driver.quit()\n self.clear_tmp_dir()\n for driver in self.all_drivers:\n try:\n driver.quit()\n except WebDriverException:\n pass","def tear_down(self):\n self.driver.close()\n self.driver.quit()","def stop(self):\n self.logger.info('Shutting down SimpleHTTPServer')\n stop_cmd = \"pkill -9 -f '{0}'\".format(self.server_cmd)\n self._execute_command(stop_cmd)","async def gracefully_shutdown_browser(self, browser: Browser) -> None:","def close(self):\n self.driver.close()","def closeChrome(self):\r\n\t\tself.driver.close()\r\n\t\treturn","async def _internalStop(self):\n self.wserver.close()\n await self.wserver.wait_closed()\n self.server.stop()\n while (self.server.is_running()):\n time.sleep(0.5)\n self.server.close()\n self.server = None","def teardown(self):\r\n self.driver.quit()","def kill(self):\n\n #Kill relevant process names\n if self.driver_type != 'firefox_wdm':\n os.system('pkill -f chrome')\n os.system('pkill -f Chrome')\n os.system('pkill -f chromedriver')\n else:\n os.system('pkill -f FireFox')\n #TODO: confirm this -> os.system('pkill -f geckodriver')","def stop():\n global server_handle\n server_handle.kill()\n server_handle = None","def quit(self):\n \n if 'driver' in self.__dict__:\n self.driver.quit()\n if 'session' in self.__dict__:\n self.session.close()\n if 'conn' in self.__dict__:\n self.conn.close()","def stop(self, loop):\n if self.server is not None:\n self.server.close()\n loop.run_until_complete(self.server.wait_closed())\n self.server = None","def stop(self):\n\n log_info(\"Stopping LiteServ ...\")\n\n self.logfile.flush()\n self.logfile.close()\n self.process.kill()\n self.process.wait()\n\n self._verify_not_running()","def close_session(self):\n self.driver.close()","def shutdown(self):\n try:\n self.driver.stop()\n except:\n logging.exception(\"Could not stop driver on shutdown\")\n\n self.arduino.stop()","def close_driver(driver):\n driver.close()","def close_driver(driver):\n driver.close()","def stop(self):\n with self.active_lock:\n self.active = False\n if self.thread:\n self.thread.join()\n for conn in self.connections:\n conn.close()\n for srv_sock in self.srv_socks:\n srv_sock.close()\n for client_sock in self.client_socks:\n client_sock.close()\n self.client_socks = []\n self.srv_socks = []\n self.connections = []\n self.scenario = None","def terminate(self) -> None:\n self.robot.terminate_all()","def quit_browser(self):\n if self.browser is not None:\n self.browser.quit()\n self.browser = None","def stop(self):\r\n for srv in self._servers:\r\n srv.stop()","def kill(self, force=Jenkins.is_ci()):\n if self.driver is not None:\n self.driver.quit()\n if force:\n if Settings.HOST_OS == OSType.OSX:\n Process.kill(proc_name='Google Chrome', proc_cmdline=None)\n else:\n Process.kill(proc_name=\"chrome\", proc_cmdline=None)\n Process.kill(proc_name='chromedriver')\n Log.info('Kill Chrome browser!')","def shutdown(self):\n try:\n self._request(\"POST /shutdown\")\n time.sleep(0.300)\n except requests.exceptions.ConnectionError:\n pass\n if self._process and self._process.poll() is None:\n self._process.kill()\n if self._session:\n self._session.close()","def stop_framework (driver):\n status = 0 if driver.run() == mesos_pb2.DRIVER_STOPPED else 1\n driver.stop();\n sys.exit(status)","def close_driver(self):\n package_dict = self.config['PACKAGE']\n try:\n self.driver.terminate_app(package_dict[self.app_name]) # Kill app\n self.driver.quit() # Kill drivers\n except WebDriverException:\n pass\n finally:\n LOGGER.info(\"Closed {apl} on {mob}!\".format(\n apl=self.app_name, mob=self.mobile_name))","def close(self):\n self._driver.close()","def tearDown(self):\n\n self._checkJSErrors()\n swt.active_driver = None\n self.driver.quit()","def stop(self):\n if self.started:\n try:\n self.server.shutdown()\n self.server.server_close()\n self.server_thread.join()\n self.server_thread = None\n except AttributeError:\n pass\n self.started = False\n self.server = None","def killTests(self):\n self.ledController.blink()\n if self.session is not None:\n print(\"ProggerStateManager: Terminating tests...\")\n self.session.terminate()\n try:\n print(\"ProggerStateManager: Waiting for tests to terminate...\")\n self.session.wait(3)\n print(\"ProggerStateManager: Tests have been Terminated.\")\n except:\n print(\"ProggerStateManager: Forced to kill the tests....\", sys.exc_info()[0])\n traceback.print_exc()\n if self.session is not None:\n self.session.kill()\n time.sleep(3)\n self.session = None","async def quit(self):\n await self.kill_server()\n await self.logout()","def stop_server(manager):\n if not manager.is_daemon:\n return\n web_server = WebServer()\n if web_server.is_alive():\n web_server.stop()","def stop_server(manager):\n if not manager.is_daemon:\n return\n web_server = WebServer()\n if web_server.is_alive():\n web_server.stop()","def close(self):\r\n t1 = time.time()\r\n self.driver.close()\r\n self.my_print(\"{0} Closed current window, Spend {1} seconds\".format(success, time.time() - t1))","def close(self):\n self._server.shutdown()\n self._server = None","def tearDownClass(cls):\n cls.driver.close()\n cls.driver.quit()","def tearDownClass(cls):\n cls.driver.close()\n cls.driver.quit()","def stop(self):\n if self._server_thread is None:\n return\n self._stopping.set()\n self._server_thread = None\n self._stopped.wait()","def stop(self):\n\n self.conn.close()\n self.engine.dispose()\n\n self.server.stop()","def teardown_browser(total):\r\n if world.LETTUCE_SELENIUM_CLIENT == 'saucelabs':\r\n set_saucelabs_job_status(world.jobid, total.scenarios_ran == total.scenarios_passed)\r\n world.browser.quit()","def tearDown(self):\n self.log.debug(\"Started TearDown\")\n self.driver.quit()\n self.log.debug(\"Completed TearDown\")","def stop():\n current_event_loop().stop()","def stop(self):\n self.api.stop()","def stop(self):\n self.shutdown_ = True\n if self.running():\n os.kill(self.server_pid_, signal.SIGTERM)","def stop(self):\n shutdown_url = self._env[\"DATASTORE_HOST\"] + \"/shutdown\"\n req = urllib.request.Request(shutdown_url, method=\"POST\")\n urllib.request.urlopen(req)","def stop_server(self):\r\n # TODO-SDH Add way to stop the server from running.\r","def Quit(self):\n t = threading.Thread(target=self.server.shutdown)\n t.start()","def tearDown(self):\n self.driver.quit()","def tearDown(self):\n self.driver.quit()","def tearDown(self):\n self.driver.quit()","def stop(self) -> None:\n # Call the server shutdown functions and wait for them to finish. These\n # must be called on the server thread's event loop.\n future = asyncio.run_coroutine_threadsafe(self._stop(), self._server_loop)\n future.result(5)\n\n # Stop the server thread's event loop\n self._server_loop.call_soon_threadsafe(self._server_loop.stop)","def stop(self):\n for c in self.openstack_endpoints.values():\n c.stop()\n #for c in self.openstack_endpoints.values():\n # if c.server_thread:\n # print(\"Waiting for WSGIServers to be stopped ...\")\n # c.server_thread.join()","def after_all(context):\n context.driver.quit()","def tearDown(self):\r\n self.driver.close()","def stop(self):\n self.__logger.info(\"Stopping server.\")\n self.__stop_event.set()\n\n if self.__server_thread:\n self.__server_thread.join()\n\n self.__close_connection_with_clients()\n self.__server_socket.close()","def atexit(self):\n self.stop_listen()\n for driver in self.drivers.values():\n driver.stop()\n if hasattr(driver, \"atexit\"):\n driver.atexit()\n try:\n self.processor_thread.join()\n except AttributeError:\n pass","def shutdown():\n return subprocess.run([\"powershell.exe\", \"-Command\", \"Stop-Computer\", \"-ComputerName\", \"localhost\"], shell=True, universal_newlines=True, check=False).returncode","def stop(self):\n for process in self.process:\n process.stop()","def stop(self):\n\n net_tuple = self.read_nodestate(0)\n\n # 1. Kill localhost client\n try:\n localhost_socket = self.lookup_socket(\"127.0.0.1\")\n localhost_connection = (localhost_socket, \"127.0.0.1\")\n self.send(localhost_connection, \"stop\")\n\n except ConnectionRefusedError:\n pass # Localhost is already disconnected\n\n log_msg = \"Attempting to gracefully disconnect and disassociate from all clients...\"\n Primitives.log(log_msg, in_log_level=\"Info\")\n\n # 2. Disconnect from all clients\n for connection in net_tuple:\n log_msg = str(\"Trying to disconnect from socket: \" + str(connection[0]))\n Primitives.log(log_msg, in_log_level=\"Debug\")\n\n try:\n self.disconnect(connection, disallow_local_disconnect=True)\n\n except OSError:\n another_log_msg = str(\"Failed to disconnect from socket: \"+str(connection[0]))\n Primitives.log(another_log_msg, in_log_level=\"Warning\")\n\n finally:\n Primitives.log(\"Successfully disconnected\", in_log_level=\"Debug\")\n\n # Forcefully close localhost socket\n localhost_sock_name = localhost.getsockname()\n localhost.close()\n\n Primitives.log(\"Exiting gracefully;\", in_log_level=\"Info\")\n\n # 3. Kill the network injector and terminate the Server.\n\n self.write_nodestate(nodeState, 2, True) # set terminated=True\n self.write_nodestate(nodeState, 4, True) # set injector_terminated = True\n\n # Hack the socket.listen() loop in the init() function by connecting to it(localhost),\n # which will force it to terminate.\n\n temp = socket.socket()\n temp.connect(localhost_sock_name) # This will kill the localhost socket\n temp.close()\n\n # noinspection PyProtectedMember\n os._exit(0)","def stop(self):\n if self._main_loop:\n self._main_loop.quit()","def stop(self):\n self.scion_sh('stop')","def close(self):\n\n self.driver.close_window(self.handle)","def loop_stop( self ):\n self.client.loop_stop()","def stop(self):\n try:\n print 'stopping AndroidDriver'\n subprocess.Popen(r'%s shell input keyevent 4'%self.adbCmd,\n stdout=PIPE, stderr=PIPE,shell=True)\n except:\n print \"\"\"AndroidDriver was not closed. Close by yourself by tapping\n back key to exit AndroidDriver on device.\"\"\"","def stop_server(self):\n if not self.server:\n raise Exception(\"Error owamp: the server must be opened to be closed\\n\")\n self.server.close_owampd()","def tear_down_all(self):\n self.dut.send_expect(\"quit\", \"# \")\n time.sleep(2)\n self.dut.kill_all()","async def stop(self):\n # don't process scheduler anymore\n self._scheduler.suspend = True\n\n # process async stop tasks\n await asyncio.wait([\n self._api.stop(),\n self._dns.stop(),\n self._websession.close(),\n self._websession_ssl.close()\n ], loop=self._loop)","def _shut_down_wsgi_server():\n print 'Stopping %s %s' % (server_class.__module__, server_name)\n\n if wsgi_server:\n wsgi_server.stop()","def shutdown(self):\n cv2.destroyAllWindows()\n rospy.loginfo(\"Stop\")\n # wait for robot to stop before shutdown\n rospy.sleep(5)","def end(self):\n for bot in self.bots:\n bot.stop()\n for sock in self.socks:\n sock.stop()\n self.replyer.stop()\n self.stop()","def stop(self, *args):\n # logging.debug(\"Stopping....\")\n self.has_been_stopped.set()\n self.server.stop(grace=1)","def close(self):\n self.loop.call_soon_threadsafe(self.stop_flag.set_result, True)\n self.server_thread.join()"],"string":"[\n \"def stop_browser(self):\\n self.driver.quit()\",\n \"def shut_down_selenium_server(host='localhost', port=4444):\\n try:\\n selenium(host, port, '', '').shut_down_selenium_server()\\n except socket.error:\\n pass\",\n \"def __exit__(self, exc_type, exc_val, exc_tb):\\n self.server.stop()\\n self.driver.quit()\",\n \"def close_browser():\\n driver.close()\",\n \"def i_close_the_browser():\\n driver.close()\\n driver.quit()\",\n \"def stop_server_and_driver(server, driver):\\n \\n driver.close()\\n server.stop()\",\n \"def close_and_finish_execution():\\n driver.close()\\n driver.quit()\\n exit(0)\",\n \"def close(self):\\n self.m_driver.close()\\n self.m_driver = None\\n\\n if self.m_display is not None:\\n self.m_display.stop()\\n self.m_display = None\\n\\n if self.m_vpn_handle is not None:\\n self.m_vpn_handle.close()\\n self.m_vpn_handle = None\\n\\n l_result = run(['sudo', 'killall', '-9', 'chromedriver'], stdout=PIPE, stderr=PIPE)\\n self.m_logger.info('Killing chromedriver : ' + repr(l_result))\\n l_result = run(['sudo', 'killall', '-9', 'chromium-browser'], stdout=PIPE, stderr=PIPE)\\n self.m_logger.info('Killing Chromium : ' + repr(l_result))\",\n \"def closeBrowser(driver):\\n driver.quit()\",\n \"def close(self):\\n\\n #Kill all zombie PIDs and exit gracefully\\n try:\\n self.webdriver.quit()\\n except:\\n pass\\n if 'p' not in sys.argv:\\n self.kill()\\n sys.exit()\",\n \"def stopBrowser(self):\\n self.browser.quit()\",\n \"def close(self):\\n self.driver.quit()\",\n \"def end_session(self):\\r\\n self.web_driver.quit()\\r\\n self.write_log(\\\"Web driver ended.\\\")\",\n \"def stop():\\n server = current_server()\\n server.stop()\",\n \"def stop(self):\\n if self.driver:\\n self.driver.stop()\\n vim_session.ConnectionHandler.stop()\",\n \"def close(self):\\n\\n self._driver.quit()\",\n \"def quit(self):\\n if self.webdriver is not None:\\n self.webdriver.quit()\\n self.webdriver = None\",\n \"def teardown(self):\\n self.log.info('Close browser')\\n self.driver.quit()\",\n \"def shutdown(self):\\n self._shutdown_browser()\",\n \"def quit(self):\\n self.driver.close_app()\\n self.driver.quit()\",\n \"def stop(self):\\n\\n self._stop_server = True\\n\\n self.join()\\n self.httpd.server_close()\",\n \"def quit(self):\\n self.driver.quit()\",\n \"def __exit__(self, *args):\\n self.driver.quit()\",\n \"def disconnect(self) -> None:\\n self.driver.quit()\",\n \"def stop() -> None:\\n global _server\\n if _server:\\n try:\\n _server.shutdown()\\n except Exception:\\n pass\",\n \"def quit(self):\\n driver.quit()\",\n \"def webserver_stop():\\n run(\\\"kill $(cat %s)\\\" % GUNICORN_PIDFILE)\\n run(\\\"rm %s\\\" % GUNICORN_PIDFILE)\",\n \"def quit(self):\\r\\n t1 = time.time()\\r\\n self.driver.quit()\\r\\n self.my_print(\\\"{0} Closed all window and quit the driver, Spend {1} seconds\\\".format(success, time.time() - t1))\",\n \"def _shutdown_browser(self):\\n if self.browser:\\n self.browser.close()\",\n \"def tear_down(self):\\n if self.driver_name != \\\"Firefox\\\":\\n for window_handle in self.driver.window_handles:\\n self.driver.switch_to.window(window_handle)\\n self.driver.quit()\\n self.clear_tmp_dir()\\n for driver in self.all_drivers:\\n try:\\n driver.quit()\\n except WebDriverException:\\n pass\",\n \"def tear_down(self):\\n self.driver.close()\\n self.driver.quit()\",\n \"def stop(self):\\n self.logger.info('Shutting down SimpleHTTPServer')\\n stop_cmd = \\\"pkill -9 -f '{0}'\\\".format(self.server_cmd)\\n self._execute_command(stop_cmd)\",\n \"async def gracefully_shutdown_browser(self, browser: Browser) -> None:\",\n \"def close(self):\\n self.driver.close()\",\n \"def closeChrome(self):\\r\\n\\t\\tself.driver.close()\\r\\n\\t\\treturn\",\n \"async def _internalStop(self):\\n self.wserver.close()\\n await self.wserver.wait_closed()\\n self.server.stop()\\n while (self.server.is_running()):\\n time.sleep(0.5)\\n self.server.close()\\n self.server = None\",\n \"def teardown(self):\\r\\n self.driver.quit()\",\n \"def kill(self):\\n\\n #Kill relevant process names\\n if self.driver_type != 'firefox_wdm':\\n os.system('pkill -f chrome')\\n os.system('pkill -f Chrome')\\n os.system('pkill -f chromedriver')\\n else:\\n os.system('pkill -f FireFox')\\n #TODO: confirm this -> os.system('pkill -f geckodriver')\",\n \"def stop():\\n global server_handle\\n server_handle.kill()\\n server_handle = None\",\n \"def quit(self):\\n \\n if 'driver' in self.__dict__:\\n self.driver.quit()\\n if 'session' in self.__dict__:\\n self.session.close()\\n if 'conn' in self.__dict__:\\n self.conn.close()\",\n \"def stop(self, loop):\\n if self.server is not None:\\n self.server.close()\\n loop.run_until_complete(self.server.wait_closed())\\n self.server = None\",\n \"def stop(self):\\n\\n log_info(\\\"Stopping LiteServ ...\\\")\\n\\n self.logfile.flush()\\n self.logfile.close()\\n self.process.kill()\\n self.process.wait()\\n\\n self._verify_not_running()\",\n \"def close_session(self):\\n self.driver.close()\",\n \"def shutdown(self):\\n try:\\n self.driver.stop()\\n except:\\n logging.exception(\\\"Could not stop driver on shutdown\\\")\\n\\n self.arduino.stop()\",\n \"def close_driver(driver):\\n driver.close()\",\n \"def close_driver(driver):\\n driver.close()\",\n \"def stop(self):\\n with self.active_lock:\\n self.active = False\\n if self.thread:\\n self.thread.join()\\n for conn in self.connections:\\n conn.close()\\n for srv_sock in self.srv_socks:\\n srv_sock.close()\\n for client_sock in self.client_socks:\\n client_sock.close()\\n self.client_socks = []\\n self.srv_socks = []\\n self.connections = []\\n self.scenario = None\",\n \"def terminate(self) -> None:\\n self.robot.terminate_all()\",\n \"def quit_browser(self):\\n if self.browser is not None:\\n self.browser.quit()\\n self.browser = None\",\n \"def stop(self):\\r\\n for srv in self._servers:\\r\\n srv.stop()\",\n \"def kill(self, force=Jenkins.is_ci()):\\n if self.driver is not None:\\n self.driver.quit()\\n if force:\\n if Settings.HOST_OS == OSType.OSX:\\n Process.kill(proc_name='Google Chrome', proc_cmdline=None)\\n else:\\n Process.kill(proc_name=\\\"chrome\\\", proc_cmdline=None)\\n Process.kill(proc_name='chromedriver')\\n Log.info('Kill Chrome browser!')\",\n \"def shutdown(self):\\n try:\\n self._request(\\\"POST /shutdown\\\")\\n time.sleep(0.300)\\n except requests.exceptions.ConnectionError:\\n pass\\n if self._process and self._process.poll() is None:\\n self._process.kill()\\n if self._session:\\n self._session.close()\",\n \"def stop_framework (driver):\\n status = 0 if driver.run() == mesos_pb2.DRIVER_STOPPED else 1\\n driver.stop();\\n sys.exit(status)\",\n \"def close_driver(self):\\n package_dict = self.config['PACKAGE']\\n try:\\n self.driver.terminate_app(package_dict[self.app_name]) # Kill app\\n self.driver.quit() # Kill drivers\\n except WebDriverException:\\n pass\\n finally:\\n LOGGER.info(\\\"Closed {apl} on {mob}!\\\".format(\\n apl=self.app_name, mob=self.mobile_name))\",\n \"def close(self):\\n self._driver.close()\",\n \"def tearDown(self):\\n\\n self._checkJSErrors()\\n swt.active_driver = None\\n self.driver.quit()\",\n \"def stop(self):\\n if self.started:\\n try:\\n self.server.shutdown()\\n self.server.server_close()\\n self.server_thread.join()\\n self.server_thread = None\\n except AttributeError:\\n pass\\n self.started = False\\n self.server = None\",\n \"def killTests(self):\\n self.ledController.blink()\\n if self.session is not None:\\n print(\\\"ProggerStateManager: Terminating tests...\\\")\\n self.session.terminate()\\n try:\\n print(\\\"ProggerStateManager: Waiting for tests to terminate...\\\")\\n self.session.wait(3)\\n print(\\\"ProggerStateManager: Tests have been Terminated.\\\")\\n except:\\n print(\\\"ProggerStateManager: Forced to kill the tests....\\\", sys.exc_info()[0])\\n traceback.print_exc()\\n if self.session is not None:\\n self.session.kill()\\n time.sleep(3)\\n self.session = None\",\n \"async def quit(self):\\n await self.kill_server()\\n await self.logout()\",\n \"def stop_server(manager):\\n if not manager.is_daemon:\\n return\\n web_server = WebServer()\\n if web_server.is_alive():\\n web_server.stop()\",\n \"def stop_server(manager):\\n if not manager.is_daemon:\\n return\\n web_server = WebServer()\\n if web_server.is_alive():\\n web_server.stop()\",\n \"def close(self):\\r\\n t1 = time.time()\\r\\n self.driver.close()\\r\\n self.my_print(\\\"{0} Closed current window, Spend {1} seconds\\\".format(success, time.time() - t1))\",\n \"def close(self):\\n self._server.shutdown()\\n self._server = None\",\n \"def tearDownClass(cls):\\n cls.driver.close()\\n cls.driver.quit()\",\n \"def tearDownClass(cls):\\n cls.driver.close()\\n cls.driver.quit()\",\n \"def stop(self):\\n if self._server_thread is None:\\n return\\n self._stopping.set()\\n self._server_thread = None\\n self._stopped.wait()\",\n \"def stop(self):\\n\\n self.conn.close()\\n self.engine.dispose()\\n\\n self.server.stop()\",\n \"def teardown_browser(total):\\r\\n if world.LETTUCE_SELENIUM_CLIENT == 'saucelabs':\\r\\n set_saucelabs_job_status(world.jobid, total.scenarios_ran == total.scenarios_passed)\\r\\n world.browser.quit()\",\n \"def tearDown(self):\\n self.log.debug(\\\"Started TearDown\\\")\\n self.driver.quit()\\n self.log.debug(\\\"Completed TearDown\\\")\",\n \"def stop():\\n current_event_loop().stop()\",\n \"def stop(self):\\n self.api.stop()\",\n \"def stop(self):\\n self.shutdown_ = True\\n if self.running():\\n os.kill(self.server_pid_, signal.SIGTERM)\",\n \"def stop(self):\\n shutdown_url = self._env[\\\"DATASTORE_HOST\\\"] + \\\"/shutdown\\\"\\n req = urllib.request.Request(shutdown_url, method=\\\"POST\\\")\\n urllib.request.urlopen(req)\",\n \"def stop_server(self):\\r\\n # TODO-SDH Add way to stop the server from running.\\r\",\n \"def Quit(self):\\n t = threading.Thread(target=self.server.shutdown)\\n t.start()\",\n \"def tearDown(self):\\n self.driver.quit()\",\n \"def tearDown(self):\\n self.driver.quit()\",\n \"def tearDown(self):\\n self.driver.quit()\",\n \"def stop(self) -> None:\\n # Call the server shutdown functions and wait for them to finish. These\\n # must be called on the server thread's event loop.\\n future = asyncio.run_coroutine_threadsafe(self._stop(), self._server_loop)\\n future.result(5)\\n\\n # Stop the server thread's event loop\\n self._server_loop.call_soon_threadsafe(self._server_loop.stop)\",\n \"def stop(self):\\n for c in self.openstack_endpoints.values():\\n c.stop()\\n #for c in self.openstack_endpoints.values():\\n # if c.server_thread:\\n # print(\\\"Waiting for WSGIServers to be stopped ...\\\")\\n # c.server_thread.join()\",\n \"def after_all(context):\\n context.driver.quit()\",\n \"def tearDown(self):\\r\\n self.driver.close()\",\n \"def stop(self):\\n self.__logger.info(\\\"Stopping server.\\\")\\n self.__stop_event.set()\\n\\n if self.__server_thread:\\n self.__server_thread.join()\\n\\n self.__close_connection_with_clients()\\n self.__server_socket.close()\",\n \"def atexit(self):\\n self.stop_listen()\\n for driver in self.drivers.values():\\n driver.stop()\\n if hasattr(driver, \\\"atexit\\\"):\\n driver.atexit()\\n try:\\n self.processor_thread.join()\\n except AttributeError:\\n pass\",\n \"def shutdown():\\n return subprocess.run([\\\"powershell.exe\\\", \\\"-Command\\\", \\\"Stop-Computer\\\", \\\"-ComputerName\\\", \\\"localhost\\\"], shell=True, universal_newlines=True, check=False).returncode\",\n \"def stop(self):\\n for process in self.process:\\n process.stop()\",\n \"def stop(self):\\n\\n net_tuple = self.read_nodestate(0)\\n\\n # 1. Kill localhost client\\n try:\\n localhost_socket = self.lookup_socket(\\\"127.0.0.1\\\")\\n localhost_connection = (localhost_socket, \\\"127.0.0.1\\\")\\n self.send(localhost_connection, \\\"stop\\\")\\n\\n except ConnectionRefusedError:\\n pass # Localhost is already disconnected\\n\\n log_msg = \\\"Attempting to gracefully disconnect and disassociate from all clients...\\\"\\n Primitives.log(log_msg, in_log_level=\\\"Info\\\")\\n\\n # 2. Disconnect from all clients\\n for connection in net_tuple:\\n log_msg = str(\\\"Trying to disconnect from socket: \\\" + str(connection[0]))\\n Primitives.log(log_msg, in_log_level=\\\"Debug\\\")\\n\\n try:\\n self.disconnect(connection, disallow_local_disconnect=True)\\n\\n except OSError:\\n another_log_msg = str(\\\"Failed to disconnect from socket: \\\"+str(connection[0]))\\n Primitives.log(another_log_msg, in_log_level=\\\"Warning\\\")\\n\\n finally:\\n Primitives.log(\\\"Successfully disconnected\\\", in_log_level=\\\"Debug\\\")\\n\\n # Forcefully close localhost socket\\n localhost_sock_name = localhost.getsockname()\\n localhost.close()\\n\\n Primitives.log(\\\"Exiting gracefully;\\\", in_log_level=\\\"Info\\\")\\n\\n # 3. Kill the network injector and terminate the Server.\\n\\n self.write_nodestate(nodeState, 2, True) # set terminated=True\\n self.write_nodestate(nodeState, 4, True) # set injector_terminated = True\\n\\n # Hack the socket.listen() loop in the init() function by connecting to it(localhost),\\n # which will force it to terminate.\\n\\n temp = socket.socket()\\n temp.connect(localhost_sock_name) # This will kill the localhost socket\\n temp.close()\\n\\n # noinspection PyProtectedMember\\n os._exit(0)\",\n \"def stop(self):\\n if self._main_loop:\\n self._main_loop.quit()\",\n \"def stop(self):\\n self.scion_sh('stop')\",\n \"def close(self):\\n\\n self.driver.close_window(self.handle)\",\n \"def loop_stop( self ):\\n self.client.loop_stop()\",\n \"def stop(self):\\n try:\\n print 'stopping AndroidDriver'\\n subprocess.Popen(r'%s shell input keyevent 4'%self.adbCmd,\\n stdout=PIPE, stderr=PIPE,shell=True)\\n except:\\n print \\\"\\\"\\\"AndroidDriver was not closed. Close by yourself by tapping\\n back key to exit AndroidDriver on device.\\\"\\\"\\\"\",\n \"def stop_server(self):\\n if not self.server:\\n raise Exception(\\\"Error owamp: the server must be opened to be closed\\\\n\\\")\\n self.server.close_owampd()\",\n \"def tear_down_all(self):\\n self.dut.send_expect(\\\"quit\\\", \\\"# \\\")\\n time.sleep(2)\\n self.dut.kill_all()\",\n \"async def stop(self):\\n # don't process scheduler anymore\\n self._scheduler.suspend = True\\n\\n # process async stop tasks\\n await asyncio.wait([\\n self._api.stop(),\\n self._dns.stop(),\\n self._websession.close(),\\n self._websession_ssl.close()\\n ], loop=self._loop)\",\n \"def _shut_down_wsgi_server():\\n print 'Stopping %s %s' % (server_class.__module__, server_name)\\n\\n if wsgi_server:\\n wsgi_server.stop()\",\n \"def shutdown(self):\\n cv2.destroyAllWindows()\\n rospy.loginfo(\\\"Stop\\\")\\n # wait for robot to stop before shutdown\\n rospy.sleep(5)\",\n \"def end(self):\\n for bot in self.bots:\\n bot.stop()\\n for sock in self.socks:\\n sock.stop()\\n self.replyer.stop()\\n self.stop()\",\n \"def stop(self, *args):\\n # logging.debug(\\\"Stopping....\\\")\\n self.has_been_stopped.set()\\n self.server.stop(grace=1)\",\n \"def close(self):\\n self.loop.call_soon_threadsafe(self.stop_flag.set_result, True)\\n self.server_thread.join()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7995364","0.7863133","0.7835495","0.74924666","0.7464111","0.7453941","0.7446109","0.7424754","0.7343588","0.73252535","0.7277652","0.72618127","0.7260277","0.7200706","0.71930265","0.71509975","0.7085253","0.70522535","0.7039435","0.7002137","0.699096","0.69813776","0.6954001","0.6946459","0.6933989","0.69214016","0.68726814","0.68595403","0.6815641","0.68151844","0.6807883","0.6799424","0.67792404","0.6772987","0.6768006","0.6723199","0.6686981","0.66807246","0.66681564","0.66651964","0.6647747","0.66294014","0.6612106","0.6597691","0.659509","0.659509","0.6575799","0.6568681","0.65362483","0.65278083","0.6520514","0.6515631","0.64929026","0.648359","0.6483456","0.64689326","0.64597154","0.64526165","0.64483684","0.6444336","0.6444336","0.64366585","0.6430555","0.6430336","0.6430336","0.64286125","0.63940096","0.63850325","0.63825","0.6377101","0.6370261","0.6366376","0.63612723","0.6358828","0.634287","0.63241583","0.63241583","0.63241583","0.63217974","0.6309031","0.6300495","0.6299205","0.6297912","0.62975466","0.62939996","0.62902445","0.62841994","0.62746006","0.626939","0.6255079","0.624328","0.6241338","0.62393737","0.6236749","0.6232284","0.6224539","0.6217803","0.62131315","0.6210287","0.62066734"],"string":"[\n \"0.7995364\",\n \"0.7863133\",\n \"0.7835495\",\n \"0.74924666\",\n \"0.7464111\",\n \"0.7453941\",\n \"0.7446109\",\n \"0.7424754\",\n \"0.7343588\",\n \"0.73252535\",\n \"0.7277652\",\n \"0.72618127\",\n \"0.7260277\",\n \"0.7200706\",\n \"0.71930265\",\n \"0.71509975\",\n \"0.7085253\",\n \"0.70522535\",\n \"0.7039435\",\n \"0.7002137\",\n \"0.699096\",\n \"0.69813776\",\n \"0.6954001\",\n \"0.6946459\",\n \"0.6933989\",\n \"0.69214016\",\n \"0.68726814\",\n \"0.68595403\",\n \"0.6815641\",\n \"0.68151844\",\n \"0.6807883\",\n \"0.6799424\",\n \"0.67792404\",\n \"0.6772987\",\n \"0.6768006\",\n \"0.6723199\",\n \"0.6686981\",\n \"0.66807246\",\n \"0.66681564\",\n \"0.66651964\",\n \"0.6647747\",\n \"0.66294014\",\n \"0.6612106\",\n \"0.6597691\",\n \"0.659509\",\n \"0.659509\",\n \"0.6575799\",\n \"0.6568681\",\n \"0.65362483\",\n \"0.65278083\",\n \"0.6520514\",\n \"0.6515631\",\n \"0.64929026\",\n \"0.648359\",\n \"0.6483456\",\n \"0.64689326\",\n \"0.64597154\",\n \"0.64526165\",\n \"0.64483684\",\n \"0.6444336\",\n \"0.6444336\",\n \"0.64366585\",\n \"0.6430555\",\n \"0.6430336\",\n \"0.6430336\",\n \"0.64286125\",\n \"0.63940096\",\n \"0.63850325\",\n \"0.63825\",\n \"0.6377101\",\n \"0.6370261\",\n \"0.6366376\",\n \"0.63612723\",\n \"0.6358828\",\n \"0.634287\",\n \"0.63241583\",\n \"0.63241583\",\n \"0.63241583\",\n \"0.63217974\",\n \"0.6309031\",\n \"0.6300495\",\n \"0.6299205\",\n \"0.6297912\",\n \"0.62975466\",\n \"0.62939996\",\n \"0.62902445\",\n \"0.62841994\",\n \"0.62746006\",\n \"0.626939\",\n \"0.6255079\",\n \"0.624328\",\n \"0.6241338\",\n \"0.62393737\",\n \"0.6236749\",\n \"0.6232284\",\n \"0.6224539\",\n \"0.6217803\",\n \"0.62131315\",\n \"0.6210287\",\n \"0.62066734\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83716977"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88382,"cells":{"query":{"kind":"string","value":"Sets the timeout used by various keywords. Keywords that expect a page load to happen will fail if the page is not loaded within the timeout specified with `seconds`. Starting from SeleniumLibrary 2.6, this timeout is also the default timeout with various `Wait ...` keywords. See `introduction` for more information about timeouts and handling page loads. The previous timeout value is returned by this keyword and can be used to set the old value back later. The default timeout is 5 seconds, but it can be altered in `importing`."},"document":{"kind":"string","value":"def set_selenium_timeout(self, seconds):\n timeout = utils.timestr_to_secs(seconds)\n old = getattr(self, '_timeout', timeout)\n self._timeout = timeout\n self._selenium.set_timeout(timeout * 1000)\n return utils.secs_to_timestr(old)"},"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 set_timeout(self, seconds):\n self._timeout = seconds","def timeout_seconds(self, timeout_seconds):\n\n self._timeout_seconds = timeout_seconds","def timeout_seconds(self, timeout_seconds):\n\n self._timeout_seconds = timeout_seconds","def set_timeout(self, timeout_secs):\n self._timeout_secs = timeout_secs","def setTimeOut(self, timeout=6.0):\n self.timeout = timeout","def set_wait_timeout(self, timeout):\n self.__wait_timeout = timeout","def set_timeout(self, timeout):\n pass","def set_timeout(self, timeout: float) -> None:\n self._timeout = timeout","def set_timeouts(self, timeouts):\n self._timeouts = timeouts","def set_timeout(self, connect_timeout, read_timeout, search_timeout = None):\n self.timeout = urllib3.util.timeout.Timeout(connect = connect_timeout, read = read_timeout)\n if (search_timeout != None):\n self.search_timeout = urllib3.util.timeout.Timeout(connect = connect_timeout, read = search_timeout)","def timeout(self, seconds: Optional[float]):\n if (seconds is not None) and (seconds < 0):\n raise ValueError(\"negative\")\n\n self._timeout = seconds","def set_timeout(self, timeout):\n self.timeout = timeout","def timeouts(self, timeouts: dict) -> NoReturn:\n if all(x in timeouts.keys() for x in [\"implicit\", \"pageLoad\", \"script\"]):\n self.set_capability(\"timeouts\", timeouts)\n else:\n raise ValueError(\"Timeout keys can only be one of the following: implicit, pageLoad, script\")","def set_timeout(self, new_timeout):\n self.timeout = new_timeout\n self._update_timestamp()","def timeout(self, seconds=None):\n if self.__timeout_coro:\n self.__timeout_coro.cancel()\n if seconds is None:\n return\n e = self.get_node().get_loop()\n self.__timeout_coro = e.call_later(seconds, self._timeout)","def set_selenium_driver_timeouts(driver: WebDriver) -> None:\n driver.set_script_timeout(90)\n driver.set_page_load_timeout(60)","def set_timeout(timeout):\n\n if timeout is None:\n raise TypeError(\"timeout is null!\")\n\n AceQLHttpApi.set_timeout(timeout)","def set_timeout(self, milliseconds):\r\n self.inst.timeout = milliseconds\r\n self.logger.info(\"Timeout set to %f milliseconds.\" % milliseconds)","def setTimeout(self, timeout):\n self.timeout = timeout","def set_timeout(self, timeout: int) -> None:\n raise WatchdogError(\"Setting timeout is not supported on {0}\".format(self.describe()))","def wait(self, seconds):\n self.driver.implicitly_wait(seconds)","def settimeout(self,timeout=10):\r\n # Update\r\n self.timeout = timeout","def timeout(self, timeout):\n assert timeout is None or timeout > 0\n self._timeout = timeout","def set_timeout():\n try:\n seconds = int(request.get_json()['timeout_seconds'])\n except (KeyError, TypeError):\n return abort(400)\n anova_controller.set_timeout(seconds)\n output = {\"timeout_seconds\": seconds, }\n return jsonify(output)","def setdefaulttimeout(timeout):\r\n global default_timeout\r\n default_timeout = timeout","def timeout(ctx, seconds):\n config_db = ConfigDBConnector()\n config_db.connect()\n\n config_db.mod_entry(\"NAT_GLOBAL\", \"Values\", {\"nat_timeout\": seconds})","def set_timeout(self, wait):\n self._screen.timeout(wait)","def setdefaulttimeout(timeout):\r\n global _TIMEOUT\r\n _TIMEOUT = timeout","def set_timeout(self, millis):\n self.timeout = self.current_milli_time() + millis","def timeout(self, timeout):\n\n self._timeout = timeout","def timeout(self, timeout):\n if (self.local_vars_configuration.client_side_validation and\n timeout is not None and not isinstance(timeout, int)):\n raise ValueError(\"Parameter `timeout` must be an integer\") # noqa: E501\n\n self._timeout = timeout","def timeout(self, value):\n if isinstance(value, timedelta):\n value = value.days * 3600 * 24 + value.seconds\n self._timeout = value # noqa","def set_retry_timeout(self, retry_timeout):","def timeout_seconds(self) -> Optional[int]:\n return pulumi.get(self, \"timeout_seconds\")","def timeout_seconds(self) -> Optional[int]:\n return pulumi.get(self, \"timeout_seconds\")","def timeout_seconds(self) -> Optional[int]:\n return pulumi.get(self, \"timeout_seconds\")","def timeout_seconds(self) -> Optional[int]:\n return pulumi.get(self, \"timeout_seconds\")","def timeout_seconds(self) -> Optional[int]:\n return pulumi.get(self, \"timeout_seconds\")","def timeout_seconds(self) -> Optional[int]:\n return pulumi.get(self, \"timeout_seconds\")","def set_timeout(self, timeout):\n if self.interface is not None:\n self.interface.timeout = timeout","def set_timeout(seconds, on_timeout):\n\n def _sighandler(signum, frame):\n on_timeout()\n\n signal.signal(signal.SIGALRM, _sighandler)\n signal.alarm(seconds)","def settimeout(self, value: int) -> None:\n ...","def winhttp_WinHttpSetTimeouts(jitter):\n ret_ad, args = jitter.func_args_stdcall([\"hInternet\", \"dwResolveTimeout\", \"dwConnectTimeout\", \"dwSendTimeout\", \"dwReceiveTimeout\"])\n raise RuntimeError('API not implemented')\n jitter.func_ret_stdcall(ret_ad, ret_value)","def setTimeOut(self, sec):\n if (sec is not None) and (sec > 0):\n to = sec\n else:\n to = None\n self._simulator_.update(timeout=to)\n\n return","def set_timeout(self, timeout):\r\n return self._arm.set_timeout(timeout)","def timeout_seconds(self) -> Optional[pulumi.Input[int]]:\n return pulumi.get(self, \"timeout_seconds\")","def timeout_seconds(self):\n return self._timeout_seconds","def reset_slide_timeout(self, widget, seconds=None):\n if seconds is None:\n try:\n seconds = self.timeouts[widget][1]\n except KeyError:\n pass\n else:\n self.remove_slide_timeout(widget)\n self.add_slide_timeout(widget, seconds)","def settimeout(self, to):\r\n self._timeout = to","def set_timeout_millis(self, value):\n self.dp.set_timeout_millis(value)","def tcp_timeout(ctx, seconds):\n config_db = ConfigDBConnector()\n config_db.connect()\n\n config_db.mod_entry(\"NAT_GLOBAL\", \"Values\", {\"nat_tcp_timeout\": seconds})","def setDefaultTimeout(controlName, defaultTimeout):\n _setDefaultTimeout(controlName, defaultTimeout)","def set_global_timeout(self, timeout: float) -> float:\n previous_timeout = self.ctx.global_timeout\n self.ctx.global_timeout = timeout\n auto.SetGlobalSearchTimeout(self.ctx.global_timeout)\n return previous_timeout","def set_ssh_timeout(self, timeout = \"30sec\"):\n return self._current.set_timeout(timeout)","def add_slide_timeout(self, widget, seconds):\n if widget in self.timeouts:\n raise RuntimeError(\"A timeout for '%s' was already added\" % widget)\n\n callback = lambda: self.slide_to(widget)\n self.timeouts[widget] = (gobject.timeout_add_seconds(seconds, callback),\n seconds)","def wait(self, seconds):\n time.sleep(seconds)","def completion_timeout_in_minutes(self, completion_timeout_in_minutes):\n\n self._completion_timeout_in_minutes = completion_timeout_in_minutes","def __timeout(self, seconds, func, *args):\n t = threading.Timer(seconds, func, *args)\n self._timer = t\n t.start()","def reset_timeout (self, new_timeout):\n self.timer.cancel()\n self.timer = Timeout(new_timeout, TestIsTakingTooLong(new_timeout))","def set_timeout(self, timeout, relative = True):\n assert timeout != TIMEOUT_CURRENT\n if timeout < 0:\n self._timeout_time = TIMEOUT_NEVER\n elif relative:\n self._timeout_time = time.time() + timeout\n else:\n self._timeout_time = timeout","def timer_object_timeout(seconds=5):\n def raise_timeout_exception():\n raise TimeoutReachedException(seconds=seconds)\n\n return Timer(seconds, raise_timeout_exception)","def sessiontimeout(self, sessiontimeout) :\n\t\ttry :\n\t\t\tself._sessiontimeout = sessiontimeout\n\t\texcept Exception as e:\n\t\t\traise e","def _make_time_pass(self, seconds, timeout, time_mock):\n time_mock.return_value = TIMEOUT_EPOCH\n timeout.start_connect()\n time_mock.return_value = TIMEOUT_EPOCH + seconds\n return timeout","def set_callback_timeout(timeout):\n if timeout <= 0 or timeout > INT32_MAX:\n raise ValueError(\"Timeout given is not within the required range.\")\n _config.set_callback_timeout(timeout)","def settimeout(self, timeout):\n assert timeout > 0.0\n self.__timeout = timeout\n self.sock.settimeout(timeout)\n # We don't query the socket's timeout or check that they're still\n # correct. Since self.sock e is public this could be the wrong\n # timeout!","def sleep(self, seconds=60):\n\t\ttime.sleep(seconds)","def setConnectTimeout(self, timeoutMilliSeconds):\n\n _ExceptionUtil.raiseOnError(\n internals.blpapi_SessionOptions_setConnectTimeout(\n self.__handle,\n timeoutMilliSeconds))","def settimeout(self, timeout):\r\n self.sock.settimeout(timeout)","def setDefaultKeepAliveResponseTimeout(self, timeoutMsecs):\n err = internals.blpapi_SessionOptions_setDefaultKeepAliveResponseTimeout(\n self.__handle, timeoutMsecs)\n _ExceptionUtil.raiseOnError(err)","def set_wait_time(self, wait_time):\n\n self.wait_time = wait_time","def set_request_timeout(self, request_timeout: int) -> None:\n self.__http_client.request_timeout = request_timeout","def implicitly_wait(self, secs):\n self.base_driver.implicitly_wait(secs)","def set_import_timeout(self, value):\n\t\tself.spinImportTimeout.set_value(value)","def timeout(self):\n self._status_update(\"Pyloton: Timeout\")\n time.sleep(3)","def set_timeout(self, visibility_timeout):\r\n retval = self.set_attribute('VisibilityTimeout', visibility_timeout)\r\n if retval:\r\n self.visibility_timeout = visibility_timeout\r\n return retval","def pytest_timeout_set_timer(item, settings):","def timeout_change(self, timedelta):\n pass # pylint: disable=unnecessary-pass\n # For backward compatibility only.","def __init__(self, timeout_time):\n self.timeout_time = timeout_time","def set_timeout(timeout):\n def decor(f):\n @functools.wraps(f)\n def inner(self, *args, **kwargs):\n self.useFixture(fixtures.Timeout(timeout, gentle=True))\n return f(self, *args, **kwargs)\n return inner\n return decor","def sleep(self, seconds):\n time.sleep(seconds)","def set_timeout(value):\n environ[\"XRD_REQUESTTIMEOUT\"] = str(value)","def timeout(ctx):\n config_db = ConfigDBConnector()\n config_db.connect()\n seconds = 600\n\n config_db.mod_entry(\"NAT_GLOBAL\", \"Values\", {\"nat_timeout\": seconds})","def wait_for_seconds(self, seconds, sleeptime=0.001):\n self.listen_until_return(timeout=seconds, sleeptime=sleeptime)","def delay(seconds):\n\n # Perform the delay\n time.sleep(seconds)","def __init__(self, seconds):\n super(RobotiqCommandTimeout, self).__init__()\n self.start_time = rospy.get_rostime()\n self.duration = rospy.Duration(seconds)","def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\n def decorator(func):\n def _handle_timeout(signum, frame):\n raise TimeoutError(error_message)\n\n @wraps(func)\n def wrapper(*args, **kwargs):\n try:\n signal.signal(signal.SIGALRM, _handle_timeout)\n signal_disabled = False\n except ValueError:\n # Possibly running in debug mode. Timeouts will be ignored\n signal_disabled = True\n pass\n\n if not signal_disabled:\n signal.alarm(seconds)\n try:\n result = func(*args, **kwargs)\n finally:\n if not signal_disabled:\n signal.alarm(0)\n return result\n\n return wrapper\n return decorator","def ttl_seconds(self, ttl_seconds: \"int\"):\n self._attrs[\"ttlSeconds\"] = ttl_seconds","def timeout(seconds=60, error_message=os.strerror(errno.ETIME)):\n def decorator(func):\n def _handle_timeout(signum, frame):\n raise TimeoutError(\n '{0} ran for more than {1} seconds'.format(\n func.__name__, seconds))\n def wrapper(*args, **kwargs):\n signal.signal(signal.SIGALRM, _handle_timeout)\n signal.alarm(seconds)\n try:\n result = func(*args, **kwargs)\n finally:\n signal.alarm(0)\n return result\n return wraps(func)(wrapper)\n\n return decorator","def __init__(self, timeout=129600):\n self.timeout = timeout","def set_cache_timeout(self, cache_key, timeout):\n self.cache_timeouts[cache_key.lower()] = timeout","def seconds(self, seconds):\n\n self._seconds = seconds","def finrsttimeout(self, finrsttimeout) :\n\t\ttry :\n\t\t\tself._finrsttimeout = finrsttimeout\n\t\texcept Exception as e:\n\t\t\traise e","def test_timeout_classic(self):\n with pytest.warns(W25, match='timed out'):\n with conf.set_temp('timeout', 1e-6):\n result = conesearch.conesearch(\n SCS_CENTER, SCS_RADIUS, cache=False,\n verbose=self.verbose, catalog_db=self.url)\n assert result is None","def make_timeout(delay_seconds):\n if delay_seconds is None:\n return None\n return time.time() + delay_seconds","def timeout(seconds, error_message=\"Time out.\"):\n import signal\n def decorator(func):\n\n def __timiout_handler(signum, frame):\n raise TimeoutError(error_message)\n\n @functools.wraps(func)\n def wrapper(*arg, **kw):\n signal.signal(signal.SIGALRM, __timiout_handler)\n signal.alarm(seconds)\n ret = \"\"\n try:\n ret = func(*arg, **kw)\n except TimeoutError,e:\n print \"TimeoutError: \", e\n print \"{name} ran more than {seconds}s.\".format(name=func.__name__, seconds=seconds)\n except Exception,e:\n print \"Error: \",e\n finally:\n signal.alarm(0)\n return ret\n return wrapper\n return decorator","def timeout_in_minutes(self) -> int:\n return pulumi.get(self, \"timeout_in_minutes\")","def pytest_timeout_set_timer(item, settings):\n tle.lib.set(int(settings.timeout), str(item).encode(\"utf-8\"))\n return True","def __init__(self, timeout=120):\n self.m_timeout = timeout","def update_lock_timeout(self, timeout):\n\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\n raise FatalError(\"Timeout is out of range!\")\n elif not self._in_use:\n raise CoreError(\"This SystemUnderTest is not currently checked-out!\")\n\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)","def org_apache_felix_http_timeout(self, org_apache_felix_http_timeout: ConfigNodePropertyInteger):\n\n self._org_apache_felix_http_timeout = org_apache_felix_http_timeout"],"string":"[\n \"def set_timeout(self, seconds):\\n self._timeout = seconds\",\n \"def timeout_seconds(self, timeout_seconds):\\n\\n self._timeout_seconds = timeout_seconds\",\n \"def timeout_seconds(self, timeout_seconds):\\n\\n self._timeout_seconds = timeout_seconds\",\n \"def set_timeout(self, timeout_secs):\\n self._timeout_secs = timeout_secs\",\n \"def setTimeOut(self, timeout=6.0):\\n self.timeout = timeout\",\n \"def set_wait_timeout(self, timeout):\\n self.__wait_timeout = timeout\",\n \"def set_timeout(self, timeout):\\n pass\",\n \"def set_timeout(self, timeout: float) -> None:\\n self._timeout = timeout\",\n \"def set_timeouts(self, timeouts):\\n self._timeouts = timeouts\",\n \"def set_timeout(self, connect_timeout, read_timeout, search_timeout = None):\\n self.timeout = urllib3.util.timeout.Timeout(connect = connect_timeout, read = read_timeout)\\n if (search_timeout != None):\\n self.search_timeout = urllib3.util.timeout.Timeout(connect = connect_timeout, read = search_timeout)\",\n \"def timeout(self, seconds: Optional[float]):\\n if (seconds is not None) and (seconds < 0):\\n raise ValueError(\\\"negative\\\")\\n\\n self._timeout = seconds\",\n \"def set_timeout(self, timeout):\\n self.timeout = timeout\",\n \"def timeouts(self, timeouts: dict) -> NoReturn:\\n if all(x in timeouts.keys() for x in [\\\"implicit\\\", \\\"pageLoad\\\", \\\"script\\\"]):\\n self.set_capability(\\\"timeouts\\\", timeouts)\\n else:\\n raise ValueError(\\\"Timeout keys can only be one of the following: implicit, pageLoad, script\\\")\",\n \"def set_timeout(self, new_timeout):\\n self.timeout = new_timeout\\n self._update_timestamp()\",\n \"def timeout(self, seconds=None):\\n if self.__timeout_coro:\\n self.__timeout_coro.cancel()\\n if seconds is None:\\n return\\n e = self.get_node().get_loop()\\n self.__timeout_coro = e.call_later(seconds, self._timeout)\",\n \"def set_selenium_driver_timeouts(driver: WebDriver) -> None:\\n driver.set_script_timeout(90)\\n driver.set_page_load_timeout(60)\",\n \"def set_timeout(timeout):\\n\\n if timeout is None:\\n raise TypeError(\\\"timeout is null!\\\")\\n\\n AceQLHttpApi.set_timeout(timeout)\",\n \"def set_timeout(self, milliseconds):\\r\\n self.inst.timeout = milliseconds\\r\\n self.logger.info(\\\"Timeout set to %f milliseconds.\\\" % milliseconds)\",\n \"def setTimeout(self, timeout):\\n self.timeout = timeout\",\n \"def set_timeout(self, timeout: int) -> None:\\n raise WatchdogError(\\\"Setting timeout is not supported on {0}\\\".format(self.describe()))\",\n \"def wait(self, seconds):\\n self.driver.implicitly_wait(seconds)\",\n \"def settimeout(self,timeout=10):\\r\\n # Update\\r\\n self.timeout = timeout\",\n \"def timeout(self, timeout):\\n assert timeout is None or timeout > 0\\n self._timeout = timeout\",\n \"def set_timeout():\\n try:\\n seconds = int(request.get_json()['timeout_seconds'])\\n except (KeyError, TypeError):\\n return abort(400)\\n anova_controller.set_timeout(seconds)\\n output = {\\\"timeout_seconds\\\": seconds, }\\n return jsonify(output)\",\n \"def setdefaulttimeout(timeout):\\r\\n global default_timeout\\r\\n default_timeout = timeout\",\n \"def timeout(ctx, seconds):\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n\\n config_db.mod_entry(\\\"NAT_GLOBAL\\\", \\\"Values\\\", {\\\"nat_timeout\\\": seconds})\",\n \"def set_timeout(self, wait):\\n self._screen.timeout(wait)\",\n \"def setdefaulttimeout(timeout):\\r\\n global _TIMEOUT\\r\\n _TIMEOUT = timeout\",\n \"def set_timeout(self, millis):\\n self.timeout = self.current_milli_time() + millis\",\n \"def timeout(self, timeout):\\n\\n self._timeout = timeout\",\n \"def timeout(self, timeout):\\n if (self.local_vars_configuration.client_side_validation and\\n timeout is not None and not isinstance(timeout, int)):\\n raise ValueError(\\\"Parameter `timeout` must be an integer\\\") # noqa: E501\\n\\n self._timeout = timeout\",\n \"def timeout(self, value):\\n if isinstance(value, timedelta):\\n value = value.days * 3600 * 24 + value.seconds\\n self._timeout = value # noqa\",\n \"def set_retry_timeout(self, retry_timeout):\",\n \"def timeout_seconds(self) -> Optional[int]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def timeout_seconds(self) -> Optional[int]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def timeout_seconds(self) -> Optional[int]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def timeout_seconds(self) -> Optional[int]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def timeout_seconds(self) -> Optional[int]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def timeout_seconds(self) -> Optional[int]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def set_timeout(self, timeout):\\n if self.interface is not None:\\n self.interface.timeout = timeout\",\n \"def set_timeout(seconds, on_timeout):\\n\\n def _sighandler(signum, frame):\\n on_timeout()\\n\\n signal.signal(signal.SIGALRM, _sighandler)\\n signal.alarm(seconds)\",\n \"def settimeout(self, value: int) -> None:\\n ...\",\n \"def winhttp_WinHttpSetTimeouts(jitter):\\n ret_ad, args = jitter.func_args_stdcall([\\\"hInternet\\\", \\\"dwResolveTimeout\\\", \\\"dwConnectTimeout\\\", \\\"dwSendTimeout\\\", \\\"dwReceiveTimeout\\\"])\\n raise RuntimeError('API not implemented')\\n jitter.func_ret_stdcall(ret_ad, ret_value)\",\n \"def setTimeOut(self, sec):\\n if (sec is not None) and (sec > 0):\\n to = sec\\n else:\\n to = None\\n self._simulator_.update(timeout=to)\\n\\n return\",\n \"def set_timeout(self, timeout):\\r\\n return self._arm.set_timeout(timeout)\",\n \"def timeout_seconds(self) -> Optional[pulumi.Input[int]]:\\n return pulumi.get(self, \\\"timeout_seconds\\\")\",\n \"def timeout_seconds(self):\\n return self._timeout_seconds\",\n \"def reset_slide_timeout(self, widget, seconds=None):\\n if seconds is None:\\n try:\\n seconds = self.timeouts[widget][1]\\n except KeyError:\\n pass\\n else:\\n self.remove_slide_timeout(widget)\\n self.add_slide_timeout(widget, seconds)\",\n \"def settimeout(self, to):\\r\\n self._timeout = to\",\n \"def set_timeout_millis(self, value):\\n self.dp.set_timeout_millis(value)\",\n \"def tcp_timeout(ctx, seconds):\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n\\n config_db.mod_entry(\\\"NAT_GLOBAL\\\", \\\"Values\\\", {\\\"nat_tcp_timeout\\\": seconds})\",\n \"def setDefaultTimeout(controlName, defaultTimeout):\\n _setDefaultTimeout(controlName, defaultTimeout)\",\n \"def set_global_timeout(self, timeout: float) -> float:\\n previous_timeout = self.ctx.global_timeout\\n self.ctx.global_timeout = timeout\\n auto.SetGlobalSearchTimeout(self.ctx.global_timeout)\\n return previous_timeout\",\n \"def set_ssh_timeout(self, timeout = \\\"30sec\\\"):\\n return self._current.set_timeout(timeout)\",\n \"def add_slide_timeout(self, widget, seconds):\\n if widget in self.timeouts:\\n raise RuntimeError(\\\"A timeout for '%s' was already added\\\" % widget)\\n\\n callback = lambda: self.slide_to(widget)\\n self.timeouts[widget] = (gobject.timeout_add_seconds(seconds, callback),\\n seconds)\",\n \"def wait(self, seconds):\\n time.sleep(seconds)\",\n \"def completion_timeout_in_minutes(self, completion_timeout_in_minutes):\\n\\n self._completion_timeout_in_minutes = completion_timeout_in_minutes\",\n \"def __timeout(self, seconds, func, *args):\\n t = threading.Timer(seconds, func, *args)\\n self._timer = t\\n t.start()\",\n \"def reset_timeout (self, new_timeout):\\n self.timer.cancel()\\n self.timer = Timeout(new_timeout, TestIsTakingTooLong(new_timeout))\",\n \"def set_timeout(self, timeout, relative = True):\\n assert timeout != TIMEOUT_CURRENT\\n if timeout < 0:\\n self._timeout_time = TIMEOUT_NEVER\\n elif relative:\\n self._timeout_time = time.time() + timeout\\n else:\\n self._timeout_time = timeout\",\n \"def timer_object_timeout(seconds=5):\\n def raise_timeout_exception():\\n raise TimeoutReachedException(seconds=seconds)\\n\\n return Timer(seconds, raise_timeout_exception)\",\n \"def sessiontimeout(self, sessiontimeout) :\\n\\t\\ttry :\\n\\t\\t\\tself._sessiontimeout = sessiontimeout\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def _make_time_pass(self, seconds, timeout, time_mock):\\n time_mock.return_value = TIMEOUT_EPOCH\\n timeout.start_connect()\\n time_mock.return_value = TIMEOUT_EPOCH + seconds\\n return timeout\",\n \"def set_callback_timeout(timeout):\\n if timeout <= 0 or timeout > INT32_MAX:\\n raise ValueError(\\\"Timeout given is not within the required range.\\\")\\n _config.set_callback_timeout(timeout)\",\n \"def settimeout(self, timeout):\\n assert timeout > 0.0\\n self.__timeout = timeout\\n self.sock.settimeout(timeout)\\n # We don't query the socket's timeout or check that they're still\\n # correct. Since self.sock e is public this could be the wrong\\n # timeout!\",\n \"def sleep(self, seconds=60):\\n\\t\\ttime.sleep(seconds)\",\n \"def setConnectTimeout(self, timeoutMilliSeconds):\\n\\n _ExceptionUtil.raiseOnError(\\n internals.blpapi_SessionOptions_setConnectTimeout(\\n self.__handle,\\n timeoutMilliSeconds))\",\n \"def settimeout(self, timeout):\\r\\n self.sock.settimeout(timeout)\",\n \"def setDefaultKeepAliveResponseTimeout(self, timeoutMsecs):\\n err = internals.blpapi_SessionOptions_setDefaultKeepAliveResponseTimeout(\\n self.__handle, timeoutMsecs)\\n _ExceptionUtil.raiseOnError(err)\",\n \"def set_wait_time(self, wait_time):\\n\\n self.wait_time = wait_time\",\n \"def set_request_timeout(self, request_timeout: int) -> None:\\n self.__http_client.request_timeout = request_timeout\",\n \"def implicitly_wait(self, secs):\\n self.base_driver.implicitly_wait(secs)\",\n \"def set_import_timeout(self, value):\\n\\t\\tself.spinImportTimeout.set_value(value)\",\n \"def timeout(self):\\n self._status_update(\\\"Pyloton: Timeout\\\")\\n time.sleep(3)\",\n \"def set_timeout(self, visibility_timeout):\\r\\n retval = self.set_attribute('VisibilityTimeout', visibility_timeout)\\r\\n if retval:\\r\\n self.visibility_timeout = visibility_timeout\\r\\n return retval\",\n \"def pytest_timeout_set_timer(item, settings):\",\n \"def timeout_change(self, timedelta):\\n pass # pylint: disable=unnecessary-pass\\n # For backward compatibility only.\",\n \"def __init__(self, timeout_time):\\n self.timeout_time = timeout_time\",\n \"def set_timeout(timeout):\\n def decor(f):\\n @functools.wraps(f)\\n def inner(self, *args, **kwargs):\\n self.useFixture(fixtures.Timeout(timeout, gentle=True))\\n return f(self, *args, **kwargs)\\n return inner\\n return decor\",\n \"def sleep(self, seconds):\\n time.sleep(seconds)\",\n \"def set_timeout(value):\\n environ[\\\"XRD_REQUESTTIMEOUT\\\"] = str(value)\",\n \"def timeout(ctx):\\n config_db = ConfigDBConnector()\\n config_db.connect()\\n seconds = 600\\n\\n config_db.mod_entry(\\\"NAT_GLOBAL\\\", \\\"Values\\\", {\\\"nat_timeout\\\": seconds})\",\n \"def wait_for_seconds(self, seconds, sleeptime=0.001):\\n self.listen_until_return(timeout=seconds, sleeptime=sleeptime)\",\n \"def delay(seconds):\\n\\n # Perform the delay\\n time.sleep(seconds)\",\n \"def __init__(self, seconds):\\n super(RobotiqCommandTimeout, self).__init__()\\n self.start_time = rospy.get_rostime()\\n self.duration = rospy.Duration(seconds)\",\n \"def timeout(seconds=10, error_message=os.strerror(errno.ETIME)):\\n def decorator(func):\\n def _handle_timeout(signum, frame):\\n raise TimeoutError(error_message)\\n\\n @wraps(func)\\n def wrapper(*args, **kwargs):\\n try:\\n signal.signal(signal.SIGALRM, _handle_timeout)\\n signal_disabled = False\\n except ValueError:\\n # Possibly running in debug mode. Timeouts will be ignored\\n signal_disabled = True\\n pass\\n\\n if not signal_disabled:\\n signal.alarm(seconds)\\n try:\\n result = func(*args, **kwargs)\\n finally:\\n if not signal_disabled:\\n signal.alarm(0)\\n return result\\n\\n return wrapper\\n return decorator\",\n \"def ttl_seconds(self, ttl_seconds: \\\"int\\\"):\\n self._attrs[\\\"ttlSeconds\\\"] = ttl_seconds\",\n \"def timeout(seconds=60, error_message=os.strerror(errno.ETIME)):\\n def decorator(func):\\n def _handle_timeout(signum, frame):\\n raise TimeoutError(\\n '{0} ran for more than {1} seconds'.format(\\n func.__name__, seconds))\\n def wrapper(*args, **kwargs):\\n signal.signal(signal.SIGALRM, _handle_timeout)\\n signal.alarm(seconds)\\n try:\\n result = func(*args, **kwargs)\\n finally:\\n signal.alarm(0)\\n return result\\n return wraps(func)(wrapper)\\n\\n return decorator\",\n \"def __init__(self, timeout=129600):\\n self.timeout = timeout\",\n \"def set_cache_timeout(self, cache_key, timeout):\\n self.cache_timeouts[cache_key.lower()] = timeout\",\n \"def seconds(self, seconds):\\n\\n self._seconds = seconds\",\n \"def finrsttimeout(self, finrsttimeout) :\\n\\t\\ttry :\\n\\t\\t\\tself._finrsttimeout = finrsttimeout\\n\\t\\texcept Exception as e:\\n\\t\\t\\traise e\",\n \"def test_timeout_classic(self):\\n with pytest.warns(W25, match='timed out'):\\n with conf.set_temp('timeout', 1e-6):\\n result = conesearch.conesearch(\\n SCS_CENTER, SCS_RADIUS, cache=False,\\n verbose=self.verbose, catalog_db=self.url)\\n assert result is None\",\n \"def make_timeout(delay_seconds):\\n if delay_seconds is None:\\n return None\\n return time.time() + delay_seconds\",\n \"def timeout(seconds, error_message=\\\"Time out.\\\"):\\n import signal\\n def decorator(func):\\n\\n def __timiout_handler(signum, frame):\\n raise TimeoutError(error_message)\\n\\n @functools.wraps(func)\\n def wrapper(*arg, **kw):\\n signal.signal(signal.SIGALRM, __timiout_handler)\\n signal.alarm(seconds)\\n ret = \\\"\\\"\\n try:\\n ret = func(*arg, **kw)\\n except TimeoutError,e:\\n print \\\"TimeoutError: \\\", e\\n print \\\"{name} ran more than {seconds}s.\\\".format(name=func.__name__, seconds=seconds)\\n except Exception,e:\\n print \\\"Error: \\\",e\\n finally:\\n signal.alarm(0)\\n return ret\\n return wrapper\\n return decorator\",\n \"def timeout_in_minutes(self) -> int:\\n return pulumi.get(self, \\\"timeout_in_minutes\\\")\",\n \"def pytest_timeout_set_timer(item, settings):\\n tle.lib.set(int(settings.timeout), str(item).encode(\\\"utf-8\\\"))\\n return True\",\n \"def __init__(self, timeout=120):\\n self.m_timeout = timeout\",\n \"def update_lock_timeout(self, timeout):\\n\\n if not 0 < timeout <= BespokeGlobals.MAX_CHECKOUT_TIME:\\n raise FatalError(\\\"Timeout is out of range!\\\")\\n elif not self._in_use:\\n raise CoreError(\\\"This SystemUnderTest is not currently checked-out!\\\")\\n\\n self._lock_expiration = datetime.now() + timedelta(seconds=timeout)\",\n \"def org_apache_felix_http_timeout(self, org_apache_felix_http_timeout: ConfigNodePropertyInteger):\\n\\n self._org_apache_felix_http_timeout = org_apache_felix_http_timeout\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7244905","0.7077083","0.7077083","0.6927818","0.6727418","0.6487171","0.63730776","0.63308954","0.6328697","0.632715","0.63181335","0.6302803","0.61149293","0.5976687","0.5967412","0.5945675","0.59285706","0.5925558","0.592076","0.58889365","0.5865888","0.58414924","0.58205307","0.5811467","0.5774083","0.5771579","0.5761816","0.57560694","0.5755476","0.574911","0.5714803","0.56808466","0.56675357","0.5628633","0.5628633","0.5628633","0.5628633","0.5628633","0.5628633","0.5600905","0.5597122","0.55594593","0.552071","0.55120534","0.54813606","0.545642","0.5420503","0.54158574","0.5402807","0.5389268","0.53758705","0.5351393","0.5349995","0.53452307","0.52973384","0.52589786","0.52257687","0.5199413","0.5195754","0.51948094","0.51742446","0.5171683","0.5123545","0.5115102","0.5109754","0.509572","0.50766504","0.5065895","0.5065816","0.5060903","0.5060335","0.50491834","0.50462836","0.501983","0.5019182","0.4999308","0.49947524","0.49925745","0.49909332","0.49756116","0.4975506","0.4968704","0.49540442","0.4937371","0.49303645","0.49229497","0.49192014","0.48952076","0.48857102","0.4884721","0.48819417","0.48809525","0.48710355","0.48709202","0.4862617","0.4859461","0.48558894","0.48471308","0.48458484","0.48417687"],"string":"[\n \"0.7244905\",\n \"0.7077083\",\n \"0.7077083\",\n \"0.6927818\",\n \"0.6727418\",\n \"0.6487171\",\n \"0.63730776\",\n \"0.63308954\",\n \"0.6328697\",\n \"0.632715\",\n \"0.63181335\",\n \"0.6302803\",\n \"0.61149293\",\n \"0.5976687\",\n \"0.5967412\",\n \"0.5945675\",\n \"0.59285706\",\n \"0.5925558\",\n \"0.592076\",\n \"0.58889365\",\n \"0.5865888\",\n \"0.58414924\",\n \"0.58205307\",\n \"0.5811467\",\n \"0.5774083\",\n \"0.5771579\",\n \"0.5761816\",\n \"0.57560694\",\n \"0.5755476\",\n \"0.574911\",\n \"0.5714803\",\n \"0.56808466\",\n \"0.56675357\",\n \"0.5628633\",\n \"0.5628633\",\n \"0.5628633\",\n \"0.5628633\",\n \"0.5628633\",\n \"0.5628633\",\n \"0.5600905\",\n \"0.5597122\",\n \"0.55594593\",\n \"0.552071\",\n \"0.55120534\",\n \"0.54813606\",\n \"0.545642\",\n \"0.5420503\",\n \"0.54158574\",\n \"0.5402807\",\n \"0.5389268\",\n \"0.53758705\",\n \"0.5351393\",\n \"0.5349995\",\n \"0.53452307\",\n \"0.52973384\",\n \"0.52589786\",\n \"0.52257687\",\n \"0.5199413\",\n \"0.5195754\",\n \"0.51948094\",\n \"0.51742446\",\n \"0.5171683\",\n \"0.5123545\",\n \"0.5115102\",\n \"0.5109754\",\n \"0.509572\",\n \"0.50766504\",\n \"0.5065895\",\n \"0.5065816\",\n \"0.5060903\",\n \"0.5060335\",\n \"0.50491834\",\n \"0.50462836\",\n \"0.501983\",\n \"0.5019182\",\n \"0.4999308\",\n \"0.49947524\",\n \"0.49925745\",\n \"0.49909332\",\n \"0.49756116\",\n \"0.4975506\",\n \"0.4968704\",\n \"0.49540442\",\n \"0.4937371\",\n \"0.49303645\",\n \"0.49229497\",\n \"0.49192014\",\n \"0.48952076\",\n \"0.48857102\",\n \"0.4884721\",\n \"0.48819417\",\n \"0.48809525\",\n \"0.48710355\",\n \"0.48709202\",\n \"0.4862617\",\n \"0.4859461\",\n \"0.48558894\",\n \"0.48471308\",\n \"0.48458484\",\n \"0.48417687\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6873225"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":88383,"cells":{"query":{"kind":"string","value":"Sets the delay that is waited after each Selenium command. This is useful mainly in slowing down the test execution to be able to view the execution. `seconds` may be given in Robot Framework time format. Returns the previous speed value."},"document":{"kind":"string","value":"def set_selenium_speed(self, seconds):\n old = self._selenium.get_speed()\n seconds = str(int(utils.timestr_to_secs(seconds)*1000))\n self._selenium.set_speed(seconds)\n return utils.secs_to_timestr(float(old)/1000)"},"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 delay(seconds):\n\n # Perform the delay\n time.sleep(seconds)","def set_selenium_timeout(self, seconds):\n timeout = utils.timestr_to_secs(seconds)\n old = getattr(self, '_timeout', timeout)\n self._timeout = timeout\n self._selenium.set_timeout(timeout * 1000)\n return utils.secs_to_timestr(old)","def sleep(self, seconds):\n time.sleep(seconds)","def sleep_approx(self, seconds):\n upperbound = (seconds+0.2)*10000\n if (seconds >= 1):\n lowerbound = (seconds-0.2)*10000\n else:\n lowerbound = seconds*10000\n\n sleeptime = random.randint(lowerbound, upperbound)\n sleeptime = sleeptime/10000\n sleeptime = sleeptime*.8\n\n if (self.botspeed == 1.25):\n sleeptime = sleeptime*.75\n elif (self.botspeed == 1.5):\n sleeptime = sleeptime*.5\n sleep(sleeptime)","def sleep(self, seconds=60):\n\t\ttime.sleep(seconds)","def sleep(self, seconds):\n ten_ms_steps = int(round(seconds * 100))\n for _i in xrange(0,ten_ms_steps):\n if self._sequence_stop_signal:\n break\n sleep(0.01)","def sleep_after(self, seconds):\n if self._firmware >= 264:\n self.write(self.ASCII_ESC, '8', seconds, seconds >> 8)\n else:\n self.write(self.ASCII_ESC, '8', seconds)","def pause(seconds: float) -> None:\n time.sleep(cast(float, seconds))","def delay(self, distance, seconds):\n delay = distance/seconds\n return delay","def wait(self, seconds):\n time.sleep(seconds)","def sleep(seconds):\r\n time.sleep(seconds)","def delay_requests(self, seconds: float):\n delta_since_last_send = time.time() - self._last_send\n self._last_send = (time.time() - delta_since_last_send) + seconds","def sleep(seconds):\n # After load and initializing the PvAPI Python's built-in 'sleep' function\n # stops working (returns too early). The is a replacement.\n from time import sleep,time\n t = t0 = time()\n while t < t0+seconds: sleep(t0+seconds - t); t = time()","def wait(self, seconds):\n self.driver.implicitly_wait(seconds)","def sleep(seconds):\n\n return Sleep(seconds)","async def sleep(self, seconds):\n await self._sleep_until_nanos(_get_future_nanos(seconds))","def delay(self, seconds):\n\n if self.call is None:\n return\n self.call.delay(seconds)","def sleep(seconds):\n\n # Check seconds to ensure it is a valid type.\n if type(seconds) not in [long, float, int]:\n raise RepyArgumentError(\"Invalid type \" + str(type(seconds)))\n\n # Using getruntime() in lieu of time.time() because we want elapsed time \n # regardless of the oddities of NTP\n start = nonportable.getruntime()\n sleeptime = seconds\n\n # Return no earlier than the finish time\n finish = start + seconds\n\n while sleeptime > 0.0:\n time.sleep(sleeptime)\n\n # If sleeptime > 0.0 then I woke up early...\n sleeptime = finish - nonportable.getruntime()","def sleep(seconds):\n time.sleep(seconds)","def sleep(seconds):\n time.sleep(seconds)","def set_sleep_time(self, milliseconds:int):\n self.send_command(f\"configure mainLoopSleepTime {milliseconds}\")","def advance_time_seconds(seconds):\r\n advance_time_delta(datetime.timedelta(0, seconds))","def delay(ms: int, /) -> None:","def sleep(secs=1.0):\n time.sleep(secs)","def set_timeout(self, seconds):\n self._timeout = seconds","def go_then_wait(self, position, seconds):\n self.go(position)\n self.wait(seconds)","def wait_for_seconds(self, seconds, sleeptime=0.001):\n self.listen_until_return(timeout=seconds, sleeptime=sleeptime)","def pause(seconds):\n time.sleep(seconds);","def sleep_sim_time(world, seconds, state_break=[False]):\n start = world.last_time if world.last_time else Time()\n remain = seconds\n\n while remain > 0 and not state_break[0]:\n yield From(trollius.sleep(0.1))\n now = world.last_time if world.last_time else Time()\n remain = seconds - float(now - start)","def timeout(self, seconds: Optional[float]):\n if (seconds is not None) and (seconds < 0):\n raise ValueError(\"negative\")\n\n self._timeout = seconds","def delay(dt):\n return dt.total_seconds()","def seconds(self, seconds):\n\n self._seconds = seconds","def get_millis(seconds):\n return seconds * 10 ** 3","def sequenceTime_sec(cmds):\n cycles = sum(MemorySequence.cmdTime_cycles(c) for c in cmds)\n return cycles * 40e-9 # assume 25 MHz clock -> 40 ns per cycle","def sleep_ms(milliseconds):\n time.sleep(milliseconds / 1000.0)","def setDelay(self, channel, delay, unitCode=0):\n resp = self.XAPCommand('DELAY', channel, delay, unitCode=unitCode)\n return float(resp)","def set_step_time(self, us):\n if us < 20: # 20 us is the shortest possible for esp8266\n self.step_time = 20\n else:\n self.step_time = us","def jump(self, seconds: float) -> None:\n if seconds < 0:\n raise ValueError(\"time can't go backwards\")\n self._virtual_base += seconds","def run(seconds=1):\n time.sleep(seconds)\n print('Slept for ',seconds,' seconds')","def setStartSpeed(self, pulses_per_sec):\n cmd_string = 'v{0}'.format(pulses_per_sec)\n self.sim_speed_change = True\n self.cmd_chain += cmd_string","def setTimeOut(self, sec):\n if (sec is not None) and (sec > 0):\n to = sec\n else:\n to = None\n self._simulator_.update(timeout=to)\n\n return","def setTopSpeed(self, pulses_per_sec):\n cmd_string = 'V{0}'.format(pulses_per_sec)\n self.sim_speed_change = True\n self.cmd_chain += cmd_string","def sleep(sleep_time=0.250):\n time.sleep(sleep_time)","def setCutoffSpeed(self, pulses_per_sec):\n cmd_string = 'c{0}'.format(pulses_per_sec)\n self.sim_speed_change = True\n self.cmd_chain += cmd_string","def wait(self, secs):\r\n t1 = time.time()\r\n self.driver.implicitly_wait(secs)\r\n self.my_print(\"{0} Set wait all element display in {1} seconds, Spend {2} seconds\".format(success,\r\n secs,time.time() - t1))","def sleep(secs: float) -> Coroutine[None, None, None]:\n return time_sleep_coro(secs)","def make_timeout(delay_seconds):\n if delay_seconds is None:\n return None\n return time.time() + delay_seconds","def sleep(seconds: typing.Union[float, int]):\n if seconds == 0:\n yield\n elif seconds == inf:\n yield from sleepinf()\n else:\n end = monotonic() + seconds\n while end >= monotonic():\n yield","def timeout_seconds(self, timeout_seconds):\n\n self._timeout_seconds = timeout_seconds","def timeout_seconds(self, timeout_seconds):\n\n self._timeout_seconds = timeout_seconds","def elapseTime(self, progress, seconds):\n cursor = connection.cursor()\n newtime = progress.time - datetime.timedelta(seconds=seconds)\n cursor.execute(\"update script_scriptprogress set time = '%s' where id = %d\" %\n (newtime.strftime('%Y-%m-%d %H:%M:%S.%f'), progress.pk))\n try:\n session = ScriptSession.objects.get(connection=progress.connection, end_time=None)\n session.start_time = session.start_time - datetime.timedelta(seconds=seconds)\n session.save()\n except ScriptSession.DoesNotExist:\n pass","def delay():\r\n time.sleep(2)","def delay(self, length):\n self.log_info(f\"Browser.delay: Sleeping for {length} seconds\")\n return sleep(length)","def SetStepDelay(self,delay=200): \n self.Bus.Transaction(chr(self.Address)+chr(0x43)+chr(delay))","def sleep(self, amount: float):\n time.sleep(amount)","async def sleep(cls, delay: float) -> None:","def deepsleep(time_ms: int = None) -> None:","def implicitly_wait(self, secs):\n self.base_driver.implicitly_wait(secs)","def sleep(min_seconds=1, max_seconds=10):\n time.sleep(randint(min_seconds, max_seconds))","def sleep(self, seconds):\n\n # We schedule an alarm signal for x=seconds out in the future.\n # noinspection PyUnusedLocal\n def handle_alarm(signal_num, frame):\n pass\n\n signal.signal(signal.SIGALRM, handle_alarm)\n signal.alarm(seconds)\n\n # Wait for either the alarm to go off or for us to receive a SIGINT.\n signal.pause()\n\n # Remove the alarm if it is still pending.\n signal.alarm(0)","def set_sleep_time(self, time):\n self.sleep_time = time","def pause(*args, seconds: int=0, **kwargs)->None:\n pass","def wait(period=5):\n import time\n print ('Wait for {val} seconds'.format(val=period))\n time.sleep(float(period))","def _make_time_pass(self, seconds, timeout, time_mock):\n time_mock.return_value = TIMEOUT_EPOCH\n timeout.start_connect()\n time_mock.return_value = TIMEOUT_EPOCH + seconds\n return timeout","def setdelay(self):\n delay=self.inputdelay.getEntry()\n cmd=\"setDelay(\"+self.board+','+self.inpedge+','+delay+')'\n self.vb.io.execute(cmd,log=\"out\",applout=\"<>\")","def set_delay(delay):\r\n inst.write(\"PULS:DEL %f\" %(delay))","def set_delay_ns(delay):\r\n inst.write(\"PULS:DEL %f NS\" %(delay))","def wait (self, seconds=0.0):\r\n\t\tstart_time = time.time()\r\n\t\twhile time.time() < start_time + seconds:\r\n\t\t\tself.receive()","def delay(self):\n _delay = self.config.get('delay', {\"hours\":0, \"minutes\":10, \"seconds\":0})\n return datetime.timedelta(\n hours=_delay.get('hours', 0), minutes=_delay.get('minutes', 0),\n seconds=_delay.get('seconds', 0))","def delay(self, delay=None):\n if delay is None:\n return self._delayvalue\n self._delayvalue = int(delay)","def pause(strength: Union[Strength, str] = None,\n seconds: Union[int, float] = None,\n milliseconds: Union[int, float] = None):\n tag = '<break {params}/>'\n\n milliseconds = milliseconds and f'{milliseconds}ms'\n seconds = seconds and f'{seconds}s'\n\n mapping = {\n 'seconds': 'time',\n 'milliseconds': 'time'\n }\n\n return tag.format(params=make_params(**locals()))","def take_actions(self, actions, seconds=None):\n if not actions:\n return\n\n self.take_action(actions[0])\n for action in actions[1:]:\n if seconds is not None:\n sleep(seconds)\n self.take_action(action)","async def _wait_setheist(self, ctx, seconds: int):\r\n guild = ctx.guild\r\n config = await self.thief.get_guild_settings(guild)\r\n theme = await self.thief.config.guild(guild).Theme()\r\n t_crew = theme[\"Crew\"]\r\n\r\n if seconds > 0:\r\n config[\"Wait\"] = seconds\r\n await self.thief.config.guild(guild).Config.set(config)\r\n time_fmt = self.thief.time_format(seconds)\r\n msg = \"Setting {} gather time to {}.\".format(t_crew, time_fmt)\r\n else:\r\n msg = \"Need a number higher than 0.\"\r\n await ctx.send(msg)","def return_delay_time(self, value):\n self._write(MX_RETURN_DELAY_TIME, value)","def __init__(self, seconds):\n super(RobotiqCommandTimeout, self).__init__()\n self.start_time = rospy.get_rostime()\n self.duration = rospy.Duration(seconds)","def set_timeout(self, milliseconds):\r\n self.inst.timeout = milliseconds\r\n self.logger.info(\"Timeout set to %f milliseconds.\" % milliseconds)","def pulse(seconds):\n index = 0\n while index < len(fake_threads):\n t = fake_threads[index]\n t['sleep'] -= seconds\n if t['sleep'] <= 0:\n t['sleep'] = 0\n t['next_sleep_time'] = None\n t['greenlet'].run()\n sleep_time = t['next_sleep_time']\n if sleep_time is None or isinstance(sleep_time, tuple):\n del fake_threads[index]\n index -= 1\n else:\n t['sleep'] = sleep_time\n index += 1","def delay(interval):\n time.sleep(interval / 1000.0)","def wait(self, seconds):\n logging.info(\"sleeping\")\n self.new_message_event.wait(seconds)\n logging.info(\"waking\")","def Time_Delay():\n Delay=[1]\n return Delay","def put_wait(duration, headers):\n debug = os.environ.get(\"DREPIN_DEBUG\")\n message = \"DREPIN_DEBUG is not defined. Delay duration: 0 sec.\"\n if debug:\n message = \"Delay duration: {} sec.\".format(duration)\n time.sleep(duration)\n return message","def wait_second(self, time_wait):\n # each test case 1st check for the stop button flag\n if not self.stopLoop:\n # get time\n ts = datetime.datetime.now().strftime(self.tsFormat)\n # Create label\n x = Label(\n self.testFrame, text=f'{ts} - Waiting {time_wait}s',\n background=self.bgChooser(),\n foreground=\"#a5120d\",\n font=self.boldFont, anchor='w')\n x.pack(fill=X)\n # add counter for BG\n self.bgCounter += 1\n # allow window to catch up\n self.tkRoot.update()\n self.update_scrollbar()\n time.sleep(1)\n # Automation Script below --------------------\n\n self.tv.wait_in_second(time_wait)\n\n # Automation Script above --------------------\n\n # revert label color to black\n x.config(foreground=\"#000\", font=self.mainFont)\n self.LabelLists.append(x)\n else:\n print(\"stopping test\")","def delayExec(self, delay_ms):\n if not 0 < delay_ms < 30000:\n raise(ValueError('`delay` [{0}] must be between 0 and 40000 ms'\n ''.format(delay_ms)))\n cmd_string = 'M{0}'.format(delay_ms)\n self.cmd_chain += cmd_string","def seconds_remaining(self):\n pass","def udelay(us: int, /) -> None:","def set_timeout(self, millis):\n self.timeout = self.current_milli_time() + millis","def set_timeout_millis(self, value):\n self.dp.set_timeout_millis(value)","def __delay(msecs):\n time.sleep(msecs / 1000)","def wait_up_to_second(second, time_template=None):\r\n current_second = datetime.datetime.now().second\r\n target_second = int(second)\r\n\r\n if current_second > target_second:\r\n sleep_time = 60 - (current_second - target_second)\r\n else:\r\n sleep_time = target_second - current_second\r\n\r\n if sleep_time:\r\n print('Waiting {} second(s)'.format(sleep_time))\r\n time.sleep(sleep_time)\r\n\r\n if time_template:\r\n return Utils.get_current_time(time_template)","def secondsPassed(self)->int:\n return self._lic.params['usedDurationInSeconds'].value","def setTimeDelay(*args):\n args[0].TimeState.TimeDelay.time_delay = args[1]","def getDelay(self, channel, unitCode=0):\n resp = self.XAPCommand('DELAY', channel, unitCode=unitCode)\n return float(resp)","def move_direction(self, direction='north', seconds=1.0):\n self.logger.debug(f'Mount simulator moving {direction} for {seconds} seconds')\n time.sleep(seconds)","def timeout(self, seconds=None):\n if self.__timeout_coro:\n self.__timeout_coro.cancel()\n if seconds is None:\n return\n e = self.get_node().get_loop()\n self.__timeout_coro = e.call_later(seconds, self._timeout)","def sleep_us(microseconds):\n time.sleep(microseconds / 1000000.0)","def test_delay(\n decoy: Decoy,\n mock_engine_client: EngineClient,\n subject: ProtocolCore,\n seconds: float,\n message: Optional[str],\n) -> None:\n subject.delay(seconds=seconds, msg=message)\n decoy.verify(mock_engine_client.wait_for_duration(seconds=seconds, message=message))","def sleep_duration(self, value=None):\n\n if value != None:\n self.write_block(REG_SLEEP_DURATION, [(value >> i * 8) & 0xFF for i in range(0, 4)])\n \n res = self.read_block(REG_SLEEP_DURATION, 4)\n\n return (res[3] << 24) + (res[2] << 16) + (res[1] << 8) + (res[0] << 0)","def run_simulation(self, seconds):\n car_position_array = np.zeros(shape=(seconds, 30))\n car_speed_array = np.zeros(shape=(seconds, 30))\n self.car_list = [] # Clear car list\n self.initialize_car_list(30)\n self.add_cars_to_road\n for i in range(seconds):\n self.one_second()\n car_position_array[i] = [car.position for car in self.car_list]\n car_speed_array[i] = [car.current_speed for car in self.car_list]\n return car_position_array, car_speed_array","def delayS(self):\n e = self.ecc()\n cE = np.cos(self.E())\n sE = np.sin(self.E())\n sOmega = np.sin(self.omega())\n cOmega = np.cos(self.omega())\n TM2 = self.M2.value*Tsun\n\n sDelay = -2*TM2* np.log(1-e*cE-self.SINI*(sOmega*(cE-e)+\n (1-e**2)**0.5*cOmega*sE))\n return sDelay","def _next_update_time(self, seconds=10):\n now = get_aware_utc_now()\n next_update_time = now + datetime.timedelta(\n seconds=seconds)\n return next_update_time"],"string":"[\n \"def delay(seconds):\\n\\n # Perform the delay\\n time.sleep(seconds)\",\n \"def set_selenium_timeout(self, seconds):\\n timeout = utils.timestr_to_secs(seconds)\\n old = getattr(self, '_timeout', timeout)\\n self._timeout = timeout\\n self._selenium.set_timeout(timeout * 1000)\\n return utils.secs_to_timestr(old)\",\n \"def sleep(self, seconds):\\n time.sleep(seconds)\",\n \"def sleep_approx(self, seconds):\\n upperbound = (seconds+0.2)*10000\\n if (seconds >= 1):\\n lowerbound = (seconds-0.2)*10000\\n else:\\n lowerbound = seconds*10000\\n\\n sleeptime = random.randint(lowerbound, upperbound)\\n sleeptime = sleeptime/10000\\n sleeptime = sleeptime*.8\\n\\n if (self.botspeed == 1.25):\\n sleeptime = sleeptime*.75\\n elif (self.botspeed == 1.5):\\n sleeptime = sleeptime*.5\\n sleep(sleeptime)\",\n \"def sleep(self, seconds=60):\\n\\t\\ttime.sleep(seconds)\",\n \"def sleep(self, seconds):\\n ten_ms_steps = int(round(seconds * 100))\\n for _i in xrange(0,ten_ms_steps):\\n if self._sequence_stop_signal:\\n break\\n sleep(0.01)\",\n \"def sleep_after(self, seconds):\\n if self._firmware >= 264:\\n self.write(self.ASCII_ESC, '8', seconds, seconds >> 8)\\n else:\\n self.write(self.ASCII_ESC, '8', seconds)\",\n \"def pause(seconds: float) -> None:\\n time.sleep(cast(float, seconds))\",\n \"def delay(self, distance, seconds):\\n delay = distance/seconds\\n return delay\",\n \"def wait(self, seconds):\\n time.sleep(seconds)\",\n \"def sleep(seconds):\\r\\n time.sleep(seconds)\",\n \"def delay_requests(self, seconds: float):\\n delta_since_last_send = time.time() - self._last_send\\n self._last_send = (time.time() - delta_since_last_send) + seconds\",\n \"def sleep(seconds):\\n # After load and initializing the PvAPI Python's built-in 'sleep' function\\n # stops working (returns too early). The is a replacement.\\n from time import sleep,time\\n t = t0 = time()\\n while t < t0+seconds: sleep(t0+seconds - t); t = time()\",\n \"def wait(self, seconds):\\n self.driver.implicitly_wait(seconds)\",\n \"def sleep(seconds):\\n\\n return Sleep(seconds)\",\n \"async def sleep(self, seconds):\\n await self._sleep_until_nanos(_get_future_nanos(seconds))\",\n \"def delay(self, seconds):\\n\\n if self.call is None:\\n return\\n self.call.delay(seconds)\",\n \"def sleep(seconds):\\n\\n # Check seconds to ensure it is a valid type.\\n if type(seconds) not in [long, float, int]:\\n raise RepyArgumentError(\\\"Invalid type \\\" + str(type(seconds)))\\n\\n # Using getruntime() in lieu of time.time() because we want elapsed time \\n # regardless of the oddities of NTP\\n start = nonportable.getruntime()\\n sleeptime = seconds\\n\\n # Return no earlier than the finish time\\n finish = start + seconds\\n\\n while sleeptime > 0.0:\\n time.sleep(sleeptime)\\n\\n # If sleeptime > 0.0 then I woke up early...\\n sleeptime = finish - nonportable.getruntime()\",\n \"def sleep(seconds):\\n time.sleep(seconds)\",\n \"def sleep(seconds):\\n time.sleep(seconds)\",\n \"def set_sleep_time(self, milliseconds:int):\\n self.send_command(f\\\"configure mainLoopSleepTime {milliseconds}\\\")\",\n \"def advance_time_seconds(seconds):\\r\\n advance_time_delta(datetime.timedelta(0, seconds))\",\n \"def delay(ms: int, /) -> None:\",\n \"def sleep(secs=1.0):\\n time.sleep(secs)\",\n \"def set_timeout(self, seconds):\\n self._timeout = seconds\",\n \"def go_then_wait(self, position, seconds):\\n self.go(position)\\n self.wait(seconds)\",\n \"def wait_for_seconds(self, seconds, sleeptime=0.001):\\n self.listen_until_return(timeout=seconds, sleeptime=sleeptime)\",\n \"def pause(seconds):\\n time.sleep(seconds);\",\n \"def sleep_sim_time(world, seconds, state_break=[False]):\\n start = world.last_time if world.last_time else Time()\\n remain = seconds\\n\\n while remain > 0 and not state_break[0]:\\n yield From(trollius.sleep(0.1))\\n now = world.last_time if world.last_time else Time()\\n remain = seconds - float(now - start)\",\n \"def timeout(self, seconds: Optional[float]):\\n if (seconds is not None) and (seconds < 0):\\n raise ValueError(\\\"negative\\\")\\n\\n self._timeout = seconds\",\n \"def delay(dt):\\n return dt.total_seconds()\",\n \"def seconds(self, seconds):\\n\\n self._seconds = seconds\",\n \"def get_millis(seconds):\\n return seconds * 10 ** 3\",\n \"def sequenceTime_sec(cmds):\\n cycles = sum(MemorySequence.cmdTime_cycles(c) for c in cmds)\\n return cycles * 40e-9 # assume 25 MHz clock -> 40 ns per cycle\",\n \"def sleep_ms(milliseconds):\\n time.sleep(milliseconds / 1000.0)\",\n \"def setDelay(self, channel, delay, unitCode=0):\\n resp = self.XAPCommand('DELAY', channel, delay, unitCode=unitCode)\\n return float(resp)\",\n \"def set_step_time(self, us):\\n if us < 20: # 20 us is the shortest possible for esp8266\\n self.step_time = 20\\n else:\\n self.step_time = us\",\n \"def jump(self, seconds: float) -> None:\\n if seconds < 0:\\n raise ValueError(\\\"time can't go backwards\\\")\\n self._virtual_base += seconds\",\n \"def run(seconds=1):\\n time.sleep(seconds)\\n print('Slept for ',seconds,' seconds')\",\n \"def setStartSpeed(self, pulses_per_sec):\\n cmd_string = 'v{0}'.format(pulses_per_sec)\\n self.sim_speed_change = True\\n self.cmd_chain += cmd_string\",\n \"def setTimeOut(self, sec):\\n if (sec is not None) and (sec > 0):\\n to = sec\\n else:\\n to = None\\n self._simulator_.update(timeout=to)\\n\\n return\",\n \"def setTopSpeed(self, pulses_per_sec):\\n cmd_string = 'V{0}'.format(pulses_per_sec)\\n self.sim_speed_change = True\\n self.cmd_chain += cmd_string\",\n \"def sleep(sleep_time=0.250):\\n time.sleep(sleep_time)\",\n \"def setCutoffSpeed(self, pulses_per_sec):\\n cmd_string = 'c{0}'.format(pulses_per_sec)\\n self.sim_speed_change = True\\n self.cmd_chain += cmd_string\",\n \"def wait(self, secs):\\r\\n t1 = time.time()\\r\\n self.driver.implicitly_wait(secs)\\r\\n self.my_print(\\\"{0} Set wait all element display in {1} seconds, Spend {2} seconds\\\".format(success,\\r\\n secs,time.time() - t1))\",\n \"def sleep(secs: float) -> Coroutine[None, None, None]:\\n return time_sleep_coro(secs)\",\n \"def make_timeout(delay_seconds):\\n if delay_seconds is None:\\n return None\\n return time.time() + delay_seconds\",\n \"def sleep(seconds: typing.Union[float, int]):\\n if seconds == 0:\\n yield\\n elif seconds == inf:\\n yield from sleepinf()\\n else:\\n end = monotonic() + seconds\\n while end >= monotonic():\\n yield\",\n \"def timeout_seconds(self, timeout_seconds):\\n\\n self._timeout_seconds = timeout_seconds\",\n \"def timeout_seconds(self, timeout_seconds):\\n\\n self._timeout_seconds = timeout_seconds\",\n \"def elapseTime(self, progress, seconds):\\n cursor = connection.cursor()\\n newtime = progress.time - datetime.timedelta(seconds=seconds)\\n cursor.execute(\\\"update script_scriptprogress set time = '%s' where id = %d\\\" %\\n (newtime.strftime('%Y-%m-%d %H:%M:%S.%f'), progress.pk))\\n try:\\n session = ScriptSession.objects.get(connection=progress.connection, end_time=None)\\n session.start_time = session.start_time - datetime.timedelta(seconds=seconds)\\n session.save()\\n except ScriptSession.DoesNotExist:\\n pass\",\n \"def delay():\\r\\n time.sleep(2)\",\n \"def delay(self, length):\\n self.log_info(f\\\"Browser.delay: Sleeping for {length} seconds\\\")\\n return sleep(length)\",\n \"def SetStepDelay(self,delay=200): \\n self.Bus.Transaction(chr(self.Address)+chr(0x43)+chr(delay))\",\n \"def sleep(self, amount: float):\\n time.sleep(amount)\",\n \"async def sleep(cls, delay: float) -> None:\",\n \"def deepsleep(time_ms: int = None) -> None:\",\n \"def implicitly_wait(self, secs):\\n self.base_driver.implicitly_wait(secs)\",\n \"def sleep(min_seconds=1, max_seconds=10):\\n time.sleep(randint(min_seconds, max_seconds))\",\n \"def sleep(self, seconds):\\n\\n # We schedule an alarm signal for x=seconds out in the future.\\n # noinspection PyUnusedLocal\\n def handle_alarm(signal_num, frame):\\n pass\\n\\n signal.signal(signal.SIGALRM, handle_alarm)\\n signal.alarm(seconds)\\n\\n # Wait for either the alarm to go off or for us to receive a SIGINT.\\n signal.pause()\\n\\n # Remove the alarm if it is still pending.\\n signal.alarm(0)\",\n \"def set_sleep_time(self, time):\\n self.sleep_time = time\",\n \"def pause(*args, seconds: int=0, **kwargs)->None:\\n pass\",\n \"def wait(period=5):\\n import time\\n print ('Wait for {val} seconds'.format(val=period))\\n time.sleep(float(period))\",\n \"def _make_time_pass(self, seconds, timeout, time_mock):\\n time_mock.return_value = TIMEOUT_EPOCH\\n timeout.start_connect()\\n time_mock.return_value = TIMEOUT_EPOCH + seconds\\n return timeout\",\n \"def setdelay(self):\\n delay=self.inputdelay.getEntry()\\n cmd=\\\"setDelay(\\\"+self.board+','+self.inpedge+','+delay+')'\\n self.vb.io.execute(cmd,log=\\\"out\\\",applout=\\\"<>\\\")\",\n \"def set_delay(delay):\\r\\n inst.write(\\\"PULS:DEL %f\\\" %(delay))\",\n \"def set_delay_ns(delay):\\r\\n inst.write(\\\"PULS:DEL %f NS\\\" %(delay))\",\n \"def wait (self, seconds=0.0):\\r\\n\\t\\tstart_time = time.time()\\r\\n\\t\\twhile time.time() < start_time + seconds:\\r\\n\\t\\t\\tself.receive()\",\n \"def delay(self):\\n _delay = self.config.get('delay', {\\\"hours\\\":0, \\\"minutes\\\":10, \\\"seconds\\\":0})\\n return datetime.timedelta(\\n hours=_delay.get('hours', 0), minutes=_delay.get('minutes', 0),\\n seconds=_delay.get('seconds', 0))\",\n \"def delay(self, delay=None):\\n if delay is None:\\n return self._delayvalue\\n self._delayvalue = int(delay)\",\n \"def pause(strength: Union[Strength, str] = None,\\n seconds: Union[int, float] = None,\\n milliseconds: Union[int, float] = None):\\n tag = '<break {params}/>'\\n\\n milliseconds = milliseconds and f'{milliseconds}ms'\\n seconds = seconds and f'{seconds}s'\\n\\n mapping = {\\n 'seconds': 'time',\\n 'milliseconds': 'time'\\n }\\n\\n return tag.format(params=make_params(**locals()))\",\n \"def take_actions(self, actions, seconds=None):\\n if not actions:\\n return\\n\\n self.take_action(actions[0])\\n for action in actions[1:]:\\n if seconds is not None:\\n sleep(seconds)\\n self.take_action(action)\",\n \"async def _wait_setheist(self, ctx, seconds: int):\\r\\n guild = ctx.guild\\r\\n config = await self.thief.get_guild_settings(guild)\\r\\n theme = await self.thief.config.guild(guild).Theme()\\r\\n t_crew = theme[\\\"Crew\\\"]\\r\\n\\r\\n if seconds > 0:\\r\\n config[\\\"Wait\\\"] = seconds\\r\\n await self.thief.config.guild(guild).Config.set(config)\\r\\n time_fmt = self.thief.time_format(seconds)\\r\\n msg = \\\"Setting {} gather time to {}.\\\".format(t_crew, time_fmt)\\r\\n else:\\r\\n msg = \\\"Need a number higher than 0.\\\"\\r\\n await ctx.send(msg)\",\n \"def return_delay_time(self, value):\\n self._write(MX_RETURN_DELAY_TIME, value)\",\n \"def __init__(self, seconds):\\n super(RobotiqCommandTimeout, self).__init__()\\n self.start_time = rospy.get_rostime()\\n self.duration = rospy.Duration(seconds)\",\n \"def set_timeout(self, milliseconds):\\r\\n self.inst.timeout = milliseconds\\r\\n self.logger.info(\\\"Timeout set to %f milliseconds.\\\" % milliseconds)\",\n \"def pulse(seconds):\\n index = 0\\n while index < len(fake_threads):\\n t = fake_threads[index]\\n t['sleep'] -= seconds\\n if t['sleep'] <= 0:\\n t['sleep'] = 0\\n t['next_sleep_time'] = None\\n t['greenlet'].run()\\n sleep_time = t['next_sleep_time']\\n if sleep_time is None or isinstance(sleep_time, tuple):\\n del fake_threads[index]\\n index -= 1\\n else:\\n t['sleep'] = sleep_time\\n index += 1\",\n \"def delay(interval):\\n time.sleep(interval / 1000.0)\",\n \"def wait(self, seconds):\\n logging.info(\\\"sleeping\\\")\\n self.new_message_event.wait(seconds)\\n logging.info(\\\"waking\\\")\",\n \"def Time_Delay():\\n Delay=[1]\\n return Delay\",\n \"def put_wait(duration, headers):\\n debug = os.environ.get(\\\"DREPIN_DEBUG\\\")\\n message = \\\"DREPIN_DEBUG is not defined. Delay duration: 0 sec.\\\"\\n if debug:\\n message = \\\"Delay duration: {} sec.\\\".format(duration)\\n time.sleep(duration)\\n return message\",\n \"def wait_second(self, time_wait):\\n # each test case 1st check for the stop button flag\\n if not self.stopLoop:\\n # get time\\n ts = datetime.datetime.now().strftime(self.tsFormat)\\n # Create label\\n x = Label(\\n self.testFrame, text=f'{ts} - Waiting {time_wait}s',\\n background=self.bgChooser(),\\n foreground=\\\"#a5120d\\\",\\n font=self.boldFont, anchor='w')\\n x.pack(fill=X)\\n # add counter for BG\\n self.bgCounter += 1\\n # allow window to catch up\\n self.tkRoot.update()\\n self.update_scrollbar()\\n time.sleep(1)\\n # Automation Script below --------------------\\n\\n self.tv.wait_in_second(time_wait)\\n\\n # Automation Script above --------------------\\n\\n # revert label color to black\\n x.config(foreground=\\\"#000\\\", font=self.mainFont)\\n self.LabelLists.append(x)\\n else:\\n print(\\\"stopping test\\\")\",\n \"def delayExec(self, delay_ms):\\n if not 0 < delay_ms < 30000:\\n raise(ValueError('`delay` [{0}] must be between 0 and 40000 ms'\\n ''.format(delay_ms)))\\n cmd_string = 'M{0}'.format(delay_ms)\\n self.cmd_chain += cmd_string\",\n \"def seconds_remaining(self):\\n pass\",\n \"def udelay(us: int, /) -> None:\",\n \"def set_timeout(self, millis):\\n self.timeout = self.current_milli_time() + millis\",\n \"def set_timeout_millis(self, value):\\n self.dp.set_timeout_millis(value)\",\n \"def __delay(msecs):\\n time.sleep(msecs / 1000)\",\n \"def wait_up_to_second(second, time_template=None):\\r\\n current_second = datetime.datetime.now().second\\r\\n target_second = int(second)\\r\\n\\r\\n if current_second > target_second:\\r\\n sleep_time = 60 - (current_second - target_second)\\r\\n else:\\r\\n sleep_time = target_second - current_second\\r\\n\\r\\n if sleep_time:\\r\\n print('Waiting {} second(s)'.format(sleep_time))\\r\\n time.sleep(sleep_time)\\r\\n\\r\\n if time_template:\\r\\n return Utils.get_current_time(time_template)\",\n \"def secondsPassed(self)->int:\\n return self._lic.params['usedDurationInSeconds'].value\",\n \"def setTimeDelay(*args):\\n args[0].TimeState.TimeDelay.time_delay = args[1]\",\n \"def getDelay(self, channel, unitCode=0):\\n resp = self.XAPCommand('DELAY', channel, unitCode=unitCode)\\n return float(resp)\",\n \"def move_direction(self, direction='north', seconds=1.0):\\n self.logger.debug(f'Mount simulator moving {direction} for {seconds} seconds')\\n time.sleep(seconds)\",\n \"def timeout(self, seconds=None):\\n if self.__timeout_coro:\\n self.__timeout_coro.cancel()\\n if seconds is None:\\n return\\n e = self.get_node().get_loop()\\n self.__timeout_coro = e.call_later(seconds, self._timeout)\",\n \"def sleep_us(microseconds):\\n time.sleep(microseconds / 1000000.0)\",\n \"def test_delay(\\n decoy: Decoy,\\n mock_engine_client: EngineClient,\\n subject: ProtocolCore,\\n seconds: float,\\n message: Optional[str],\\n) -> None:\\n subject.delay(seconds=seconds, msg=message)\\n decoy.verify(mock_engine_client.wait_for_duration(seconds=seconds, message=message))\",\n \"def sleep_duration(self, value=None):\\n\\n if value != None:\\n self.write_block(REG_SLEEP_DURATION, [(value >> i * 8) & 0xFF for i in range(0, 4)])\\n \\n res = self.read_block(REG_SLEEP_DURATION, 4)\\n\\n return (res[3] << 24) + (res[2] << 16) + (res[1] << 8) + (res[0] << 0)\",\n \"def run_simulation(self, seconds):\\n car_position_array = np.zeros(shape=(seconds, 30))\\n car_speed_array = np.zeros(shape=(seconds, 30))\\n self.car_list = [] # Clear car list\\n self.initialize_car_list(30)\\n self.add_cars_to_road\\n for i in range(seconds):\\n self.one_second()\\n car_position_array[i] = [car.position for car in self.car_list]\\n car_speed_array[i] = [car.current_speed for car in self.car_list]\\n return car_position_array, car_speed_array\",\n \"def delayS(self):\\n e = self.ecc()\\n cE = np.cos(self.E())\\n sE = np.sin(self.E())\\n sOmega = np.sin(self.omega())\\n cOmega = np.cos(self.omega())\\n TM2 = self.M2.value*Tsun\\n\\n sDelay = -2*TM2* np.log(1-e*cE-self.SINI*(sOmega*(cE-e)+\\n (1-e**2)**0.5*cOmega*sE))\\n return sDelay\",\n \"def _next_update_time(self, seconds=10):\\n now = get_aware_utc_now()\\n next_update_time = now + datetime.timedelta(\\n seconds=seconds)\\n return next_update_time\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66323715","0.6297846","0.6280223","0.62300897","0.6206175","0.6159071","0.6082828","0.60776395","0.60160977","0.60102314","0.59985185","0.59399515","0.5932031","0.5910213","0.5898481","0.58874804","0.5863831","0.5814787","0.5781439","0.5781439","0.5674142","0.5670888","0.5644514","0.56096554","0.5604961","0.5538949","0.5492041","0.5476859","0.5472427","0.5405509","0.5368463","0.5352711","0.5349302","0.53204817","0.52545106","0.5186753","0.5184319","0.51728094","0.51713115","0.516864","0.5132502","0.5111774","0.5069038","0.50324744","0.5026867","0.50199324","0.5017583","0.4994048","0.49913555","0.49913555","0.49889","0.49773866","0.49669698","0.49455294","0.49329096","0.4927735","0.49272352","0.4923296","0.4907474","0.4900757","0.48848298","0.48715496","0.48682997","0.4834508","0.4821398","0.4816403","0.4810844","0.47987813","0.4798314","0.4791605","0.47788066","0.47783607","0.47736162","0.47684422","0.47604823","0.47547865","0.4745064","0.47448036","0.47392887","0.47210348","0.47127262","0.47104812","0.47042403","0.47026414","0.46928215","0.46921128","0.4684488","0.46835098","0.46730092","0.4666358","0.46536183","0.46519196","0.46387073","0.46357408","0.46333933","0.46258911","0.46239445","0.461314","0.46080798","0.46069148"],"string":"[\n \"0.66323715\",\n \"0.6297846\",\n \"0.6280223\",\n \"0.62300897\",\n \"0.6206175\",\n \"0.6159071\",\n \"0.6082828\",\n \"0.60776395\",\n \"0.60160977\",\n \"0.60102314\",\n \"0.59985185\",\n \"0.59399515\",\n \"0.5932031\",\n \"0.5910213\",\n \"0.5898481\",\n \"0.58874804\",\n \"0.5863831\",\n \"0.5814787\",\n \"0.5781439\",\n \"0.5781439\",\n \"0.5674142\",\n \"0.5670888\",\n \"0.5644514\",\n \"0.56096554\",\n \"0.5604961\",\n \"0.5538949\",\n \"0.5492041\",\n \"0.5476859\",\n \"0.5472427\",\n \"0.5405509\",\n \"0.5368463\",\n \"0.5352711\",\n \"0.5349302\",\n \"0.53204817\",\n \"0.52545106\",\n \"0.5186753\",\n \"0.5184319\",\n \"0.51728094\",\n \"0.51713115\",\n \"0.516864\",\n \"0.5132502\",\n \"0.5111774\",\n \"0.5069038\",\n \"0.50324744\",\n \"0.5026867\",\n \"0.50199324\",\n \"0.5017583\",\n \"0.4994048\",\n \"0.49913555\",\n \"0.49913555\",\n \"0.49889\",\n \"0.49773866\",\n \"0.49669698\",\n \"0.49455294\",\n \"0.49329096\",\n \"0.4927735\",\n \"0.49272352\",\n \"0.4923296\",\n \"0.4907474\",\n \"0.4900757\",\n \"0.48848298\",\n \"0.48715496\",\n \"0.48682997\",\n \"0.4834508\",\n \"0.4821398\",\n \"0.4816403\",\n \"0.4810844\",\n \"0.47987813\",\n \"0.4798314\",\n \"0.4791605\",\n \"0.47788066\",\n \"0.47783607\",\n \"0.47736162\",\n \"0.47684422\",\n \"0.47604823\",\n \"0.47547865\",\n \"0.4745064\",\n \"0.47448036\",\n \"0.47392887\",\n \"0.47210348\",\n \"0.47127262\",\n \"0.47104812\",\n \"0.47042403\",\n \"0.47026414\",\n \"0.46928215\",\n \"0.46921128\",\n \"0.4684488\",\n \"0.46835098\",\n \"0.46730092\",\n \"0.4666358\",\n \"0.46536183\",\n \"0.46519196\",\n \"0.46387073\",\n \"0.46357408\",\n \"0.46333933\",\n \"0.46258911\",\n \"0.46239445\",\n \"0.461314\",\n \"0.46080798\",\n \"0.46069148\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6863085"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88384,"cells":{"query":{"kind":"string","value":"Calls a method in the Selenium remote control API directly. This keyword can be used if some functionality provided by Selenium is not yet exposed as a keyword. `method_name` is the name of the method to call in the Selenium API and `args` specify the arguments it expects. The keyword first tries to find a method in Selenium's Python API provided by the `selenium.py` file. If no matching method is found, the keyword calls the Selenium Server's Remote Controller API directly via the `do_command` method in the Python API [1]. In both cases the keyword returns the return value of the call directly without any modifications or verifications."},"document":{"kind":"string","value":"def call_selenium_api(self, method_name, *args):\n try:\n method = getattr(self._selenium, method_name)\n except AttributeError:\n method = lambda *args: self._selenium.do_command(method_name, args)\n return method(*args)"},"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 _call_command_method(self, name, original_method, args, kwargs):\n if threadprop.current_controller() is not self:\n action=self._direct_comm_call_action\n if action==\"warning\":\n if name not in self._command_warned:\n print(\"Warning: direct call of command '{}' of thread '{}' from a different thread '{}'\".format(\n name,self.name,threadprop.current_controller().name),file=sys.stderr)\n self._command_warned.add(name)\n else:\n accessor=QMultiRepeatingThreadController.__getattribute__(self,action)\n return accessor.__getattr__(name)(*args,**kwargs)\n return original_method(*args,**kwargs)","def command(self, name, method_name=None, **kwargs):\n return self._command(name, method_name=method_name, **kwargs)","def _remote_call(self,\n method_name,\n target='Widget',\n args=None,\n kwargs=None):\n args = [] if args is None else args\n kwargs = {} if kwargs is None else kwargs\n\n msg = {}\n\n if 'component_index' in kwargs:\n msg['component_index'] = kwargs.pop('component_index')\n if 'repr_index' in kwargs:\n msg['repr_index'] = kwargs.pop('repr_index')\n\n msg['target'] = target\n msg['type'] = 'call_method'\n msg['methodName'] = method_name\n msg['args'] = args\n msg['kwargs'] = kwargs\n\n def callback(widget, msg=msg):\n widget.send(msg)\n\n callback._method_name = method_name\n callback._ngl_msg = msg\n\n if self.loaded:\n self._remote_call_thread.q.append(callback)\n else:\n # send later\n # all callbacks will be called right after widget is loaded\n self._ngl_displayed_callbacks_before_loaded.append(callback)\n\n if callback._method_name not in _EXCLUDED_CALLBACK_AFTER_FIRING:\n self._ngl_displayed_callbacks_after_loaded.append(callback)","def callRemote(self, methname, *args, **kwargs):\n try:\n schema = self._referenceable.getInterface()[methname]\n if self.check_args:\n schema.checkAllArgs(args, kwargs, inbound=True)\n _check_copyables(list(args) + kwargs.values())\n result = self._referenceable.doRemoteCall(\n methname,\n args,\n kwargs,\n )\n schema.checkResults(result, inbound=False)\n _check_copyables([result])\n return succeed(result)\n except:\n return fail()","def _override_command_method(self, name):\n method=getattr(self,name,None)\n if method is not None:\n @func_utils.getargsfrom(method)\n def new_method(*args, **kwargs):\n return self._call_command_method(name,method,args,kwargs)\n setattr(self,name,new_method)","def callRemote(self, methname, *args, **kwargs):\n schema = self._referenceable.getInterface()[methname]\n if self.check_args:\n schema.checkAllArgs(args, kwargs, inbound=False)\n # TODO: Figure out how to call checkResults on the result.\n return execute(\n self._referenceable.doRemoteCall,\n methname,\n args,\n kwargs,\n )","def _call(self, rpc_method_name, *args, **kwargs):\n method = getattr(self, rpc_method_name)\n return method(*args, **kwargs)","def call(self, method, *args, **kwargs):\n if method in self.handlers:\n handler = self.handlers[method]\n if self.single_server:\n self.send_request(self.single_server, method, handler, *args, **kwargs)\n else:\n if method in [\"completion\", \"completion_item_resolve\", \"diagnostics\", \"code_action\", \"execute_command\"]:\n method_server_names = self.multi_servers_info[method]\n else:\n method_server_names = [self.multi_servers_info[method]]\n\n for method_server_name in method_server_names:\n method_server = self.multi_servers[method_server_name]\n self.send_request(method_server, method, handler, *args, **kwargs)\n elif hasattr(self, method):\n getattr(self, method)(*args, **kwargs)","def execute(self, methodname, *args):\n if not methodname in self.methods:\n raise BlogError(BlogError.METHOD_NOT_SUPPORTED)\n\n try:\n r = getattr(self.server, methodname)(args)\n except xmlrpclib.Fault, fault:\n raise BlogError(fault.faultString)\n\n return r","def export_callProxyMethod( self, name, args, kargs ):\n res = pythonCall( 120, self.__proxyWrapper, name, args, kargs )\n if res['OK']:\n return res['Value']\n else:\n return res","def callRemote(self, name, *args, **kw):\n if hasattr(self, 'sync_'+name):\n return getattr(self, 'sync_'+name)(*args, **kw)\n try:\n method = getattr(self, \"async_\" + name)\n return defer.succeed(method(*args, **kw))\n except:\n f = Failure()\n if self.reportAllTracebacks:\n f.printTraceback()\n return defer.fail(f)","def _call_method(self, module, method, *args, **kwargs):\n return self.invoke_api(module, method, *args, **kwargs)","def custom_command(self, name, method_name=None, **kwargs):\n return self._command(name, method_name=method_name, custom_command=True, **kwargs)","def callmethod(\n self, method: str, *args: Sequence[Any], **kwargs: Sequence[Any]\n ) -> List[Any]:\n return getattr(self, method)(*args, **kwargs)","def call_command(self, name, args):\n try:\n cmd = self.commands[name]\n except KeyError:\n self.answer(\"Unknown command\", success=False)\n else:\n try:\n result, success = cmd(*args)\n result = result or \"\"\n self.answer(result, success=success)\n except TypeError as e:\n self.answer(\n \"Error when calling function: {}\".format(e),\n success=False,\n )","def _call_method(self, module, method, *args, **kwargs):\n if not self._is_vim_object(module):\n return self.invoke_api(module, method, self.vim, *args, **kwargs)\n else:\n return self.invoke_api(module, method, *args, **kwargs)","def call_method(self, name, method, params):\n self.logger.debug(\"API call: {}.{}({})\".format(name, method, params))\n if name in self.systems:\n obj = self.systems[name]\n if is_api_method(obj, method):\n try:\n # Calls given obj.method, unpacking and passing params dict\n call_return = getattr(obj, method)(**params)\n msg = \"Called {}.{}\".format(name, method)\n self.logger.debug(msg + \",returned:{}\".format(call_return))\n return msgs.call_reply(msg, call_return)\n except TypeError:\n # Raised when we have a mismatch of the method's kwargs\n # TODO: Return argspec here?\n err_msg = \"Invalid params for {}.{}\".format(name, method)\n self.logger.warning(err_msg)\n return msgs.error(err_msg)\n except Exception as e:\n # Catch exception raised by called method, notify client\n err_msg = \"Exception: '{}'\".format(str(e))\n self.logger.warning(err_msg)\n return msgs.error(err_msg)\n else:\n err_msg = \"Invalid method: '{}.{}'\".format(name, method)\n self.logger.warning(err_msg)\n return msgs.error(err_msg)\n else:\n err_msg = \"Invalid object: '{}'\".format(name)\n self.logger.warning(err_msg)\n return msgs.error(err_msg)","def _method_call(self, msg):\n #print(\"Performing service: %s, method_name: %s\" % (msg.service_name, msg.method_name))\n service = self._services.get(msg.service_name)\n if service is None:\n raise MessageHandleError(MessageHandleError.RESULT_UNKNOWN_SERVICE, msg)\n\n try:\n return execute_remote_method_call(service, msg.method_name, *msg.pargs, **msg.kwargs)\n #return service.call(msg.method_name, *msg.pargs, **msg.kwargs)\n except MessageHandleError as error:\n error.original_message = msg\n raise error","def call_thread_method(self, name, *args, **kwargs):\n return self._thread_methods[name](*args,**kwargs)","def _platformix_call(self, context, fake_reply, method, *args, **kwargs):\r\n if hasattr(self.host, method):\r\n if not callable(getattr(self.host, method)):\r\n self._reply(context, proto_failure(\"Attribute {} of {} is a property\".format(\r\n property, self.host.name)), fake_reply)\r\n return\r\n try:\r\n result = getattr(self.host, method)(*args, **kwargs)\r\n except Exception as e:\r\n eprint(\"Platformix protocol: failed to call method {} of {} with args {}, kwargs {} \"\r\n \"due to exception {}\".format(method, self.host.name, args, kwargs, e))\r\n exprint()\r\n self._reply(context, proto_failure(\r\n \"Failed to call method {} of {} with args {}, kwargs {} \"\r\n \"due to exception {}\".format(method, self.host.name, args, kwargs, e)), fake_reply)\r\n return\r\n self._reply(context, proto_success(result), fake_reply)\r\n else:\r\n self._reply(context, proto_failure(\"Method {} not found on {}\".format(property, self.host.name)),\r\n fake_reply)","def __call__(self, method, *args, **kwargs):\n if hasattr(self, 'channel'):\n kwargs.setdefault('channel', self.channel)\n resp = self._client.api_call(method, *args, **kwargs)\n if not resp['ok']:\n print unicode(resp)\n raise RuntimeError(resp.get('error', unicode(resp)))\n return resp","def exec_method(self, module_name, version=None, client_class=None,\n method_name=None, *args, **kwargs):\n client_class = client_class or 'Client'\n client_version = version or 2\n _client = self.create_client(module_name, client_version,\n client_class)\n try:\n # NOTE(kiennt): method_name could be a combination\n # for example 'servers.list'. Here is the\n # workaround.\n method = getattr(_client, method_name.split('.')[0])\n for attr in method_name.split('.')[1:]:\n method = getattr(method, attr)\n return method(*args, **kwargs)\n except Exception as err:\n raise err","def allow_remote_invocation(func, method='auto'):\r\n setattr(func, 'allow_rmi', method)\r\n return func","def call(self, name, *args, **kwargs):\r\n return self.client.call(self.name, name, *args, **kwargs)","def call(self, method=None, args=[]):\n\n client = xmlclient.ServerProxy(uri=self.api_endpoint, encoding='utf-8',\n allow_none=True)\n response = getattr(client, method)(self.username, self.password, *args)\n if response == 'OK':\n return True\n elif 'AUTH_ERROR' in response:\n raise AuthError()\n elif response == 'DOMAIN_OCCUPIED':\n raise DomainOccupiedError()\n elif response == 'RATE_LIMITED':\n raise RateLimitedError()\n elif response == 'BAD_INDATA':\n raise BadInDataError()\n elif response == 'UNKNOWN_ERROR':\n raise UnknownError()\n else:\n return response","def call_command_direct(self, name, args=None, kwargs=None):\n comm,_=self._commands[name]\n return comm(*(args or []),**(kwargs or {}))","def call(self, method, *args):\n flatcall = flatten(\n m(n=method, t=self.groupName)[[\n squish(x) for x in args if x is not None]])\n self.socket.write(flatcall + '\\0')","def __call__(self, method=None):\n\n if method is None:\n action = self.method\n else:\n action = method\n\n if action == Du.WALK_METHOD:\n return self._du_using_walk()\n elif action == Du.RECURSION_METHOD:\n return self._du_using_recursion()\n elif action == Du.QUEUE_METHOD:\n return self._du_using_list()\n elif action == Du.SUBPROCESSES_METHOD:\n return self._du_using_subprocesses()\n\n raise InvalidDuMethodError(\n 'InvalidDuMethodError: This method doesn\\'t exist!'\n )","def call(self, obj_name, method_name, param_dict=dict()):\n result = self.ctrl_client.call(obj_name, method_name, param_dict)\n if result['type'] == 'error':\n self.logger.error(\"API call error: {}\".format(result['msg']))\n return None\n else:\n return result['call_return']","def call(self, method, name, params=None, payload=None, **kwds):","def send_method_call(self, service_name, method_name, *pargs, **kwargs):\n msg = MethodCallMessage(service_name=service_name, method_name=method_name, pargs=pargs, kwargs=kwargs)\n return self.send_message_blocking(msg)","def execute_method(self, method, params):\n args, varargs, varkw, defaults = getargspec(method)\n if varargs or varkw:\n raise InvalidParamsError(\n \"Service method definition must not have variable parameters\")\n args_set = set(args[1:])\n if params is None:\n if not len(args_set) == 0:\n raise InvalidParamsError(\n \"Wrong number of parameters; \"\n \"expected %i but 'params' was omitted \"\n \"from JSON-RPC message\" % (len(args_set)))\n return method()\n elif isinstance(params, (list, tuple)):\n if not len(args_set) == len(params):\n raise InvalidParamsError(\n \"Wrong number of parameters; \"\n \"expected %i got %i\" % (len(args_set),len(params)))\n return method(*params)\n elif isinstance(params, dict):\n paramset = set(params)\n if not args_set == paramset:\n raise InvalidParamsError(\n \"Named parameters do not \"\n \"match method; expected %s\" % (str(args_set)))\n params = self.decode_dict_keys(params)\n return method(**params)","def env_method(self, method_name, *method_args, indices=None, **method_kwargs):\n target_remotes = self._get_target_remotes(indices)\n for remote in target_remotes:\n remote.send(('env_method', (method_name, method_args, method_kwargs)))\n return [remote.recv() for remote in target_remotes]","def call(self, port, method, *args, **kwargs):\n method = self.provides[port][method]\n return method(*args, **kwargs)","def setup_method(self, method):\r\n self.cf = self.config = saunter.ConfigWrapper.ConfigWrapper()\r\n\r\n self.current_method_name = method.__name__\r\n\r\n browser = self.cf[\"browsers\"][self.cf[\"saunter\"][\"default_browser\"]]\r\n if browser[\"type\"][0] == \"*\":\r\n browser = browser[\"type\"] = browser[\"type\"][1:]\r\n\r\n profile = None\r\n if browser[\"type\"] == 'firefox':\r\n if browser[\"profiles\"][sys.platform]:\r\n profile_path = os.path.join(self.cf[\"saunter\"][\"base\"], 'support', 'profiles', browser[\"profiles\"][sys.platform])\r\n elif browser[\"profiles\"][\"profile\"]:\r\n profile_path = os.path.join(self.cf[\"saunter\"][\"base\"], 'support', 'profiles', browser[\"profiles\"][\"profile\"])\r\n else:\r\n profile_path = None\r\n\r\n if profile_path:\r\n if os.path.isdir(profile_path):\r\n profile = FirefoxProfile(profile_path)\r\n else:\r\n raise ProfileNotFound(\"Profile not found at %s\" % profile_path)\r\n\r\n if \"saucelabs\" in browser and browser[\"saucelabs\"][\"ondemand\"]:\r\n desired_capabilities = {\r\n \"platform\": self.cf[\"sauceLabs\"][\"os\"],\r\n \"browserName\": self.cf[\"sauceLabs\"][\"browser\"],\r\n \"version\": self.cf.get(\"SauceLabs\", \"browser_version\"),\r\n \"name\": method.__name__\r\n }\r\n if desired_capabilities[\"browserName\"][0] == \"*\":\r\n desired_capabilities[\"browserName\"] = desired_capabilities[\"browserName\"][1:]\r\n if desired_capabilities[\"platform\"] in os_map:\r\n desired_capabilities[\"platform\"] = os_map[desired_capabilities[\"platform\"]]\r\n\r\n if self.cf.has_option(\"SauceLabs\", \"selenium_version\"):\r\n desired_capabilities['selenium-version'] = self.cf.get('SauceLabs', 'selenium_version')\r\n\r\n command_executor = \"http://%s:%s@ondemand.saucelabs.com:80/wd/hub\" % (self.cf.get(\"SauceLabs\", \"username\"), self.cf.get(\"SauceLabs\", \"key\"))\r\n else:\r\n desired_capabilities = capabilities_map[browser[\"type\"]]\r\n\r\n if browser[\"proxy\"][\"type\"] and browser[\"proxy\"][\"type\"].lower() == \"browsermob\":\r\n from browsermobproxy import Client\r\n self.client = Client(self.cf.get(\"Proxy\", \"proxy_url\"))\r\n self.client.add_to_webdriver_capabilities(desired_capabilities)\r\n\r\n if \"is grid\" in self.cf[\"selenium\"] and self.cf[\"selenium\"][\"executor\"][\"is grid\"]:\r\n if browser[\"grid filters\"][\"platform\"]:\r\n desired_capabilities[\"platform\"] = browser[\"grid filters\"][\"platform\"].upper()\r\n if browser[\"grid filters\"][\"version\"]:\r\n desired_capabilities[\"platform\"] = str(browser[\"grid filters\"][\"version\"])\r\n\r\n command_executor = \"http://%s:%s/wd/hub\" % (self.cf[\"selenium\"][\"executor\"][\"host\"], self.cf[\"selenium\"][\"executor\"][\"port\"])\r\n\r\n self.driver = WebDriver(desired_capabilities=desired_capabilities, command_executor=command_executor, browser_profile=profile)\r\n\r\n self.verificationErrors = []\r\n self.matchers = Matchers(self.driver, self.verificationErrors)\r\n\r\n if \"saucelabs\" in self.cf[\"browsers\"][self.cf[\"saunter\"][\"default_browser\"]] and self.cf[\"browsers\"][self.cf[\"saunter\"][\"default_browser\"]][\"saucelabs\"][\"ondemand\"]:\r\n self.sauce_session = self.driver.session_id\r\n\r\n self._screenshot_number = 1","def __getattr__(self, method):\n def run_callback(func, plus, result):\n \"\"\"Execute the given callback safely.\n Get data and/or error from result and call func passing it\n data, plus (if needed) and error. Catch, log and suppress\n all exceptions.\n func (function): the callback to invoke.\n plus (object): optional additional data.\n result (AsyncResult): the result of a (finished) RPC call.\n \"\"\"\n data = result.value\n error = None if result.successful() else \"%s\" % result.exception\n try:\n if plus is None:\n func(data, error=error)\n else:\n func(data, plus, error=error)\n except Exception as error:\n logger.error(\"RPC callback for %s.%s raised exception.\",\n self.remote_service_coord.name, method,\n exc_info=True)\n\n def remote_method(**data):\n \"\"\"Forward arguments to execute_rpc.\n \"\"\"\n callback = data.pop(\"callback\", None)\n plus = data.pop(\"plus\", None)\n result = self.execute_rpc(method=method, data=data)\n if callback is not None:\n callback = functools.partial(run_callback, callback, plus)\n result.rawlink(functools.partial(gevent.spawn, callback))\n return result\n\n return remote_method","def _multiproc_execute(obj, method, args):# pragma: no cover\n #We don't cover this because it won't necessarily be caught be the coverage\n #program that is running on the main thread; it may only execute on other\n #threads.\n if hasattr(obj, method):\n return getattr(obj, method)(*args)","def _call_qc_method(self, method_name, *args, **kwargs):\n qc_method = getattr(self._query_compiler, f\"rolling_{method_name}\")\n return qc_method(self.axis, self.rolling_kwargs, *args, **kwargs)","def __call__(self, *args, **kwargs):\n return self.method(*args, **kwargs)","def call_method(self, method_name: str, timeout=None, **params) -> dict:\n timeout = timeout or self.timeout\n request_id = uuid.uuid4().hex\n data = {'@type': method_name,\n '@extra': {'request_id': request_id}}\n data.update(params)\n self._tdjson_client.send(data)\n\n result = self._wait_result(request_id, timeout)\n return result","def __getattr__(self, method: str):\n @exception_handler\n def func(*args, **kwargs):\n return self._client.PyCall(method, list(args), kwargs,\n self._wait_for_ready, self._call_timeout,\n self._compress)\n\n setattr(self, method, func)\n return func","def __getattr__(self, method_name):\n return partial(self.exec, method_name.replace(\"_\", \" \"))","def _execute_impl(self, *args, **kwargs):\n # Execute with bound args.\n method_body = getattr(self._deployment_node, self._deployment_method_name)\n return method_body.remote(\n *self._bound_args,\n **self._bound_kwargs,\n )","def env_method(self, method_name, *method_args, **method_kwargs):\n for pipe in self.remotes:\n pipe.send(('env_method', (method_name, method_args, method_kwargs)))\n return [remote.recv() for remote in self.remotes]","def servicemethod(*args, **kwargs):\n # Default options\n options = {'name': None, 'store': None, 'request_arg': True, 'store_arg': True}\n\n # Figure out if we were called with arguments\n # If we were called with args, ie:\n # @servicemethod(name='Foo')\n # Then the only argument here will be the pre-decorated function/method object.\n method = ( (len(args) == 1) and callable(args[0]) ) and args[0] or None\n\n if method is None:\n # We were called with args, (or @servicemethod() )\n # so figure out what they were ...\n\n # The method name should be either the first non-kwarg\n # or the kwarg 'name'\n # Example: @servicemethod('my_method', ...) or @servicemethod(name='my_method')\n options.update({\n 'name': bool(args) and args[0] or kwargs.pop('name', None),\n 'store': (len(args) >= 2) and args[1] or kwargs.pop('store', None),\n 'request_arg': kwargs.pop('request_arg', True),\n 'store_arg': kwargs.pop('store_arg', True),\n })\n else:\n options['name'] = method.__name__\n method.__servicemethod__ = options\n\n def method_with_args_wrapper(method):\n \"\"\" Wrapper for a method decorated with decorator arguments\n \"\"\"\n if options['name'] is None:\n options['name'] = method.__name__\n method.__servicemethod__ = options\n\n if options['store'] is not None:\n options['store'].service.add_method(method)\n\n return method\n\n return method or method_with_args_wrapper","def method(self,methodname):\n\t\tif methodname in self.methods:\n\t\t\treturn self.methods[methodname]\n\t\treturn None","def methodHelp(self, name):\r\n methods = self._listMethods()\r\n for methodname in methods.keys():\r\n if methodname == name:\r\n return methods[methodname]\r\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)","def execute_method_for_keyword(self):\n\n kwargs, kw_status = self.get_argument_as_keywords()\n print_info(\"The Arguments passed for the current Step is: '{0}'\".format(kwargs))\n if kw_status:\n # Execute the corresponding method\n method_loader = self.exec_obj.im_class()\n try:\n keyword_result = self.exec_obj(method_loader, **kwargs)\n except Exception as exception:\n trcback = print_exception(exception)\n keyword_result = (\"EXCEPTION\", trcback)\n\n self.data_repository = self.update_data_repository(self.keyword,\n keyword_result,\n self.data_repository)\n return self.data_repository","def wrap(*args):\n # If this class has a method callback registered, then\n # make sure we call the callback. Otherwise, just pass\n # the call through to the true ROS master server\n try:\n callback = \"_%s\" % method\n if hasattr(self, callback):\n callbackFn = getattr(self, callback)\n callbackFn(*args)\n except Exception, e:\n import traceback\n traceback.print_exc()\n\n # Pass the call through to the ROS master\n masterFn = getattr(self.__client, method)\n return masterFn(*args)","def run(self, command, *args):\n command = command.lower()\n\n if callable(getattr(self, command, None)):\n getattr(self, command)(*args)\n return\n\n send.error_message(\"Command '{}' not found\".format(command))","def __call__(self, args, kwargs):\n im_self = self._im_self_ref()\n if im_self is not None:\n method = MethodType(self._im_func, im_self, self._im_class)\n method(*args, **kwargs)","def _call(self, args):\n a = args.split(' ', 1)\n if a:\n getattr(self, a[0])(*a[1:])","def method_with_args_wrapper(method):\n if options['name'] is None:\n options['name'] = method.__name__\n method.__servicemethod__ = options\n\n if options['store'] is not None:\n options['store'].service.add_method(method)\n\n return method","def test_basic_method_call_wrapper():\n my_method = SGMethod(\"test\")\n other_method = SGMethod(\"other\")\n \n my_method.calls(other_method)\n my_method.check_call_validity();\n \n assert other_method == my_method.method_called\n assert len(my_method.args) == 0","def env_method(self, method_name: str, *method_args, indices: VecEnvIndices = None, **method_kwargs) -> List[Any]:\n raise NotImplementedError()","def\trunMethod(self, name = \"__default\", prms = {}):\n\n\t\tprms = self.CSLBuildPrmList(prms)\n\t\tlocalTbl = { 'vars':{}, 'status':0, 'props':{}, 'alias':{}, 'persistent':{}, 'instance':{}}\n\n\t\tres = self.callMethod(name, prms, localTbl)\n\n\t\tif localTbl[\"status\"] == 2:\n\t\t\treturn self.COMARValue.COMARRetVal(1, None)\n\t\telse:\t\t\t\n\t\t\tret = self.CSLtoCOMARValue(res)\n\t\t\tself.debug(DEBUG_FATAL, \"RETS:\", res, '(%s)->' % (res.type), ret)\n\t\t\treturn self.COMARValue.COMARRetVal(0, ret)","def RunNamedCommand(self, command_name, args=None, headers=None, debug=0,\n parallel_operations=False, test_method=None,\n bypass_prodaccess=True):\n if not args:\n args = []\n\n # Include api_version header in all commands.\n api_version = boto.config.get_value('GSUtil', 'default_api_version', '1')\n if not headers:\n headers = {}\n headers['x-goog-api-version'] = api_version\n\n if command_name not in self.command_map:\n raise CommandException('Invalid command \"%s\".' % command_name)\n command_class = self.command_map[command_name]\n command_inst = command_class(self, args, headers, debug,\n parallel_operations, self.gsutil_bin_dir,\n self.boto_lib_dir, self.config_file_list,\n self.gsutil_ver, self.bucket_storage_uri_class,\n test_method, bypass_prodaccess)\n return command_inst.RunCommand()","def calls(self, method, args=None):\n if self.method_called != None:\n logger.error('Model Error: Changing method called by %s', self.name)\n assert False\n self.method_called = method\n self.args = list()\n \n for arg in args:\n if not isinstance(arg, SGParameter):\n self.args.append(arg)\n else:\n self.args.append(self.get_parameter(arg.name))","def test_method_selection(self, method):\n wsgi._retryable(method, 'http://some.thing')\n\n getattr(self.session, method).assert_called_once_with(\n 'http://some.thing'\n )","def make_call(self, method, _):\n raise CallNotFound('{}.{} does not exist'.format(self.service_name,\n method))","def get_method(self, name):\n try:\n return self.methods[name]\n except KeyError:\n raise ServiceException('Service method \"%s\" not registered' % name)","def _trace_call(self, method: module_utils._FunctionWrapper, method_name: str):\n\n def call(*args, **kwargs):\n # Pop manually specified tolerances from the kwargs (if any).\n tolerances = {}\n tolerances[\"rtol\"] = kwargs.pop(\"rtol\", None)\n tolerances[\"atol\"] = kwargs.pop(\"atol\", None)\n # Only pass these to ModuleCall if they were specified by the user.\n tolerances = {k: v for k, v in tolerances.items() if v is not None}\n\n # Ensure the inputs are numpy inputs.\n args = tf_utils.convert_to_numpy(args)\n kwargs = tf_utils.convert_to_numpy(kwargs)\n\n # Run the method and record the details of the call.\n outputs = method(*args, **kwargs)\n serialized_inputs, serialized_outputs = method.get_serialized_values()\n self._trace.calls.append(\n ModuleCall(\n method_name,\n args,\n outputs,\n serialized_inputs,\n serialized_outputs,\n **tolerances,\n )\n )\n return outputs\n\n return call","def call_method(self, action):\n\n\t\tif action[0] in self.methods:\n\t\t\tself.methods[action[0]](action[0:])\n\t\telse:\n\t\t\tself.no_such_method()","def __executeOperation( self, url, method ):\n fcn = None\n if hasattr( self, method ) and callable( getattr( self, method ) ):\n fcn = getattr( self, method )\n if not fcn:\n return S_ERROR( \"Unable to invoke %s, it isn't a member function of DIPStorage\" % method )\n\n res = fcn( url )\n if not res['OK']:\n return res\n elif url not in res['Value']['Successful']:\n return S_ERROR( res['Value']['Failed'][url] )\n\n return S_OK( res['Value']['Successful'][url] )","def _wrapped_method(self, _meth_name, *args, **kwargs):\n return self._delegate(_meth_name, *args, **kwargs)","def call(self, source, method, *args):\n\n function = self.callable(method)\n function.source = source\n return function(*args)","def _call_method(self, call, method):\n raise Exception(\"_call_method must be implemented by subclasses.\")","def _call(self, name, *args, **kwargs):\r\n if len(args) and len(kwargs):\r\n raise TypeError(\r\n 'Use positional or keyword argument only.'\r\n )\r\n\r\n callinfo = getattr(self, name).callinfo\r\n soapAction = callinfo.soapAction\r\n url = callinfo.location\r\n (protocol, host, uri, query, fragment, identifier) = urlparse(url)\r\n port = '80'\r\n if host.find(':') >= 0:\r\n host, port = host.split(':')\r\n\r\n binding = Binding(host=host, tracefile=self._tracefile,\r\n ssl=(protocol == 'https'),\r\n port=port, url=None, typesmodule=self._typesmodule,\r\n nsdict=self._nsdict, soapaction=self._soapAction,\r\n ns=self._ns, op_ns=self._op_ns)\r\n\r\n if self._use_wsdl:\r\n request, response = self._getTypeCodes(callinfo)\r\n if len(kwargs): args = kwargs\r\n if request is None:\r\n request = Any(oname=name)\r\n binding.Send(url=uri, opname=None, obj=args,\r\n nsdict=self._nsdict, soapaction=soapAction, requesttypecode=request)\r\n return binding.Receive(replytype=response)\r\n\r\n apply(getattr(binding, callinfo.methodName), args)\r\n\r\n return binding.Receive()","def check_and_run_arguments(self, method_name = \"\", argument_list = [] ):\n\t\tcomplicate_argument_list = []\n\t\tdir_list = dir(self)\n\t\tif method_name not in dir_list:\n\t\t\tprint( f\"EasygoParser only has these methods: {dir_list}\" )\n\t\t\treturn False\n\t\tif method_name in complicate_argument_list and -1 == argument_list[0].find( \"filename=\" ):\n\t\t\tprint( f\"Method {method_name} of EasygoParser needs complicate arguments and can ONLY read arguments from a file\" )\n\n\t\targuments_dict = {}\n\t\tif -1 < argument_list[0].find( \"filename=\" ):\n\t\t\tfilename_list = argument_list[0].split(\"=\")\n\t\t\tif 2 != len( filename_list ):\n\t\t\t\tprint( f\"use filename=xxxx to let this script understand the argument file name\" )\n\t\t\t\treturn False\n\t\t\targuments_dict = self.read_argument_file( filename = filename_list[1], method_name = method_name )\n\t\t\tif 1 > len( arguments_dict ):\n\t\t\t\tprint( f\"Warning! There is no argument in file {filename_list[1]}\" )\n\t\telse:\n\t\t\tfor one in argument_list:\n\t\t\t\tif -1 == one.find( \"=\" ):\n\t\t\t\t\tprint( f\"argument {one} needs = to separate key and value\" )\n\t\t\t\t\treturn False\n\t\t\t\ttemp_list = one.split(\"=\")\n\t\t\t\tif 2 != len( temp_list ):\n\t\t\t\t\tprint( f\"argument {one} needs ONLY one = to separate key and value\" )\n\t\t\t\t\treturn False\n\t\t\t\targuments_dict[ temp_list[0] ] = temp_list[1]\n\t\tmethodcaller( method_name, **arguments_dict )(self)\n\t\t# https://blog.csdn.net/pythondafahao/article/details/79616294\n\t\t# https://blog.csdn.net/chenjinyu_tang/article/details/8136841\n\t\t# https://www.cnblogs.com/2bjiujiu/p/7289961.html\n\t\t# https://docs.python.org/3/library/operator.html\n\t\t# https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p20_call_method_on_object_by_string_name.html\n\t\t# https://blog.csdn.net/mrqingyu/article/details/84403924\n\t\t# https://stackoverflow.com/questions/3061/calling-a-function-of-a-module-by-using-its-name-a-string","def _traverse_command(self, name, *args, **kwargs):\n # TODO: implement instance level cache\n if not name in self.available_commands:\n raise AttributeError(\"%s is not an available command for %s\" % (name, self.__class__.__name__))\n attr = getattr(self.connection, \"%s\" % name)\n key = self.key\n log.debug(u\"Requesting %s with key %s and args %s\" % (name, key, args))\n result = attr(key, *args, **kwargs)\n result = self.post_command(\n sender=self,\n name=name,\n result=result,\n args=args,\n kwargs=kwargs\n )\n return result","def call(self, name: str, *args, **kwargs) -> List[Any]:\n self.call_async(name, *args, **kwargs)\n return self.call_wait()","def callRemote(self, _name, *args, **kw):\r\n if self.__failure is not None:\r\n d = fail(self.__failure)\r\n elif self.__pending is not None:\r\n d = Deferred()\r\n self.__pending.append(d)\r\n else:\r\n d = succeed(self.__obj)\r\n\r\n d.addCallback(lambda ref: ref.callRemote(_name, *args, **kw))\r\n d.addErrback(self.__filter, _name)\r\n return d","def execute_method(method, kwargs):\n for k, v in kwargs.items():\n kwargs[k] = deserialise(v)\n\n # Find any parameters which are not in the method signature and throw them away.\n invalid_kwargs=[]\n for kwarg in kwargs:\n if kwarg not in method.__code__.co_varnames:\n LOG.warning(\"WARNING: Parameter '%s' is not in the method signature of '%s'\", kwarg, method.__name__)\n invalid_kwargs.append(kwarg)\n # Remove invalid arguments (avoiding mutating the dictionary while iterating).\n for invalid_kwarg in invalid_kwargs:\n kwargs.pop(invalid_kwarg)\n\n # Call SDK method\n try:\n method_result = method(**kwargs)\n except ApiErrorResponse as api_error:\n if api_error.status_code == 404:\n result = {}\n else:\n # Anything other than a 404 re-raise the exception\n raise\n else:\n if isinstance(method_result, pagination.PaginatedResponse):\n result = dict(payload=method_result.data)\n else:\n result = dict(payload=method_result)\n\n return json.dumps(result, default=serialise_entity)","def run(self, **kwargs):\n\n if self.specified_method == '':\n return {'response': \"<br>No command specified\"}\n else:\n found = False\n\n for command in Command.commands_list:\n if command.name == self.specified_method:\n found = True\n if '--help' in self.params:\n # Return help text for the command\n return {'response': command.help_text}\n else:\n # Run the action function of the command\n return command.action(self.request, self.params, **kwargs)\n\n if not found:\n # If invalid command\n return {'response': f\"<br>{self.specified_method}: Command not found. Please enter a valid command.\"}","def handler(self, command, args=[]):\n ###\n # command parsing and handling logic to be implemented by child\n ###\n if not command and not hasattr(self, 'handle_'):\n return f'Service {str(self.__class__.__name__)}: {self.__doc__ or \"\"}'\n methodname = 'handle_{}'.format(command or '')\n logger.info('method name: {}'.format(methodname))\n logger.info('args: {}'.format(args))\n method = self.__getattribute__(methodname)\n return method(args)","def builtin_wrapper(method_name):\n def wrapper(self, *args, **kwargs):\n if method_name not in self.__dict__:\n raise AttributeError(\n \"object '%s' has no mock method '%s'\" %\n (mock_object_names.get(id(self)), method_name)\n )\n return self.__dict__[method_name](*args, **kwargs)\n return wrapper","def test_raises_when_unimplemented_method_called(self, method):\n\n class API(platform.PlatformAPI):\n pass\n\n name, impl = method\n params = platform.parameters(impl)\n\n with pytest.raises(NotImplementedError):\n m = getattr(API, name)\n arguments = (None,) * len(params)\n m(*arguments)","def _process_method(self, method):\n return method","def __getattr__(self, attr):\n\n #print \"checking for attribute %r remotely\" % attr\n\n # note that this will fail if it doesn't exist, and that's good\n check_attr = getattr(self.machine, attr)\n\n if callable(check_attr):\n # it's a method, call it and return it\n def wrap_remote_call(*args, **kargs):\n return check_attr(*args, **kargs)\n return wrap_remote_call\n else:\n # it' just an attribute, return it\n return check_attr","def call_command(self, name, *args, **kwargs):\r\n out = StringIO() # To Capture the output of the command\r\n call_command(name, *args, stdout=out, **kwargs)\r\n out.seek(0)\r\n return out.read()","def set_method(self, method, **kwargs):\n if isinstance(method, str) and method in self.available_methods.keys():\n self.method_name = method\n self.method = self.available_methods[method]['IDIMethod'](self, **kwargs)\n elif callable(method) and hasattr(method, 'calculate_displacements'):\n self.method_name = 'external_method'\n try:\n self.method = method(self, **kwargs)\n except:\n raise ValueError(\"The input `method` is not a valid `IDIMethod`.\")\n else:\n raise ValueError(\"method must either be a valid name from `available_methods` or an `IDIMethod`.\")\n \n # Update `get_displacements` docstring\n tools.update_docstring(self.get_displacements, self.method.calculate_displacements)\n # Update `show_points` docstring\n if hasattr(self.method, 'show_points'):\n try:\n tools.update_docstring(self.show_points, self.method.show_points)\n except:\n pass","def mappedQuicklookAction(self, method_name):\n # find currently active quicklook instance\n active_win = util.get_active_MDI_win()\n # call the function of the action on the instance\n getattr(active_win, str(method_name))()","def TestMethodBody(run_method_name, run_dargs):\n return lambda self: getattr(self, run_method_name)(**run_dargs)","def command(self, function=None, name=None):\r\n if name is None:\r\n return self._command(function)\r\n else:\r\n return partial(self._command, name=name)","def map_method(self, names, method_name, *args, **kwds):\r\n return self.map(names, self._call_extension_method,\r\n method_name, *args, **kwds)","def __getattr__(self, name):\n name = name.replace('_', '-')\n\n def wrapper(*args, **kwargs):\n if len(args) != 0 and len(kwargs) != 0:\n raise RpcError(name, {}, \"Cannot mix positional and non-positional arguments\")\n elif len(args) != 0:\n return self.call(name, payload=args)\n else:\n return self.call(name, payload=list(kwargs.values()))\n return wrapper","def __getattr__(self, cmd):\n\n if hasattr(self._rpc, cmd+'Request'):\n lnfunc = getattr(self._rpc, cmd+'Request')\n elif hasattr(self._rpc, f'Get{cmd}Request'):\n lnfunc = getattr(self._rpc, f'Get{cmd}Request')\n else:\n raise NotImplementedError('Unhandled method self._rpc.(Get)' + cmd + 'Request')\n\n if hasattr(self._stub, cmd):\n stubfunc = getattr(self._stub, cmd)\n\n def rpcCommand(*args,**kwargs):\n return stubfunc(lnfunc(*args, **kwargs))\n return rpcCommand\n\n elif hasattr(self._stub, 'Get'+cmd):\n stubfunc = getattr(self._stub, 'Get'+cmd)\n def rpcCommand(*args,**kwargs):\n if args:\n raise TypeError('Cannot use positional arguments with this command')\n return stubfunc(lnfunc(**kwargs))\n return rpcCommand\n\n else:\n raise NotImplementedError('Unhandled method stub.(Get)' + cmd)","def _traverse_command(self, name, *args, **kwargs):\n\n # Commands defined in \"_commands_to_proxy\" are handled here, to call\n # their proxy methods. Then, these proxy methods can call this\n # _traverse_command method with a named argument \"_bypass_proxy\" to True\n # to really do (de)indexing and execute the command\n bypass_proxy = kwargs.pop('_bypass_proxy', False)\n if name in self._commands_to_proxy and not bypass_proxy:\n command = getattr(self, self._commands_to_proxy[name])\n return command(name, *args)\n\n values_to_index = kwargs.pop('_to_index', None)\n values_to_deindex = kwargs.pop('_to_deindex', None)\n\n # TODO manage transaction\n if self.indexable and name in self.available_modifiers:\n self.deindex(values_to_deindex)\n\n # we don't call _traverse_command from IndexableField, but the one from\n # RedisField because we manage indexes manually here\n result = super(IndexableField, self)._traverse_command(name, *args, **kwargs)\n\n if self.indexable and name in self.available_modifiers:\n self.index(values_to_index)\n\n return result","def call_application(self, method_name, *args, **kwargs):\n request = CallRequest(\n method_name=method_name,\n args=self.json_encoder.encode(args),\n kwargs=self.json_encoder.encode(kwargs),\n )\n response = self.stub.CallApplicationMethod(request, timeout=5)\n return self.json_decoder.decode(response.data)","def call(self, method, *args):\n data = [method]\n data.extend(args)\n\n if method == 'auth.login':\n self.client.request('POST', self.uri, msgpack.packb(data), self.header)\n response = self.client.getresponse()\n\n if response.status == 200:\n return msgpack.unpackb(response.read())\n else:\n raise MSFClientError('Unknown error occurred when trying to login')\n\n elif self.authenticated:\n data.insert(1, self.sessionid)\n self.client.request('POST', self.uri, msgpack.packb(data), self.header)\n response = self.client.getresponse()\n\n if (response.status == 200):\n result = msgpack.unpackb(response.read())\n if 'error' in result:\n raise MSFClientError(result['error_message'])\n return result\n raise MSFClientError('An unknown error occurred')\n else:\n raise MSFClientError('You have to be authenticated')","def twitterCall(methodName,args,credentials=False):\n api = ratedTwitter(credentials=credentials)\n limit = api.__can_we_do_that__(methodName)\n if limit:\n print '*** TWITTER RATE-LIMITED: '+methodName+' ***'\n raise twitterCall.retry(exc=Exception('Twitter rate-limited',methodName), countdown = limit)\n else:\n okay, result = api.__method_call__(methodName,args)\n if okay:\n print '*** TWITTER CALL: '+methodName+' ***' \n return result\n else:\n assert False","def __call__(self, receiver, *args, convert_args=True, convert_result=True):\n\n if len(args) != len(self.method_argtypes):\n raise TypeError(\n f\"Method {self.name} takes {len(args)} arguments, but got {len(self.method_argtypes)} arguments\"\n )\n\n if convert_args:\n converted_args = []\n for argtype, arg in zip(self.method_argtypes, args):\n if isinstance(arg, enum.Enum):\n # Convert Python enum objects to their values\n arg = arg.value\n\n if issubclass(argtype, objc_block):\n if arg is None:\n # allow for 'nil' block args, which some objc methods accept\n arg = ns_from_py(arg)\n elif callable(arg) and not isinstance(\n arg, Block\n ): # <-- guard against someone someday making Block callable\n # Note: We need to keep the temp. Block instance\n # around at least until the objc method is called.\n # _as_parameter_ is used in the actual ctypes marshalling below.\n arg = Block(arg)\n # ^ For blocks at this point either arg is a Block instance\n # (making use of _as_parameter_), is None, or if it isn't either of\n # those two, an ArgumentError will be raised below.\n elif issubclass(argtype, objc_id):\n # Convert Python objects to Foundation objects\n arg = ns_from_py(arg)\n elif isinstance(arg, collections.abc.Sequence) and issubclass(\n argtype, (Structure, Array)\n ):\n arg = compound_value_for_sequence(arg, argtype)\n\n converted_args.append(arg)\n else:\n converted_args = args\n\n result = send_message(\n receiver,\n self.selector,\n *converted_args,\n restype=self.restype,\n argtypes=self.method_argtypes,\n )\n\n if not convert_result:\n return result\n\n # Convert result to python type if it is a instance or class pointer.\n if self.restype is not None and issubclass(self.restype, objc_id):\n result = ObjCInstance(result)\n\n # Mark for release if we acquire ownership of an object. Do not autorelease here because\n # we might retain a Python reference while the Obj-C reference goes out of scope.\n if self.name.startswith((b\"alloc\", b\"new\", b\"copy\", b\"mutableCopy\")):\n result._needs_release = True\n\n return result","def stubFunc( *args, **keywords ):\n maya.cmds.dynamicLoad( library )\n # call the real function which has replaced us\n return maya.cmds.__dict__[command]( *args, **keywords )","def client_member_function(self, method: ProtoServiceMethod) -> None:","def call_method(self, request, context):\n response = CallMethodResponse()\n args = []\n for arg in request.args:\n args.append(decode(arg))\n if args != []:\n result = \\\n self._delegator.call_method(\n request.component, request.method, *args)\n else:\n result = \\\n self._delegator.call_method(\n request.component, request.method, None)\n response.result = encode(result)\n return response","def apply(self, method, arguments):\n return method(arguments)","def xen_rpc_call(ip, method, *args):\n try:\n if not ip:\n return xen_api_error(\"Invalid ip for rpc call\")\n # create\n proxy = ServerProxy(\"http://\" + ip + \":9363/\")\n \n # login \n response = proxy.session.login('root')\n if cmp(response['Status'], 'Failure') == 0:\n log.exception(response['ErrorDescription'])\n return xen_api_error(response['ErrorDescription']) \n session_ref = response['Value']\n \n # excute\n method_parts = method.split('_')\n method_class = method_parts[0]\n method_name = '_'.join(method_parts[1:])\n \n if method.find(\"host_metrics\") == 0:\n method_class = \"host_metrics\"\n method_name = '_'.join(method_parts[2:])\n #log.debug(method_class)\n #log.debug(method_name)\n if method_class.find(\"Async\") == 0:\n method_class = method_class.split(\".\")[1]\n response = proxy.__getattr__(\"Async\").__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\n else:\n response = proxy.__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\n if cmp(response['Status'], 'Failure') == 0:\n log.exception(response['ErrorDescription'])\n return xen_api_error(response['ErrorDescription'])\n # result\n return response\n except socket.error:\n return xen_api_error('socket error')","def wrapper(*args, **kwargs):\n loop = asyncio.get_event_loop()\n return loop.run_until_complete(method(*args, **kwargs))","def execute(self, data, options):\n obj = self.fetch(data)\n if isinstance(obj, dict) and self.method_name in obj: # if dict\n return obj[self.method_name]\n try:\n prop = getattr(obj, self.method_name)\n rv = callable(prop) and prop() or prop\n return escape_if_needed(rv, options)\n except AttributeError:\n raise MethodDoesNotExist(self.name, self.method_name)","def run(self, username, setting, method, args):\n if setting == 'label':\n if method == 'get':\n print \"getting labels for %s...\\n\" % (username)\n print self.client.RetrieveLabels(username=username)\n elif method == 'set':\n print \"creating label for %s...\\n\" % (username)\n print self.client.CreateLabel(username=username, name=LABEL_NAME)\n else:\n print \"deleting labels isn't supported\"\n elif setting == 'forwarding':\n if method == 'get':\n print \"getting forwarding for %s...\\n\" % (username)\n print self.client.RetrieveForwarding(username)\n elif method == 'set':\n print \"updating forwarding settings for %s...\\n\" % (username)\n print self.client.UpdateForwarding(username=username, \n enable=not(options.disable),\n forward_to=FORWARD_TO,\n action=FORWARDING_ACTION)\n else:\n print \"deleting forwarding settings isn't supported\"\n elif setting == 'sendas':\n if method == 'get':\n print \"getting sendAs alias for %s...\\n\" % (username)\n print self.client.RetrieveSendAs(username=username)\n elif method == 'set':\n print \"creating sendAs alias for %s...\\n\" % (username)\n print self.client.CreateSendAs(username=username, name=SEND_AS_NAME, \n address=SEND_AS_ADDRESS,\n reply_to=SEND_AS_REPLY_TO, \n make_default=SEND_AS_MAKE_DEFAULT)\n else:\n print \"deleting send-as settings isn't supported\"\n elif setting == 'pop':\n if method == 'get':\n print \"getting pop settings for %s...\\n\" % (username)\n print self.client.RetrievePop(username=username)\n elif method == 'set':\n print \"updating pop settings for %s...\\n\" % (username)\n print self.client.UpdatePop(username=username, \n enable=not(options.disable), \n enable_for=POP_ENABLE_FOR,\n action=POP_ACTION)\n else:\n print \"deleting pop settings isn't supported\"\n elif setting == 'signature':\n if method == 'get':\n print \"getting signature for %s...\\n\" % (username)\n print self.client.RetrieveSignature(username=username)\n elif method == 'set':\n print \"updating signature for %s...\\n\" % (username)\n print self.client.UpdateSignature(username=username, \n signature=SIGNATURE)\n else:\n print \"deleting signature settings isn't supported\"\n elif setting == 'vacation':\n if method == 'get':\n print \"getting vacation settings for %s...\\n\" % (username)\n print self.client.RetrieveVacation(username=username)\n elif method == 'set':\n print \"updating vacation settings for %s...\\n\" % (username)\n print self.client.UpdateVacation(username=username, \n enable=not(options.disable),\n subject=VACATION_SUBJECT, \n message=VACATION_MESSAGE,\n contacts_only=VACATION_CONTACTS_ONLY)\n else:\n print \"deleting vacation settings isn't supported\"\n elif setting == 'imap':\n if method == 'get':\n print \"getting imap settings for %s...\\n\" % (username)\n print self.client.RetrieveImap(username)\n elif setting == 'set':\n print \"updating imap settings for %s...\\n\" % (username)\n print self.client.UpdateImap(username=username, \n enable=not(options.disable))\n else:\n print \"deleting imap settings isn't supported\"\n elif setting == 'filter':\n if method == 'get':\n print \"getting email filters is not yet possible\\n\"\n parser.print_help()\n elif method == 'set':\n print \"creating an email filter for %s...\\n\" % (username)\n print self.client.CreateFilter(username=username, \n from_address=FILTER_FROM, \n to_address=FILTER_TO,\n subject=FILTER_SUBJECT, \n has_the_word=FILTER_HAS_THE_WORD,\n does_not_have_the_word=\n FILTER_DOES_NOT_HAVE_THE_WORD,\n has_attachments=FILTER_HAS_ATTACHMENT, \n label=FILTER_LABEL,\n mark_as_read=FILTER_SHOULD_MARK_AS_READ,\n archive=FILTER_SHOULD_ARCHIVE)\n else:\n print \"deleting filters isn't supported\"\n elif setting == 'general':\n if method == 'get':\n print \"getting general email settings is not yet possible\\n\"\n parser.print_help()\n elif method == 'set':\n print \"updating general settings for %s...\\n\" % (username)\n print self.client.UpdateGeneralSettings(username=username, \n page_size=GENERAL_PAGE_SIZE,\n shortcuts=\n GENERAL_ENABLE_SHORTCUTS,\n arrows=\n GENERAL_ENABLE_ARROWS,\n snippets=\n GENERAL_ENABLE_SNIPPETS,\n use_unicode=\n GENERAL_ENABLE_UNICODE)\n else:\n print \"deleting general settings isn't supported\"\n elif setting == 'language':\n if method == 'get':\n print \"getting language settings is not yet possible\\n\"\n parser.print_help()\n elif method == 'set':\n print \"updating language for %s...\\n\" % (username)\n print self.client.UpdateLanguage(username=username, language=LANGUAGE)\n else:\n print \"deleting language settings isn't supported\"\n elif setting == 'webclip':\n if method == 'get':\n print \"getting webclip settings is not yet possible\\n\"\n parser.print_help()\n elif method == 'get':\n print \"updating webclip settings for %s...\\n\" % (username)\n print self.client.UpdateWebclip(username=username, \n enable=not(options.disable))\n else:\n print \"deleting webclip settings isn't supported\"\n elif setting == 'delegation':\n if method == 'get':\n print \"getting email delegates for %s...\" % (username)\n print self.client.RetrieveEmailDelegates(username=username)\n elif method == 'set':\n address = args['delegationId']\n print \"adding %s as an email delegate to %s...\" % (address, username)\n print self.client.AddEmailDelegate(username=username, address=address)\n else:\n address = args['delegationId']\n print \"deleting %s as an email delegate for %s...\" % (address, username)\n print self.client.DeleteEmailDelegate(username=username, \n address=address)\n else:\n parser.print_help()"],"string":"[\n \"def _call_command_method(self, name, original_method, args, kwargs):\\n if threadprop.current_controller() is not self:\\n action=self._direct_comm_call_action\\n if action==\\\"warning\\\":\\n if name not in self._command_warned:\\n print(\\\"Warning: direct call of command '{}' of thread '{}' from a different thread '{}'\\\".format(\\n name,self.name,threadprop.current_controller().name),file=sys.stderr)\\n self._command_warned.add(name)\\n else:\\n accessor=QMultiRepeatingThreadController.__getattribute__(self,action)\\n return accessor.__getattr__(name)(*args,**kwargs)\\n return original_method(*args,**kwargs)\",\n \"def command(self, name, method_name=None, **kwargs):\\n return self._command(name, method_name=method_name, **kwargs)\",\n \"def _remote_call(self,\\n method_name,\\n target='Widget',\\n args=None,\\n kwargs=None):\\n args = [] if args is None else args\\n kwargs = {} if kwargs is None else kwargs\\n\\n msg = {}\\n\\n if 'component_index' in kwargs:\\n msg['component_index'] = kwargs.pop('component_index')\\n if 'repr_index' in kwargs:\\n msg['repr_index'] = kwargs.pop('repr_index')\\n\\n msg['target'] = target\\n msg['type'] = 'call_method'\\n msg['methodName'] = method_name\\n msg['args'] = args\\n msg['kwargs'] = kwargs\\n\\n def callback(widget, msg=msg):\\n widget.send(msg)\\n\\n callback._method_name = method_name\\n callback._ngl_msg = msg\\n\\n if self.loaded:\\n self._remote_call_thread.q.append(callback)\\n else:\\n # send later\\n # all callbacks will be called right after widget is loaded\\n self._ngl_displayed_callbacks_before_loaded.append(callback)\\n\\n if callback._method_name not in _EXCLUDED_CALLBACK_AFTER_FIRING:\\n self._ngl_displayed_callbacks_after_loaded.append(callback)\",\n \"def callRemote(self, methname, *args, **kwargs):\\n try:\\n schema = self._referenceable.getInterface()[methname]\\n if self.check_args:\\n schema.checkAllArgs(args, kwargs, inbound=True)\\n _check_copyables(list(args) + kwargs.values())\\n result = self._referenceable.doRemoteCall(\\n methname,\\n args,\\n kwargs,\\n )\\n schema.checkResults(result, inbound=False)\\n _check_copyables([result])\\n return succeed(result)\\n except:\\n return fail()\",\n \"def _override_command_method(self, name):\\n method=getattr(self,name,None)\\n if method is not None:\\n @func_utils.getargsfrom(method)\\n def new_method(*args, **kwargs):\\n return self._call_command_method(name,method,args,kwargs)\\n setattr(self,name,new_method)\",\n \"def callRemote(self, methname, *args, **kwargs):\\n schema = self._referenceable.getInterface()[methname]\\n if self.check_args:\\n schema.checkAllArgs(args, kwargs, inbound=False)\\n # TODO: Figure out how to call checkResults on the result.\\n return execute(\\n self._referenceable.doRemoteCall,\\n methname,\\n args,\\n kwargs,\\n )\",\n \"def _call(self, rpc_method_name, *args, **kwargs):\\n method = getattr(self, rpc_method_name)\\n return method(*args, **kwargs)\",\n \"def call(self, method, *args, **kwargs):\\n if method in self.handlers:\\n handler = self.handlers[method]\\n if self.single_server:\\n self.send_request(self.single_server, method, handler, *args, **kwargs)\\n else:\\n if method in [\\\"completion\\\", \\\"completion_item_resolve\\\", \\\"diagnostics\\\", \\\"code_action\\\", \\\"execute_command\\\"]:\\n method_server_names = self.multi_servers_info[method]\\n else:\\n method_server_names = [self.multi_servers_info[method]]\\n\\n for method_server_name in method_server_names:\\n method_server = self.multi_servers[method_server_name]\\n self.send_request(method_server, method, handler, *args, **kwargs)\\n elif hasattr(self, method):\\n getattr(self, method)(*args, **kwargs)\",\n \"def execute(self, methodname, *args):\\n if not methodname in self.methods:\\n raise BlogError(BlogError.METHOD_NOT_SUPPORTED)\\n\\n try:\\n r = getattr(self.server, methodname)(args)\\n except xmlrpclib.Fault, fault:\\n raise BlogError(fault.faultString)\\n\\n return r\",\n \"def export_callProxyMethod( self, name, args, kargs ):\\n res = pythonCall( 120, self.__proxyWrapper, name, args, kargs )\\n if res['OK']:\\n return res['Value']\\n else:\\n return res\",\n \"def callRemote(self, name, *args, **kw):\\n if hasattr(self, 'sync_'+name):\\n return getattr(self, 'sync_'+name)(*args, **kw)\\n try:\\n method = getattr(self, \\\"async_\\\" + name)\\n return defer.succeed(method(*args, **kw))\\n except:\\n f = Failure()\\n if self.reportAllTracebacks:\\n f.printTraceback()\\n return defer.fail(f)\",\n \"def _call_method(self, module, method, *args, **kwargs):\\n return self.invoke_api(module, method, *args, **kwargs)\",\n \"def custom_command(self, name, method_name=None, **kwargs):\\n return self._command(name, method_name=method_name, custom_command=True, **kwargs)\",\n \"def callmethod(\\n self, method: str, *args: Sequence[Any], **kwargs: Sequence[Any]\\n ) -> List[Any]:\\n return getattr(self, method)(*args, **kwargs)\",\n \"def call_command(self, name, args):\\n try:\\n cmd = self.commands[name]\\n except KeyError:\\n self.answer(\\\"Unknown command\\\", success=False)\\n else:\\n try:\\n result, success = cmd(*args)\\n result = result or \\\"\\\"\\n self.answer(result, success=success)\\n except TypeError as e:\\n self.answer(\\n \\\"Error when calling function: {}\\\".format(e),\\n success=False,\\n )\",\n \"def _call_method(self, module, method, *args, **kwargs):\\n if not self._is_vim_object(module):\\n return self.invoke_api(module, method, self.vim, *args, **kwargs)\\n else:\\n return self.invoke_api(module, method, *args, **kwargs)\",\n \"def call_method(self, name, method, params):\\n self.logger.debug(\\\"API call: {}.{}({})\\\".format(name, method, params))\\n if name in self.systems:\\n obj = self.systems[name]\\n if is_api_method(obj, method):\\n try:\\n # Calls given obj.method, unpacking and passing params dict\\n call_return = getattr(obj, method)(**params)\\n msg = \\\"Called {}.{}\\\".format(name, method)\\n self.logger.debug(msg + \\\",returned:{}\\\".format(call_return))\\n return msgs.call_reply(msg, call_return)\\n except TypeError:\\n # Raised when we have a mismatch of the method's kwargs\\n # TODO: Return argspec here?\\n err_msg = \\\"Invalid params for {}.{}\\\".format(name, method)\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\\n except Exception as e:\\n # Catch exception raised by called method, notify client\\n err_msg = \\\"Exception: '{}'\\\".format(str(e))\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\\n else:\\n err_msg = \\\"Invalid method: '{}.{}'\\\".format(name, method)\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\\n else:\\n err_msg = \\\"Invalid object: '{}'\\\".format(name)\\n self.logger.warning(err_msg)\\n return msgs.error(err_msg)\",\n \"def _method_call(self, msg):\\n #print(\\\"Performing service: %s, method_name: %s\\\" % (msg.service_name, msg.method_name))\\n service = self._services.get(msg.service_name)\\n if service is None:\\n raise MessageHandleError(MessageHandleError.RESULT_UNKNOWN_SERVICE, msg)\\n\\n try:\\n return execute_remote_method_call(service, msg.method_name, *msg.pargs, **msg.kwargs)\\n #return service.call(msg.method_name, *msg.pargs, **msg.kwargs)\\n except MessageHandleError as error:\\n error.original_message = msg\\n raise error\",\n \"def call_thread_method(self, name, *args, **kwargs):\\n return self._thread_methods[name](*args,**kwargs)\",\n \"def _platformix_call(self, context, fake_reply, method, *args, **kwargs):\\r\\n if hasattr(self.host, method):\\r\\n if not callable(getattr(self.host, method)):\\r\\n self._reply(context, proto_failure(\\\"Attribute {} of {} is a property\\\".format(\\r\\n property, self.host.name)), fake_reply)\\r\\n return\\r\\n try:\\r\\n result = getattr(self.host, method)(*args, **kwargs)\\r\\n except Exception as e:\\r\\n eprint(\\\"Platformix protocol: failed to call method {} of {} with args {}, kwargs {} \\\"\\r\\n \\\"due to exception {}\\\".format(method, self.host.name, args, kwargs, e))\\r\\n exprint()\\r\\n self._reply(context, proto_failure(\\r\\n \\\"Failed to call method {} of {} with args {}, kwargs {} \\\"\\r\\n \\\"due to exception {}\\\".format(method, self.host.name, args, kwargs, e)), fake_reply)\\r\\n return\\r\\n self._reply(context, proto_success(result), fake_reply)\\r\\n else:\\r\\n self._reply(context, proto_failure(\\\"Method {} not found on {}\\\".format(property, self.host.name)),\\r\\n fake_reply)\",\n \"def __call__(self, method, *args, **kwargs):\\n if hasattr(self, 'channel'):\\n kwargs.setdefault('channel', self.channel)\\n resp = self._client.api_call(method, *args, **kwargs)\\n if not resp['ok']:\\n print unicode(resp)\\n raise RuntimeError(resp.get('error', unicode(resp)))\\n return resp\",\n \"def exec_method(self, module_name, version=None, client_class=None,\\n method_name=None, *args, **kwargs):\\n client_class = client_class or 'Client'\\n client_version = version or 2\\n _client = self.create_client(module_name, client_version,\\n client_class)\\n try:\\n # NOTE(kiennt): method_name could be a combination\\n # for example 'servers.list'. Here is the\\n # workaround.\\n method = getattr(_client, method_name.split('.')[0])\\n for attr in method_name.split('.')[1:]:\\n method = getattr(method, attr)\\n return method(*args, **kwargs)\\n except Exception as err:\\n raise err\",\n \"def allow_remote_invocation(func, method='auto'):\\r\\n setattr(func, 'allow_rmi', method)\\r\\n return func\",\n \"def call(self, name, *args, **kwargs):\\r\\n return self.client.call(self.name, name, *args, **kwargs)\",\n \"def call(self, method=None, args=[]):\\n\\n client = xmlclient.ServerProxy(uri=self.api_endpoint, encoding='utf-8',\\n allow_none=True)\\n response = getattr(client, method)(self.username, self.password, *args)\\n if response == 'OK':\\n return True\\n elif 'AUTH_ERROR' in response:\\n raise AuthError()\\n elif response == 'DOMAIN_OCCUPIED':\\n raise DomainOccupiedError()\\n elif response == 'RATE_LIMITED':\\n raise RateLimitedError()\\n elif response == 'BAD_INDATA':\\n raise BadInDataError()\\n elif response == 'UNKNOWN_ERROR':\\n raise UnknownError()\\n else:\\n return response\",\n \"def call_command_direct(self, name, args=None, kwargs=None):\\n comm,_=self._commands[name]\\n return comm(*(args or []),**(kwargs or {}))\",\n \"def call(self, method, *args):\\n flatcall = flatten(\\n m(n=method, t=self.groupName)[[\\n squish(x) for x in args if x is not None]])\\n self.socket.write(flatcall + '\\\\0')\",\n \"def __call__(self, method=None):\\n\\n if method is None:\\n action = self.method\\n else:\\n action = method\\n\\n if action == Du.WALK_METHOD:\\n return self._du_using_walk()\\n elif action == Du.RECURSION_METHOD:\\n return self._du_using_recursion()\\n elif action == Du.QUEUE_METHOD:\\n return self._du_using_list()\\n elif action == Du.SUBPROCESSES_METHOD:\\n return self._du_using_subprocesses()\\n\\n raise InvalidDuMethodError(\\n 'InvalidDuMethodError: This method doesn\\\\'t exist!'\\n )\",\n \"def call(self, obj_name, method_name, param_dict=dict()):\\n result = self.ctrl_client.call(obj_name, method_name, param_dict)\\n if result['type'] == 'error':\\n self.logger.error(\\\"API call error: {}\\\".format(result['msg']))\\n return None\\n else:\\n return result['call_return']\",\n \"def call(self, method, name, params=None, payload=None, **kwds):\",\n \"def send_method_call(self, service_name, method_name, *pargs, **kwargs):\\n msg = MethodCallMessage(service_name=service_name, method_name=method_name, pargs=pargs, kwargs=kwargs)\\n return self.send_message_blocking(msg)\",\n \"def execute_method(self, method, params):\\n args, varargs, varkw, defaults = getargspec(method)\\n if varargs or varkw:\\n raise InvalidParamsError(\\n \\\"Service method definition must not have variable parameters\\\")\\n args_set = set(args[1:])\\n if params is None:\\n if not len(args_set) == 0:\\n raise InvalidParamsError(\\n \\\"Wrong number of parameters; \\\"\\n \\\"expected %i but 'params' was omitted \\\"\\n \\\"from JSON-RPC message\\\" % (len(args_set)))\\n return method()\\n elif isinstance(params, (list, tuple)):\\n if not len(args_set) == len(params):\\n raise InvalidParamsError(\\n \\\"Wrong number of parameters; \\\"\\n \\\"expected %i got %i\\\" % (len(args_set),len(params)))\\n return method(*params)\\n elif isinstance(params, dict):\\n paramset = set(params)\\n if not args_set == paramset:\\n raise InvalidParamsError(\\n \\\"Named parameters do not \\\"\\n \\\"match method; expected %s\\\" % (str(args_set)))\\n params = self.decode_dict_keys(params)\\n return method(**params)\",\n \"def env_method(self, method_name, *method_args, indices=None, **method_kwargs):\\n target_remotes = self._get_target_remotes(indices)\\n for remote in target_remotes:\\n remote.send(('env_method', (method_name, method_args, method_kwargs)))\\n return [remote.recv() for remote in target_remotes]\",\n \"def call(self, port, method, *args, **kwargs):\\n method = self.provides[port][method]\\n return method(*args, **kwargs)\",\n \"def setup_method(self, method):\\r\\n self.cf = self.config = saunter.ConfigWrapper.ConfigWrapper()\\r\\n\\r\\n self.current_method_name = method.__name__\\r\\n\\r\\n browser = self.cf[\\\"browsers\\\"][self.cf[\\\"saunter\\\"][\\\"default_browser\\\"]]\\r\\n if browser[\\\"type\\\"][0] == \\\"*\\\":\\r\\n browser = browser[\\\"type\\\"] = browser[\\\"type\\\"][1:]\\r\\n\\r\\n profile = None\\r\\n if browser[\\\"type\\\"] == 'firefox':\\r\\n if browser[\\\"profiles\\\"][sys.platform]:\\r\\n profile_path = os.path.join(self.cf[\\\"saunter\\\"][\\\"base\\\"], 'support', 'profiles', browser[\\\"profiles\\\"][sys.platform])\\r\\n elif browser[\\\"profiles\\\"][\\\"profile\\\"]:\\r\\n profile_path = os.path.join(self.cf[\\\"saunter\\\"][\\\"base\\\"], 'support', 'profiles', browser[\\\"profiles\\\"][\\\"profile\\\"])\\r\\n else:\\r\\n profile_path = None\\r\\n\\r\\n if profile_path:\\r\\n if os.path.isdir(profile_path):\\r\\n profile = FirefoxProfile(profile_path)\\r\\n else:\\r\\n raise ProfileNotFound(\\\"Profile not found at %s\\\" % profile_path)\\r\\n\\r\\n if \\\"saucelabs\\\" in browser and browser[\\\"saucelabs\\\"][\\\"ondemand\\\"]:\\r\\n desired_capabilities = {\\r\\n \\\"platform\\\": self.cf[\\\"sauceLabs\\\"][\\\"os\\\"],\\r\\n \\\"browserName\\\": self.cf[\\\"sauceLabs\\\"][\\\"browser\\\"],\\r\\n \\\"version\\\": self.cf.get(\\\"SauceLabs\\\", \\\"browser_version\\\"),\\r\\n \\\"name\\\": method.__name__\\r\\n }\\r\\n if desired_capabilities[\\\"browserName\\\"][0] == \\\"*\\\":\\r\\n desired_capabilities[\\\"browserName\\\"] = desired_capabilities[\\\"browserName\\\"][1:]\\r\\n if desired_capabilities[\\\"platform\\\"] in os_map:\\r\\n desired_capabilities[\\\"platform\\\"] = os_map[desired_capabilities[\\\"platform\\\"]]\\r\\n\\r\\n if self.cf.has_option(\\\"SauceLabs\\\", \\\"selenium_version\\\"):\\r\\n desired_capabilities['selenium-version'] = self.cf.get('SauceLabs', 'selenium_version')\\r\\n\\r\\n command_executor = \\\"http://%s:%s@ondemand.saucelabs.com:80/wd/hub\\\" % (self.cf.get(\\\"SauceLabs\\\", \\\"username\\\"), self.cf.get(\\\"SauceLabs\\\", \\\"key\\\"))\\r\\n else:\\r\\n desired_capabilities = capabilities_map[browser[\\\"type\\\"]]\\r\\n\\r\\n if browser[\\\"proxy\\\"][\\\"type\\\"] and browser[\\\"proxy\\\"][\\\"type\\\"].lower() == \\\"browsermob\\\":\\r\\n from browsermobproxy import Client\\r\\n self.client = Client(self.cf.get(\\\"Proxy\\\", \\\"proxy_url\\\"))\\r\\n self.client.add_to_webdriver_capabilities(desired_capabilities)\\r\\n\\r\\n if \\\"is grid\\\" in self.cf[\\\"selenium\\\"] and self.cf[\\\"selenium\\\"][\\\"executor\\\"][\\\"is grid\\\"]:\\r\\n if browser[\\\"grid filters\\\"][\\\"platform\\\"]:\\r\\n desired_capabilities[\\\"platform\\\"] = browser[\\\"grid filters\\\"][\\\"platform\\\"].upper()\\r\\n if browser[\\\"grid filters\\\"][\\\"version\\\"]:\\r\\n desired_capabilities[\\\"platform\\\"] = str(browser[\\\"grid filters\\\"][\\\"version\\\"])\\r\\n\\r\\n command_executor = \\\"http://%s:%s/wd/hub\\\" % (self.cf[\\\"selenium\\\"][\\\"executor\\\"][\\\"host\\\"], self.cf[\\\"selenium\\\"][\\\"executor\\\"][\\\"port\\\"])\\r\\n\\r\\n self.driver = WebDriver(desired_capabilities=desired_capabilities, command_executor=command_executor, browser_profile=profile)\\r\\n\\r\\n self.verificationErrors = []\\r\\n self.matchers = Matchers(self.driver, self.verificationErrors)\\r\\n\\r\\n if \\\"saucelabs\\\" in self.cf[\\\"browsers\\\"][self.cf[\\\"saunter\\\"][\\\"default_browser\\\"]] and self.cf[\\\"browsers\\\"][self.cf[\\\"saunter\\\"][\\\"default_browser\\\"]][\\\"saucelabs\\\"][\\\"ondemand\\\"]:\\r\\n self.sauce_session = self.driver.session_id\\r\\n\\r\\n self._screenshot_number = 1\",\n \"def __getattr__(self, method):\\n def run_callback(func, plus, result):\\n \\\"\\\"\\\"Execute the given callback safely.\\n Get data and/or error from result and call func passing it\\n data, plus (if needed) and error. Catch, log and suppress\\n all exceptions.\\n func (function): the callback to invoke.\\n plus (object): optional additional data.\\n result (AsyncResult): the result of a (finished) RPC call.\\n \\\"\\\"\\\"\\n data = result.value\\n error = None if result.successful() else \\\"%s\\\" % result.exception\\n try:\\n if plus is None:\\n func(data, error=error)\\n else:\\n func(data, plus, error=error)\\n except Exception as error:\\n logger.error(\\\"RPC callback for %s.%s raised exception.\\\",\\n self.remote_service_coord.name, method,\\n exc_info=True)\\n\\n def remote_method(**data):\\n \\\"\\\"\\\"Forward arguments to execute_rpc.\\n \\\"\\\"\\\"\\n callback = data.pop(\\\"callback\\\", None)\\n plus = data.pop(\\\"plus\\\", None)\\n result = self.execute_rpc(method=method, data=data)\\n if callback is not None:\\n callback = functools.partial(run_callback, callback, plus)\\n result.rawlink(functools.partial(gevent.spawn, callback))\\n return result\\n\\n return remote_method\",\n \"def _multiproc_execute(obj, method, args):# pragma: no cover\\n #We don't cover this because it won't necessarily be caught be the coverage\\n #program that is running on the main thread; it may only execute on other\\n #threads.\\n if hasattr(obj, method):\\n return getattr(obj, method)(*args)\",\n \"def _call_qc_method(self, method_name, *args, **kwargs):\\n qc_method = getattr(self._query_compiler, f\\\"rolling_{method_name}\\\")\\n return qc_method(self.axis, self.rolling_kwargs, *args, **kwargs)\",\n \"def __call__(self, *args, **kwargs):\\n return self.method(*args, **kwargs)\",\n \"def call_method(self, method_name: str, timeout=None, **params) -> dict:\\n timeout = timeout or self.timeout\\n request_id = uuid.uuid4().hex\\n data = {'@type': method_name,\\n '@extra': {'request_id': request_id}}\\n data.update(params)\\n self._tdjson_client.send(data)\\n\\n result = self._wait_result(request_id, timeout)\\n return result\",\n \"def __getattr__(self, method: str):\\n @exception_handler\\n def func(*args, **kwargs):\\n return self._client.PyCall(method, list(args), kwargs,\\n self._wait_for_ready, self._call_timeout,\\n self._compress)\\n\\n setattr(self, method, func)\\n return func\",\n \"def __getattr__(self, method_name):\\n return partial(self.exec, method_name.replace(\\\"_\\\", \\\" \\\"))\",\n \"def _execute_impl(self, *args, **kwargs):\\n # Execute with bound args.\\n method_body = getattr(self._deployment_node, self._deployment_method_name)\\n return method_body.remote(\\n *self._bound_args,\\n **self._bound_kwargs,\\n )\",\n \"def env_method(self, method_name, *method_args, **method_kwargs):\\n for pipe in self.remotes:\\n pipe.send(('env_method', (method_name, method_args, method_kwargs)))\\n return [remote.recv() for remote in self.remotes]\",\n \"def servicemethod(*args, **kwargs):\\n # Default options\\n options = {'name': None, 'store': None, 'request_arg': True, 'store_arg': True}\\n\\n # Figure out if we were called with arguments\\n # If we were called with args, ie:\\n # @servicemethod(name='Foo')\\n # Then the only argument here will be the pre-decorated function/method object.\\n method = ( (len(args) == 1) and callable(args[0]) ) and args[0] or None\\n\\n if method is None:\\n # We were called with args, (or @servicemethod() )\\n # so figure out what they were ...\\n\\n # The method name should be either the first non-kwarg\\n # or the kwarg 'name'\\n # Example: @servicemethod('my_method', ...) or @servicemethod(name='my_method')\\n options.update({\\n 'name': bool(args) and args[0] or kwargs.pop('name', None),\\n 'store': (len(args) >= 2) and args[1] or kwargs.pop('store', None),\\n 'request_arg': kwargs.pop('request_arg', True),\\n 'store_arg': kwargs.pop('store_arg', True),\\n })\\n else:\\n options['name'] = method.__name__\\n method.__servicemethod__ = options\\n\\n def method_with_args_wrapper(method):\\n \\\"\\\"\\\" Wrapper for a method decorated with decorator arguments\\n \\\"\\\"\\\"\\n if options['name'] is None:\\n options['name'] = method.__name__\\n method.__servicemethod__ = options\\n\\n if options['store'] is not None:\\n options['store'].service.add_method(method)\\n\\n return method\\n\\n return method or method_with_args_wrapper\",\n \"def method(self,methodname):\\n\\t\\tif methodname in self.methods:\\n\\t\\t\\treturn self.methods[methodname]\\n\\t\\treturn None\",\n \"def methodHelp(self, name):\\r\\n methods = self._listMethods()\\r\\n for methodname in methods.keys():\\r\\n if methodname == name:\\r\\n return methods[methodname]\\r\\n raise RPCError(Faults.SIGNATURE_UNSUPPORTED)\",\n \"def execute_method_for_keyword(self):\\n\\n kwargs, kw_status = self.get_argument_as_keywords()\\n print_info(\\\"The Arguments passed for the current Step is: '{0}'\\\".format(kwargs))\\n if kw_status:\\n # Execute the corresponding method\\n method_loader = self.exec_obj.im_class()\\n try:\\n keyword_result = self.exec_obj(method_loader, **kwargs)\\n except Exception as exception:\\n trcback = print_exception(exception)\\n keyword_result = (\\\"EXCEPTION\\\", trcback)\\n\\n self.data_repository = self.update_data_repository(self.keyword,\\n keyword_result,\\n self.data_repository)\\n return self.data_repository\",\n \"def wrap(*args):\\n # If this class has a method callback registered, then\\n # make sure we call the callback. Otherwise, just pass\\n # the call through to the true ROS master server\\n try:\\n callback = \\\"_%s\\\" % method\\n if hasattr(self, callback):\\n callbackFn = getattr(self, callback)\\n callbackFn(*args)\\n except Exception, e:\\n import traceback\\n traceback.print_exc()\\n\\n # Pass the call through to the ROS master\\n masterFn = getattr(self.__client, method)\\n return masterFn(*args)\",\n \"def run(self, command, *args):\\n command = command.lower()\\n\\n if callable(getattr(self, command, None)):\\n getattr(self, command)(*args)\\n return\\n\\n send.error_message(\\\"Command '{}' not found\\\".format(command))\",\n \"def __call__(self, args, kwargs):\\n im_self = self._im_self_ref()\\n if im_self is not None:\\n method = MethodType(self._im_func, im_self, self._im_class)\\n method(*args, **kwargs)\",\n \"def _call(self, args):\\n a = args.split(' ', 1)\\n if a:\\n getattr(self, a[0])(*a[1:])\",\n \"def method_with_args_wrapper(method):\\n if options['name'] is None:\\n options['name'] = method.__name__\\n method.__servicemethod__ = options\\n\\n if options['store'] is not None:\\n options['store'].service.add_method(method)\\n\\n return method\",\n \"def test_basic_method_call_wrapper():\\n my_method = SGMethod(\\\"test\\\")\\n other_method = SGMethod(\\\"other\\\")\\n \\n my_method.calls(other_method)\\n my_method.check_call_validity();\\n \\n assert other_method == my_method.method_called\\n assert len(my_method.args) == 0\",\n \"def env_method(self, method_name: str, *method_args, indices: VecEnvIndices = None, **method_kwargs) -> List[Any]:\\n raise NotImplementedError()\",\n \"def\\trunMethod(self, name = \\\"__default\\\", prms = {}):\\n\\n\\t\\tprms = self.CSLBuildPrmList(prms)\\n\\t\\tlocalTbl = { 'vars':{}, 'status':0, 'props':{}, 'alias':{}, 'persistent':{}, 'instance':{}}\\n\\n\\t\\tres = self.callMethod(name, prms, localTbl)\\n\\n\\t\\tif localTbl[\\\"status\\\"] == 2:\\n\\t\\t\\treturn self.COMARValue.COMARRetVal(1, None)\\n\\t\\telse:\\t\\t\\t\\n\\t\\t\\tret = self.CSLtoCOMARValue(res)\\n\\t\\t\\tself.debug(DEBUG_FATAL, \\\"RETS:\\\", res, '(%s)->' % (res.type), ret)\\n\\t\\t\\treturn self.COMARValue.COMARRetVal(0, ret)\",\n \"def RunNamedCommand(self, command_name, args=None, headers=None, debug=0,\\n parallel_operations=False, test_method=None,\\n bypass_prodaccess=True):\\n if not args:\\n args = []\\n\\n # Include api_version header in all commands.\\n api_version = boto.config.get_value('GSUtil', 'default_api_version', '1')\\n if not headers:\\n headers = {}\\n headers['x-goog-api-version'] = api_version\\n\\n if command_name not in self.command_map:\\n raise CommandException('Invalid command \\\"%s\\\".' % command_name)\\n command_class = self.command_map[command_name]\\n command_inst = command_class(self, args, headers, debug,\\n parallel_operations, self.gsutil_bin_dir,\\n self.boto_lib_dir, self.config_file_list,\\n self.gsutil_ver, self.bucket_storage_uri_class,\\n test_method, bypass_prodaccess)\\n return command_inst.RunCommand()\",\n \"def calls(self, method, args=None):\\n if self.method_called != None:\\n logger.error('Model Error: Changing method called by %s', self.name)\\n assert False\\n self.method_called = method\\n self.args = list()\\n \\n for arg in args:\\n if not isinstance(arg, SGParameter):\\n self.args.append(arg)\\n else:\\n self.args.append(self.get_parameter(arg.name))\",\n \"def test_method_selection(self, method):\\n wsgi._retryable(method, 'http://some.thing')\\n\\n getattr(self.session, method).assert_called_once_with(\\n 'http://some.thing'\\n )\",\n \"def make_call(self, method, _):\\n raise CallNotFound('{}.{} does not exist'.format(self.service_name,\\n method))\",\n \"def get_method(self, name):\\n try:\\n return self.methods[name]\\n except KeyError:\\n raise ServiceException('Service method \\\"%s\\\" not registered' % name)\",\n \"def _trace_call(self, method: module_utils._FunctionWrapper, method_name: str):\\n\\n def call(*args, **kwargs):\\n # Pop manually specified tolerances from the kwargs (if any).\\n tolerances = {}\\n tolerances[\\\"rtol\\\"] = kwargs.pop(\\\"rtol\\\", None)\\n tolerances[\\\"atol\\\"] = kwargs.pop(\\\"atol\\\", None)\\n # Only pass these to ModuleCall if they were specified by the user.\\n tolerances = {k: v for k, v in tolerances.items() if v is not None}\\n\\n # Ensure the inputs are numpy inputs.\\n args = tf_utils.convert_to_numpy(args)\\n kwargs = tf_utils.convert_to_numpy(kwargs)\\n\\n # Run the method and record the details of the call.\\n outputs = method(*args, **kwargs)\\n serialized_inputs, serialized_outputs = method.get_serialized_values()\\n self._trace.calls.append(\\n ModuleCall(\\n method_name,\\n args,\\n outputs,\\n serialized_inputs,\\n serialized_outputs,\\n **tolerances,\\n )\\n )\\n return outputs\\n\\n return call\",\n \"def call_method(self, action):\\n\\n\\t\\tif action[0] in self.methods:\\n\\t\\t\\tself.methods[action[0]](action[0:])\\n\\t\\telse:\\n\\t\\t\\tself.no_such_method()\",\n \"def __executeOperation( self, url, method ):\\n fcn = None\\n if hasattr( self, method ) and callable( getattr( self, method ) ):\\n fcn = getattr( self, method )\\n if not fcn:\\n return S_ERROR( \\\"Unable to invoke %s, it isn't a member function of DIPStorage\\\" % method )\\n\\n res = fcn( url )\\n if not res['OK']:\\n return res\\n elif url not in res['Value']['Successful']:\\n return S_ERROR( res['Value']['Failed'][url] )\\n\\n return S_OK( res['Value']['Successful'][url] )\",\n \"def _wrapped_method(self, _meth_name, *args, **kwargs):\\n return self._delegate(_meth_name, *args, **kwargs)\",\n \"def call(self, source, method, *args):\\n\\n function = self.callable(method)\\n function.source = source\\n return function(*args)\",\n \"def _call_method(self, call, method):\\n raise Exception(\\\"_call_method must be implemented by subclasses.\\\")\",\n \"def _call(self, name, *args, **kwargs):\\r\\n if len(args) and len(kwargs):\\r\\n raise TypeError(\\r\\n 'Use positional or keyword argument only.'\\r\\n )\\r\\n\\r\\n callinfo = getattr(self, name).callinfo\\r\\n soapAction = callinfo.soapAction\\r\\n url = callinfo.location\\r\\n (protocol, host, uri, query, fragment, identifier) = urlparse(url)\\r\\n port = '80'\\r\\n if host.find(':') >= 0:\\r\\n host, port = host.split(':')\\r\\n\\r\\n binding = Binding(host=host, tracefile=self._tracefile,\\r\\n ssl=(protocol == 'https'),\\r\\n port=port, url=None, typesmodule=self._typesmodule,\\r\\n nsdict=self._nsdict, soapaction=self._soapAction,\\r\\n ns=self._ns, op_ns=self._op_ns)\\r\\n\\r\\n if self._use_wsdl:\\r\\n request, response = self._getTypeCodes(callinfo)\\r\\n if len(kwargs): args = kwargs\\r\\n if request is None:\\r\\n request = Any(oname=name)\\r\\n binding.Send(url=uri, opname=None, obj=args,\\r\\n nsdict=self._nsdict, soapaction=soapAction, requesttypecode=request)\\r\\n return binding.Receive(replytype=response)\\r\\n\\r\\n apply(getattr(binding, callinfo.methodName), args)\\r\\n\\r\\n return binding.Receive()\",\n \"def check_and_run_arguments(self, method_name = \\\"\\\", argument_list = [] ):\\n\\t\\tcomplicate_argument_list = []\\n\\t\\tdir_list = dir(self)\\n\\t\\tif method_name not in dir_list:\\n\\t\\t\\tprint( f\\\"EasygoParser only has these methods: {dir_list}\\\" )\\n\\t\\t\\treturn False\\n\\t\\tif method_name in complicate_argument_list and -1 == argument_list[0].find( \\\"filename=\\\" ):\\n\\t\\t\\tprint( f\\\"Method {method_name} of EasygoParser needs complicate arguments and can ONLY read arguments from a file\\\" )\\n\\n\\t\\targuments_dict = {}\\n\\t\\tif -1 < argument_list[0].find( \\\"filename=\\\" ):\\n\\t\\t\\tfilename_list = argument_list[0].split(\\\"=\\\")\\n\\t\\t\\tif 2 != len( filename_list ):\\n\\t\\t\\t\\tprint( f\\\"use filename=xxxx to let this script understand the argument file name\\\" )\\n\\t\\t\\t\\treturn False\\n\\t\\t\\targuments_dict = self.read_argument_file( filename = filename_list[1], method_name = method_name )\\n\\t\\t\\tif 1 > len( arguments_dict ):\\n\\t\\t\\t\\tprint( f\\\"Warning! There is no argument in file {filename_list[1]}\\\" )\\n\\t\\telse:\\n\\t\\t\\tfor one in argument_list:\\n\\t\\t\\t\\tif -1 == one.find( \\\"=\\\" ):\\n\\t\\t\\t\\t\\tprint( f\\\"argument {one} needs = to separate key and value\\\" )\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t\\ttemp_list = one.split(\\\"=\\\")\\n\\t\\t\\t\\tif 2 != len( temp_list ):\\n\\t\\t\\t\\t\\tprint( f\\\"argument {one} needs ONLY one = to separate key and value\\\" )\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t\\t\\targuments_dict[ temp_list[0] ] = temp_list[1]\\n\\t\\tmethodcaller( method_name, **arguments_dict )(self)\\n\\t\\t# https://blog.csdn.net/pythondafahao/article/details/79616294\\n\\t\\t# https://blog.csdn.net/chenjinyu_tang/article/details/8136841\\n\\t\\t# https://www.cnblogs.com/2bjiujiu/p/7289961.html\\n\\t\\t# https://docs.python.org/3/library/operator.html\\n\\t\\t# https://python3-cookbook.readthedocs.io/zh_CN/latest/c08/p20_call_method_on_object_by_string_name.html\\n\\t\\t# https://blog.csdn.net/mrqingyu/article/details/84403924\\n\\t\\t# https://stackoverflow.com/questions/3061/calling-a-function-of-a-module-by-using-its-name-a-string\",\n \"def _traverse_command(self, name, *args, **kwargs):\\n # TODO: implement instance level cache\\n if not name in self.available_commands:\\n raise AttributeError(\\\"%s is not an available command for %s\\\" % (name, self.__class__.__name__))\\n attr = getattr(self.connection, \\\"%s\\\" % name)\\n key = self.key\\n log.debug(u\\\"Requesting %s with key %s and args %s\\\" % (name, key, args))\\n result = attr(key, *args, **kwargs)\\n result = self.post_command(\\n sender=self,\\n name=name,\\n result=result,\\n args=args,\\n kwargs=kwargs\\n )\\n return result\",\n \"def call(self, name: str, *args, **kwargs) -> List[Any]:\\n self.call_async(name, *args, **kwargs)\\n return self.call_wait()\",\n \"def callRemote(self, _name, *args, **kw):\\r\\n if self.__failure is not None:\\r\\n d = fail(self.__failure)\\r\\n elif self.__pending is not None:\\r\\n d = Deferred()\\r\\n self.__pending.append(d)\\r\\n else:\\r\\n d = succeed(self.__obj)\\r\\n\\r\\n d.addCallback(lambda ref: ref.callRemote(_name, *args, **kw))\\r\\n d.addErrback(self.__filter, _name)\\r\\n return d\",\n \"def execute_method(method, kwargs):\\n for k, v in kwargs.items():\\n kwargs[k] = deserialise(v)\\n\\n # Find any parameters which are not in the method signature and throw them away.\\n invalid_kwargs=[]\\n for kwarg in kwargs:\\n if kwarg not in method.__code__.co_varnames:\\n LOG.warning(\\\"WARNING: Parameter '%s' is not in the method signature of '%s'\\\", kwarg, method.__name__)\\n invalid_kwargs.append(kwarg)\\n # Remove invalid arguments (avoiding mutating the dictionary while iterating).\\n for invalid_kwarg in invalid_kwargs:\\n kwargs.pop(invalid_kwarg)\\n\\n # Call SDK method\\n try:\\n method_result = method(**kwargs)\\n except ApiErrorResponse as api_error:\\n if api_error.status_code == 404:\\n result = {}\\n else:\\n # Anything other than a 404 re-raise the exception\\n raise\\n else:\\n if isinstance(method_result, pagination.PaginatedResponse):\\n result = dict(payload=method_result.data)\\n else:\\n result = dict(payload=method_result)\\n\\n return json.dumps(result, default=serialise_entity)\",\n \"def run(self, **kwargs):\\n\\n if self.specified_method == '':\\n return {'response': \\\"<br>No command specified\\\"}\\n else:\\n found = False\\n\\n for command in Command.commands_list:\\n if command.name == self.specified_method:\\n found = True\\n if '--help' in self.params:\\n # Return help text for the command\\n return {'response': command.help_text}\\n else:\\n # Run the action function of the command\\n return command.action(self.request, self.params, **kwargs)\\n\\n if not found:\\n # If invalid command\\n return {'response': f\\\"<br>{self.specified_method}: Command not found. Please enter a valid command.\\\"}\",\n \"def handler(self, command, args=[]):\\n ###\\n # command parsing and handling logic to be implemented by child\\n ###\\n if not command and not hasattr(self, 'handle_'):\\n return f'Service {str(self.__class__.__name__)}: {self.__doc__ or \\\"\\\"}'\\n methodname = 'handle_{}'.format(command or '')\\n logger.info('method name: {}'.format(methodname))\\n logger.info('args: {}'.format(args))\\n method = self.__getattribute__(methodname)\\n return method(args)\",\n \"def builtin_wrapper(method_name):\\n def wrapper(self, *args, **kwargs):\\n if method_name not in self.__dict__:\\n raise AttributeError(\\n \\\"object '%s' has no mock method '%s'\\\" %\\n (mock_object_names.get(id(self)), method_name)\\n )\\n return self.__dict__[method_name](*args, **kwargs)\\n return wrapper\",\n \"def test_raises_when_unimplemented_method_called(self, method):\\n\\n class API(platform.PlatformAPI):\\n pass\\n\\n name, impl = method\\n params = platform.parameters(impl)\\n\\n with pytest.raises(NotImplementedError):\\n m = getattr(API, name)\\n arguments = (None,) * len(params)\\n m(*arguments)\",\n \"def _process_method(self, method):\\n return method\",\n \"def __getattr__(self, attr):\\n\\n #print \\\"checking for attribute %r remotely\\\" % attr\\n\\n # note that this will fail if it doesn't exist, and that's good\\n check_attr = getattr(self.machine, attr)\\n\\n if callable(check_attr):\\n # it's a method, call it and return it\\n def wrap_remote_call(*args, **kargs):\\n return check_attr(*args, **kargs)\\n return wrap_remote_call\\n else:\\n # it' just an attribute, return it\\n return check_attr\",\n \"def call_command(self, name, *args, **kwargs):\\r\\n out = StringIO() # To Capture the output of the command\\r\\n call_command(name, *args, stdout=out, **kwargs)\\r\\n out.seek(0)\\r\\n return out.read()\",\n \"def set_method(self, method, **kwargs):\\n if isinstance(method, str) and method in self.available_methods.keys():\\n self.method_name = method\\n self.method = self.available_methods[method]['IDIMethod'](self, **kwargs)\\n elif callable(method) and hasattr(method, 'calculate_displacements'):\\n self.method_name = 'external_method'\\n try:\\n self.method = method(self, **kwargs)\\n except:\\n raise ValueError(\\\"The input `method` is not a valid `IDIMethod`.\\\")\\n else:\\n raise ValueError(\\\"method must either be a valid name from `available_methods` or an `IDIMethod`.\\\")\\n \\n # Update `get_displacements` docstring\\n tools.update_docstring(self.get_displacements, self.method.calculate_displacements)\\n # Update `show_points` docstring\\n if hasattr(self.method, 'show_points'):\\n try:\\n tools.update_docstring(self.show_points, self.method.show_points)\\n except:\\n pass\",\n \"def mappedQuicklookAction(self, method_name):\\n # find currently active quicklook instance\\n active_win = util.get_active_MDI_win()\\n # call the function of the action on the instance\\n getattr(active_win, str(method_name))()\",\n \"def TestMethodBody(run_method_name, run_dargs):\\n return lambda self: getattr(self, run_method_name)(**run_dargs)\",\n \"def command(self, function=None, name=None):\\r\\n if name is None:\\r\\n return self._command(function)\\r\\n else:\\r\\n return partial(self._command, name=name)\",\n \"def map_method(self, names, method_name, *args, **kwds):\\r\\n return self.map(names, self._call_extension_method,\\r\\n method_name, *args, **kwds)\",\n \"def __getattr__(self, name):\\n name = name.replace('_', '-')\\n\\n def wrapper(*args, **kwargs):\\n if len(args) != 0 and len(kwargs) != 0:\\n raise RpcError(name, {}, \\\"Cannot mix positional and non-positional arguments\\\")\\n elif len(args) != 0:\\n return self.call(name, payload=args)\\n else:\\n return self.call(name, payload=list(kwargs.values()))\\n return wrapper\",\n \"def __getattr__(self, cmd):\\n\\n if hasattr(self._rpc, cmd+'Request'):\\n lnfunc = getattr(self._rpc, cmd+'Request')\\n elif hasattr(self._rpc, f'Get{cmd}Request'):\\n lnfunc = getattr(self._rpc, f'Get{cmd}Request')\\n else:\\n raise NotImplementedError('Unhandled method self._rpc.(Get)' + cmd + 'Request')\\n\\n if hasattr(self._stub, cmd):\\n stubfunc = getattr(self._stub, cmd)\\n\\n def rpcCommand(*args,**kwargs):\\n return stubfunc(lnfunc(*args, **kwargs))\\n return rpcCommand\\n\\n elif hasattr(self._stub, 'Get'+cmd):\\n stubfunc = getattr(self._stub, 'Get'+cmd)\\n def rpcCommand(*args,**kwargs):\\n if args:\\n raise TypeError('Cannot use positional arguments with this command')\\n return stubfunc(lnfunc(**kwargs))\\n return rpcCommand\\n\\n else:\\n raise NotImplementedError('Unhandled method stub.(Get)' + cmd)\",\n \"def _traverse_command(self, name, *args, **kwargs):\\n\\n # Commands defined in \\\"_commands_to_proxy\\\" are handled here, to call\\n # their proxy methods. Then, these proxy methods can call this\\n # _traverse_command method with a named argument \\\"_bypass_proxy\\\" to True\\n # to really do (de)indexing and execute the command\\n bypass_proxy = kwargs.pop('_bypass_proxy', False)\\n if name in self._commands_to_proxy and not bypass_proxy:\\n command = getattr(self, self._commands_to_proxy[name])\\n return command(name, *args)\\n\\n values_to_index = kwargs.pop('_to_index', None)\\n values_to_deindex = kwargs.pop('_to_deindex', None)\\n\\n # TODO manage transaction\\n if self.indexable and name in self.available_modifiers:\\n self.deindex(values_to_deindex)\\n\\n # we don't call _traverse_command from IndexableField, but the one from\\n # RedisField because we manage indexes manually here\\n result = super(IndexableField, self)._traverse_command(name, *args, **kwargs)\\n\\n if self.indexable and name in self.available_modifiers:\\n self.index(values_to_index)\\n\\n return result\",\n \"def call_application(self, method_name, *args, **kwargs):\\n request = CallRequest(\\n method_name=method_name,\\n args=self.json_encoder.encode(args),\\n kwargs=self.json_encoder.encode(kwargs),\\n )\\n response = self.stub.CallApplicationMethod(request, timeout=5)\\n return self.json_decoder.decode(response.data)\",\n \"def call(self, method, *args):\\n data = [method]\\n data.extend(args)\\n\\n if method == 'auth.login':\\n self.client.request('POST', self.uri, msgpack.packb(data), self.header)\\n response = self.client.getresponse()\\n\\n if response.status == 200:\\n return msgpack.unpackb(response.read())\\n else:\\n raise MSFClientError('Unknown error occurred when trying to login')\\n\\n elif self.authenticated:\\n data.insert(1, self.sessionid)\\n self.client.request('POST', self.uri, msgpack.packb(data), self.header)\\n response = self.client.getresponse()\\n\\n if (response.status == 200):\\n result = msgpack.unpackb(response.read())\\n if 'error' in result:\\n raise MSFClientError(result['error_message'])\\n return result\\n raise MSFClientError('An unknown error occurred')\\n else:\\n raise MSFClientError('You have to be authenticated')\",\n \"def twitterCall(methodName,args,credentials=False):\\n api = ratedTwitter(credentials=credentials)\\n limit = api.__can_we_do_that__(methodName)\\n if limit:\\n print '*** TWITTER RATE-LIMITED: '+methodName+' ***'\\n raise twitterCall.retry(exc=Exception('Twitter rate-limited',methodName), countdown = limit)\\n else:\\n okay, result = api.__method_call__(methodName,args)\\n if okay:\\n print '*** TWITTER CALL: '+methodName+' ***' \\n return result\\n else:\\n assert False\",\n \"def __call__(self, receiver, *args, convert_args=True, convert_result=True):\\n\\n if len(args) != len(self.method_argtypes):\\n raise TypeError(\\n f\\\"Method {self.name} takes {len(args)} arguments, but got {len(self.method_argtypes)} arguments\\\"\\n )\\n\\n if convert_args:\\n converted_args = []\\n for argtype, arg in zip(self.method_argtypes, args):\\n if isinstance(arg, enum.Enum):\\n # Convert Python enum objects to their values\\n arg = arg.value\\n\\n if issubclass(argtype, objc_block):\\n if arg is None:\\n # allow for 'nil' block args, which some objc methods accept\\n arg = ns_from_py(arg)\\n elif callable(arg) and not isinstance(\\n arg, Block\\n ): # <-- guard against someone someday making Block callable\\n # Note: We need to keep the temp. Block instance\\n # around at least until the objc method is called.\\n # _as_parameter_ is used in the actual ctypes marshalling below.\\n arg = Block(arg)\\n # ^ For blocks at this point either arg is a Block instance\\n # (making use of _as_parameter_), is None, or if it isn't either of\\n # those two, an ArgumentError will be raised below.\\n elif issubclass(argtype, objc_id):\\n # Convert Python objects to Foundation objects\\n arg = ns_from_py(arg)\\n elif isinstance(arg, collections.abc.Sequence) and issubclass(\\n argtype, (Structure, Array)\\n ):\\n arg = compound_value_for_sequence(arg, argtype)\\n\\n converted_args.append(arg)\\n else:\\n converted_args = args\\n\\n result = send_message(\\n receiver,\\n self.selector,\\n *converted_args,\\n restype=self.restype,\\n argtypes=self.method_argtypes,\\n )\\n\\n if not convert_result:\\n return result\\n\\n # Convert result to python type if it is a instance or class pointer.\\n if self.restype is not None and issubclass(self.restype, objc_id):\\n result = ObjCInstance(result)\\n\\n # Mark for release if we acquire ownership of an object. Do not autorelease here because\\n # we might retain a Python reference while the Obj-C reference goes out of scope.\\n if self.name.startswith((b\\\"alloc\\\", b\\\"new\\\", b\\\"copy\\\", b\\\"mutableCopy\\\")):\\n result._needs_release = True\\n\\n return result\",\n \"def stubFunc( *args, **keywords ):\\n maya.cmds.dynamicLoad( library )\\n # call the real function which has replaced us\\n return maya.cmds.__dict__[command]( *args, **keywords )\",\n \"def client_member_function(self, method: ProtoServiceMethod) -> None:\",\n \"def call_method(self, request, context):\\n response = CallMethodResponse()\\n args = []\\n for arg in request.args:\\n args.append(decode(arg))\\n if args != []:\\n result = \\\\\\n self._delegator.call_method(\\n request.component, request.method, *args)\\n else:\\n result = \\\\\\n self._delegator.call_method(\\n request.component, request.method, None)\\n response.result = encode(result)\\n return response\",\n \"def apply(self, method, arguments):\\n return method(arguments)\",\n \"def xen_rpc_call(ip, method, *args):\\n try:\\n if not ip:\\n return xen_api_error(\\\"Invalid ip for rpc call\\\")\\n # create\\n proxy = ServerProxy(\\\"http://\\\" + ip + \\\":9363/\\\")\\n \\n # login \\n response = proxy.session.login('root')\\n if cmp(response['Status'], 'Failure') == 0:\\n log.exception(response['ErrorDescription'])\\n return xen_api_error(response['ErrorDescription']) \\n session_ref = response['Value']\\n \\n # excute\\n method_parts = method.split('_')\\n method_class = method_parts[0]\\n method_name = '_'.join(method_parts[1:])\\n \\n if method.find(\\\"host_metrics\\\") == 0:\\n method_class = \\\"host_metrics\\\"\\n method_name = '_'.join(method_parts[2:])\\n #log.debug(method_class)\\n #log.debug(method_name)\\n if method_class.find(\\\"Async\\\") == 0:\\n method_class = method_class.split(\\\".\\\")[1]\\n response = proxy.__getattr__(\\\"Async\\\").__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\\n else:\\n response = proxy.__getattr__(method_class).__getattr__(method_name)(session_ref, *args)\\n if cmp(response['Status'], 'Failure') == 0:\\n log.exception(response['ErrorDescription'])\\n return xen_api_error(response['ErrorDescription'])\\n # result\\n return response\\n except socket.error:\\n return xen_api_error('socket error')\",\n \"def wrapper(*args, **kwargs):\\n loop = asyncio.get_event_loop()\\n return loop.run_until_complete(method(*args, **kwargs))\",\n \"def execute(self, data, options):\\n obj = self.fetch(data)\\n if isinstance(obj, dict) and self.method_name in obj: # if dict\\n return obj[self.method_name]\\n try:\\n prop = getattr(obj, self.method_name)\\n rv = callable(prop) and prop() or prop\\n return escape_if_needed(rv, options)\\n except AttributeError:\\n raise MethodDoesNotExist(self.name, self.method_name)\",\n \"def run(self, username, setting, method, args):\\n if setting == 'label':\\n if method == 'get':\\n print \\\"getting labels for %s...\\\\n\\\" % (username)\\n print self.client.RetrieveLabels(username=username)\\n elif method == 'set':\\n print \\\"creating label for %s...\\\\n\\\" % (username)\\n print self.client.CreateLabel(username=username, name=LABEL_NAME)\\n else:\\n print \\\"deleting labels isn't supported\\\"\\n elif setting == 'forwarding':\\n if method == 'get':\\n print \\\"getting forwarding for %s...\\\\n\\\" % (username)\\n print self.client.RetrieveForwarding(username)\\n elif method == 'set':\\n print \\\"updating forwarding settings for %s...\\\\n\\\" % (username)\\n print self.client.UpdateForwarding(username=username, \\n enable=not(options.disable),\\n forward_to=FORWARD_TO,\\n action=FORWARDING_ACTION)\\n else:\\n print \\\"deleting forwarding settings isn't supported\\\"\\n elif setting == 'sendas':\\n if method == 'get':\\n print \\\"getting sendAs alias for %s...\\\\n\\\" % (username)\\n print self.client.RetrieveSendAs(username=username)\\n elif method == 'set':\\n print \\\"creating sendAs alias for %s...\\\\n\\\" % (username)\\n print self.client.CreateSendAs(username=username, name=SEND_AS_NAME, \\n address=SEND_AS_ADDRESS,\\n reply_to=SEND_AS_REPLY_TO, \\n make_default=SEND_AS_MAKE_DEFAULT)\\n else:\\n print \\\"deleting send-as settings isn't supported\\\"\\n elif setting == 'pop':\\n if method == 'get':\\n print \\\"getting pop settings for %s...\\\\n\\\" % (username)\\n print self.client.RetrievePop(username=username)\\n elif method == 'set':\\n print \\\"updating pop settings for %s...\\\\n\\\" % (username)\\n print self.client.UpdatePop(username=username, \\n enable=not(options.disable), \\n enable_for=POP_ENABLE_FOR,\\n action=POP_ACTION)\\n else:\\n print \\\"deleting pop settings isn't supported\\\"\\n elif setting == 'signature':\\n if method == 'get':\\n print \\\"getting signature for %s...\\\\n\\\" % (username)\\n print self.client.RetrieveSignature(username=username)\\n elif method == 'set':\\n print \\\"updating signature for %s...\\\\n\\\" % (username)\\n print self.client.UpdateSignature(username=username, \\n signature=SIGNATURE)\\n else:\\n print \\\"deleting signature settings isn't supported\\\"\\n elif setting == 'vacation':\\n if method == 'get':\\n print \\\"getting vacation settings for %s...\\\\n\\\" % (username)\\n print self.client.RetrieveVacation(username=username)\\n elif method == 'set':\\n print \\\"updating vacation settings for %s...\\\\n\\\" % (username)\\n print self.client.UpdateVacation(username=username, \\n enable=not(options.disable),\\n subject=VACATION_SUBJECT, \\n message=VACATION_MESSAGE,\\n contacts_only=VACATION_CONTACTS_ONLY)\\n else:\\n print \\\"deleting vacation settings isn't supported\\\"\\n elif setting == 'imap':\\n if method == 'get':\\n print \\\"getting imap settings for %s...\\\\n\\\" % (username)\\n print self.client.RetrieveImap(username)\\n elif setting == 'set':\\n print \\\"updating imap settings for %s...\\\\n\\\" % (username)\\n print self.client.UpdateImap(username=username, \\n enable=not(options.disable))\\n else:\\n print \\\"deleting imap settings isn't supported\\\"\\n elif setting == 'filter':\\n if method == 'get':\\n print \\\"getting email filters is not yet possible\\\\n\\\"\\n parser.print_help()\\n elif method == 'set':\\n print \\\"creating an email filter for %s...\\\\n\\\" % (username)\\n print self.client.CreateFilter(username=username, \\n from_address=FILTER_FROM, \\n to_address=FILTER_TO,\\n subject=FILTER_SUBJECT, \\n has_the_word=FILTER_HAS_THE_WORD,\\n does_not_have_the_word=\\n FILTER_DOES_NOT_HAVE_THE_WORD,\\n has_attachments=FILTER_HAS_ATTACHMENT, \\n label=FILTER_LABEL,\\n mark_as_read=FILTER_SHOULD_MARK_AS_READ,\\n archive=FILTER_SHOULD_ARCHIVE)\\n else:\\n print \\\"deleting filters isn't supported\\\"\\n elif setting == 'general':\\n if method == 'get':\\n print \\\"getting general email settings is not yet possible\\\\n\\\"\\n parser.print_help()\\n elif method == 'set':\\n print \\\"updating general settings for %s...\\\\n\\\" % (username)\\n print self.client.UpdateGeneralSettings(username=username, \\n page_size=GENERAL_PAGE_SIZE,\\n shortcuts=\\n GENERAL_ENABLE_SHORTCUTS,\\n arrows=\\n GENERAL_ENABLE_ARROWS,\\n snippets=\\n GENERAL_ENABLE_SNIPPETS,\\n use_unicode=\\n GENERAL_ENABLE_UNICODE)\\n else:\\n print \\\"deleting general settings isn't supported\\\"\\n elif setting == 'language':\\n if method == 'get':\\n print \\\"getting language settings is not yet possible\\\\n\\\"\\n parser.print_help()\\n elif method == 'set':\\n print \\\"updating language for %s...\\\\n\\\" % (username)\\n print self.client.UpdateLanguage(username=username, language=LANGUAGE)\\n else:\\n print \\\"deleting language settings isn't supported\\\"\\n elif setting == 'webclip':\\n if method == 'get':\\n print \\\"getting webclip settings is not yet possible\\\\n\\\"\\n parser.print_help()\\n elif method == 'get':\\n print \\\"updating webclip settings for %s...\\\\n\\\" % (username)\\n print self.client.UpdateWebclip(username=username, \\n enable=not(options.disable))\\n else:\\n print \\\"deleting webclip settings isn't supported\\\"\\n elif setting == 'delegation':\\n if method == 'get':\\n print \\\"getting email delegates for %s...\\\" % (username)\\n print self.client.RetrieveEmailDelegates(username=username)\\n elif method == 'set':\\n address = args['delegationId']\\n print \\\"adding %s as an email delegate to %s...\\\" % (address, username)\\n print self.client.AddEmailDelegate(username=username, address=address)\\n else:\\n address = args['delegationId']\\n print \\\"deleting %s as an email delegate for %s...\\\" % (address, username)\\n print self.client.DeleteEmailDelegate(username=username, \\n address=address)\\n else:\\n parser.print_help()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64679945","0.6191388","0.6156052","0.614689","0.6126066","0.61218405","0.6005276","0.59827995","0.59674746","0.5966414","0.5953731","0.5952385","0.5854593","0.576358","0.5734514","0.5709739","0.5668814","0.56597054","0.5618796","0.55931056","0.5582841","0.5569383","0.55282253","0.5512849","0.55100614","0.5507957","0.54962754","0.5479802","0.5476833","0.5441043","0.54383945","0.54004157","0.53947264","0.53567743","0.53539133","0.53370434","0.5222137","0.5201775","0.519738","0.5182835","0.5150997","0.51367754","0.512877","0.5124975","0.51165795","0.5080291","0.50454766","0.5015103","0.50075275","0.5001176","0.49943528","0.4990158","0.4988886","0.4986552","0.49741945","0.4973981","0.49738383","0.4952494","0.4948003","0.4944255","0.49372253","0.49279466","0.4906861","0.49047998","0.48748702","0.48656884","0.4851269","0.48476896","0.4842718","0.48408046","0.4817662","0.48153317","0.48119935","0.48050007","0.47948173","0.478916","0.47865185","0.47823742","0.47772682","0.47752532","0.47642192","0.47552672","0.47546026","0.47538868","0.47174218","0.47144082","0.47143033","0.47112387","0.47057137","0.46962517","0.46957743","0.4695555","0.4694149","0.46926612","0.4692179","0.4691056","0.46896487","0.46856523","0.46830633","0.46830532"],"string":"[\n \"0.64679945\",\n \"0.6191388\",\n \"0.6156052\",\n \"0.614689\",\n \"0.6126066\",\n \"0.61218405\",\n \"0.6005276\",\n \"0.59827995\",\n \"0.59674746\",\n \"0.5966414\",\n \"0.5953731\",\n \"0.5952385\",\n \"0.5854593\",\n \"0.576358\",\n \"0.5734514\",\n \"0.5709739\",\n \"0.5668814\",\n \"0.56597054\",\n \"0.5618796\",\n \"0.55931056\",\n \"0.5582841\",\n \"0.5569383\",\n \"0.55282253\",\n \"0.5512849\",\n \"0.55100614\",\n \"0.5507957\",\n \"0.54962754\",\n \"0.5479802\",\n \"0.5476833\",\n \"0.5441043\",\n \"0.54383945\",\n \"0.54004157\",\n \"0.53947264\",\n \"0.53567743\",\n \"0.53539133\",\n \"0.53370434\",\n \"0.5222137\",\n \"0.5201775\",\n \"0.519738\",\n \"0.5182835\",\n \"0.5150997\",\n \"0.51367754\",\n \"0.512877\",\n \"0.5124975\",\n \"0.51165795\",\n \"0.5080291\",\n \"0.50454766\",\n \"0.5015103\",\n \"0.50075275\",\n \"0.5001176\",\n \"0.49943528\",\n \"0.4990158\",\n \"0.4988886\",\n \"0.4986552\",\n \"0.49741945\",\n \"0.4973981\",\n \"0.49738383\",\n \"0.4952494\",\n \"0.4948003\",\n \"0.4944255\",\n \"0.49372253\",\n \"0.49279466\",\n \"0.4906861\",\n \"0.49047998\",\n \"0.48748702\",\n \"0.48656884\",\n \"0.4851269\",\n \"0.48476896\",\n \"0.4842718\",\n \"0.48408046\",\n \"0.4817662\",\n \"0.48153317\",\n \"0.48119935\",\n \"0.48050007\",\n \"0.47948173\",\n \"0.478916\",\n \"0.47865185\",\n \"0.47823742\",\n \"0.47772682\",\n \"0.47752532\",\n \"0.47642192\",\n \"0.47552672\",\n \"0.47546026\",\n \"0.47538868\",\n \"0.47174218\",\n \"0.47144082\",\n \"0.47143033\",\n \"0.47112387\",\n \"0.47057137\",\n \"0.46962517\",\n \"0.46957743\",\n \"0.4695555\",\n \"0.4694149\",\n \"0.46926612\",\n \"0.4692179\",\n \"0.4691056\",\n \"0.46896487\",\n \"0.46856523\",\n \"0.46830633\",\n \"0.46830532\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7929701"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88385,"cells":{"query":{"kind":"string","value":"Adds a custom location strategy. `strategy_name` is the name of the strategy; a prefix used when addressing an element. `function_definition` is the JavaScript that will be called. It must return a DOM reference, an array with DOM references, or null. Together with the modified seleniumserver.jar it can provide a new method of locating elements on the page. For example, a jQuery strategy can be added to locate elements given jQuery selector syntax."},"document":{"kind":"string","value":"def add_location_strategy(self, strategy_name, function_definition):\n self._locator_parser.add_strategy(strategy_name)\n self._selenium.add_location_strategy(strategy_name, function_definition)"},"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 strategy(func):\n strategies.append(func)\n return func","def strategy(strategy_name: str):\r\n def wrapper(finder_class):\r\n global strategies\r\n strategies[strategy_name] = finder_class\r\n return finder_class\r\n return wrapper","def _apply_hooks(\n context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str\n) -> st.SearchStrategy[Case]:\n container = LOCATION_TO_CONTAINER[location]\n for hook in hooks.get_all_by_name(f\"before_generate_{container}\"):\n strategy = hook(context, strategy)\n return strategy","def initialize_location_strategies(self):\n locator_manager.register_locators(\"sf\", lex_locators)\n locator_manager.register_locators(\"text\", \"Salesforce.Locate Element by Text\")\n locator_manager.register_locators(\"title\", \"Salesforce.Locate Element by Title\")\n\n # This does the work of actually adding all of the above-registered\n # location strategies, plus any that were registered by keyword\n # libraries.\n locator_manager.add_location_strategies()","def apply_hooks(\n endpoint: Endpoint,\n context: HookContext,\n hooks: Optional[HookDispatcher],\n strategy: st.SearchStrategy[Case],\n location: str,\n) -> st.SearchStrategy[Case]:\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\n if hooks is not None:\n strategy = _apply_hooks(context, hooks, strategy, location)\n return strategy","def location(name, factory=None):\n\n def set_location(config, name, factory):\n root = config.registry[LOCATION_ROOT]\n root.attach(name, factory)\n\n def decorate(factory):\n def callback(scanner, factory_name, factory):\n scanner.config.action(('location', name), set_location,\n args=(scanner.config, name, factory),\n order=PHASE2_CONFIG)\n venusian.attach(factory, callback, category='pyramid')\n return factory\n\n return decorate","def InitStrategy(self, sname, strategy):\n\n self._string = sname\n\n self.strategy = strategy\n self.postracker = position.PositionTracker(self.strategy)","def add_location(self, **kwargs):\n \n self.options.update(kwargs)\n self.options['action'] = 'locator.location.add'\n return self.call(self.options)","def get_parameters_strategy(\n endpoint: Endpoint, to_strategy: Callable[[Dict[str, Any]], st.SearchStrategy], location: str\n) -> st.SearchStrategy:\n parameters = getattr(endpoint, LOCATION_TO_CONTAINER[location])\n if parameters:\n schema = parameters_to_json_schema(parameters)\n strategy = to_strategy(schema)\n serialize = endpoint.get_parameter_serializer(location)\n if serialize is not None:\n strategy = strategy.map(serialize)\n filter_func = {\n \"path\": is_valid_path,\n \"header\": is_valid_header,\n \"cookie\": is_valid_header,\n \"query\": is_valid_query,\n }[location]\n strategy = strategy.filter(filter_func)\n map_func = {\"path\": quote_all}.get(location)\n if map_func:\n strategy = strategy.map(map_func)\n return strategy\n # No parameters defined for this location\n return st.none()","def on_route_increased_position(self, strategy) -> None:\n pass","def create_strategy(config):\n build_strategy = paddle.static.BuildStrategy()\n exec_strategy = paddle.static.ExecutionStrategy()\n\n exec_strategy.num_threads = 1\n exec_strategy.num_iteration_per_drop_scope = (\n 10000\n if 'AMP' in config and config.AMP.get(\"use_pure_fp16\", False) else 10)\n\n fuse_op = True if 'AMP' in config else False\n\n fuse_bn_act_ops = config.get('fuse_bn_act_ops', fuse_op)\n fuse_elewise_add_act_ops = config.get('fuse_elewise_add_act_ops', fuse_op)\n fuse_bn_add_act_ops = config.get('fuse_bn_add_act_ops', fuse_op)\n enable_addto = config.get('enable_addto', fuse_op)\n\n build_strategy.fuse_bn_act_ops = fuse_bn_act_ops\n build_strategy.fuse_elewise_add_act_ops = fuse_elewise_add_act_ops\n build_strategy.fuse_bn_add_act_ops = fuse_bn_add_act_ops\n build_strategy.enable_addto = enable_addto\n\n return build_strategy, exec_strategy","def add_straight_through_estimator(jax_function):\n\n # See\n # https://jax.readthedocs.io/en/latest/notebooks/Custom_derivative_rules_for_Python_code.html\n def ste(primals, tangents):\n return jax_function(primals[0]), tangents[0]\n\n jax_function.defjvp(ste)","def createFunction(self, entryPoint: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.listing.Function:\n ...","def used_implementation(self, impl: str, value):","def add_impl(opaque_func, name, implementation, restype=None, restype_func=None):\n def impl(py_func, argtypes):\n # TODO: do this better\n from flypy.compiler import representation_type\n\n ll_argtypes = [representation_type(x) for x in argtypes]\n argnames = list(string.ascii_letters[:len(argtypes)])\n\n # Determine return type\n if restype_func:\n result_type = restype_func(argtypes)\n else:\n result_type = restype or ll_argtypes[0]\n\n type = ptypes.Function(result_type, tuple(ll_argtypes), False)\n func = ir.Function(name, argnames, type)\n func.new_block(\"entry\")\n b = ir.Builder(func)\n b.position_at_beginning(func.startblock)\n implementation(b, argtypes, *func.args)\n return func\n\n opaque.implement_opaque(opaque_func, impl)","def add_function_attribute(self, name, value):\n # Transcode the function to javascript\n xml.add_attribute(self, name, ajax.JS(value))","def map_function(self, name):\n def decorator(func):\n\n # Check if the Thrift function was already assigned\n if name in self.__mapped_names:\n raise NameError(\n f'Thrift Function \"{name}\" is already assigned!'\n )\n\n self.__mapped_names.add(name)\n\n setattr(self, name, func)\n return func\n\n return decorator","def register(name, fn=None):\n def _hook_add(func):\n if name not in _hooks:\n logger.debug(\"Creating new hook %s\" % name)\n _hooks[name] = []\n\n logger.debug('Registering hook %s for function %s' % (name, fn))\n _hooks[name].append(func)\n\n if fn is None:\n # Behave like a decorator\n def decorator(func):\n _hook_add(func)\n return func\n return decorator\n else:\n # Behave like a function, just register hook\n _hook_add(fn)","def _register_function(parser, name, fn):\n argspec = inspect.getargspec(fn)\n\n # agent_daemon_context is used to pass daemon context to the agnet, the user cannot provide it and\n # so functions that require it cannot be called from the CLI\n # In future we might want to 'create' a context so these functions can be called, but today the only\n # usages do not make sense to call from the CLI.\n if \"agent_daemon_context\" in argspec[0]:\n return\n\n p = parser.add_parser(name, help=fn.__doc__)\n\n def wrap(args):\n args = vars(args)\n del args[\"func\"]\n return fn(**args)\n\n p.set_defaults(func=wrap)\n\n if argspec.defaults is not None:\n positional_arg_count = len(argspec.args) - len(argspec.defaults)\n else:\n positional_arg_count = len(argspec.args)\n\n for i, arg in enumerate(argspec.args):\n if i < positional_arg_count:\n p.add_argument(\"--%s\" % arg, required=True)\n else:\n if isinstance(argspec.defaults[i - positional_arg_count], bool):\n p.add_argument(\"--%s\" % arg, required=False, action=\"store_true\")\n else:\n p.add_argument(\"--%s\" % arg, required=False)","def get_mapping_function(\n function_name: Text, functions_mapping: FunctionsMapping\n) -> Callable:\n if function_name in functions_mapping:\n return functions_mapping[function_name]\n\n elif function_name in [\"parameterize\", \"P\"]:\n return loader.load_csv_file\n\n elif function_name in [\"environ\", \"ENV\"]:\n return utils.get_os_environ\n\n elif function_name in [\"multipart_encoder\", \"multipart_content_type\"]:\n # extension for upload test\n from httprunner.ext import uploader\n\n return getattr(uploader, function_name)\n\n try:\n # check if HttpRunner builtin functions\n built_in_functions = loader.load_builtin_functions()\n return built_in_functions[function_name]\n except KeyError:\n pass\n\n try:\n # check if Python builtin functions\n return getattr(builtins, function_name)\n except AttributeError:\n pass\n\n raise exceptions.FunctionNotFound(f\"{function_name} is not found.\")","def optimize(fn, search_strategy=PESearch, generations=100, pop_size=10, allow_duplicates=False, logger=None, **kwargs):\n params_func = _make_params_func(fn)\n\n @functools.wraps(fn)\n def eval_func(kwargs):\n return fn(**kwargs)\n\n grammar = generate_cfg(params_func)\n\n search = search_strategy(grammar, eval_func, pop_size=pop_size, allow_duplicates=allow_duplicates, **kwargs)\n best, best_fn = search.run(generations, logger=logger)\n\n return best, best_fn","def register_string_format(name: str, strategy: st.SearchStrategy) -> None:\n if not isinstance(name, str):\n raise TypeError(f\"name must be of type {str}, not {type(name)}\")\n if not isinstance(strategy, st.SearchStrategy):\n raise TypeError(f\"strategy must be of type {st.SearchStrategy}, not {type(strategy)}\")\n\n STRING_FORMATS[name] = strategy","def strategy_config(self, strategy_config):\n self._strategy_config = strategy_config","def get_address(supvisors, strategy, addresses, expected_loading):\n if strategy == StartingStrategies.CONFIG:\n instance = ConfigStrategy(supvisors)\n if strategy == StartingStrategies.LESS_LOADED:\n instance = LessLoadedStrategy(supvisors)\n if strategy == StartingStrategies.MOST_LOADED:\n instance = MostLoadedStrategy(supvisors)\n # apply strategy result\n return instance.get_address(addresses, expected_loading)","def location():\n return _locate_or_create()","def get_location(self):\n self.location = self.func(0)","def register_step_function(\n fn: StepFunction,\n identifier: str,\n aggregate_map: Optional[Dict[str, str]] = None,\n overwrite: bool = False,\n) -> None:\n if identifier in STEP_SCORES_MAP:\n if not overwrite:\n raise ValueError(\n f\"{identifier} is already registered in step functions map. Override with overwrite=True.\"\n )\n logger.warning(f\"Overwriting {identifier} step function.\")\n STEP_SCORES_MAP[identifier] = fn\n if isinstance(aggregate_map, dict):\n for agg_name, aggregation_fn_identifier in aggregate_map.items():\n if agg_name not in DEFAULT_ATTRIBUTION_AGGREGATE_DICT[\"step_scores\"]:\n DEFAULT_ATTRIBUTION_AGGREGATE_DICT[\"step_scores\"][agg_name] = {}\n DEFAULT_ATTRIBUTION_AGGREGATE_DICT[\"step_scores\"][agg_name][identifier] = aggregation_fn_identifier","def lookup_function(self, name, context):\n if name not in self.functions:\n raise Exception(\"No such function: \" + str(name))\n return Function(self.functions[name], context)","def register_function(self, function, name=None):\n if name:\n self[name] = function\n else:\n self[function.__name__] = function","def add_function(self, return_type: str, function_name: str, lines, arguments: list, add_scope=add_raw, *,\n name_abs=False, fragments=()) -> str:\n if name_abs:\n name = function_name\n else:\n name = self.create_unique_id(function_name)\n frag_str = (',fragment=\"' + ','.join(fragments) + '\"') if fragments else ''\n lines = clean_source(lines)\n lines = [\n '%fragment (\"' + name + '\",\"header\"' + frag_str + '){',\n return_type + ' ' + name + '(' + ', '.join(arguments) + ') {',\n *('\\t' + l for l in lines),\n '}',\n '}'\n ]\n add_scope(self, lines)\n return name","def add_render_function(self, render_function):\n self._render_function_tmp = render_function\n if self._render_function_tmp is None:\n def render_function_with_get_options(name, value):\n # Get all the selected values\n self._get_selected_options()\n # Make displacements menu invisible\n self.plot_displacements_menu.visible = False\n else:\n def render_function_with_get_options(name, value):\n # Get all the selected values\n self._get_selected_options()\n # Call render function\n self._render_function_tmp(name, value)\n self._render_function = render_function_with_get_options\n self.renderer_widget.add_render_function(self._render_function)\n self.x_limit.on_trait_change(self._render_function, 'value')\n self.y_limit.on_trait_change(self._render_function, 'value')\n self.x_label.on_trait_change(self._render_function, 'value')\n self.y_label.on_trait_change(self._render_function, 'value')\n self.title.on_trait_change(self._render_function, 'value')\n self.legend_entries.on_trait_change(self._render_function, 'value')","def pulldiscovery(stepname):\n\n def dec(func):\n assert stepname not in pulldiscoverymapping\n pulldiscoverymapping[stepname] = func\n pulldiscoveryorder.append(stepname)\n return func\n\n return dec","def register_function(self, function, name=None):\n if name is None:\n name = function.__name__\n self.funcs[name] = function","def register_report_location_callback(self, callback=None, report_cartesian=True, report_joints=True):\r\n return self._arm.register_report_location_callback(callback=callback,\r\n report_cartesian=report_cartesian,\r\n report_joints=report_joints)","def test_strategy_attribute_correct():\n assert 'css' == FindByCss.strategy\n assert 'id' == FindById.strategy\n assert 'name' == FindByName.strategy\n assert 'tag' == FindByTag.strategy\n assert 'text' == FindByText.strategy\n assert 'value' == FindByValue.strategy\n assert 'xpath' == FindByXPath.strategy","def test_function_definition(self):\n self.script(\"# script.py\\n\"\n \"def f():\\n\"\n \" 'fdoc'\\n\"\n \" pass\\n\")\n self.compile()\n\n script = self.find_code_component(name=\"script.py\")\n function_def = self.find_code_component(name=\"f\")\n\n self.assertEqual(function_def.type, \"function_def\")\n self.assertEqual(function_def.mode, \"w\")\n self.assertEqual(function_def.first_char_line, 2)\n self.assertEqual(function_def.first_char_column, 0)\n self.assertEqual(function_def.last_char_line, 4)\n self.assertEqual(function_def.last_char_column, 8)\n self.assertEqual(function_def.container_id, script.id)\n\n function_def_block = self.metascript.code_blocks_store[function_def.id]\n self.assertEqual(function_def_block.code,\n \"def f():\\n\"\n \" 'fdoc'\\n\"\n \" pass\")\n self.assertEqual(function_def_block.docstring, \"fdoc\")\n self.assertTrue(bool(function_def_block.code_hash))","def stmt_def(executor, stmt:ParsedStatementDef):\n executor.put_symbol(stmt._variable, stmt._tokens, SymbolType.FUNCTION, stmt._function_arg)","def strategy(self, strategy):\n\n if strategy == \"auto\":\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 0)\n elif strategy == \"cranelift\":\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 1)\n elif strategy == \"lightbeam\":\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 2)\n else:\n raise WasmtimeError(\"unknown strategy: \" + str(strategy))\n if error:\n raise WasmtimeError.__from_ptr__(error)","def add_custom_widget(self, name, widget, value_handler=None, indicator_handler=None, location=(None,0,1,None)):\n if name in self.params:\n raise KeyError(\"widget {} already exists\".format(name))\n location=self._normalize_location(location,default=(None,0,1,3))\n self.formLayout.addWidget(widget,*location)\n value_handler=value_handler or values_module.get_default_value_handler(widget)\n indicator_handler=indicator_handler or values_module.get_default_indicator_handler(widget)\n self._add_widget(name,self.ParamRow(widget,None,value_handler,indicator_handler))\n return value_handler","def on_game_start(self, config):\n gamelib.debug_write('Configuring your custom algo strategy...')\n self.config = config\n global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER\n FILTER = config[\"unitInformation\"][0][\"shorthand\"]\n ENCRYPTOR = config[\"unitInformation\"][1][\"shorthand\"]\n DESTRUCTOR = config[\"unitInformation\"][2][\"shorthand\"]\n PING = config[\"unitInformation\"][3][\"shorthand\"]\n EMP = config[\"unitInformation\"][4][\"shorthand\"]\n SCRAMBLER = config[\"unitInformation\"][5][\"shorthand\"]\n\n # Can store custom variables and settings here:\n self.hole_x_location = 17","def getstrategy(stname, visited=None, retval=None):\n dprint(2, 'getstrategy', stname)\n dprint(3, 'getstrategy', stname, visited, retval)\n if visited is None:\n visited = []\n if retval is None:\n retval = []\n if stname in visited:\n dprint(0, 'loop detected', stname, visited)\n # resilient but dangerous; keeps going\n return retval\n visited.append(stname)\n\n sto, sts = stname.split('/')\n surl = os.path.join(args.trserver, sto, 'strategy', sts)\n outp = trgeturl(surl, 'lines')\n if not outp:\n dprint(0, 'failed strategy', stname)\n # resilient but dangerous; keeps going\n return retval\n for ln in outp:\n cmdln = ln.split()\n cmd = cmdln.pop(0)\n if cmd == 'test':\n pri = 50\n if cmdln[0].startswith('pri='):\n pric = cmdln.pop(0)\n pri = int(pric.split('=')[1])\n test = cmdln.pop(0)\n retval.append((pri, test, cmdln))\n dprint(3, 'added test', pri, test, cmdln)\n elif cmd == 'include' or cmd == 'strategy':\n dprint(3, 'including strategy', cmdln)\n retval = getstrategy(cmdln.pop(0), visited, retval)\n else:\n dprint(0, 'error unknown cmd', cmd)\n\n return retval","def create_test_strategy(context, **kw):\n strategy = get_test_strategy(context, **kw)\n strategy.create()\n return strategy","def test_stepregistry_step_decorator_should_register_func_with_proper_keyword(keyword):\n # given\n registry = StepRegistry()\n context = {}\n registry.create_step_decorators(context)\n\n # when\n def test_step():\n ...\n\n test_step = context[keyword.lower()](\"pattern\")(test_step)\n\n # then\n assert registry.step_implementations(keyword) == [\n StepImpl(keyword, \"pattern\", test_step)\n ]","def navigate_to_function(self, function_address, address):\n pass","def calculation_strategy(self) -> CalculationStrategy:\n if \"calculation_strategy\" in self._json_data:\n return CalculationStrategy(str(self._json_data.get(\"calculation_strategy\")))\n return CalculationStrategy.LUT","def test_function_definition_with_decorator(self):\n self.script(\"# script.py\\n\"\n \"def g(x):\\n\"\n \" return x\\n\"\n \"@g\\n\"\n \"def f():\\n\"\n \" 'fdoc'\\n\"\n \" pass\\n\")\n self.compile()\n\n script = self.find_code_component(name=\"script.py\")\n function_def = self.find_code_component(name=\"f\")\n\n self.assertEqual(function_def.type, \"function_def\")\n self.assertEqual(function_def.mode, \"w\")\n self.assertEqual(function_def.first_char_line, 4)\n self.assertEqual(function_def.first_char_column, 0)\n self.assertEqual(function_def.last_char_line, 7)\n self.assertEqual(function_def.last_char_column, 8)\n self.assertEqual(function_def.container_id, script.id)\n\n function_def_block = self.metascript.code_blocks_store[function_def.id]\n self.assertEqual(function_def_block.code,\n \"@g\\n\"\n \"def f():\\n\"\n \" 'fdoc'\\n\"\n \" pass\")\n self.assertEqual(function_def_block.docstring, \"fdoc\")\n self.assertTrue(bool(function_def_block.code_hash))","def setStrategy(self, value):\n return self._set(strategy=value)","def strategy(self, opponent):\n raise NotImplementedError()","def add_new_function(self, pfunc, pfunc_bound= True, index = None):\n raise NotImplementedError()","def add_child_function(\n self, name, url=None, image=None, requirements=None, kind=None\n ):\n function_reference = FunctionReference(\n url, image, requirements=requirements, kind=kind or \"serving\"\n )\n self._spec.function_refs.update(function_reference, name)\n func = function_reference.to_function(self.kind)\n func.set_env(\"SERVING_CURRENT_FUNCTION\", function_reference.name)\n return func","def setFunctionName(self, function_name):\r\n self.actualFunction = function_name","def register_step(step_function: StepFunction) -> None:\n global _step_function\n _step_function = step_function","def add_component(self, function_name: str, path: pathlib.Path):\n self._components[function_name] = str(path)","def mock_fcn(self, name):\n return MockFunction(self._context, name)","def register(self, function, name=None, method='POST'):\r\n\r\n method = self.clean_method(method)\r\n\r\n # Generate a default name\r\n if not name:\r\n module = ''.join(str(function.__module__).rsplit('.ajax', 1))\r\n name = '.'.join((module, function.__name__))\r\n\r\n if ':' in name:\r\n log.error('Ivalid function name %s.' % name)\r\n return\r\n\r\n # Check for already registered functions\r\n if name in self._registry:\r\n log.error('%s was already registered.' % name)\r\n return\r\n\r\n # Create the dajaxice function.\r\n function = DajaxiceFunction(function=function,\r\n name=name,\r\n method=method)\r\n\r\n # Register this new ajax function\r\n self._registry[name] = function","def pick(func):\n setattr(world, func.__name__, func)\n return func","def add_decl_function(node, func, is_override):\n name = func.__name__\n klass = node.klass\n if is_override:\n current = getattr(klass, name, None)\n if not getattr(current, \"_d_func\", False):\n raise TypeError(\"'%s' is not a declarative function\" % name)\n elif hasattr(klass, name):\n _override_fail(klass, name)\n d_func = DeclarativeFunction(func, node.scope_key)\n setattr(klass, name, d_func)","def add_url_rule(self, rule, view_func, endpoint=None, **options):\n if endpoint is None:\n endpoint = view_func.__name__\n\n options['endpoint'] = endpoint\n methods = options.pop('methods', None)\n\n # TODO: allow one django urlpattern to route to different rules\n\n rule = self.url_rule_class(rule, **options)\n\n self.url_map.add(rule)\n self.view_functions[endpoint] = self.build_view_wrapper(view_func, rule)","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_function_definition(self):\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\n assert func is not None","def test_unexpected_strategy():\n assert strategies == {\n 'css': FindByCss,\n 'xpath': FindByXPath,\n 'tag': FindByTag,\n 'name': FindByName,\n 'text': FindByText,\n 'id': FindById,\n 'value': FindByValue,\n }","async def register_endpoint(\n self, callback: Callable[[Any, dict], Any], endpoint: str = None, **kwargs: Optional[Any]\n ) -> str:\n if endpoint is None:\n endpoint = self.name\n\n if self.AD.http is not None:\n return await self.AD.http.register_endpoint(callback, endpoint, self.name, **kwargs)\n else:\n self.logger.warning(\n \"register_endpoint for %s failed - HTTP component is not configured\",\n endpoint,\n )","def func(self, name=None):\n def wrapper(fn):\n if name is not None:\n _name = name\n else:\n _name = fn.__name__\n\n if _name in self._funcs:\n raise Error(\"Function already defined: {0}\".format(_name))\n\n self._funcs[_name] = fn\n return fn\n return wrapper","def get_strategy_name(self):\n return self._java_ref.getStrategyName()","def decorator_register(func, name=None):\n self.register_command(func, name, description, show_if, args_opts)\n\n def func_wrapper(*args, **kwargs):\n return func(*args, **kwargs)\n\n return func_wrapper","def setting_handler(setting_name):\n def wrap(command_function):\n if isinstance(setting_name, basestring):\n local_executer.SETTING_FUNCTIONS[setting_name] = command_function\n elif isinstance(setting_name, tuple):\n for name in setting_name:\n local_executer.SETTING_FUNCTIONS[name] = command_function\n else:\n raise Exception('Invalid use of \"local_command\" decorator')\n \n #We don't really want to decorate this function.\n return command_function\n \n return wrap","def add_url_rule(self, rule, view_func, **options):\n methods = options.pop('methods', None)\n\n if methods is None:\n methods = ('GET',) # add default method\n\n methods = set(methods)\n\n# if not 'POST' or not 'GET' in methods:\n# sys.stderr.write('Method <%s> not implemented for function: <%s>.\\n' % (methods, view_func.__name__))\n# sys.exit(1)\n\n map_url = {'rule': rule,\n 'endpoint': view_func.__name__,\n 'view_func': view_func,\n 'methods': methods,\n '_regex': compile(rule)}\n\n if 'POST' in methods:\n self.post_map_url.append(map_url)\n elif 'GET' in methods:\n self.get_map_url.append(map_url)","def create_location(self, location):\n \"Does nothing\"","def register_dashboard(self, function):\n\n plugin_file = None\n frame = inspect.stack()[1]\n\n if hasattr(frame, 'filename'):\n # Changed from Python 3.5\n plugin_file = os.path.basename(os.path.normpath(frame.filename))\n else:\n plugin_file = os.path.basename(os.path.normpath(frame[1]))\n\n plugin_name = plugin_file.split(\".\")[0]\n if plugin_name in self.dashboard_handlers:\n L.error(\"Error:\" + plugin_name + \" is already in dashboard\")\n return False\n self.dashboard_handlers[plugin_name] = function\n return True","def on_route_open_position(self, strategy) -> None:\n pass","def hook(self, name):\r\n def wrapper(func):\r\n self.hooks.add(name, func)\r\n return func\r\n return wrapper","def add_function_entry(self, name=None):\n return self._build_op('function_entry', [], name=name)","def registerMLPlugin(self, tag, handler_fn):\n self.ml_plugins[tag] = handler_fn","def __init__(self, function, original_name, cache_name=None, default_value=None, use_default=True,\n key_replace_name=None):\n functools.update_wrapper(self, function)\n self.func = function\n self.name = function.__name__\n self.original_name = original_name\n self.cache_name = cache_name\n self.default_value = default_value\n self.use_default = use_default\n self.key_replace_name = key_replace_name","def get_case_strategy( # pylint: disable=too-many-locals\n draw: Callable,\n endpoint: Endpoint,\n hooks: Optional[HookDispatcher] = None,\n feedback: Optional[Feedback] = None,\n data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),\n path_parameters: Any = NOT_SET,\n headers: Any = NOT_SET,\n cookies: Any = NOT_SET,\n query: Any = NOT_SET,\n body: Any = NOT_SET,\n) -> Any:\n to_strategy = {DataGenerationMethod.positive: make_positive_strategy}[data_generation_method]\n\n context = HookContext(endpoint)\n\n if path_parameters is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"path\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"path\")\n path_parameters = draw(strategy)\n if headers is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"header\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"header\")\n headers = draw(strategy)\n if cookies is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"cookie\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"cookie\")\n cookies = draw(strategy)\n if query is NOT_SET:\n strategy = get_parameters_strategy(endpoint, to_strategy, \"query\")\n strategy = apply_hooks(endpoint, context, hooks, strategy, \"query\")\n query = draw(strategy)\n\n media_type = None\n if body is NOT_SET:\n if endpoint.body:\n parameter = draw(st.sampled_from(endpoint.body.items))\n strategy = _get_body_strategy(parameter, to_strategy)\n media_type = parameter.media_type\n body = draw(strategy)\n else:\n media_types = endpoint.get_request_payload_content_types() or [\"application/json\"]\n # Take the first available media type.\n # POSSIBLE IMPROVEMENT:\n # - Test examples for each available media type on Open API 2.0;\n # - On Open API 3.0, media types are explicit, and each example has it. We can pass `OpenAPIBody.media_type`\n # here from the examples handling code.\n media_type = media_types[0]\n if endpoint.schema.validate_schema and endpoint.method.upper() == \"GET\" and endpoint.body:\n raise InvalidSchema(\"Body parameters are defined for GET request.\")\n return Case(\n endpoint=endpoint,\n feedback=feedback,\n media_type=media_type,\n path_parameters=path_parameters,\n headers=headers,\n cookies=cookies,\n query=query,\n body=body,\n )","def create_location_based(cls, name, question, default_response, contacts, user): \n poll = Poll.objects.create(\n name=name,\n question=question,\n default_response=default_response, \n user=user,\n type=Poll.TYPE_LOCATION)\n poll.contacts = contacts\n return poll","def visit(location):\r\n \r\n func_map = {\r\n 'woods':woods_0_0,\r\n 'purchase beer':beer,\r\n 'purchase weapons':buy,\r\n 'sell stuff':sell,\r\n 'purchase map':buy_map,\r\n 'map':inspect_map\r\n }\r\n \r\n global locations_list\r\n global press_enter\r\n global map_0, map_1, map_2\r\n\r\n # reset map\r\n map_0 = '| |' + map_0[12:]\r\n map_1 = '| |' + map_1[12:]\r\n map_2 = '| |' + map_2[12:]\r\n\r\n locations_list = func_map.keys()\r\n \r\n if location not in locations_list:\r\n \r\n try:\r\n func = eval(location)\r\n except:\r\n print 'you dumb, bro'\r\n return 'death'\r\n\r\n else:\r\n func = func_map[location]\r\n\r\n crazy_spot = 0\r\n\r\n if location[0:5] == 'woods': #only go into the portal/bongos from the woods\r\n crazy_spot = random.randint(0,9)\r\n if crazy_spot == 1:\r\n func = bongos\r\n if crazy_spot == 2:\r\n func = portal\r\n\r\n return func()","def make(cls, cluster_name: str, backend: 'backends.Backend',\n task: 'task_lib.Task', retry_until_up: bool) -> 'StrategyExecutor':\n task_resources = task.resources\n assert len(task_resources) == 1, 'Only one resource is supported.'\n resources: 'sky.Resources' = list(task_resources)[0]\n\n spot_recovery = resources.spot_recovery\n assert spot_recovery is not None, (\n 'spot_recovery is required to use spot strategy.')\n # Remove the spot_recovery field from the resources, as the strategy\n # will be handled by the strategy class.\n task.set_resources({resources.copy(spot_recovery=None)})\n return SPOT_STRATEGIES[spot_recovery](cluster_name, backend, task,\n retry_until_up)","def add_function(self, function):\n self.functions.append(function)","def add_function(self, function):\n self.functions.append(function)","def find(name: str):\n return _functions[name]","def navigate(self, address, function_address=None):\n pass","def add(self, name: str, binary: str) -> None:\n\n def func(\n args_as_list: List[str], capture_output: bool = False, dir_to_execute: str = None\n ) -> List[str]:\n \"\"\"Provide the adapter arguments as a list via \"args_as_list\".\"\"\"\n cmd = [binary] + args_as_list\n return self._run(cmd, capture_output, dir_to_execute)\n\n self.adapters[name] = func","def add_custom_hook(hook_name):\n globs = globals()\n if hook_name in _CUSTOM_HOOKS or hook_name in globs:\n raise HookAlreadyExists(\"Hook named {0!r} already exists!\".format(hook_name))\n\n returned = _CUSTOM_HOOKS[hook_name] = globs[hook_name] = Callback()\n return returned","def addFunction(name, callables, icon=None):\n\n\tif not _funcDict.has_key(name):\n\t\t_functionOrder.append(name)\n\t_funcDict[name] = callables\n\tif icon:\n\t\timageDict[name] = icon\n\tif _mouseCategory:\n\t\t_mouseCategory.addFunc(name, callables)","def _fn(self, e_s, e_p, e_o):\n logger.error('_fn is a placeholder function in an abstract class')\n NotImplementedError(\"This function is a placeholder in an abstract class\")","def manage_addCustomGraphPoint(self, new_id, flavor, REQUEST=None):\n exec 'import %s' % flavor\n cls = eval('%s.%s' % (flavor, flavor))\n gp = self.createGraphPoint(cls, new_id)\n if REQUEST:\n audit('UI.GraphDefinition.AddGraphPoint', self.id, graphPointType=flavor, graphPoint=gp.id)\n url = '%s/graphPoints/%s' % (self.getPrimaryUrlPath(), gp.id)\n REQUEST['RESPONSE'].redirect(url)\n return self.callZenScreen(REQUEST)\n return gp","def add_handler ( handler_list, handler_function ):\n if not (handler_function in handler_list):\n handler_list.append ( handler_function )\n \n #cellblender_added_handlers","def addLocation(self, locationString):\r\n self.location = locationString\r\n self.addFiles(locationString)\r\n return","def add(self, name, function):\r\n\r\n # If this is not the final function name (there are more modules)\r\n # split the name again an register a new submodule.\r\n if '.' in name:\r\n module, extra = name.split('.', 1)\r\n if module not in self.submodules:\r\n self.submodules[module] = DajaxiceModule(module)\r\n self.submodules[module].add(extra, function)\r\n else:\r\n self.functions[name] = function","def DoBoundsSearch(lat, lng, lod, output, function_name=\"\"):\n\n if output == \"json\":\n # For json request, assume 2d Mercator request.\n bounds = MercatorBounds(lat, lng, lod)\n BoundsToJson(lat, lng, lod, bounds)\n elif output == \"kml\":\n # For kml request, assume 3d flat request.\n bounds = FlatBounds(lat, lng, lod)\n BoundsToKml(lat, lng, lod, bounds)\n else:\n # Return jsonp (javascript with function call) by default.\n # For jsonp request, assume 2d Mercator request.\n bounds = MercatorBounds(lat, lng, lod)\n BoundsToJsonp(lat, lng, lod, bounds, function_name)","def advice(*args, **kwargs):\n # TODO: make implementation as stated above\n return function(*args, **kwargs)"],"string":"[\n \"def strategy(func):\\n strategies.append(func)\\n return func\",\n \"def strategy(strategy_name: str):\\r\\n def wrapper(finder_class):\\r\\n global strategies\\r\\n strategies[strategy_name] = finder_class\\r\\n return finder_class\\r\\n return wrapper\",\n \"def _apply_hooks(\\n context: HookContext, hooks: HookDispatcher, strategy: st.SearchStrategy[Case], location: str\\n) -> st.SearchStrategy[Case]:\\n container = LOCATION_TO_CONTAINER[location]\\n for hook in hooks.get_all_by_name(f\\\"before_generate_{container}\\\"):\\n strategy = hook(context, strategy)\\n return strategy\",\n \"def initialize_location_strategies(self):\\n locator_manager.register_locators(\\\"sf\\\", lex_locators)\\n locator_manager.register_locators(\\\"text\\\", \\\"Salesforce.Locate Element by Text\\\")\\n locator_manager.register_locators(\\\"title\\\", \\\"Salesforce.Locate Element by Title\\\")\\n\\n # This does the work of actually adding all of the above-registered\\n # location strategies, plus any that were registered by keyword\\n # libraries.\\n locator_manager.add_location_strategies()\",\n \"def apply_hooks(\\n endpoint: Endpoint,\\n context: HookContext,\\n hooks: Optional[HookDispatcher],\\n strategy: st.SearchStrategy[Case],\\n location: str,\\n) -> st.SearchStrategy[Case]:\\n strategy = _apply_hooks(context, GLOBAL_HOOK_DISPATCHER, strategy, location)\\n strategy = _apply_hooks(context, endpoint.schema.hooks, strategy, location)\\n if hooks is not None:\\n strategy = _apply_hooks(context, hooks, strategy, location)\\n return strategy\",\n \"def location(name, factory=None):\\n\\n def set_location(config, name, factory):\\n root = config.registry[LOCATION_ROOT]\\n root.attach(name, factory)\\n\\n def decorate(factory):\\n def callback(scanner, factory_name, factory):\\n scanner.config.action(('location', name), set_location,\\n args=(scanner.config, name, factory),\\n order=PHASE2_CONFIG)\\n venusian.attach(factory, callback, category='pyramid')\\n return factory\\n\\n return decorate\",\n \"def InitStrategy(self, sname, strategy):\\n\\n self._string = sname\\n\\n self.strategy = strategy\\n self.postracker = position.PositionTracker(self.strategy)\",\n \"def add_location(self, **kwargs):\\n \\n self.options.update(kwargs)\\n self.options['action'] = 'locator.location.add'\\n return self.call(self.options)\",\n \"def get_parameters_strategy(\\n endpoint: Endpoint, to_strategy: Callable[[Dict[str, Any]], st.SearchStrategy], location: str\\n) -> st.SearchStrategy:\\n parameters = getattr(endpoint, LOCATION_TO_CONTAINER[location])\\n if parameters:\\n schema = parameters_to_json_schema(parameters)\\n strategy = to_strategy(schema)\\n serialize = endpoint.get_parameter_serializer(location)\\n if serialize is not None:\\n strategy = strategy.map(serialize)\\n filter_func = {\\n \\\"path\\\": is_valid_path,\\n \\\"header\\\": is_valid_header,\\n \\\"cookie\\\": is_valid_header,\\n \\\"query\\\": is_valid_query,\\n }[location]\\n strategy = strategy.filter(filter_func)\\n map_func = {\\\"path\\\": quote_all}.get(location)\\n if map_func:\\n strategy = strategy.map(map_func)\\n return strategy\\n # No parameters defined for this location\\n return st.none()\",\n \"def on_route_increased_position(self, strategy) -> None:\\n pass\",\n \"def create_strategy(config):\\n build_strategy = paddle.static.BuildStrategy()\\n exec_strategy = paddle.static.ExecutionStrategy()\\n\\n exec_strategy.num_threads = 1\\n exec_strategy.num_iteration_per_drop_scope = (\\n 10000\\n if 'AMP' in config and config.AMP.get(\\\"use_pure_fp16\\\", False) else 10)\\n\\n fuse_op = True if 'AMP' in config else False\\n\\n fuse_bn_act_ops = config.get('fuse_bn_act_ops', fuse_op)\\n fuse_elewise_add_act_ops = config.get('fuse_elewise_add_act_ops', fuse_op)\\n fuse_bn_add_act_ops = config.get('fuse_bn_add_act_ops', fuse_op)\\n enable_addto = config.get('enable_addto', fuse_op)\\n\\n build_strategy.fuse_bn_act_ops = fuse_bn_act_ops\\n build_strategy.fuse_elewise_add_act_ops = fuse_elewise_add_act_ops\\n build_strategy.fuse_bn_add_act_ops = fuse_bn_add_act_ops\\n build_strategy.enable_addto = enable_addto\\n\\n return build_strategy, exec_strategy\",\n \"def add_straight_through_estimator(jax_function):\\n\\n # See\\n # https://jax.readthedocs.io/en/latest/notebooks/Custom_derivative_rules_for_Python_code.html\\n def ste(primals, tangents):\\n return jax_function(primals[0]), tangents[0]\\n\\n jax_function.defjvp(ste)\",\n \"def createFunction(self, entryPoint: ghidra.program.model.address.Address, name: unicode) -> ghidra.program.model.listing.Function:\\n ...\",\n \"def used_implementation(self, impl: str, value):\",\n \"def add_impl(opaque_func, name, implementation, restype=None, restype_func=None):\\n def impl(py_func, argtypes):\\n # TODO: do this better\\n from flypy.compiler import representation_type\\n\\n ll_argtypes = [representation_type(x) for x in argtypes]\\n argnames = list(string.ascii_letters[:len(argtypes)])\\n\\n # Determine return type\\n if restype_func:\\n result_type = restype_func(argtypes)\\n else:\\n result_type = restype or ll_argtypes[0]\\n\\n type = ptypes.Function(result_type, tuple(ll_argtypes), False)\\n func = ir.Function(name, argnames, type)\\n func.new_block(\\\"entry\\\")\\n b = ir.Builder(func)\\n b.position_at_beginning(func.startblock)\\n implementation(b, argtypes, *func.args)\\n return func\\n\\n opaque.implement_opaque(opaque_func, impl)\",\n \"def add_function_attribute(self, name, value):\\n # Transcode the function to javascript\\n xml.add_attribute(self, name, ajax.JS(value))\",\n \"def map_function(self, name):\\n def decorator(func):\\n\\n # Check if the Thrift function was already assigned\\n if name in self.__mapped_names:\\n raise NameError(\\n f'Thrift Function \\\"{name}\\\" is already assigned!'\\n )\\n\\n self.__mapped_names.add(name)\\n\\n setattr(self, name, func)\\n return func\\n\\n return decorator\",\n \"def register(name, fn=None):\\n def _hook_add(func):\\n if name not in _hooks:\\n logger.debug(\\\"Creating new hook %s\\\" % name)\\n _hooks[name] = []\\n\\n logger.debug('Registering hook %s for function %s' % (name, fn))\\n _hooks[name].append(func)\\n\\n if fn is None:\\n # Behave like a decorator\\n def decorator(func):\\n _hook_add(func)\\n return func\\n return decorator\\n else:\\n # Behave like a function, just register hook\\n _hook_add(fn)\",\n \"def _register_function(parser, name, fn):\\n argspec = inspect.getargspec(fn)\\n\\n # agent_daemon_context is used to pass daemon context to the agnet, the user cannot provide it and\\n # so functions that require it cannot be called from the CLI\\n # In future we might want to 'create' a context so these functions can be called, but today the only\\n # usages do not make sense to call from the CLI.\\n if \\\"agent_daemon_context\\\" in argspec[0]:\\n return\\n\\n p = parser.add_parser(name, help=fn.__doc__)\\n\\n def wrap(args):\\n args = vars(args)\\n del args[\\\"func\\\"]\\n return fn(**args)\\n\\n p.set_defaults(func=wrap)\\n\\n if argspec.defaults is not None:\\n positional_arg_count = len(argspec.args) - len(argspec.defaults)\\n else:\\n positional_arg_count = len(argspec.args)\\n\\n for i, arg in enumerate(argspec.args):\\n if i < positional_arg_count:\\n p.add_argument(\\\"--%s\\\" % arg, required=True)\\n else:\\n if isinstance(argspec.defaults[i - positional_arg_count], bool):\\n p.add_argument(\\\"--%s\\\" % arg, required=False, action=\\\"store_true\\\")\\n else:\\n p.add_argument(\\\"--%s\\\" % arg, required=False)\",\n \"def get_mapping_function(\\n function_name: Text, functions_mapping: FunctionsMapping\\n) -> Callable:\\n if function_name in functions_mapping:\\n return functions_mapping[function_name]\\n\\n elif function_name in [\\\"parameterize\\\", \\\"P\\\"]:\\n return loader.load_csv_file\\n\\n elif function_name in [\\\"environ\\\", \\\"ENV\\\"]:\\n return utils.get_os_environ\\n\\n elif function_name in [\\\"multipart_encoder\\\", \\\"multipart_content_type\\\"]:\\n # extension for upload test\\n from httprunner.ext import uploader\\n\\n return getattr(uploader, function_name)\\n\\n try:\\n # check if HttpRunner builtin functions\\n built_in_functions = loader.load_builtin_functions()\\n return built_in_functions[function_name]\\n except KeyError:\\n pass\\n\\n try:\\n # check if Python builtin functions\\n return getattr(builtins, function_name)\\n except AttributeError:\\n pass\\n\\n raise exceptions.FunctionNotFound(f\\\"{function_name} is not found.\\\")\",\n \"def optimize(fn, search_strategy=PESearch, generations=100, pop_size=10, allow_duplicates=False, logger=None, **kwargs):\\n params_func = _make_params_func(fn)\\n\\n @functools.wraps(fn)\\n def eval_func(kwargs):\\n return fn(**kwargs)\\n\\n grammar = generate_cfg(params_func)\\n\\n search = search_strategy(grammar, eval_func, pop_size=pop_size, allow_duplicates=allow_duplicates, **kwargs)\\n best, best_fn = search.run(generations, logger=logger)\\n\\n return best, best_fn\",\n \"def register_string_format(name: str, strategy: st.SearchStrategy) -> None:\\n if not isinstance(name, str):\\n raise TypeError(f\\\"name must be of type {str}, not {type(name)}\\\")\\n if not isinstance(strategy, st.SearchStrategy):\\n raise TypeError(f\\\"strategy must be of type {st.SearchStrategy}, not {type(strategy)}\\\")\\n\\n STRING_FORMATS[name] = strategy\",\n \"def strategy_config(self, strategy_config):\\n self._strategy_config = strategy_config\",\n \"def get_address(supvisors, strategy, addresses, expected_loading):\\n if strategy == StartingStrategies.CONFIG:\\n instance = ConfigStrategy(supvisors)\\n if strategy == StartingStrategies.LESS_LOADED:\\n instance = LessLoadedStrategy(supvisors)\\n if strategy == StartingStrategies.MOST_LOADED:\\n instance = MostLoadedStrategy(supvisors)\\n # apply strategy result\\n return instance.get_address(addresses, expected_loading)\",\n \"def location():\\n return _locate_or_create()\",\n \"def get_location(self):\\n self.location = self.func(0)\",\n \"def register_step_function(\\n fn: StepFunction,\\n identifier: str,\\n aggregate_map: Optional[Dict[str, str]] = None,\\n overwrite: bool = False,\\n) -> None:\\n if identifier in STEP_SCORES_MAP:\\n if not overwrite:\\n raise ValueError(\\n f\\\"{identifier} is already registered in step functions map. Override with overwrite=True.\\\"\\n )\\n logger.warning(f\\\"Overwriting {identifier} step function.\\\")\\n STEP_SCORES_MAP[identifier] = fn\\n if isinstance(aggregate_map, dict):\\n for agg_name, aggregation_fn_identifier in aggregate_map.items():\\n if agg_name not in DEFAULT_ATTRIBUTION_AGGREGATE_DICT[\\\"step_scores\\\"]:\\n DEFAULT_ATTRIBUTION_AGGREGATE_DICT[\\\"step_scores\\\"][agg_name] = {}\\n DEFAULT_ATTRIBUTION_AGGREGATE_DICT[\\\"step_scores\\\"][agg_name][identifier] = aggregation_fn_identifier\",\n \"def lookup_function(self, name, context):\\n if name not in self.functions:\\n raise Exception(\\\"No such function: \\\" + str(name))\\n return Function(self.functions[name], context)\",\n \"def register_function(self, function, name=None):\\n if name:\\n self[name] = function\\n else:\\n self[function.__name__] = function\",\n \"def add_function(self, return_type: str, function_name: str, lines, arguments: list, add_scope=add_raw, *,\\n name_abs=False, fragments=()) -> str:\\n if name_abs:\\n name = function_name\\n else:\\n name = self.create_unique_id(function_name)\\n frag_str = (',fragment=\\\"' + ','.join(fragments) + '\\\"') if fragments else ''\\n lines = clean_source(lines)\\n lines = [\\n '%fragment (\\\"' + name + '\\\",\\\"header\\\"' + frag_str + '){',\\n return_type + ' ' + name + '(' + ', '.join(arguments) + ') {',\\n *('\\\\t' + l for l in lines),\\n '}',\\n '}'\\n ]\\n add_scope(self, lines)\\n return name\",\n \"def add_render_function(self, render_function):\\n self._render_function_tmp = render_function\\n if self._render_function_tmp is None:\\n def render_function_with_get_options(name, value):\\n # Get all the selected values\\n self._get_selected_options()\\n # Make displacements menu invisible\\n self.plot_displacements_menu.visible = False\\n else:\\n def render_function_with_get_options(name, value):\\n # Get all the selected values\\n self._get_selected_options()\\n # Call render function\\n self._render_function_tmp(name, value)\\n self._render_function = render_function_with_get_options\\n self.renderer_widget.add_render_function(self._render_function)\\n self.x_limit.on_trait_change(self._render_function, 'value')\\n self.y_limit.on_trait_change(self._render_function, 'value')\\n self.x_label.on_trait_change(self._render_function, 'value')\\n self.y_label.on_trait_change(self._render_function, 'value')\\n self.title.on_trait_change(self._render_function, 'value')\\n self.legend_entries.on_trait_change(self._render_function, 'value')\",\n \"def pulldiscovery(stepname):\\n\\n def dec(func):\\n assert stepname not in pulldiscoverymapping\\n pulldiscoverymapping[stepname] = func\\n pulldiscoveryorder.append(stepname)\\n return func\\n\\n return dec\",\n \"def register_function(self, function, name=None):\\n if name is None:\\n name = function.__name__\\n self.funcs[name] = function\",\n \"def register_report_location_callback(self, callback=None, report_cartesian=True, report_joints=True):\\r\\n return self._arm.register_report_location_callback(callback=callback,\\r\\n report_cartesian=report_cartesian,\\r\\n report_joints=report_joints)\",\n \"def test_strategy_attribute_correct():\\n assert 'css' == FindByCss.strategy\\n assert 'id' == FindById.strategy\\n assert 'name' == FindByName.strategy\\n assert 'tag' == FindByTag.strategy\\n assert 'text' == FindByText.strategy\\n assert 'value' == FindByValue.strategy\\n assert 'xpath' == FindByXPath.strategy\",\n \"def test_function_definition(self):\\n self.script(\\\"# script.py\\\\n\\\"\\n \\\"def f():\\\\n\\\"\\n \\\" 'fdoc'\\\\n\\\"\\n \\\" pass\\\\n\\\")\\n self.compile()\\n\\n script = self.find_code_component(name=\\\"script.py\\\")\\n function_def = self.find_code_component(name=\\\"f\\\")\\n\\n self.assertEqual(function_def.type, \\\"function_def\\\")\\n self.assertEqual(function_def.mode, \\\"w\\\")\\n self.assertEqual(function_def.first_char_line, 2)\\n self.assertEqual(function_def.first_char_column, 0)\\n self.assertEqual(function_def.last_char_line, 4)\\n self.assertEqual(function_def.last_char_column, 8)\\n self.assertEqual(function_def.container_id, script.id)\\n\\n function_def_block = self.metascript.code_blocks_store[function_def.id]\\n self.assertEqual(function_def_block.code,\\n \\\"def f():\\\\n\\\"\\n \\\" 'fdoc'\\\\n\\\"\\n \\\" pass\\\")\\n self.assertEqual(function_def_block.docstring, \\\"fdoc\\\")\\n self.assertTrue(bool(function_def_block.code_hash))\",\n \"def stmt_def(executor, stmt:ParsedStatementDef):\\n executor.put_symbol(stmt._variable, stmt._tokens, SymbolType.FUNCTION, stmt._function_arg)\",\n \"def strategy(self, strategy):\\n\\n if strategy == \\\"auto\\\":\\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 0)\\n elif strategy == \\\"cranelift\\\":\\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 1)\\n elif strategy == \\\"lightbeam\\\":\\n error = dll.wasmtime_config_strategy_set(self.__ptr__, 2)\\n else:\\n raise WasmtimeError(\\\"unknown strategy: \\\" + str(strategy))\\n if error:\\n raise WasmtimeError.__from_ptr__(error)\",\n \"def add_custom_widget(self, name, widget, value_handler=None, indicator_handler=None, location=(None,0,1,None)):\\n if name in self.params:\\n raise KeyError(\\\"widget {} already exists\\\".format(name))\\n location=self._normalize_location(location,default=(None,0,1,3))\\n self.formLayout.addWidget(widget,*location)\\n value_handler=value_handler or values_module.get_default_value_handler(widget)\\n indicator_handler=indicator_handler or values_module.get_default_indicator_handler(widget)\\n self._add_widget(name,self.ParamRow(widget,None,value_handler,indicator_handler))\\n return value_handler\",\n \"def on_game_start(self, config):\\n gamelib.debug_write('Configuring your custom algo strategy...')\\n self.config = config\\n global FILTER, ENCRYPTOR, DESTRUCTOR, PING, EMP, SCRAMBLER\\n FILTER = config[\\\"unitInformation\\\"][0][\\\"shorthand\\\"]\\n ENCRYPTOR = config[\\\"unitInformation\\\"][1][\\\"shorthand\\\"]\\n DESTRUCTOR = config[\\\"unitInformation\\\"][2][\\\"shorthand\\\"]\\n PING = config[\\\"unitInformation\\\"][3][\\\"shorthand\\\"]\\n EMP = config[\\\"unitInformation\\\"][4][\\\"shorthand\\\"]\\n SCRAMBLER = config[\\\"unitInformation\\\"][5][\\\"shorthand\\\"]\\n\\n # Can store custom variables and settings here:\\n self.hole_x_location = 17\",\n \"def getstrategy(stname, visited=None, retval=None):\\n dprint(2, 'getstrategy', stname)\\n dprint(3, 'getstrategy', stname, visited, retval)\\n if visited is None:\\n visited = []\\n if retval is None:\\n retval = []\\n if stname in visited:\\n dprint(0, 'loop detected', stname, visited)\\n # resilient but dangerous; keeps going\\n return retval\\n visited.append(stname)\\n\\n sto, sts = stname.split('/')\\n surl = os.path.join(args.trserver, sto, 'strategy', sts)\\n outp = trgeturl(surl, 'lines')\\n if not outp:\\n dprint(0, 'failed strategy', stname)\\n # resilient but dangerous; keeps going\\n return retval\\n for ln in outp:\\n cmdln = ln.split()\\n cmd = cmdln.pop(0)\\n if cmd == 'test':\\n pri = 50\\n if cmdln[0].startswith('pri='):\\n pric = cmdln.pop(0)\\n pri = int(pric.split('=')[1])\\n test = cmdln.pop(0)\\n retval.append((pri, test, cmdln))\\n dprint(3, 'added test', pri, test, cmdln)\\n elif cmd == 'include' or cmd == 'strategy':\\n dprint(3, 'including strategy', cmdln)\\n retval = getstrategy(cmdln.pop(0), visited, retval)\\n else:\\n dprint(0, 'error unknown cmd', cmd)\\n\\n return retval\",\n \"def create_test_strategy(context, **kw):\\n strategy = get_test_strategy(context, **kw)\\n strategy.create()\\n return strategy\",\n \"def test_stepregistry_step_decorator_should_register_func_with_proper_keyword(keyword):\\n # given\\n registry = StepRegistry()\\n context = {}\\n registry.create_step_decorators(context)\\n\\n # when\\n def test_step():\\n ...\\n\\n test_step = context[keyword.lower()](\\\"pattern\\\")(test_step)\\n\\n # then\\n assert registry.step_implementations(keyword) == [\\n StepImpl(keyword, \\\"pattern\\\", test_step)\\n ]\",\n \"def navigate_to_function(self, function_address, address):\\n pass\",\n \"def calculation_strategy(self) -> CalculationStrategy:\\n if \\\"calculation_strategy\\\" in self._json_data:\\n return CalculationStrategy(str(self._json_data.get(\\\"calculation_strategy\\\")))\\n return CalculationStrategy.LUT\",\n \"def test_function_definition_with_decorator(self):\\n self.script(\\\"# script.py\\\\n\\\"\\n \\\"def g(x):\\\\n\\\"\\n \\\" return x\\\\n\\\"\\n \\\"@g\\\\n\\\"\\n \\\"def f():\\\\n\\\"\\n \\\" 'fdoc'\\\\n\\\"\\n \\\" pass\\\\n\\\")\\n self.compile()\\n\\n script = self.find_code_component(name=\\\"script.py\\\")\\n function_def = self.find_code_component(name=\\\"f\\\")\\n\\n self.assertEqual(function_def.type, \\\"function_def\\\")\\n self.assertEqual(function_def.mode, \\\"w\\\")\\n self.assertEqual(function_def.first_char_line, 4)\\n self.assertEqual(function_def.first_char_column, 0)\\n self.assertEqual(function_def.last_char_line, 7)\\n self.assertEqual(function_def.last_char_column, 8)\\n self.assertEqual(function_def.container_id, script.id)\\n\\n function_def_block = self.metascript.code_blocks_store[function_def.id]\\n self.assertEqual(function_def_block.code,\\n \\\"@g\\\\n\\\"\\n \\\"def f():\\\\n\\\"\\n \\\" 'fdoc'\\\\n\\\"\\n \\\" pass\\\")\\n self.assertEqual(function_def_block.docstring, \\\"fdoc\\\")\\n self.assertTrue(bool(function_def_block.code_hash))\",\n \"def setStrategy(self, value):\\n return self._set(strategy=value)\",\n \"def strategy(self, opponent):\\n raise NotImplementedError()\",\n \"def add_new_function(self, pfunc, pfunc_bound= True, index = None):\\n raise NotImplementedError()\",\n \"def add_child_function(\\n self, name, url=None, image=None, requirements=None, kind=None\\n ):\\n function_reference = FunctionReference(\\n url, image, requirements=requirements, kind=kind or \\\"serving\\\"\\n )\\n self._spec.function_refs.update(function_reference, name)\\n func = function_reference.to_function(self.kind)\\n func.set_env(\\\"SERVING_CURRENT_FUNCTION\\\", function_reference.name)\\n return func\",\n \"def setFunctionName(self, function_name):\\r\\n self.actualFunction = function_name\",\n \"def register_step(step_function: StepFunction) -> None:\\n global _step_function\\n _step_function = step_function\",\n \"def add_component(self, function_name: str, path: pathlib.Path):\\n self._components[function_name] = str(path)\",\n \"def mock_fcn(self, name):\\n return MockFunction(self._context, name)\",\n \"def register(self, function, name=None, method='POST'):\\r\\n\\r\\n method = self.clean_method(method)\\r\\n\\r\\n # Generate a default name\\r\\n if not name:\\r\\n module = ''.join(str(function.__module__).rsplit('.ajax', 1))\\r\\n name = '.'.join((module, function.__name__))\\r\\n\\r\\n if ':' in name:\\r\\n log.error('Ivalid function name %s.' % name)\\r\\n return\\r\\n\\r\\n # Check for already registered functions\\r\\n if name in self._registry:\\r\\n log.error('%s was already registered.' % name)\\r\\n return\\r\\n\\r\\n # Create the dajaxice function.\\r\\n function = DajaxiceFunction(function=function,\\r\\n name=name,\\r\\n method=method)\\r\\n\\r\\n # Register this new ajax function\\r\\n self._registry[name] = function\",\n \"def pick(func):\\n setattr(world, func.__name__, func)\\n return func\",\n \"def add_decl_function(node, func, is_override):\\n name = func.__name__\\n klass = node.klass\\n if is_override:\\n current = getattr(klass, name, None)\\n if not getattr(current, \\\"_d_func\\\", False):\\n raise TypeError(\\\"'%s' is not a declarative function\\\" % name)\\n elif hasattr(klass, name):\\n _override_fail(klass, name)\\n d_func = DeclarativeFunction(func, node.scope_key)\\n setattr(klass, name, d_func)\",\n \"def add_url_rule(self, rule, view_func, endpoint=None, **options):\\n if endpoint is None:\\n endpoint = view_func.__name__\\n\\n options['endpoint'] = endpoint\\n methods = options.pop('methods', None)\\n\\n # TODO: allow one django urlpattern to route to different rules\\n\\n rule = self.url_rule_class(rule, **options)\\n\\n self.url_map.add(rule)\\n self.view_functions[endpoint] = self.build_view_wrapper(view_func, rule)\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_function_definition(self):\\n func = get_function_definition(PACKAGE_NAME, FUNCTION_NAME)\\n assert func is not None\",\n \"def test_unexpected_strategy():\\n assert strategies == {\\n 'css': FindByCss,\\n 'xpath': FindByXPath,\\n 'tag': FindByTag,\\n 'name': FindByName,\\n 'text': FindByText,\\n 'id': FindById,\\n 'value': FindByValue,\\n }\",\n \"async def register_endpoint(\\n self, callback: Callable[[Any, dict], Any], endpoint: str = None, **kwargs: Optional[Any]\\n ) -> str:\\n if endpoint is None:\\n endpoint = self.name\\n\\n if self.AD.http is not None:\\n return await self.AD.http.register_endpoint(callback, endpoint, self.name, **kwargs)\\n else:\\n self.logger.warning(\\n \\\"register_endpoint for %s failed - HTTP component is not configured\\\",\\n endpoint,\\n )\",\n \"def func(self, name=None):\\n def wrapper(fn):\\n if name is not None:\\n _name = name\\n else:\\n _name = fn.__name__\\n\\n if _name in self._funcs:\\n raise Error(\\\"Function already defined: {0}\\\".format(_name))\\n\\n self._funcs[_name] = fn\\n return fn\\n return wrapper\",\n \"def get_strategy_name(self):\\n return self._java_ref.getStrategyName()\",\n \"def decorator_register(func, name=None):\\n self.register_command(func, name, description, show_if, args_opts)\\n\\n def func_wrapper(*args, **kwargs):\\n return func(*args, **kwargs)\\n\\n return func_wrapper\",\n \"def setting_handler(setting_name):\\n def wrap(command_function):\\n if isinstance(setting_name, basestring):\\n local_executer.SETTING_FUNCTIONS[setting_name] = command_function\\n elif isinstance(setting_name, tuple):\\n for name in setting_name:\\n local_executer.SETTING_FUNCTIONS[name] = command_function\\n else:\\n raise Exception('Invalid use of \\\"local_command\\\" decorator')\\n \\n #We don't really want to decorate this function.\\n return command_function\\n \\n return wrap\",\n \"def add_url_rule(self, rule, view_func, **options):\\n methods = options.pop('methods', None)\\n\\n if methods is None:\\n methods = ('GET',) # add default method\\n\\n methods = set(methods)\\n\\n# if not 'POST' or not 'GET' in methods:\\n# sys.stderr.write('Method <%s> not implemented for function: <%s>.\\\\n' % (methods, view_func.__name__))\\n# sys.exit(1)\\n\\n map_url = {'rule': rule,\\n 'endpoint': view_func.__name__,\\n 'view_func': view_func,\\n 'methods': methods,\\n '_regex': compile(rule)}\\n\\n if 'POST' in methods:\\n self.post_map_url.append(map_url)\\n elif 'GET' in methods:\\n self.get_map_url.append(map_url)\",\n \"def create_location(self, location):\\n \\\"Does nothing\\\"\",\n \"def register_dashboard(self, function):\\n\\n plugin_file = None\\n frame = inspect.stack()[1]\\n\\n if hasattr(frame, 'filename'):\\n # Changed from Python 3.5\\n plugin_file = os.path.basename(os.path.normpath(frame.filename))\\n else:\\n plugin_file = os.path.basename(os.path.normpath(frame[1]))\\n\\n plugin_name = plugin_file.split(\\\".\\\")[0]\\n if plugin_name in self.dashboard_handlers:\\n L.error(\\\"Error:\\\" + plugin_name + \\\" is already in dashboard\\\")\\n return False\\n self.dashboard_handlers[plugin_name] = function\\n return True\",\n \"def on_route_open_position(self, strategy) -> None:\\n pass\",\n \"def hook(self, name):\\r\\n def wrapper(func):\\r\\n self.hooks.add(name, func)\\r\\n return func\\r\\n return wrapper\",\n \"def add_function_entry(self, name=None):\\n return self._build_op('function_entry', [], name=name)\",\n \"def registerMLPlugin(self, tag, handler_fn):\\n self.ml_plugins[tag] = handler_fn\",\n \"def __init__(self, function, original_name, cache_name=None, default_value=None, use_default=True,\\n key_replace_name=None):\\n functools.update_wrapper(self, function)\\n self.func = function\\n self.name = function.__name__\\n self.original_name = original_name\\n self.cache_name = cache_name\\n self.default_value = default_value\\n self.use_default = use_default\\n self.key_replace_name = key_replace_name\",\n \"def get_case_strategy( # pylint: disable=too-many-locals\\n draw: Callable,\\n endpoint: Endpoint,\\n hooks: Optional[HookDispatcher] = None,\\n feedback: Optional[Feedback] = None,\\n data_generation_method: DataGenerationMethod = DataGenerationMethod.default(),\\n path_parameters: Any = NOT_SET,\\n headers: Any = NOT_SET,\\n cookies: Any = NOT_SET,\\n query: Any = NOT_SET,\\n body: Any = NOT_SET,\\n) -> Any:\\n to_strategy = {DataGenerationMethod.positive: make_positive_strategy}[data_generation_method]\\n\\n context = HookContext(endpoint)\\n\\n if path_parameters is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"path\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"path\\\")\\n path_parameters = draw(strategy)\\n if headers is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"header\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"header\\\")\\n headers = draw(strategy)\\n if cookies is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"cookie\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"cookie\\\")\\n cookies = draw(strategy)\\n if query is NOT_SET:\\n strategy = get_parameters_strategy(endpoint, to_strategy, \\\"query\\\")\\n strategy = apply_hooks(endpoint, context, hooks, strategy, \\\"query\\\")\\n query = draw(strategy)\\n\\n media_type = None\\n if body is NOT_SET:\\n if endpoint.body:\\n parameter = draw(st.sampled_from(endpoint.body.items))\\n strategy = _get_body_strategy(parameter, to_strategy)\\n media_type = parameter.media_type\\n body = draw(strategy)\\n else:\\n media_types = endpoint.get_request_payload_content_types() or [\\\"application/json\\\"]\\n # Take the first available media type.\\n # POSSIBLE IMPROVEMENT:\\n # - Test examples for each available media type on Open API 2.0;\\n # - On Open API 3.0, media types are explicit, and each example has it. We can pass `OpenAPIBody.media_type`\\n # here from the examples handling code.\\n media_type = media_types[0]\\n if endpoint.schema.validate_schema and endpoint.method.upper() == \\\"GET\\\" and endpoint.body:\\n raise InvalidSchema(\\\"Body parameters are defined for GET request.\\\")\\n return Case(\\n endpoint=endpoint,\\n feedback=feedback,\\n media_type=media_type,\\n path_parameters=path_parameters,\\n headers=headers,\\n cookies=cookies,\\n query=query,\\n body=body,\\n )\",\n \"def create_location_based(cls, name, question, default_response, contacts, user): \\n poll = Poll.objects.create(\\n name=name,\\n question=question,\\n default_response=default_response, \\n user=user,\\n type=Poll.TYPE_LOCATION)\\n poll.contacts = contacts\\n return poll\",\n \"def visit(location):\\r\\n \\r\\n func_map = {\\r\\n 'woods':woods_0_0,\\r\\n 'purchase beer':beer,\\r\\n 'purchase weapons':buy,\\r\\n 'sell stuff':sell,\\r\\n 'purchase map':buy_map,\\r\\n 'map':inspect_map\\r\\n }\\r\\n \\r\\n global locations_list\\r\\n global press_enter\\r\\n global map_0, map_1, map_2\\r\\n\\r\\n # reset map\\r\\n map_0 = '| |' + map_0[12:]\\r\\n map_1 = '| |' + map_1[12:]\\r\\n map_2 = '| |' + map_2[12:]\\r\\n\\r\\n locations_list = func_map.keys()\\r\\n \\r\\n if location not in locations_list:\\r\\n \\r\\n try:\\r\\n func = eval(location)\\r\\n except:\\r\\n print 'you dumb, bro'\\r\\n return 'death'\\r\\n\\r\\n else:\\r\\n func = func_map[location]\\r\\n\\r\\n crazy_spot = 0\\r\\n\\r\\n if location[0:5] == 'woods': #only go into the portal/bongos from the woods\\r\\n crazy_spot = random.randint(0,9)\\r\\n if crazy_spot == 1:\\r\\n func = bongos\\r\\n if crazy_spot == 2:\\r\\n func = portal\\r\\n\\r\\n return func()\",\n \"def make(cls, cluster_name: str, backend: 'backends.Backend',\\n task: 'task_lib.Task', retry_until_up: bool) -> 'StrategyExecutor':\\n task_resources = task.resources\\n assert len(task_resources) == 1, 'Only one resource is supported.'\\n resources: 'sky.Resources' = list(task_resources)[0]\\n\\n spot_recovery = resources.spot_recovery\\n assert spot_recovery is not None, (\\n 'spot_recovery is required to use spot strategy.')\\n # Remove the spot_recovery field from the resources, as the strategy\\n # will be handled by the strategy class.\\n task.set_resources({resources.copy(spot_recovery=None)})\\n return SPOT_STRATEGIES[spot_recovery](cluster_name, backend, task,\\n retry_until_up)\",\n \"def add_function(self, function):\\n self.functions.append(function)\",\n \"def add_function(self, function):\\n self.functions.append(function)\",\n \"def find(name: str):\\n return _functions[name]\",\n \"def navigate(self, address, function_address=None):\\n pass\",\n \"def add(self, name: str, binary: str) -> None:\\n\\n def func(\\n args_as_list: List[str], capture_output: bool = False, dir_to_execute: str = None\\n ) -> List[str]:\\n \\\"\\\"\\\"Provide the adapter arguments as a list via \\\"args_as_list\\\".\\\"\\\"\\\"\\n cmd = [binary] + args_as_list\\n return self._run(cmd, capture_output, dir_to_execute)\\n\\n self.adapters[name] = func\",\n \"def add_custom_hook(hook_name):\\n globs = globals()\\n if hook_name in _CUSTOM_HOOKS or hook_name in globs:\\n raise HookAlreadyExists(\\\"Hook named {0!r} already exists!\\\".format(hook_name))\\n\\n returned = _CUSTOM_HOOKS[hook_name] = globs[hook_name] = Callback()\\n return returned\",\n \"def addFunction(name, callables, icon=None):\\n\\n\\tif not _funcDict.has_key(name):\\n\\t\\t_functionOrder.append(name)\\n\\t_funcDict[name] = callables\\n\\tif icon:\\n\\t\\timageDict[name] = icon\\n\\tif _mouseCategory:\\n\\t\\t_mouseCategory.addFunc(name, callables)\",\n \"def _fn(self, e_s, e_p, e_o):\\n logger.error('_fn is a placeholder function in an abstract class')\\n NotImplementedError(\\\"This function is a placeholder in an abstract class\\\")\",\n \"def manage_addCustomGraphPoint(self, new_id, flavor, REQUEST=None):\\n exec 'import %s' % flavor\\n cls = eval('%s.%s' % (flavor, flavor))\\n gp = self.createGraphPoint(cls, new_id)\\n if REQUEST:\\n audit('UI.GraphDefinition.AddGraphPoint', self.id, graphPointType=flavor, graphPoint=gp.id)\\n url = '%s/graphPoints/%s' % (self.getPrimaryUrlPath(), gp.id)\\n REQUEST['RESPONSE'].redirect(url)\\n return self.callZenScreen(REQUEST)\\n return gp\",\n \"def add_handler ( handler_list, handler_function ):\\n if not (handler_function in handler_list):\\n handler_list.append ( handler_function )\\n \\n #cellblender_added_handlers\",\n \"def addLocation(self, locationString):\\r\\n self.location = locationString\\r\\n self.addFiles(locationString)\\r\\n return\",\n \"def add(self, name, function):\\r\\n\\r\\n # If this is not the final function name (there are more modules)\\r\\n # split the name again an register a new submodule.\\r\\n if '.' in name:\\r\\n module, extra = name.split('.', 1)\\r\\n if module not in self.submodules:\\r\\n self.submodules[module] = DajaxiceModule(module)\\r\\n self.submodules[module].add(extra, function)\\r\\n else:\\r\\n self.functions[name] = function\",\n \"def DoBoundsSearch(lat, lng, lod, output, function_name=\\\"\\\"):\\n\\n if output == \\\"json\\\":\\n # For json request, assume 2d Mercator request.\\n bounds = MercatorBounds(lat, lng, lod)\\n BoundsToJson(lat, lng, lod, bounds)\\n elif output == \\\"kml\\\":\\n # For kml request, assume 3d flat request.\\n bounds = FlatBounds(lat, lng, lod)\\n BoundsToKml(lat, lng, lod, bounds)\\n else:\\n # Return jsonp (javascript with function call) by default.\\n # For jsonp request, assume 2d Mercator request.\\n bounds = MercatorBounds(lat, lng, lod)\\n BoundsToJsonp(lat, lng, lod, bounds, function_name)\",\n \"def advice(*args, **kwargs):\\n # TODO: make implementation as stated above\\n return function(*args, **kwargs)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5778675","0.5589892","0.47768068","0.4705223","0.46349427","0.45650652","0.44619638","0.44110903","0.43347523","0.42556694","0.42554522","0.4228382","0.41904864","0.41884336","0.41832274","0.41638365","0.4158864","0.4145258","0.41342977","0.41133204","0.40893945","0.40761042","0.40721855","0.4070602","0.4050641","0.40422696","0.40297917","0.40256727","0.4024236","0.39873117","0.39857683","0.3975973","0.39634037","0.3940882","0.39393663","0.39373463","0.39308333","0.3928616","0.39277306","0.39256218","0.39218628","0.39164793","0.39137718","0.39091563","0.38971466","0.38940746","0.38921428","0.38883418","0.38852453","0.38800144","0.38749644","0.387425","0.38460523","0.38289604","0.38262707","0.38178545","0.3816241","0.38156977","0.38141236","0.38141236","0.38141236","0.38141236","0.38141236","0.38141236","0.38141236","0.38141236","0.38141236","0.38141236","0.3813722","0.3805727","0.38003746","0.37986088","0.37940833","0.37851626","0.37837023","0.37789115","0.37664506","0.37659827","0.37648657","0.3764337","0.37585962","0.37516242","0.3749299","0.37374735","0.37314305","0.37304708","0.37273526","0.37273526","0.37258065","0.37233722","0.37179667","0.37167293","0.37166435","0.37147963","0.37146825","0.37141374","0.37090322","0.3706224","0.37037316","0.37035114"],"string":"[\n \"0.5778675\",\n \"0.5589892\",\n \"0.47768068\",\n \"0.4705223\",\n \"0.46349427\",\n \"0.45650652\",\n \"0.44619638\",\n \"0.44110903\",\n \"0.43347523\",\n \"0.42556694\",\n \"0.42554522\",\n \"0.4228382\",\n \"0.41904864\",\n \"0.41884336\",\n \"0.41832274\",\n \"0.41638365\",\n \"0.4158864\",\n \"0.4145258\",\n \"0.41342977\",\n \"0.41133204\",\n \"0.40893945\",\n \"0.40761042\",\n \"0.40721855\",\n \"0.4070602\",\n \"0.4050641\",\n \"0.40422696\",\n \"0.40297917\",\n \"0.40256727\",\n \"0.4024236\",\n \"0.39873117\",\n \"0.39857683\",\n \"0.3975973\",\n \"0.39634037\",\n \"0.3940882\",\n \"0.39393663\",\n \"0.39373463\",\n \"0.39308333\",\n \"0.3928616\",\n \"0.39277306\",\n \"0.39256218\",\n \"0.39218628\",\n \"0.39164793\",\n \"0.39137718\",\n \"0.39091563\",\n \"0.38971466\",\n \"0.38940746\",\n \"0.38921428\",\n \"0.38883418\",\n \"0.38852453\",\n \"0.38800144\",\n \"0.38749644\",\n \"0.387425\",\n \"0.38460523\",\n \"0.38289604\",\n \"0.38262707\",\n \"0.38178545\",\n \"0.3816241\",\n \"0.38156977\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.38141236\",\n \"0.3813722\",\n \"0.3805727\",\n \"0.38003746\",\n \"0.37986088\",\n \"0.37940833\",\n \"0.37851626\",\n \"0.37837023\",\n \"0.37789115\",\n \"0.37664506\",\n \"0.37659827\",\n \"0.37648657\",\n \"0.3764337\",\n \"0.37585962\",\n \"0.37516242\",\n \"0.3749299\",\n \"0.37374735\",\n \"0.37314305\",\n \"0.37304708\",\n \"0.37273526\",\n \"0.37273526\",\n \"0.37258065\",\n \"0.37233722\",\n \"0.37179667\",\n \"0.37167293\",\n \"0.37166435\",\n \"0.37147963\",\n \"0.37146825\",\n \"0.37141374\",\n \"0.37090322\",\n \"0.3706224\",\n \"0.37037316\",\n \"0.37035114\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.85643756"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88386,"cells":{"query":{"kind":"string","value":"Squash deeply nested dictionary."},"document":{"kind":"string","value":"def squash(data, parent_key=\"\", sep=\".\"):\n items = []\n for k, v in data.items():\n k = str(k)\n if k[0] == \"_\":\n k = k[1:]\n\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(v, collections.abc.MutableMapping):\n items.extend(squash(v, new_key, sep=sep).items())\n else:\n items.append((new_key, v))\n\n return dict(items)"},"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 recursive_squeeze(dictlike):\n out = {}\n for k, v in dictlike.items():\n if isinstance(v, dict):\n out[k] = recursive_squeeze(v)\n else:\n out[k] = np.squeeze(v)\n return out","def unflatten(\n d: Dict[str, Any],\n base: Dict[str, Any] = None,\n) -> Dict[str, Any]:\n if base is None:\n base = {}\n\n for key, value in d.items():\n root = base\n\n ###\n # If a dotted path is encountered, create nested dicts for all but\n # the last level, then change root to that last level, and key to\n # the final key in the path. This allows one final setitem at the bottom\n # of the loop.\n if '.' in key:\n *parts, key = key.split('.')\n\n for part in parts:\n root.setdefault(part, {})\n root = root[part]\n\n if isinstance(value, dict):\n value = unflatten(value, root.get(key, {}))\n\n root[key] = value\n\n return base","def deepupdate(original, update):\n for key, value in original.iteritems():\n if not key in update:\n update[key] = value\n elif isinstance(value, dict):\n deepupdate(value, update[key])\n return update","def simplify_dict(d: Dict[str, Any]) -> Dict[str, Any]:\n return {\n k: [ast_to_testing_string(n) for n in v] if k == \"children\" else v\n for k, v in d.items()\n }","def nested_to_flat(self, data: dict, target: str, **kwargs):\n data.update(data.pop(target, {}))\n return data","def flatten(d, parent_key='', sep='_'):\n items = []\n for k, v in d.items():\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(v, collections.MutableMapping):\n items.extend(flatten(v, new_key, sep=sep).items())\n else:\n items.append((new_key, v))\n items = dict(items)\n # remove info like PCA primitive ID\n items_not_strings = {k: v for k, v in items.items() if type(v) != str}\n return dict(items_not_strings)","def flatten(d, parent_key='', sep='_'):\n items = []\n for k, v in d.items():\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(v, collections.MutableMapping):\n items.extend(flatten(v, new_key, sep=sep).items())\n else:\n items.append((new_key, v))\n return dict(items)","def flatten_nested_dict(prefix, nested_dict):\n\n cleaned_nested_dict = {}\n cleaned_nested_dict = {\n f'{prefix}_{key}': val for key, val in nested_dict.items()}\n\n return cleaned_nested_dict","def flatten_dict(nested):\n flattened = {}\n for key, value in nested.items():\n if isinstance(value, Mapping):\n for subkey, subval in value.items():\n newkey = '.'.join([key, subkey])\n flattened[newkey] = subval\n flatten_dict(flattened)\n else:\n flattened[key] = value\n mappings = [isinstance(value, Mapping) for key, value in flattened.items()]\n if len(set(mappings)) == 1 and set(mappings).pop() is False:\n return flattened\n else:\n return flatten_dict(flattened)","def flatten_dict(d, parent_key=\"\", sep=\"_\"):\n items = []\n for k, v in d.items():\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(v, MutableMapping):\n items.extend(flatten_dict(v, new_key, sep=sep).items())\n else:\n items.append((new_key, v))\n return dict(items)","def flatten_dict(d, sep=' ', parent_key=''):\n items = []\n for k, v in d.items():\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(v, collections.MutableMapping):\n items.extend(flatten_dict(v, sep=sep, parent_key=new_key).items())\n else:\n items.append((new_key, v))\n return dict(items)","def _flatten_dict(self, current, key, result):\n if isinstance(current, dict):\n for k in current:\n new_key = \"{1}\".format(key, k) if len(key) > 0 else k\n self._flatten_dict(current[k], new_key, result)\n else:\n result[key] = current\n return result","def _dictRoundTripNormalize(self, treedict):\n for key, value in list(treedict.items()):\n if isinstance(value, dict):\n self._dictRoundTripNormalize(value)\n\n # Expand treedict[(\"group\", \"attr_name\")]\n # to treedict[\"group\"][\"attr_name\"]\n for key, value in list(treedict.items()):\n if not isinstance(key, tuple):\n continue\n # Put the attribute inside the group\n grpname, attr = key\n if not grpname:\n continue\n group = treedict.setdefault(grpname, dict())\n if isinstance(group, dict):\n del treedict[key]\n group[(\"\", attr)] = value","def merge_dict_recursive(target, src):\r\n for k in src.keys():\r\n if ((k in target and isinstance(target[k], dict) and\r\n isinstance(src[k], collections.Mapping))):\r\n merge_dict_recursive(target[k], src[k])\r\n else:\r\n target[k] = src[k]","def flatten(d: MutableMapping, sep: str = \".\", parent_key: str = \"\") -> dict:\n items = []\n for k, v in d.items():\n new_key = parent_key + sep + k if parent_key else k\n if isinstance(v, MutableMapping):\n items.extend(flatten(v, sep=sep, parent_key=new_key).items())\n else:\n items.append((new_key, v))\n return dict(items)","def recursive_dictionary_clear(d):\n for key in list(d):\n if isinstance(d[key], dict):\n recursive_dictionary_clear(d[key])\n\n if d[key] == \"\" or d[key] == {}:\n del d[key]","def _flatten_dict(x: Dict) ->Dict:\n new_dict = {}\n for key, value in x.items():\n if isinstance(value, dict):\n for k, v in value.items():\n new_dict[k] = v\n else:\n new_dict[key] = value\n return new_dict","def _flatten_dictionary(self, params, parent=None):\r\n data = OrderedDict()\r\n for key, val in params.items():\r\n full_key = parent + \"[\" + key + \"]\" if parent else key\r\n if isinstance(val, dict):\r\n data.update(self._flatten_dictionary(val, full_key))\r\n else:\r\n data[full_key] = val\r\n return data","def flatten(dictionary, sep=\".\"):\n\n def _flatten(dictionary):\n if dictionary == {}:\n return dictionary\n\n key, value = dictionary.popitem()\n if not isinstance(value, dict) or not value:\n new_dictionary = {key: value}\n new_dictionary.update(flatten(dictionary, sep=sep))\n return new_dictionary\n\n flat_sub_dictionary = flatten(value, sep=sep)\n for flat_sub_key in list(flat_sub_dictionary.keys()):\n flat_key = key + sep + flat_sub_key\n flat_sub_dictionary[flat_key] = flat_sub_dictionary.pop(flat_sub_key)\n\n new_dictionary = flat_sub_dictionary\n new_dictionary.update(flatten(dictionary, sep=sep))\n return new_dictionary\n\n return _flatten(copy.deepcopy(dictionary))","def flatten(self):\n flat = {}\n for d in self.dicts:\n flat.update(d)\n return flat","def recursive_update_cfg(d, u):\n for k, v in u.iteritems():\n if isinstance(v, collections.Mapping):\n r = update(d.get(k, {}), v)\n d[k] = r\n else:\n d[k] = u[k]\n return d","def deep_normalize(d):\n if 'sudsobject' in str(d.__class__):\n d = deep_normalize(dict(d))\n elif isinstance(d, dict):\n for k,v in d.iteritems():\n if 'sudsobject' in str(v.__class__):\n #print k, v, '%s' % v.__class__\n r = deep_normalize(dict(v))\n d[k] = r\n elif isinstance(v, dict):\n r = deep_normalize(v)\n d[k] = r\n elif isinstance(v, (list, tuple, )):\n d[k] = [deep_normalize(i) for i in v]\n elif isinstance(v, datetime):\n # per problemi di permessi sugli oggetti datetime trasformo\n # in DateTime di Zope\n d[k] = DateTime(v.isoformat())\n elif isinstance(d, (list, tuple, )):\n d = [deep_normalize(i) for i in d]\n\n return d","def _flatten_dict(self, d: Mapping[str, Any]) -> Dict[str, Any]:\n nested = {k for k, v in d.items() if isinstance(v, (Mapping, Configuration))}\n if self._lowercase:\n result = {\n k.lower() + \".\" + ki: vi\n for k in nested\n for ki, vi in self._flatten_dict(d[k]).items()\n }\n result.update(\n (k.lower(), v)\n for k, v in d.items()\n if not isinstance(v, (Mapping, Configuration))\n )\n else:\n result = {\n k + \".\" + ki: vi\n for k in nested\n for ki, vi in self._flatten_dict(d[k]).items()\n }\n result.update(\n (k, v)\n for k, v in d.items()\n if not isinstance(v, (Mapping, Configuration))\n )\n return result","def _flatten(object_, key):\n # Empty object can't be iterated, take as is\n if not object_:\n flattened_dict[key] = object_\n # These object types support iteration\n elif isinstance(object_, dict):\n for object_key in object_:\n if not (not key and object_key in root_keys_to_ignore):\n _flatten(object_[object_key], _construct_key(key,\n separator,\n object_key))\n elif isinstance(object_, (list, set, tuple)):\n for index, item in enumerate(object_):\n _flatten(item, _construct_key(key, separator, index))\n # Anything left take as is\n else:\n flattened_dict[key] = object_","def pivot_nested_dict(nested_dict):\r\n\r\n reverse_nest_dict = {} #Create an empty dictionary\r\n for k, v in nested_dict.items(): #Iterate through each pair of elements\r\n for k2, v2 in v.items(): #Iterate through pair of values\r\n try:\r\n reverse_nest_dict[k2][k] = v2\r\n except KeyError:\r\n reverse_nest_dict[k2] = { k : v2 }\r\n return reverse_nest_dict\r\n \r\n #Create a dictionary that produces a different nested dictionary which\r\n #contains the same values\r","def recursive_mapping_update(d, u):\n if u is not None:\n for k, v in u.items():\n if isinstance(v, collections.Mapping):\n r = recursive_mapping_update(d.get(k, {}), v)\n d[k] = r\n else:\n d[k] = u[k]\n return d","def flatten(d):\n\n c = {}\n\n def _flatten(parents, items):\n for k, v in items:\n cur = parents + [k]\n if isinstance(v, list):\n _flatten(cur, enumerate(v))\n elif isinstance(v, dict):\n _flatten(cur, v.items())\n else:\n if v is None:\n cur.append('$NULL')\n v = ''\n name = str(cur[0]) + ''.join(['['+str(x)+']' for x in cur[1:]])\n c[name] = v\n \n _flatten([], d.items())\n\n return c","def recursive_update(to_update, update):\n if update:\n for key, value in update.items():\n if isinstance(value, dict):\n value = recursive_update(to_update.get(key, {}), value)\n to_update[key] = value\n return to_update","def flatten_dict(d, separator=':', _parent_key=''):\n items = []\n for k, v in d.items():\n new_key = _parent_key + separator + k if _parent_key else k\n if isinstance(v, collections.MutableMapping):\n items.extend(flatten_dict(v, separator=separator, _parent_key=new_key).items())\n else:\n items.append((new_key, v))\n return dict(items)","def flatten_values(d):\n if isinstance(d, dict):\n for v in d.values():\n if isinstance(v, dict):\n yield from flatten_values(v)\n else:\n yield v\n else:\n yield d","def flatten_hpo_params(params_dict: DictConfig) -> DictConfig:\n\n def process_params(nested_params: DictConfig, keys: list[str], flattened_params: DictConfig) -> None:\n \"\"\"Flatten nested dictionary till the time it reaches the hpo params.\n\n Recursive helper function that traverses the nested config object and stores the leaf nodes in a flattened\n dictionary.\n\n Args:\n nested_params: DictConfig: config object containing the original parameters.\n keys: list[str]: list of keys leading to the current location in the config.\n flattened_params: DictConfig: Dictionary in which the flattened parameters are stored.\n \"\"\"\n if len({\"values\", \"min\", \"max\"}.intersection(nested_params.keys())) > 0:\n key = \".\".join(keys)\n flattened_params[key] = nested_params\n else:\n for name, cfg in nested_params.items():\n if isinstance(cfg, DictConfig):\n process_params(cfg, keys + [str(name)], flattened_params)\n\n flattened_params_dict = DictConfig({})\n process_params(params_dict, [], flattened_params_dict)\n\n return flattened_params_dict","def depth_wrap(self, value):\n return DictToObj(**value) if isinstance(value, dict) else value","def flatten_dict(nested, prefix=''):\n result = dict()\n\n for key, value in nested.items():\n prefix_key = '__'.join([prefix, str(key)]) if len(prefix) else key\n\n if key in IGNORED_DICT_KEYS and not isinstance(value, (dict, list)):\n continue\n\n elif isinstance(value, dict):\n result.update(flatten_dict(value, prefix_key))\n\n elif isinstance(value, (np.ndarray, list)):\n result.update(flatten_array(value, prefix_key))\n\n else:\n result[prefix_key] = value\n\n return result","def flatten_dict(\n d, parent_key=\"\", sep=\".\", ignore_under_prefixed=True, mark_value=True\n):\n items = {}\n for k in d:\n if ignore_under_prefixed and k.startswith(\"__\"):\n continue\n v = d[k]\n if mark_value and k.startswith(\"_\") and not k.startswith(\"__\"):\n v = MarkValue(repr(v))\n\n new_key = sep.join((parent_key, k)) if parent_key else k\n if isinstance(v, collections.MutableMapping):\n items.update(\n flatten_dict(\n v, new_key, sep=sep, ignore_under_prefixed=True, mark_value=True\n )\n )\n else:\n items[new_key] = v\n\n return items","def removenone(d):\n if isinstance(d, dict):\n # Recursively call removenone on values in case value is itself a dict\n d = {k:removenone(v) for (k,v) in d.items()}\n # Filter out k,v tuples where v is None\n return dict(filter(lambda t: t[1] != None, d.items()))\n elif isinstance(d, list):\n # Recursively call removenone on values in case any is a dict\n d = [removenone(v) for v in d]\n # Filter out array values which are None\n return list(filter(lambda e: e!=None, d))\n else:\n # Do not iterate into d\n return d","def deep_update(d, u):\n for k, v in six.iteritems(u):\n dv = d.get(k, {})\n if not isinstance(dv, collections.abc.Mapping):\n d[k] = v\n elif isinstance(v, collections.abc.Mapping):\n d[k] = deep_update(dv, v)\n else:\n d[k] = v\n return d","def flatten_dict(base, v, d):\n if base != '':\n base = base + \".\"\n for k in d:\n if type(d[k]) in (type('a'), type(u'a'), type(1), type(1.1), type(False), type(None)):\n v[base + k] = d[k]\n elif type(d[k]) in (type([]), type((1,2))):\n v[base + k] = \", \".join(d[k])\n elif type(d[k]) == type({}):\n flatten_dict(base + k, v, d[k])\n else:\n print \"huh,\", type(d[k])","def unflatten(dictionary, sep=\".\"):\n unflattened_dictionary = {}\n for key, value in dictionary.items():\n parts = key.split(sep)\n sub_dictionary = unflattened_dictionary\n for part in parts[:-1]:\n if part not in sub_dictionary:\n sub_dictionary[part] = {}\n sub_dictionary = sub_dictionary[part]\n sub_dictionary[parts[-1]] = value\n return unflattened_dictionary","def flatten(nested_dict, separator=\"_\", root_keys_to_ignore=set()):\n assert isinstance(nested_dict, dict), \"flatten requires a dictionary input\"\n assert isinstance(separator, six.string_types), \"separator must be string\"\n\n # This global dictionary stores the flattened keys and values and is\n # ultimately returned\n flattened_dict = dict()\n\n def _flatten(object_, key):\n \"\"\"\n For dict, list and set objects_ calls itself on the elements and for\n other types assigns the object_ to\n the corresponding key in the global flattened_dict\n :param object_: object to flatten\n :param key: carries the concatenated key for the object_\n :return: None\n \"\"\"\n # Empty object can't be iterated, take as is\n if not object_:\n flattened_dict[key] = object_\n # These object types support iteration\n elif isinstance(object_, dict):\n for object_key in object_:\n if not (not key and object_key in root_keys_to_ignore):\n _flatten(object_[object_key], _construct_key(key,\n separator,\n object_key))\n elif isinstance(object_, (list, set, tuple)):\n for index, item in enumerate(object_):\n _flatten(item, _construct_key(key, separator, index))\n # Anything left take as is\n else:\n flattened_dict[key] = object_\n\n _flatten(nested_dict, None)\n return flattened_dict\n\n ###############################################################################################","def deep_merge(d, u):\n stack = [(d, u)]\n while stack:\n d, u = stack.pop(0)\n for k, v in u.items():\n if not isinstance(v, collections.abc.Mapping):\n d[k] = v\n else:\n dv = d.setdefault(k, {})\n if not isinstance(dv, collections.abc.Mapping):\n d[k] = v\n else:\n stack.append((dv, v))","def add_flat(dict_, key, elem):\r\n\r\n if isinstance(elem, dict):\r\n dict_.update(elem)\r\n else:\r\n dict_[key] = elem","def flatten_dict(d):\n def items():\n for key, value in d.items():\n if isinstance(value, dict):\n for subkey, subvalue in flatten_dict(value).items():\n yield subkey, subvalue\n else:\n yield key, value\n\n return dict(items())","def expand_flattened_dict(flattened, separator='.'):\n merged = {}\n for key, value in flattened.items():\n expanded = expand_flattened_path(key, value=value, separator=separator)\n merged = merge_dicts(merged, expanded)\n return merged","def shrink(body):\n toremove = []\n for key, value in body.iteritems():\n if isinstance(value, basestring):\n if key.endswith('url'):\n if (value.startswith('https://api.github.com/') or\n value.startswith('https://avatars.githubusercontent.com')):\n toremove.append(key)\n elif isinstance(value, dict):\n shrink(value)\n elif isinstance(value, list):\n for el in value:\n if isinstance(el, dict):\n shrink(el)\n for key in toremove:\n body.pop(key)\n return body","def _normalize(self, schema: t.Dict) -> t.Dict:\n normalized_mapping: t.Dict = {}\n flattened_schema = flatten_schema(schema, depth=dict_depth(schema) - 1)\n\n for keys in flattened_schema:\n columns = nested_get(schema, *zip(keys, keys))\n\n if not isinstance(columns, dict):\n raise SchemaError(\n f\"Table {'.'.join(keys[:-1])} must match the schema's nesting level: {len(flattened_schema[0])}.\"\n )\n\n normalized_keys = [\n self._normalize_name(key, dialect=self.dialect, is_table=True) for key in keys\n ]\n for column_name, column_type in columns.items():\n nested_set(\n normalized_mapping,\n normalized_keys + [self._normalize_name(column_name, dialect=self.dialect)],\n column_type,\n )\n\n return normalized_mapping","def unflatten(arg):\n if hasattr(arg, \"iteritems\"):\n items = arg.iteritems()\n elif hasattr(arg, \"items\"):\n items = arg.items()\n else:\n items = arg\n\n data = {}\n holders = []\n for flat_key, val in items:\n parsed_key = _parse_key(flat_key)\n obj = data\n for depth, (key, next_key) in enumerate(zip(parsed_key, parsed_key[1:]), 1):\n if isinstance(next_key, string_type):\n holder_type = _dict_holder\n else:\n holder_type = _list_holder\n\n if key not in obj:\n obj[key] = holder_type(_unparse_key(parsed_key[:depth]))\n holders.append((obj, key))\n elif not isinstance(obj[key], holder_type):\n raise ValueError(\n \"conflicting types %s and %s for key %r\"\n % (\n _node_type(obj[key]),\n holder_type.node_type,\n _unparse_key(parsed_key[:depth]),\n )\n )\n obj = obj[key]\n\n last_key = parsed_key[-1]\n if isinstance(obj.get(last_key), _holder):\n raise ValueError(\n \"conflicting types %s and terminal for key %r\"\n % (_node_type(obj[last_key]), flat_key)\n )\n obj[last_key] = val\n\n for obj, key in reversed(holders):\n obj[key] = obj[key].getvalue()\n\n return data","def _reduce_shapesdict(shapes_dict):\n for shape in shapes_dict[\"shapes\"]:\n for sc in shape[\"statement_constraints\"]:\n if sc.get(\"extra_elements\"):\n for (k, v) in sc[\"extra_elements\"].items():\n sc[k] = v\n del sc[\"extra_elements\"]\n if sc.get(\"sc_warnings\"):\n del sc[\"sc_warnings\"]\n for empty_element in [key for key in sc if not sc[key]]:\n del sc[empty_element]\n if shape.get(\"extra_elements\"):\n for (k, v) in shape[\"extra_elements\"].items():\n shape[k] = v\n del shape[\"extra_elements\"]\n if shape.get(\"sh_warnings\"):\n del shape[\"sh_warnings\"]\n for empty_element in [key for key in shape if not shape[key]]:\n del shape[empty_element]\n return shapes_dict","def recursive_update(d1, d2):\n\n for key, value in d2.items():\n if key in d1 and isinstance(d1[key], dict) and isinstance(value, dict):\n recursive_update(d1[key], value)\n else:\n d1[key] = value","def dict_deep_update(d, u, handlers=None):\n if handlers is None:\n handlers = {}\n for k, v in u.items():\n if isinstance(v, collections.Mapping):\n r = dict_deep_update(d.get(k, {}), v, handlers)\n d[k] = r\n elif k in d:\n h = handlers.get(type(v), None)\n if h is not None:\n d[k] = h(d[k], u[k])\n else:\n d[k] = u[k]\n else:\n d[k] = u[k]\n return d","def flatten(parsed):\r\n parsedList = [parsed] if isinstance(parsed, dict) else parsed\r\n result = []\r\n for dico in parsedList:\r\n #Sort keys between actual values and nested dicts\r\n listKeys = []\r\n standardKeys = []\r\n for key in dico:\r\n if isinstance(dico[key], list):\r\n listKeys.append(key)\r\n else:\r\n standardKeys.append(key)\r\n if not listKeys:\r\n #Terminal condition: no nested dict\r\n result.append(dico)\r\n else:\r\n partialResult = [{x:dico[x] for x in standardKeys}]\r\n for key in listKeys:\r\n #Create a dict with the keys from partialResult and\r\n #from the nested dicts\r\n recurs = Bricks.flatten(dico[key])\r\n partialResult = [{**x, **y} for x in partialResult for y in recurs]\r\n result.extend(partialResult)\r\n return result","def drop_keys(d):\n if isinstance(d, dict):\n return {\n k: drop_keys(v)\n for k, v in d.items()\n if k not in [\"propNames\", \"package\"]\n and v is not None\n and not (k == \"children\" and v == \"\")\n }\n elif isinstance(d, list):\n return [drop_keys(x) for x in d]\n return d","def flatten(d, path):\n\n if isinstance(d, dict):\n for k, v in d.items():\n yield from flatten(v, path + [k])\n else:\n yield (\".\".join(path), d)","def flat_dict(d):\n nd = {}\n for (key, value) in d.items():\n nd[key] = value.pop()\n\n return nd","def unflatten_dict(flat):\n unflattened = dict()\n\n for key, value in sorted(flat.items(), key=_key_order):\n if '__' in key:\n key, subkey = key.split('__', 1)\n subkey, name = subkey.rsplit('__', 1)\n\n if name.isdigit():\n column_index = int(name)\n row_index = int(subkey)\n\n array = unflattened.setdefault(key, list())\n\n if len(array) == row_index:\n row = list()\n array.append(row)\n elif len(array) == row_index + 1:\n row = array[row_index]\n else:\n # This should never happen\n raise ValueError('There was an error unflattening the extension.')\n\n if len(row) == column_index:\n row.append(value)\n else:\n # This should never happen\n raise ValueError('There was an error unflattening the extension.')\n\n else:\n subdict = unflattened.setdefault(key, dict())\n if subkey.isdigit():\n subkey = int(subkey)\n\n inner = subdict.setdefault(subkey, dict())\n inner[name] = value\n\n else:\n unflattened[key] = value\n\n return unflattened","def flatten_dict(dict_input):\n flattened_dict = dict()\n\n for key, value in dict_input.items():\n if isinstance(value, dict):\n new_keys = sorted(value.keys())\n for new_key in new_keys:\n entry = {key + '_' + new_key: value[new_key]}\n flattened_dict.update(entry)\n else:\n entry = {key: value}\n flattened_dict.update(entry)\n\n return flattened_dict","def pivot_nested_dict(nested_dict):\n # declare res as the return object which should be a dict\n res = dict()\n # traverse the pollsters\n for pollster in nested_dict:\n \t# travserse the states\n \tfor state in nested_dict[pollster]:\n \t\t# if first meet a state, we need to create a new dict\n \t\tif state not in res:\n \t\t\tres[state] = dict()\n \t\t# put the pollster value in the state dict\n \t\tres[state][pollster] = nested_dict[pollster][state]\n return res","def test_single_level(self):\n dict_1 = {\n 'key_1': 'original_value_1',\n 'key_2': 'original_value_2'\n }\n dict_2 = {\n 'key_2': 'new_value_2',\n 'key_3': 'new_value_3'\n }\n\n result = deep_dict_merge(dict_1, dict_2)\n\n assert dict_1 == {\n 'key_1': 'original_value_1',\n 'key_2': 'original_value_2'\n }\n assert dict_2 == {\n 'key_2': 'new_value_2',\n 'key_3': 'new_value_3'\n }\n assert result == {\n 'key_1': 'original_value_1',\n 'key_2': 'new_value_2',\n 'key_3': 'new_value_3',\n }","def remove_and_prune(a_dict, b_dict):\n for k in b_dict:\n if isinstance(b_dict[k], dict):\n if k in a_dict and type(a_dict[k]) is configobj.Section:\n remove_and_prune(a_dict[k], b_dict[k])\n if not a_dict[k].sections:\n a_dict.pop(k)\n elif k in a_dict:\n a_dict.pop(k)","def flatten_dict(d):\n\n def expand(key, value):\n if isinstance(value, dict):\n return [(key + '.' + k, v) for k, v in flatten_dict(value).items()]\n else:\n return [(key, value)]\n\n items = [item for k, v in d.items() for item in expand(k, v)]\n return dict(items)","def get_hashable_entries(nested:dict):\n for key, value in nested.items():\n if isinstance(value, abc.Mapping):\n yield from get_hashable_entries(value)\n else:\n yield (key, value)","def graph_walk_collection_flat(indict, pre=None):\n pre = pre[:] if pre else []\n \n # if isinstance(indict, dict):\n if type(indict) in [dict, OrderedDict]:\n for key, value in indict.items():\n # if isinstance(value, dict):\n if type(value) in [dict, OrderedDict]:\n for d in graph_walk_collection_flat(value, [key] + pre):\n yield d\n # elif isinstance(value, list) or isinstance(value, tuple):\n elif type(value) in [list, tuple]:\n for v in value:\n for d in graph_walk_collection_flat(v, [key] + pre):\n yield d\n else:\n yield pre + [key, value]\n else:\n yield indict","def flatten(d: Union[dict, list], parent_key: str = \"\", sep: str = \".\") -> dict:\n items = []\n if isinstance(d, dict):\n for k, v in d.items():\n new_key = f\"{parent_key}{sep}{k}\" if parent_key else str(k)\n items.extend(flatten(v, new_key, sep=sep).items())\n elif isinstance(d, list):\n for i, elem in enumerate(d):\n new_key = f\"{parent_key}{sep}{i}\" if parent_key else str(i)\n items.extend(flatten(elem, new_key, sep).items())\n else:\n items.append((parent_key, d))\n return dict(items)","def fix_up_tree(tree_dict):\n if isinstance(tree_dict, dict):\n for key in list(tree_dict.keys()):\n if key == 'ARGS':\n tree_dict[str(tree_dict[key][0]).replace(\"\\'\", \"\")] = []\n tree_dict.pop(key)\n continue\n if isinstance(tree_dict[key], dict) and (key == 'LearnerType' or key == \"EnsembleType\"):\n arg_dict = {}\n value_dict = {}\n for k in tree_dict[key].keys():\n if isinstance(tree_dict[key][k], list):\n arg_dict[k] = tree_dict[key][k]\n else:\n try:\n value = int(tree_dict[key][k])\n except:\n try:\n value = float(tree_dict[key][k])\n except:\n value = tree_dict[key][k]\n value_dict[k] = value\n arg_dict[str(value_dict)] = []\n tree_dict[key] = arg_dict\n if isinstance(tree_dict[key], str):\n tree_dict[key] = {tree_dict[key]: []}\n if isinstance(tree_dict[key], list) and tree_dict[key] != []:\n arg_dict = {}\n for item in tree_dict[key]:\n if isinstance(item, list):\n item = [int(i) for i in item]\n arg_dict[str(item)] = []\n else:\n arg_dict[item] = []\n tree_dict[key] = arg_dict\n fix_up_tree(tree_dict[key])\n else:\n return","def cleanup(child):\n children = child.get('children', [])\n for childchild in children:\n cleanup(childchild)\n cleaned = {u'title': child['Title'], u'name': child['id'],\n u'children': children}\n child.clear()\n child.update(cleaned)","def recursive_drop_falsy(d):\r\n if isinstance(d, dict):\r\n return dict((k, recursive_drop_falsy(v)) for k, v in d.items() if v)\r\n elif isinstance(d, list):\r\n return map(recursive_drop_falsy, d)\r\n elif isinstance(d, basestring):\r\n return force_bytes(d)\r\n else:\r\n return d","def merge_dict(a: dict, b: dict, path=None) -> dict:\n if path is None:\n path = []\n for key in b:\n if key in a:\n if isinstance(a[key], dict) and isinstance(b[key], dict):\n merge_dict(a[key], b[key], path + [str(key)])\n elif a[key] == b[key]:\n pass # same leaf value\n else:\n a[key] = b[key]\n else:\n a[key] = b[key]\n return a","def expand(d):\n # make sure everything is a list\n for k, v in d.iteritems():\n if type(v) is not list:\n d[k] = [v]\n\n # take cross product\n product = [x for x in apply(itertools.product, d.values())]\n return flatten([dict(zip(d.keys(), p)) for p in product])","def sub_dict(d):\n r = {}\n for k in d:\n if type(d[k]) in prims:\n r[k] = d[k]\n elif type(d[k]) is list:\n r[k] = sub_list(d[k])\n elif type(d[k]) is dict:\n r[k] = sub_dict(d[k])\n else:\n print \"Unknown Type: {}\".format(type(d[k]))\n return r","def flatten_dict(d, target='key' or 'value'):\n def format_nested(nested, _key=None):\n if _key is None:\n _key = key\n return '{}_{}'.format(_key, nested)\n\n flattened = []\n target_is_key = target == 'key'\n for key, value in OrderedDict(sorted(d.items())).items():\n\n # Simple case: recursively flatten the dictionary.\n if isinstance(value, dict):\n flattened += map(\n format_nested if target_is_key else lambda x: x,\n flatten_dict(value, target=target)\n )\n\n # We are suddenly in muddy waters, because lists can have multiple types within them in JSON.\n elif isinstance(value, list):\n items_are_dict = [isinstance(item, dict) for item in value]\n items_are_list = [isinstance(item, list) for item in value]\n\n # To help reduce the complexity here, let's not support this case.\n # Besides, most sensible APIs won't bump into this case.\n if any(items_are_dict) and not all(items_are_dict):\n raise NotImplementedError(\"Ability to flatten dict with list of mixed dict and non-dict types \"\n \"is not currently supported\")\n\n # Same here, this is just weird.\n if any(items_are_list):\n raise NotImplementedError(\"Ability to flatten a dict with lists within lists \"\n \"is not currently supported. And we'd like to ask you to take it easy.\")\n\n # This case is common, but a little complex.\n elif all(items_are_dict):\n for index, item in enumerate(value):\n _flattened_dict = flatten_dict(item, target=target)\n\n # In this case we actually want to prepend the dict's index in the list to each flattened dict.\n if target_is_key:\n _flattened_dict = [format_nested(flattened_item, _key=index)\n for flattened_item in _flattened_dict]\n\n flattened += map(format_nested if target_is_key else lambda x: x, _flattened_dict)\n\n # All items are non-dict, so just directly add either the index or the value.\n else:\n flattened += map(format_nested, range(len(value))) if target_is_key else value\n\n # Kindergarten -- just add to the list.\n else:\n flattened.append(key if target_is_key else value)\n return flattened","def _prepare_freeze(xs: Any) -> Any:\n if isinstance(xs, FrozenDict):\n # we can safely ref share the internal state of a FrozenDict\n # because it is immutable.\n return xs._dict # pylint: disable=protected-access\n if not isinstance(xs, dict):\n # return a leaf as is.\n return xs\n # recursively copy dictionary to avoid ref sharing\n return {key: _prepare_freeze(val) for key, val in xs.items()}","def clean_dict(d):\n\n if not isinstance(d, (dict, list)):\n return d\n if isinstance(d, list):\n return [v for v in (clean_dict(v) for v in d) if v]\n return OrderedDict([(k, v) for k, v in ((k, clean_dict(v)) for k, v in list(d.items())) if v])","def _flatten_lists(\n data: Union[Dict[str, Any], List[Any], Any]\n ) -> Union[Dict[str, Any], Any]:\n if not isinstance(data, dict):\n return data\n copy_data = cast(Dict[str, Any], data.copy())\n for attr, val in copy_data.items():\n if isinstance(val, list):\n if len(cast(List[Any], val)) == 1:\n # pull single values out of lists\n data[attr] = _flatten_lists(cast(Any, val[0]))\n else:\n data[attr] = [_flatten_lists(v) for v in cast(List[Any], val)]\n elif isinstance(val, dict):\n data[attr] = _flatten_lists(cast(Dict[str, Any], val))\n return data","def flatten(orig):\n\n\t# Empty dictionary\n\tdata = {}\n\tfor c in orig['tree']['children']:\n\t\t# in operator\n\t\tif 'children' in c:\n\t\t\tfor c2 in c['children']:\n\t\t\t\tif 'children' in c2:\n\t\t\t\t\tfor c3 in c2['children']:\n\t\t\t\t\t\tif 'children' in c3:\n\t\t\t\t\t\t\tfor c4 in c3['children']:\n\t\t\t\t\t\t\t\tif (c4['category'] == 'personality'):\n\t\t\t\t\t\t\t\t\tdata[c4['id']] = c4['percentage']\n\t\t\t\t\t\telse:\n\t\t\t\t\t\t\tif (c3['category'] == 'personality'):\n\t\t\t\t\t\t\t\tdata[c3['id']] = c3['percentage']\n\n\treturn data","def deep_merge(origin: dict, renovator: Mapping) -> dict:\n\n for key, value in renovator.items():\n if isinstance(value, Mapping):\n node = origin.setdefault(key, {})\n deep_merge(node, value)\n else:\n origin[key] = value\n\n return origin","def process_dict(self, dictionary):\n return self._flatten(dictionary)","def merge_dict(target, addition):\n for key in addition:\n if key in target and isinstance(target[key], dict) \\\n and isinstance(addition[key], dict):\n merge_dict(target[key], addition[key])\n else:\n target[key] = addition[key]","def flat_to_nested(self, data: dict, original_data, target, method):\n data[target] = method(original_data)\n return data","def recursive_update(d1, d2):\n\n for k in d1.keys():\n if k not in d2:\n continue\n\n if isinstance(d1[k], dict) and isinstance(d2[k], dict):\n d1[k] = recursive_update(d1[k], d2[k])\n else:\n d1[k] = d2[k]\n\n for k in d2.keys():\n if k not in d1:\n d1[k] = d2[k]\n\n return d1","def dict_normalization(dict_, nested=False):\n dict_norm = dict()\n if not nested:\n if dict_.values():\n d_max = max(dict_.values())\n d_min = min(dict_.values())\n if d_max - d_min == 0:\n dict_norm = {key: 1 for key in dict_}\n else:\n dict_norm = {key: (dict_[key] - d_min) / (d_max - d_min) for key in dict_}\n else:\n for key_1 in dict_:\n if dict_[key_1]:\n dict_norm[key_1] = dict()\n else: continue\n d_max = max(dict_[key_1].values())\n d_min = min(dict_[key_1].values())\n for key_2 in dict_[key_1]:\n if d_max - d_min == 0:\n dict_norm[key_1][key_2] = 1 / len(dict_[key_1])\n else:\n dict_norm[key_1][key_2] = (dict_[key_1][key_2] - d_min) / (d_max - d_min)\n return dict_norm","def recursively_update_with(a, b):\n\n for key in b:\n if key in a:\n if isinstance(a[key], dict) and isinstance(b[key], dict):\n recursively_update_with(a[key], b[key])\n else:\n a[key] = b[key]\n else:\n a[key] = b[key]","def merge_trees(data, new_data):\n for key, val in new_data.items():\n if isinstance(val, dict):\n if key not in data:\n data[key] = new_data[key]\n else:\n merge_trees(data[key], new_data[key])\n\n else:\n if key not in data:\n data[key] = val\n else:\n data[key] = data[key] + val","def _unflatten_incr_state(\n self, flat_incr_state: Dict[str, torch.Tensor]\n ) -> Dict[int, Dict[str, Dict[str, torch.Tensor]]]:\n structured_incr_state = defaultdict(lambda: defaultdict(dict))\n for key, state in flat_incr_state.items():\n layer_idx_str, attn_type, state_type = key.split('__')\n structured_incr_state[int(layer_idx_str)][attn_type][state_type] = state\n return dict({k: dict(v) for k, v in structured_incr_state.items()})\n # Turn the nested defaultdicts back into regular dicts","def stringify_keys(d):\n di = copy.deepcopy(d)\n for key in di.keys():\n # check inner dict\n if isinstance(d[key], dict):\n value = stringify_keys(d[key])\n else:\n value = d[key]\n\n # convert nonstring to string if needed\n if not isinstance(key, str):\n try:\n d[str(key)] = value\n except Exception:\n try:\n d[repr(key)] = value\n except Exception:\n raise\n\n # delete old key\n del d[key]\n return d","def clean_keys_of_slashes(record):\n for key in list(record):\n value = record[key]\n if \"/\" in key:\n # replace with _\n record[key.replace(\"/\", \"_\")] = record.pop(key)\n # Check if the value is a list containing nested dict and apply same\n if value:\n if isinstance(value, list) and isinstance(value[0], dict):\n for v in value:\n clean_keys_of_slashes(v)\n\n return record","def _flatten_metadata(metadata):\r\n if metadata:\r\n # After changing recursive_keypairs` output we need to keep\r\n # flattening output unchanged.\r\n # Example: recursive_keypairs({'a': {'b':{'c':'d'}}}, '.')\r\n # output before: a.b:c=d\r\n # output now: a.b.c=d\r\n # So to keep the first variant just replace all dots except the first\r\n return dict((k.replace('.', ':').replace(':', '.', 1),\r\n six.text_type(v))\r\n for k, v in utils.recursive_keypairs(metadata,\r\n separator='.')\r\n if type(v) is not set)\r\n return {}","def deepwrap_userdict(obj) -> ColumnGroupSchema:\n if isinstance(obj, collections.abc.Mapping):\n # UserDict trick does not require multi-level UserDict\n return UserDict(obj)\n if isinstance(obj, collections.abc.Collection) and not isinstance(obj, str):\n return [deepwrap_userdict(value) for value in obj]\n return obj","def keep_entry(dict_input, parent_key, child_keys):\n\n dict_output = dict()\n\n child_keys = [''.join((parent_key, '_', child_key)) for child_key in child_keys]\n\n for key, value in dict_input.items():\n if key.startswith(parent_key) and key not in child_keys:\n pass\n else:\n dict_output.update({key: value})\n\n return dict_output","def test_recursive_merge(self):\n dict_1 = {\n 'key': {\n 'deep_key_1': 'original_value_1',\n 'deep_key_2': 'original_value_2'\n }\n }\n dict_2 = {\n 'key': {\n 'deep_key_2': 'new_value_2',\n 'deep_key_3': 'new_value_3'\n }\n }\n\n result = deep_dict_merge(dict_1, dict_2)\n\n assert dict_1 == {\n 'key': {\n 'deep_key_1': 'original_value_1',\n 'deep_key_2': 'original_value_2'\n }\n }\n assert dict_2 == {\n 'key': {\n 'deep_key_2': 'new_value_2',\n 'deep_key_3': 'new_value_3'\n }\n }\n assert result == {\n 'key': {\n 'deep_key_1': 'original_value_1',\n 'deep_key_2': 'new_value_2',\n 'deep_key_3': 'new_value_3'\n }\n }","def flatten_state_dict(state_dict, keep_empty_nodes = False):\n return traverse_util.flatten_dict(\n state_dict,\n is_leaf=tensorstore_leaf,\n keep_empty_nodes=keep_empty_nodes,\n sep='/')","def deep_merge(source, dest):\n for key, value in source.iteritems():\n if key in dest:\n if isinstance(value, dict) and isinstance(dest[key], dict):\n deep_merge(value, dest[key])\n continue\n elif isinstance(value, list) and isinstance(dest[key], list):\n for item in value:\n if item not in dest[key]:\n dest[key].append(item)\n continue\n dest[key] = value","def flatten_tree(tree):\n yield dict([\n (k, v)\n for k, v in tree.items()\n if k != 'contents'\n ])\n if 'contents' in tree:\n for x in tree['contents']:\n for y in flatten_tree(x):\n yield y","def dict_collapse(d, into=dict):\n d_collapsed = defaultdict(list)\n for k,v in d.items():\n d_collapsed[v].append(k)\n return into(d_collapsed)","def _flatten(flat_json: FlatJSON, keys: FlatKey, obj: JSONType) -> FlatJSON:\n jtype = typeof(obj)\n if jtype is JSONValue:\n flat_json[keys] = obj\n elif jtype is JSONArray:\n for index, value in enumerate(obj):\n _flatten(flat_json, (*keys, index), value)\n elif jtype is JSONObject:\n for key, value in obj.items():\n _flatten(flat_json, (*keys, key), value)\n else:\n raise PheresInternalError(f\"Unhandled json type {jtype} in flatten()\")\n return flat_json","def deep_copy(old_dict, parent=None, depth=None, main=None):\n\n # Is this a copy starting from the top level?\n if isinstance(old_dict, configobj.ConfigObj):\n new_dict = configobj.ConfigObj('',\n encoding=old_dict.encoding,\n default_encoding=old_dict.default_encoding,\n interpolation=old_dict.interpolation)\n else:\n # No. It's a copy of something deeper down. If no parent or main is given, then\n # adopt the parent and main of the incoming dictionary.\n new_dict = configobj.Section(parent if parent is not None else old_dict.parent,\n depth if depth is not None else old_dict.depth,\n main if main is not None else old_dict.main)\n for entry in old_dict:\n # Avoid interpolation by using the version of __getitem__ from dict\n old_value = dict.__getitem__(old_dict, entry)\n if isinstance(old_value, configobj.Section):\n new_value = deep_copy(old_value, new_dict, new_dict.depth+1, new_dict.main)\n elif isinstance(old_value, list):\n # Make a copy\n new_value = list(old_value)\n elif isinstance(old_value, tuple):\n # Make a copy\n new_value = tuple(old_value)\n else:\n # It's a scalar\n new_value = old_value\n new_dict[entry] = new_value\n return new_dict","def test_deep_update(self):\n mdict = copy.deepcopy(self.dict1)\n res = dictupdate.update_dict_key_value(\n mdict, \"C:F\", {\"foo\": \"bar\", \"qux\": \"quux\"}\n )\n self.assertEqual(\n {\n \"A\": \"B\",\n \"C\": {\"D\": \"E\", \"F\": {\"G\": \"H\", \"I\": \"J\", \"foo\": \"bar\", \"qux\": \"quux\"}},\n },\n res,\n )\n\n # Test updating a non-existing subkey\n res = dictupdate.update_dict_key_value({}, \"foo:bar:baz\", {\"qux\": \"quux\"})\n self.assertEqual({\"foo\": {\"bar\": {\"baz\": {\"qux\": \"quux\"}}}}, res)\n # Test updating a non-existing subkey, with a different delimiter\n res = dictupdate.update_dict_key_value(\n {}, \"foo bar baz\", {\"qux\": \"quux\"}, delimiter=\" \"\n )\n self.assertEqual({\"foo\": {\"bar\": {\"baz\": {\"qux\": \"quux\"}}}}, res)","def update(d, u):\n\n for k, v in u.items():\n if isinstance(v, collections.Mapping):\n d[k] = update(d.get(k, {}), v)\n else:\n d[k] = v\n return d","def iteritemsdeep(dct):\n for (key, val) in dct.items():\n if isinstance(val, dict):\n for (key_child, val_child) in iteritemsdeep(val):\n yield ((key,) + key_child, val_child)\n else:\n yield ((key,), val)","def update_double_dict(outer, inner):\n for k, v in outer.items():\n outer[k].update(inner[k])","def make_recursive(obj):\n if isinstance(obj, list):\n for i, l in enumerate(obj):\n obj[i] = AttrDict.make_recursive(l)\n elif isinstance(obj, dict):\n for k, v in obj.items():\n obj[k] = AttrDict.make_recursive(v)\n return AttrDict(obj)\n return obj","def flatten(self):\n\t\treturn self.__flatten(self, '', {})"],"string":"[\n \"def recursive_squeeze(dictlike):\\n out = {}\\n for k, v in dictlike.items():\\n if isinstance(v, dict):\\n out[k] = recursive_squeeze(v)\\n else:\\n out[k] = np.squeeze(v)\\n return out\",\n \"def unflatten(\\n d: Dict[str, Any],\\n base: Dict[str, Any] = None,\\n) -> Dict[str, Any]:\\n if base is None:\\n base = {}\\n\\n for key, value in d.items():\\n root = base\\n\\n ###\\n # If a dotted path is encountered, create nested dicts for all but\\n # the last level, then change root to that last level, and key to\\n # the final key in the path. This allows one final setitem at the bottom\\n # of the loop.\\n if '.' in key:\\n *parts, key = key.split('.')\\n\\n for part in parts:\\n root.setdefault(part, {})\\n root = root[part]\\n\\n if isinstance(value, dict):\\n value = unflatten(value, root.get(key, {}))\\n\\n root[key] = value\\n\\n return base\",\n \"def deepupdate(original, update):\\n for key, value in original.iteritems():\\n if not key in update:\\n update[key] = value\\n elif isinstance(value, dict):\\n deepupdate(value, update[key])\\n return update\",\n \"def simplify_dict(d: Dict[str, Any]) -> Dict[str, Any]:\\n return {\\n k: [ast_to_testing_string(n) for n in v] if k == \\\"children\\\" else v\\n for k, v in d.items()\\n }\",\n \"def nested_to_flat(self, data: dict, target: str, **kwargs):\\n data.update(data.pop(target, {}))\\n return data\",\n \"def flatten(d, parent_key='', sep='_'):\\n items = []\\n for k, v in d.items():\\n new_key = parent_key + sep + k if parent_key else k\\n if isinstance(v, collections.MutableMapping):\\n items.extend(flatten(v, new_key, sep=sep).items())\\n else:\\n items.append((new_key, v))\\n items = dict(items)\\n # remove info like PCA primitive ID\\n items_not_strings = {k: v for k, v in items.items() if type(v) != str}\\n return dict(items_not_strings)\",\n \"def flatten(d, parent_key='', sep='_'):\\n items = []\\n for k, v in d.items():\\n new_key = parent_key + sep + k if parent_key else k\\n if isinstance(v, collections.MutableMapping):\\n items.extend(flatten(v, new_key, sep=sep).items())\\n else:\\n items.append((new_key, v))\\n return dict(items)\",\n \"def flatten_nested_dict(prefix, nested_dict):\\n\\n cleaned_nested_dict = {}\\n cleaned_nested_dict = {\\n f'{prefix}_{key}': val for key, val in nested_dict.items()}\\n\\n return cleaned_nested_dict\",\n \"def flatten_dict(nested):\\n flattened = {}\\n for key, value in nested.items():\\n if isinstance(value, Mapping):\\n for subkey, subval in value.items():\\n newkey = '.'.join([key, subkey])\\n flattened[newkey] = subval\\n flatten_dict(flattened)\\n else:\\n flattened[key] = value\\n mappings = [isinstance(value, Mapping) for key, value in flattened.items()]\\n if len(set(mappings)) == 1 and set(mappings).pop() is False:\\n return flattened\\n else:\\n return flatten_dict(flattened)\",\n \"def flatten_dict(d, parent_key=\\\"\\\", sep=\\\"_\\\"):\\n items = []\\n for k, v in d.items():\\n new_key = parent_key + sep + k if parent_key else k\\n if isinstance(v, MutableMapping):\\n items.extend(flatten_dict(v, new_key, sep=sep).items())\\n else:\\n items.append((new_key, v))\\n return dict(items)\",\n \"def flatten_dict(d, sep=' ', parent_key=''):\\n items = []\\n for k, v in d.items():\\n new_key = parent_key + sep + k if parent_key else k\\n if isinstance(v, collections.MutableMapping):\\n items.extend(flatten_dict(v, sep=sep, parent_key=new_key).items())\\n else:\\n items.append((new_key, v))\\n return dict(items)\",\n \"def _flatten_dict(self, current, key, result):\\n if isinstance(current, dict):\\n for k in current:\\n new_key = \\\"{1}\\\".format(key, k) if len(key) > 0 else k\\n self._flatten_dict(current[k], new_key, result)\\n else:\\n result[key] = current\\n return result\",\n \"def _dictRoundTripNormalize(self, treedict):\\n for key, value in list(treedict.items()):\\n if isinstance(value, dict):\\n self._dictRoundTripNormalize(value)\\n\\n # Expand treedict[(\\\"group\\\", \\\"attr_name\\\")]\\n # to treedict[\\\"group\\\"][\\\"attr_name\\\"]\\n for key, value in list(treedict.items()):\\n if not isinstance(key, tuple):\\n continue\\n # Put the attribute inside the group\\n grpname, attr = key\\n if not grpname:\\n continue\\n group = treedict.setdefault(grpname, dict())\\n if isinstance(group, dict):\\n del treedict[key]\\n group[(\\\"\\\", attr)] = value\",\n \"def merge_dict_recursive(target, src):\\r\\n for k in src.keys():\\r\\n if ((k in target and isinstance(target[k], dict) and\\r\\n isinstance(src[k], collections.Mapping))):\\r\\n merge_dict_recursive(target[k], src[k])\\r\\n else:\\r\\n target[k] = src[k]\",\n \"def flatten(d: MutableMapping, sep: str = \\\".\\\", parent_key: str = \\\"\\\") -> dict:\\n items = []\\n for k, v in d.items():\\n new_key = parent_key + sep + k if parent_key else k\\n if isinstance(v, MutableMapping):\\n items.extend(flatten(v, sep=sep, parent_key=new_key).items())\\n else:\\n items.append((new_key, v))\\n return dict(items)\",\n \"def recursive_dictionary_clear(d):\\n for key in list(d):\\n if isinstance(d[key], dict):\\n recursive_dictionary_clear(d[key])\\n\\n if d[key] == \\\"\\\" or d[key] == {}:\\n del d[key]\",\n \"def _flatten_dict(x: Dict) ->Dict:\\n new_dict = {}\\n for key, value in x.items():\\n if isinstance(value, dict):\\n for k, v in value.items():\\n new_dict[k] = v\\n else:\\n new_dict[key] = value\\n return new_dict\",\n \"def _flatten_dictionary(self, params, parent=None):\\r\\n data = OrderedDict()\\r\\n for key, val in params.items():\\r\\n full_key = parent + \\\"[\\\" + key + \\\"]\\\" if parent else key\\r\\n if isinstance(val, dict):\\r\\n data.update(self._flatten_dictionary(val, full_key))\\r\\n else:\\r\\n data[full_key] = val\\r\\n return data\",\n \"def flatten(dictionary, sep=\\\".\\\"):\\n\\n def _flatten(dictionary):\\n if dictionary == {}:\\n return dictionary\\n\\n key, value = dictionary.popitem()\\n if not isinstance(value, dict) or not value:\\n new_dictionary = {key: value}\\n new_dictionary.update(flatten(dictionary, sep=sep))\\n return new_dictionary\\n\\n flat_sub_dictionary = flatten(value, sep=sep)\\n for flat_sub_key in list(flat_sub_dictionary.keys()):\\n flat_key = key + sep + flat_sub_key\\n flat_sub_dictionary[flat_key] = flat_sub_dictionary.pop(flat_sub_key)\\n\\n new_dictionary = flat_sub_dictionary\\n new_dictionary.update(flatten(dictionary, sep=sep))\\n return new_dictionary\\n\\n return _flatten(copy.deepcopy(dictionary))\",\n \"def flatten(self):\\n flat = {}\\n for d in self.dicts:\\n flat.update(d)\\n return flat\",\n \"def recursive_update_cfg(d, u):\\n for k, v in u.iteritems():\\n if isinstance(v, collections.Mapping):\\n r = update(d.get(k, {}), v)\\n d[k] = r\\n else:\\n d[k] = u[k]\\n return d\",\n \"def deep_normalize(d):\\n if 'sudsobject' in str(d.__class__):\\n d = deep_normalize(dict(d))\\n elif isinstance(d, dict):\\n for k,v in d.iteritems():\\n if 'sudsobject' in str(v.__class__):\\n #print k, v, '%s' % v.__class__\\n r = deep_normalize(dict(v))\\n d[k] = r\\n elif isinstance(v, dict):\\n r = deep_normalize(v)\\n d[k] = r\\n elif isinstance(v, (list, tuple, )):\\n d[k] = [deep_normalize(i) for i in v]\\n elif isinstance(v, datetime):\\n # per problemi di permessi sugli oggetti datetime trasformo\\n # in DateTime di Zope\\n d[k] = DateTime(v.isoformat())\\n elif isinstance(d, (list, tuple, )):\\n d = [deep_normalize(i) for i in d]\\n\\n return d\",\n \"def _flatten_dict(self, d: Mapping[str, Any]) -> Dict[str, Any]:\\n nested = {k for k, v in d.items() if isinstance(v, (Mapping, Configuration))}\\n if self._lowercase:\\n result = {\\n k.lower() + \\\".\\\" + ki: vi\\n for k in nested\\n for ki, vi in self._flatten_dict(d[k]).items()\\n }\\n result.update(\\n (k.lower(), v)\\n for k, v in d.items()\\n if not isinstance(v, (Mapping, Configuration))\\n )\\n else:\\n result = {\\n k + \\\".\\\" + ki: vi\\n for k in nested\\n for ki, vi in self._flatten_dict(d[k]).items()\\n }\\n result.update(\\n (k, v)\\n for k, v in d.items()\\n if not isinstance(v, (Mapping, Configuration))\\n )\\n return result\",\n \"def _flatten(object_, key):\\n # Empty object can't be iterated, take as is\\n if not object_:\\n flattened_dict[key] = object_\\n # These object types support iteration\\n elif isinstance(object_, dict):\\n for object_key in object_:\\n if not (not key and object_key in root_keys_to_ignore):\\n _flatten(object_[object_key], _construct_key(key,\\n separator,\\n object_key))\\n elif isinstance(object_, (list, set, tuple)):\\n for index, item in enumerate(object_):\\n _flatten(item, _construct_key(key, separator, index))\\n # Anything left take as is\\n else:\\n flattened_dict[key] = object_\",\n \"def pivot_nested_dict(nested_dict):\\r\\n\\r\\n reverse_nest_dict = {} #Create an empty dictionary\\r\\n for k, v in nested_dict.items(): #Iterate through each pair of elements\\r\\n for k2, v2 in v.items(): #Iterate through pair of values\\r\\n try:\\r\\n reverse_nest_dict[k2][k] = v2\\r\\n except KeyError:\\r\\n reverse_nest_dict[k2] = { k : v2 }\\r\\n return reverse_nest_dict\\r\\n \\r\\n #Create a dictionary that produces a different nested dictionary which\\r\\n #contains the same values\\r\",\n \"def recursive_mapping_update(d, u):\\n if u is not None:\\n for k, v in u.items():\\n if isinstance(v, collections.Mapping):\\n r = recursive_mapping_update(d.get(k, {}), v)\\n d[k] = r\\n else:\\n d[k] = u[k]\\n return d\",\n \"def flatten(d):\\n\\n c = {}\\n\\n def _flatten(parents, items):\\n for k, v in items:\\n cur = parents + [k]\\n if isinstance(v, list):\\n _flatten(cur, enumerate(v))\\n elif isinstance(v, dict):\\n _flatten(cur, v.items())\\n else:\\n if v is None:\\n cur.append('$NULL')\\n v = ''\\n name = str(cur[0]) + ''.join(['['+str(x)+']' for x in cur[1:]])\\n c[name] = v\\n \\n _flatten([], d.items())\\n\\n return c\",\n \"def recursive_update(to_update, update):\\n if update:\\n for key, value in update.items():\\n if isinstance(value, dict):\\n value = recursive_update(to_update.get(key, {}), value)\\n to_update[key] = value\\n return to_update\",\n \"def flatten_dict(d, separator=':', _parent_key=''):\\n items = []\\n for k, v in d.items():\\n new_key = _parent_key + separator + k if _parent_key else k\\n if isinstance(v, collections.MutableMapping):\\n items.extend(flatten_dict(v, separator=separator, _parent_key=new_key).items())\\n else:\\n items.append((new_key, v))\\n return dict(items)\",\n \"def flatten_values(d):\\n if isinstance(d, dict):\\n for v in d.values():\\n if isinstance(v, dict):\\n yield from flatten_values(v)\\n else:\\n yield v\\n else:\\n yield d\",\n \"def flatten_hpo_params(params_dict: DictConfig) -> DictConfig:\\n\\n def process_params(nested_params: DictConfig, keys: list[str], flattened_params: DictConfig) -> None:\\n \\\"\\\"\\\"Flatten nested dictionary till the time it reaches the hpo params.\\n\\n Recursive helper function that traverses the nested config object and stores the leaf nodes in a flattened\\n dictionary.\\n\\n Args:\\n nested_params: DictConfig: config object containing the original parameters.\\n keys: list[str]: list of keys leading to the current location in the config.\\n flattened_params: DictConfig: Dictionary in which the flattened parameters are stored.\\n \\\"\\\"\\\"\\n if len({\\\"values\\\", \\\"min\\\", \\\"max\\\"}.intersection(nested_params.keys())) > 0:\\n key = \\\".\\\".join(keys)\\n flattened_params[key] = nested_params\\n else:\\n for name, cfg in nested_params.items():\\n if isinstance(cfg, DictConfig):\\n process_params(cfg, keys + [str(name)], flattened_params)\\n\\n flattened_params_dict = DictConfig({})\\n process_params(params_dict, [], flattened_params_dict)\\n\\n return flattened_params_dict\",\n \"def depth_wrap(self, value):\\n return DictToObj(**value) if isinstance(value, dict) else value\",\n \"def flatten_dict(nested, prefix=''):\\n result = dict()\\n\\n for key, value in nested.items():\\n prefix_key = '__'.join([prefix, str(key)]) if len(prefix) else key\\n\\n if key in IGNORED_DICT_KEYS and not isinstance(value, (dict, list)):\\n continue\\n\\n elif isinstance(value, dict):\\n result.update(flatten_dict(value, prefix_key))\\n\\n elif isinstance(value, (np.ndarray, list)):\\n result.update(flatten_array(value, prefix_key))\\n\\n else:\\n result[prefix_key] = value\\n\\n return result\",\n \"def flatten_dict(\\n d, parent_key=\\\"\\\", sep=\\\".\\\", ignore_under_prefixed=True, mark_value=True\\n):\\n items = {}\\n for k in d:\\n if ignore_under_prefixed and k.startswith(\\\"__\\\"):\\n continue\\n v = d[k]\\n if mark_value and k.startswith(\\\"_\\\") and not k.startswith(\\\"__\\\"):\\n v = MarkValue(repr(v))\\n\\n new_key = sep.join((parent_key, k)) if parent_key else k\\n if isinstance(v, collections.MutableMapping):\\n items.update(\\n flatten_dict(\\n v, new_key, sep=sep, ignore_under_prefixed=True, mark_value=True\\n )\\n )\\n else:\\n items[new_key] = v\\n\\n return items\",\n \"def removenone(d):\\n if isinstance(d, dict):\\n # Recursively call removenone on values in case value is itself a dict\\n d = {k:removenone(v) for (k,v) in d.items()}\\n # Filter out k,v tuples where v is None\\n return dict(filter(lambda t: t[1] != None, d.items()))\\n elif isinstance(d, list):\\n # Recursively call removenone on values in case any is a dict\\n d = [removenone(v) for v in d]\\n # Filter out array values which are None\\n return list(filter(lambda e: e!=None, d))\\n else:\\n # Do not iterate into d\\n return d\",\n \"def deep_update(d, u):\\n for k, v in six.iteritems(u):\\n dv = d.get(k, {})\\n if not isinstance(dv, collections.abc.Mapping):\\n d[k] = v\\n elif isinstance(v, collections.abc.Mapping):\\n d[k] = deep_update(dv, v)\\n else:\\n d[k] = v\\n return d\",\n \"def flatten_dict(base, v, d):\\n if base != '':\\n base = base + \\\".\\\"\\n for k in d:\\n if type(d[k]) in (type('a'), type(u'a'), type(1), type(1.1), type(False), type(None)):\\n v[base + k] = d[k]\\n elif type(d[k]) in (type([]), type((1,2))):\\n v[base + k] = \\\", \\\".join(d[k])\\n elif type(d[k]) == type({}):\\n flatten_dict(base + k, v, d[k])\\n else:\\n print \\\"huh,\\\", type(d[k])\",\n \"def unflatten(dictionary, sep=\\\".\\\"):\\n unflattened_dictionary = {}\\n for key, value in dictionary.items():\\n parts = key.split(sep)\\n sub_dictionary = unflattened_dictionary\\n for part in parts[:-1]:\\n if part not in sub_dictionary:\\n sub_dictionary[part] = {}\\n sub_dictionary = sub_dictionary[part]\\n sub_dictionary[parts[-1]] = value\\n return unflattened_dictionary\",\n \"def flatten(nested_dict, separator=\\\"_\\\", root_keys_to_ignore=set()):\\n assert isinstance(nested_dict, dict), \\\"flatten requires a dictionary input\\\"\\n assert isinstance(separator, six.string_types), \\\"separator must be string\\\"\\n\\n # This global dictionary stores the flattened keys and values and is\\n # ultimately returned\\n flattened_dict = dict()\\n\\n def _flatten(object_, key):\\n \\\"\\\"\\\"\\n For dict, list and set objects_ calls itself on the elements and for\\n other types assigns the object_ to\\n the corresponding key in the global flattened_dict\\n :param object_: object to flatten\\n :param key: carries the concatenated key for the object_\\n :return: None\\n \\\"\\\"\\\"\\n # Empty object can't be iterated, take as is\\n if not object_:\\n flattened_dict[key] = object_\\n # These object types support iteration\\n elif isinstance(object_, dict):\\n for object_key in object_:\\n if not (not key and object_key in root_keys_to_ignore):\\n _flatten(object_[object_key], _construct_key(key,\\n separator,\\n object_key))\\n elif isinstance(object_, (list, set, tuple)):\\n for index, item in enumerate(object_):\\n _flatten(item, _construct_key(key, separator, index))\\n # Anything left take as is\\n else:\\n flattened_dict[key] = object_\\n\\n _flatten(nested_dict, None)\\n return flattened_dict\\n\\n ###############################################################################################\",\n \"def deep_merge(d, u):\\n stack = [(d, u)]\\n while stack:\\n d, u = stack.pop(0)\\n for k, v in u.items():\\n if not isinstance(v, collections.abc.Mapping):\\n d[k] = v\\n else:\\n dv = d.setdefault(k, {})\\n if not isinstance(dv, collections.abc.Mapping):\\n d[k] = v\\n else:\\n stack.append((dv, v))\",\n \"def add_flat(dict_, key, elem):\\r\\n\\r\\n if isinstance(elem, dict):\\r\\n dict_.update(elem)\\r\\n else:\\r\\n dict_[key] = elem\",\n \"def flatten_dict(d):\\n def items():\\n for key, value in d.items():\\n if isinstance(value, dict):\\n for subkey, subvalue in flatten_dict(value).items():\\n yield subkey, subvalue\\n else:\\n yield key, value\\n\\n return dict(items())\",\n \"def expand_flattened_dict(flattened, separator='.'):\\n merged = {}\\n for key, value in flattened.items():\\n expanded = expand_flattened_path(key, value=value, separator=separator)\\n merged = merge_dicts(merged, expanded)\\n return merged\",\n \"def shrink(body):\\n toremove = []\\n for key, value in body.iteritems():\\n if isinstance(value, basestring):\\n if key.endswith('url'):\\n if (value.startswith('https://api.github.com/') or\\n value.startswith('https://avatars.githubusercontent.com')):\\n toremove.append(key)\\n elif isinstance(value, dict):\\n shrink(value)\\n elif isinstance(value, list):\\n for el in value:\\n if isinstance(el, dict):\\n shrink(el)\\n for key in toremove:\\n body.pop(key)\\n return body\",\n \"def _normalize(self, schema: t.Dict) -> t.Dict:\\n normalized_mapping: t.Dict = {}\\n flattened_schema = flatten_schema(schema, depth=dict_depth(schema) - 1)\\n\\n for keys in flattened_schema:\\n columns = nested_get(schema, *zip(keys, keys))\\n\\n if not isinstance(columns, dict):\\n raise SchemaError(\\n f\\\"Table {'.'.join(keys[:-1])} must match the schema's nesting level: {len(flattened_schema[0])}.\\\"\\n )\\n\\n normalized_keys = [\\n self._normalize_name(key, dialect=self.dialect, is_table=True) for key in keys\\n ]\\n for column_name, column_type in columns.items():\\n nested_set(\\n normalized_mapping,\\n normalized_keys + [self._normalize_name(column_name, dialect=self.dialect)],\\n column_type,\\n )\\n\\n return normalized_mapping\",\n \"def unflatten(arg):\\n if hasattr(arg, \\\"iteritems\\\"):\\n items = arg.iteritems()\\n elif hasattr(arg, \\\"items\\\"):\\n items = arg.items()\\n else:\\n items = arg\\n\\n data = {}\\n holders = []\\n for flat_key, val in items:\\n parsed_key = _parse_key(flat_key)\\n obj = data\\n for depth, (key, next_key) in enumerate(zip(parsed_key, parsed_key[1:]), 1):\\n if isinstance(next_key, string_type):\\n holder_type = _dict_holder\\n else:\\n holder_type = _list_holder\\n\\n if key not in obj:\\n obj[key] = holder_type(_unparse_key(parsed_key[:depth]))\\n holders.append((obj, key))\\n elif not isinstance(obj[key], holder_type):\\n raise ValueError(\\n \\\"conflicting types %s and %s for key %r\\\"\\n % (\\n _node_type(obj[key]),\\n holder_type.node_type,\\n _unparse_key(parsed_key[:depth]),\\n )\\n )\\n obj = obj[key]\\n\\n last_key = parsed_key[-1]\\n if isinstance(obj.get(last_key), _holder):\\n raise ValueError(\\n \\\"conflicting types %s and terminal for key %r\\\"\\n % (_node_type(obj[last_key]), flat_key)\\n )\\n obj[last_key] = val\\n\\n for obj, key in reversed(holders):\\n obj[key] = obj[key].getvalue()\\n\\n return data\",\n \"def _reduce_shapesdict(shapes_dict):\\n for shape in shapes_dict[\\\"shapes\\\"]:\\n for sc in shape[\\\"statement_constraints\\\"]:\\n if sc.get(\\\"extra_elements\\\"):\\n for (k, v) in sc[\\\"extra_elements\\\"].items():\\n sc[k] = v\\n del sc[\\\"extra_elements\\\"]\\n if sc.get(\\\"sc_warnings\\\"):\\n del sc[\\\"sc_warnings\\\"]\\n for empty_element in [key for key in sc if not sc[key]]:\\n del sc[empty_element]\\n if shape.get(\\\"extra_elements\\\"):\\n for (k, v) in shape[\\\"extra_elements\\\"].items():\\n shape[k] = v\\n del shape[\\\"extra_elements\\\"]\\n if shape.get(\\\"sh_warnings\\\"):\\n del shape[\\\"sh_warnings\\\"]\\n for empty_element in [key for key in shape if not shape[key]]:\\n del shape[empty_element]\\n return shapes_dict\",\n \"def recursive_update(d1, d2):\\n\\n for key, value in d2.items():\\n if key in d1 and isinstance(d1[key], dict) and isinstance(value, dict):\\n recursive_update(d1[key], value)\\n else:\\n d1[key] = value\",\n \"def dict_deep_update(d, u, handlers=None):\\n if handlers is None:\\n handlers = {}\\n for k, v in u.items():\\n if isinstance(v, collections.Mapping):\\n r = dict_deep_update(d.get(k, {}), v, handlers)\\n d[k] = r\\n elif k in d:\\n h = handlers.get(type(v), None)\\n if h is not None:\\n d[k] = h(d[k], u[k])\\n else:\\n d[k] = u[k]\\n else:\\n d[k] = u[k]\\n return d\",\n \"def flatten(parsed):\\r\\n parsedList = [parsed] if isinstance(parsed, dict) else parsed\\r\\n result = []\\r\\n for dico in parsedList:\\r\\n #Sort keys between actual values and nested dicts\\r\\n listKeys = []\\r\\n standardKeys = []\\r\\n for key in dico:\\r\\n if isinstance(dico[key], list):\\r\\n listKeys.append(key)\\r\\n else:\\r\\n standardKeys.append(key)\\r\\n if not listKeys:\\r\\n #Terminal condition: no nested dict\\r\\n result.append(dico)\\r\\n else:\\r\\n partialResult = [{x:dico[x] for x in standardKeys}]\\r\\n for key in listKeys:\\r\\n #Create a dict with the keys from partialResult and\\r\\n #from the nested dicts\\r\\n recurs = Bricks.flatten(dico[key])\\r\\n partialResult = [{**x, **y} for x in partialResult for y in recurs]\\r\\n result.extend(partialResult)\\r\\n return result\",\n \"def drop_keys(d):\\n if isinstance(d, dict):\\n return {\\n k: drop_keys(v)\\n for k, v in d.items()\\n if k not in [\\\"propNames\\\", \\\"package\\\"]\\n and v is not None\\n and not (k == \\\"children\\\" and v == \\\"\\\")\\n }\\n elif isinstance(d, list):\\n return [drop_keys(x) for x in d]\\n return d\",\n \"def flatten(d, path):\\n\\n if isinstance(d, dict):\\n for k, v in d.items():\\n yield from flatten(v, path + [k])\\n else:\\n yield (\\\".\\\".join(path), d)\",\n \"def flat_dict(d):\\n nd = {}\\n for (key, value) in d.items():\\n nd[key] = value.pop()\\n\\n return nd\",\n \"def unflatten_dict(flat):\\n unflattened = dict()\\n\\n for key, value in sorted(flat.items(), key=_key_order):\\n if '__' in key:\\n key, subkey = key.split('__', 1)\\n subkey, name = subkey.rsplit('__', 1)\\n\\n if name.isdigit():\\n column_index = int(name)\\n row_index = int(subkey)\\n\\n array = unflattened.setdefault(key, list())\\n\\n if len(array) == row_index:\\n row = list()\\n array.append(row)\\n elif len(array) == row_index + 1:\\n row = array[row_index]\\n else:\\n # This should never happen\\n raise ValueError('There was an error unflattening the extension.')\\n\\n if len(row) == column_index:\\n row.append(value)\\n else:\\n # This should never happen\\n raise ValueError('There was an error unflattening the extension.')\\n\\n else:\\n subdict = unflattened.setdefault(key, dict())\\n if subkey.isdigit():\\n subkey = int(subkey)\\n\\n inner = subdict.setdefault(subkey, dict())\\n inner[name] = value\\n\\n else:\\n unflattened[key] = value\\n\\n return unflattened\",\n \"def flatten_dict(dict_input):\\n flattened_dict = dict()\\n\\n for key, value in dict_input.items():\\n if isinstance(value, dict):\\n new_keys = sorted(value.keys())\\n for new_key in new_keys:\\n entry = {key + '_' + new_key: value[new_key]}\\n flattened_dict.update(entry)\\n else:\\n entry = {key: value}\\n flattened_dict.update(entry)\\n\\n return flattened_dict\",\n \"def pivot_nested_dict(nested_dict):\\n # declare res as the return object which should be a dict\\n res = dict()\\n # traverse the pollsters\\n for pollster in nested_dict:\\n \\t# travserse the states\\n \\tfor state in nested_dict[pollster]:\\n \\t\\t# if first meet a state, we need to create a new dict\\n \\t\\tif state not in res:\\n \\t\\t\\tres[state] = dict()\\n \\t\\t# put the pollster value in the state dict\\n \\t\\tres[state][pollster] = nested_dict[pollster][state]\\n return res\",\n \"def test_single_level(self):\\n dict_1 = {\\n 'key_1': 'original_value_1',\\n 'key_2': 'original_value_2'\\n }\\n dict_2 = {\\n 'key_2': 'new_value_2',\\n 'key_3': 'new_value_3'\\n }\\n\\n result = deep_dict_merge(dict_1, dict_2)\\n\\n assert dict_1 == {\\n 'key_1': 'original_value_1',\\n 'key_2': 'original_value_2'\\n }\\n assert dict_2 == {\\n 'key_2': 'new_value_2',\\n 'key_3': 'new_value_3'\\n }\\n assert result == {\\n 'key_1': 'original_value_1',\\n 'key_2': 'new_value_2',\\n 'key_3': 'new_value_3',\\n }\",\n \"def remove_and_prune(a_dict, b_dict):\\n for k in b_dict:\\n if isinstance(b_dict[k], dict):\\n if k in a_dict and type(a_dict[k]) is configobj.Section:\\n remove_and_prune(a_dict[k], b_dict[k])\\n if not a_dict[k].sections:\\n a_dict.pop(k)\\n elif k in a_dict:\\n a_dict.pop(k)\",\n \"def flatten_dict(d):\\n\\n def expand(key, value):\\n if isinstance(value, dict):\\n return [(key + '.' + k, v) for k, v in flatten_dict(value).items()]\\n else:\\n return [(key, value)]\\n\\n items = [item for k, v in d.items() for item in expand(k, v)]\\n return dict(items)\",\n \"def get_hashable_entries(nested:dict):\\n for key, value in nested.items():\\n if isinstance(value, abc.Mapping):\\n yield from get_hashable_entries(value)\\n else:\\n yield (key, value)\",\n \"def graph_walk_collection_flat(indict, pre=None):\\n pre = pre[:] if pre else []\\n \\n # if isinstance(indict, dict):\\n if type(indict) in [dict, OrderedDict]:\\n for key, value in indict.items():\\n # if isinstance(value, dict):\\n if type(value) in [dict, OrderedDict]:\\n for d in graph_walk_collection_flat(value, [key] + pre):\\n yield d\\n # elif isinstance(value, list) or isinstance(value, tuple):\\n elif type(value) in [list, tuple]:\\n for v in value:\\n for d in graph_walk_collection_flat(v, [key] + pre):\\n yield d\\n else:\\n yield pre + [key, value]\\n else:\\n yield indict\",\n \"def flatten(d: Union[dict, list], parent_key: str = \\\"\\\", sep: str = \\\".\\\") -> dict:\\n items = []\\n if isinstance(d, dict):\\n for k, v in d.items():\\n new_key = f\\\"{parent_key}{sep}{k}\\\" if parent_key else str(k)\\n items.extend(flatten(v, new_key, sep=sep).items())\\n elif isinstance(d, list):\\n for i, elem in enumerate(d):\\n new_key = f\\\"{parent_key}{sep}{i}\\\" if parent_key else str(i)\\n items.extend(flatten(elem, new_key, sep).items())\\n else:\\n items.append((parent_key, d))\\n return dict(items)\",\n \"def fix_up_tree(tree_dict):\\n if isinstance(tree_dict, dict):\\n for key in list(tree_dict.keys()):\\n if key == 'ARGS':\\n tree_dict[str(tree_dict[key][0]).replace(\\\"\\\\'\\\", \\\"\\\")] = []\\n tree_dict.pop(key)\\n continue\\n if isinstance(tree_dict[key], dict) and (key == 'LearnerType' or key == \\\"EnsembleType\\\"):\\n arg_dict = {}\\n value_dict = {}\\n for k in tree_dict[key].keys():\\n if isinstance(tree_dict[key][k], list):\\n arg_dict[k] = tree_dict[key][k]\\n else:\\n try:\\n value = int(tree_dict[key][k])\\n except:\\n try:\\n value = float(tree_dict[key][k])\\n except:\\n value = tree_dict[key][k]\\n value_dict[k] = value\\n arg_dict[str(value_dict)] = []\\n tree_dict[key] = arg_dict\\n if isinstance(tree_dict[key], str):\\n tree_dict[key] = {tree_dict[key]: []}\\n if isinstance(tree_dict[key], list) and tree_dict[key] != []:\\n arg_dict = {}\\n for item in tree_dict[key]:\\n if isinstance(item, list):\\n item = [int(i) for i in item]\\n arg_dict[str(item)] = []\\n else:\\n arg_dict[item] = []\\n tree_dict[key] = arg_dict\\n fix_up_tree(tree_dict[key])\\n else:\\n return\",\n \"def cleanup(child):\\n children = child.get('children', [])\\n for childchild in children:\\n cleanup(childchild)\\n cleaned = {u'title': child['Title'], u'name': child['id'],\\n u'children': children}\\n child.clear()\\n child.update(cleaned)\",\n \"def recursive_drop_falsy(d):\\r\\n if isinstance(d, dict):\\r\\n return dict((k, recursive_drop_falsy(v)) for k, v in d.items() if v)\\r\\n elif isinstance(d, list):\\r\\n return map(recursive_drop_falsy, d)\\r\\n elif isinstance(d, basestring):\\r\\n return force_bytes(d)\\r\\n else:\\r\\n return d\",\n \"def merge_dict(a: dict, b: dict, path=None) -> dict:\\n if path is None:\\n path = []\\n for key in b:\\n if key in a:\\n if isinstance(a[key], dict) and isinstance(b[key], dict):\\n merge_dict(a[key], b[key], path + [str(key)])\\n elif a[key] == b[key]:\\n pass # same leaf value\\n else:\\n a[key] = b[key]\\n else:\\n a[key] = b[key]\\n return a\",\n \"def expand(d):\\n # make sure everything is a list\\n for k, v in d.iteritems():\\n if type(v) is not list:\\n d[k] = [v]\\n\\n # take cross product\\n product = [x for x in apply(itertools.product, d.values())]\\n return flatten([dict(zip(d.keys(), p)) for p in product])\",\n \"def sub_dict(d):\\n r = {}\\n for k in d:\\n if type(d[k]) in prims:\\n r[k] = d[k]\\n elif type(d[k]) is list:\\n r[k] = sub_list(d[k])\\n elif type(d[k]) is dict:\\n r[k] = sub_dict(d[k])\\n else:\\n print \\\"Unknown Type: {}\\\".format(type(d[k]))\\n return r\",\n \"def flatten_dict(d, target='key' or 'value'):\\n def format_nested(nested, _key=None):\\n if _key is None:\\n _key = key\\n return '{}_{}'.format(_key, nested)\\n\\n flattened = []\\n target_is_key = target == 'key'\\n for key, value in OrderedDict(sorted(d.items())).items():\\n\\n # Simple case: recursively flatten the dictionary.\\n if isinstance(value, dict):\\n flattened += map(\\n format_nested if target_is_key else lambda x: x,\\n flatten_dict(value, target=target)\\n )\\n\\n # We are suddenly in muddy waters, because lists can have multiple types within them in JSON.\\n elif isinstance(value, list):\\n items_are_dict = [isinstance(item, dict) for item in value]\\n items_are_list = [isinstance(item, list) for item in value]\\n\\n # To help reduce the complexity here, let's not support this case.\\n # Besides, most sensible APIs won't bump into this case.\\n if any(items_are_dict) and not all(items_are_dict):\\n raise NotImplementedError(\\\"Ability to flatten dict with list of mixed dict and non-dict types \\\"\\n \\\"is not currently supported\\\")\\n\\n # Same here, this is just weird.\\n if any(items_are_list):\\n raise NotImplementedError(\\\"Ability to flatten a dict with lists within lists \\\"\\n \\\"is not currently supported. And we'd like to ask you to take it easy.\\\")\\n\\n # This case is common, but a little complex.\\n elif all(items_are_dict):\\n for index, item in enumerate(value):\\n _flattened_dict = flatten_dict(item, target=target)\\n\\n # In this case we actually want to prepend the dict's index in the list to each flattened dict.\\n if target_is_key:\\n _flattened_dict = [format_nested(flattened_item, _key=index)\\n for flattened_item in _flattened_dict]\\n\\n flattened += map(format_nested if target_is_key else lambda x: x, _flattened_dict)\\n\\n # All items are non-dict, so just directly add either the index or the value.\\n else:\\n flattened += map(format_nested, range(len(value))) if target_is_key else value\\n\\n # Kindergarten -- just add to the list.\\n else:\\n flattened.append(key if target_is_key else value)\\n return flattened\",\n \"def _prepare_freeze(xs: Any) -> Any:\\n if isinstance(xs, FrozenDict):\\n # we can safely ref share the internal state of a FrozenDict\\n # because it is immutable.\\n return xs._dict # pylint: disable=protected-access\\n if not isinstance(xs, dict):\\n # return a leaf as is.\\n return xs\\n # recursively copy dictionary to avoid ref sharing\\n return {key: _prepare_freeze(val) for key, val in xs.items()}\",\n \"def clean_dict(d):\\n\\n if not isinstance(d, (dict, list)):\\n return d\\n if isinstance(d, list):\\n return [v for v in (clean_dict(v) for v in d) if v]\\n return OrderedDict([(k, v) for k, v in ((k, clean_dict(v)) for k, v in list(d.items())) if v])\",\n \"def _flatten_lists(\\n data: Union[Dict[str, Any], List[Any], Any]\\n ) -> Union[Dict[str, Any], Any]:\\n if not isinstance(data, dict):\\n return data\\n copy_data = cast(Dict[str, Any], data.copy())\\n for attr, val in copy_data.items():\\n if isinstance(val, list):\\n if len(cast(List[Any], val)) == 1:\\n # pull single values out of lists\\n data[attr] = _flatten_lists(cast(Any, val[0]))\\n else:\\n data[attr] = [_flatten_lists(v) for v in cast(List[Any], val)]\\n elif isinstance(val, dict):\\n data[attr] = _flatten_lists(cast(Dict[str, Any], val))\\n return data\",\n \"def flatten(orig):\\n\\n\\t# Empty dictionary\\n\\tdata = {}\\n\\tfor c in orig['tree']['children']:\\n\\t\\t# in operator\\n\\t\\tif 'children' in c:\\n\\t\\t\\tfor c2 in c['children']:\\n\\t\\t\\t\\tif 'children' in c2:\\n\\t\\t\\t\\t\\tfor c3 in c2['children']:\\n\\t\\t\\t\\t\\t\\tif 'children' in c3:\\n\\t\\t\\t\\t\\t\\t\\tfor c4 in c3['children']:\\n\\t\\t\\t\\t\\t\\t\\t\\tif (c4['category'] == 'personality'):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tdata[c4['id']] = c4['percentage']\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tif (c3['category'] == 'personality'):\\n\\t\\t\\t\\t\\t\\t\\t\\tdata[c3['id']] = c3['percentage']\\n\\n\\treturn data\",\n \"def deep_merge(origin: dict, renovator: Mapping) -> dict:\\n\\n for key, value in renovator.items():\\n if isinstance(value, Mapping):\\n node = origin.setdefault(key, {})\\n deep_merge(node, value)\\n else:\\n origin[key] = value\\n\\n return origin\",\n \"def process_dict(self, dictionary):\\n return self._flatten(dictionary)\",\n \"def merge_dict(target, addition):\\n for key in addition:\\n if key in target and isinstance(target[key], dict) \\\\\\n and isinstance(addition[key], dict):\\n merge_dict(target[key], addition[key])\\n else:\\n target[key] = addition[key]\",\n \"def flat_to_nested(self, data: dict, original_data, target, method):\\n data[target] = method(original_data)\\n return data\",\n \"def recursive_update(d1, d2):\\n\\n for k in d1.keys():\\n if k not in d2:\\n continue\\n\\n if isinstance(d1[k], dict) and isinstance(d2[k], dict):\\n d1[k] = recursive_update(d1[k], d2[k])\\n else:\\n d1[k] = d2[k]\\n\\n for k in d2.keys():\\n if k not in d1:\\n d1[k] = d2[k]\\n\\n return d1\",\n \"def dict_normalization(dict_, nested=False):\\n dict_norm = dict()\\n if not nested:\\n if dict_.values():\\n d_max = max(dict_.values())\\n d_min = min(dict_.values())\\n if d_max - d_min == 0:\\n dict_norm = {key: 1 for key in dict_}\\n else:\\n dict_norm = {key: (dict_[key] - d_min) / (d_max - d_min) for key in dict_}\\n else:\\n for key_1 in dict_:\\n if dict_[key_1]:\\n dict_norm[key_1] = dict()\\n else: continue\\n d_max = max(dict_[key_1].values())\\n d_min = min(dict_[key_1].values())\\n for key_2 in dict_[key_1]:\\n if d_max - d_min == 0:\\n dict_norm[key_1][key_2] = 1 / len(dict_[key_1])\\n else:\\n dict_norm[key_1][key_2] = (dict_[key_1][key_2] - d_min) / (d_max - d_min)\\n return dict_norm\",\n \"def recursively_update_with(a, b):\\n\\n for key in b:\\n if key in a:\\n if isinstance(a[key], dict) and isinstance(b[key], dict):\\n recursively_update_with(a[key], b[key])\\n else:\\n a[key] = b[key]\\n else:\\n a[key] = b[key]\",\n \"def merge_trees(data, new_data):\\n for key, val in new_data.items():\\n if isinstance(val, dict):\\n if key not in data:\\n data[key] = new_data[key]\\n else:\\n merge_trees(data[key], new_data[key])\\n\\n else:\\n if key not in data:\\n data[key] = val\\n else:\\n data[key] = data[key] + val\",\n \"def _unflatten_incr_state(\\n self, flat_incr_state: Dict[str, torch.Tensor]\\n ) -> Dict[int, Dict[str, Dict[str, torch.Tensor]]]:\\n structured_incr_state = defaultdict(lambda: defaultdict(dict))\\n for key, state in flat_incr_state.items():\\n layer_idx_str, attn_type, state_type = key.split('__')\\n structured_incr_state[int(layer_idx_str)][attn_type][state_type] = state\\n return dict({k: dict(v) for k, v in structured_incr_state.items()})\\n # Turn the nested defaultdicts back into regular dicts\",\n \"def stringify_keys(d):\\n di = copy.deepcopy(d)\\n for key in di.keys():\\n # check inner dict\\n if isinstance(d[key], dict):\\n value = stringify_keys(d[key])\\n else:\\n value = d[key]\\n\\n # convert nonstring to string if needed\\n if not isinstance(key, str):\\n try:\\n d[str(key)] = value\\n except Exception:\\n try:\\n d[repr(key)] = value\\n except Exception:\\n raise\\n\\n # delete old key\\n del d[key]\\n return d\",\n \"def clean_keys_of_slashes(record):\\n for key in list(record):\\n value = record[key]\\n if \\\"/\\\" in key:\\n # replace with _\\n record[key.replace(\\\"/\\\", \\\"_\\\")] = record.pop(key)\\n # Check if the value is a list containing nested dict and apply same\\n if value:\\n if isinstance(value, list) and isinstance(value[0], dict):\\n for v in value:\\n clean_keys_of_slashes(v)\\n\\n return record\",\n \"def _flatten_metadata(metadata):\\r\\n if metadata:\\r\\n # After changing recursive_keypairs` output we need to keep\\r\\n # flattening output unchanged.\\r\\n # Example: recursive_keypairs({'a': {'b':{'c':'d'}}}, '.')\\r\\n # output before: a.b:c=d\\r\\n # output now: a.b.c=d\\r\\n # So to keep the first variant just replace all dots except the first\\r\\n return dict((k.replace('.', ':').replace(':', '.', 1),\\r\\n six.text_type(v))\\r\\n for k, v in utils.recursive_keypairs(metadata,\\r\\n separator='.')\\r\\n if type(v) is not set)\\r\\n return {}\",\n \"def deepwrap_userdict(obj) -> ColumnGroupSchema:\\n if isinstance(obj, collections.abc.Mapping):\\n # UserDict trick does not require multi-level UserDict\\n return UserDict(obj)\\n if isinstance(obj, collections.abc.Collection) and not isinstance(obj, str):\\n return [deepwrap_userdict(value) for value in obj]\\n return obj\",\n \"def keep_entry(dict_input, parent_key, child_keys):\\n\\n dict_output = dict()\\n\\n child_keys = [''.join((parent_key, '_', child_key)) for child_key in child_keys]\\n\\n for key, value in dict_input.items():\\n if key.startswith(parent_key) and key not in child_keys:\\n pass\\n else:\\n dict_output.update({key: value})\\n\\n return dict_output\",\n \"def test_recursive_merge(self):\\n dict_1 = {\\n 'key': {\\n 'deep_key_1': 'original_value_1',\\n 'deep_key_2': 'original_value_2'\\n }\\n }\\n dict_2 = {\\n 'key': {\\n 'deep_key_2': 'new_value_2',\\n 'deep_key_3': 'new_value_3'\\n }\\n }\\n\\n result = deep_dict_merge(dict_1, dict_2)\\n\\n assert dict_1 == {\\n 'key': {\\n 'deep_key_1': 'original_value_1',\\n 'deep_key_2': 'original_value_2'\\n }\\n }\\n assert dict_2 == {\\n 'key': {\\n 'deep_key_2': 'new_value_2',\\n 'deep_key_3': 'new_value_3'\\n }\\n }\\n assert result == {\\n 'key': {\\n 'deep_key_1': 'original_value_1',\\n 'deep_key_2': 'new_value_2',\\n 'deep_key_3': 'new_value_3'\\n }\\n }\",\n \"def flatten_state_dict(state_dict, keep_empty_nodes = False):\\n return traverse_util.flatten_dict(\\n state_dict,\\n is_leaf=tensorstore_leaf,\\n keep_empty_nodes=keep_empty_nodes,\\n sep='/')\",\n \"def deep_merge(source, dest):\\n for key, value in source.iteritems():\\n if key in dest:\\n if isinstance(value, dict) and isinstance(dest[key], dict):\\n deep_merge(value, dest[key])\\n continue\\n elif isinstance(value, list) and isinstance(dest[key], list):\\n for item in value:\\n if item not in dest[key]:\\n dest[key].append(item)\\n continue\\n dest[key] = value\",\n \"def flatten_tree(tree):\\n yield dict([\\n (k, v)\\n for k, v in tree.items()\\n if k != 'contents'\\n ])\\n if 'contents' in tree:\\n for x in tree['contents']:\\n for y in flatten_tree(x):\\n yield y\",\n \"def dict_collapse(d, into=dict):\\n d_collapsed = defaultdict(list)\\n for k,v in d.items():\\n d_collapsed[v].append(k)\\n return into(d_collapsed)\",\n \"def _flatten(flat_json: FlatJSON, keys: FlatKey, obj: JSONType) -> FlatJSON:\\n jtype = typeof(obj)\\n if jtype is JSONValue:\\n flat_json[keys] = obj\\n elif jtype is JSONArray:\\n for index, value in enumerate(obj):\\n _flatten(flat_json, (*keys, index), value)\\n elif jtype is JSONObject:\\n for key, value in obj.items():\\n _flatten(flat_json, (*keys, key), value)\\n else:\\n raise PheresInternalError(f\\\"Unhandled json type {jtype} in flatten()\\\")\\n return flat_json\",\n \"def deep_copy(old_dict, parent=None, depth=None, main=None):\\n\\n # Is this a copy starting from the top level?\\n if isinstance(old_dict, configobj.ConfigObj):\\n new_dict = configobj.ConfigObj('',\\n encoding=old_dict.encoding,\\n default_encoding=old_dict.default_encoding,\\n interpolation=old_dict.interpolation)\\n else:\\n # No. It's a copy of something deeper down. If no parent or main is given, then\\n # adopt the parent and main of the incoming dictionary.\\n new_dict = configobj.Section(parent if parent is not None else old_dict.parent,\\n depth if depth is not None else old_dict.depth,\\n main if main is not None else old_dict.main)\\n for entry in old_dict:\\n # Avoid interpolation by using the version of __getitem__ from dict\\n old_value = dict.__getitem__(old_dict, entry)\\n if isinstance(old_value, configobj.Section):\\n new_value = deep_copy(old_value, new_dict, new_dict.depth+1, new_dict.main)\\n elif isinstance(old_value, list):\\n # Make a copy\\n new_value = list(old_value)\\n elif isinstance(old_value, tuple):\\n # Make a copy\\n new_value = tuple(old_value)\\n else:\\n # It's a scalar\\n new_value = old_value\\n new_dict[entry] = new_value\\n return new_dict\",\n \"def test_deep_update(self):\\n mdict = copy.deepcopy(self.dict1)\\n res = dictupdate.update_dict_key_value(\\n mdict, \\\"C:F\\\", {\\\"foo\\\": \\\"bar\\\", \\\"qux\\\": \\\"quux\\\"}\\n )\\n self.assertEqual(\\n {\\n \\\"A\\\": \\\"B\\\",\\n \\\"C\\\": {\\\"D\\\": \\\"E\\\", \\\"F\\\": {\\\"G\\\": \\\"H\\\", \\\"I\\\": \\\"J\\\", \\\"foo\\\": \\\"bar\\\", \\\"qux\\\": \\\"quux\\\"}},\\n },\\n res,\\n )\\n\\n # Test updating a non-existing subkey\\n res = dictupdate.update_dict_key_value({}, \\\"foo:bar:baz\\\", {\\\"qux\\\": \\\"quux\\\"})\\n self.assertEqual({\\\"foo\\\": {\\\"bar\\\": {\\\"baz\\\": {\\\"qux\\\": \\\"quux\\\"}}}}, res)\\n # Test updating a non-existing subkey, with a different delimiter\\n res = dictupdate.update_dict_key_value(\\n {}, \\\"foo bar baz\\\", {\\\"qux\\\": \\\"quux\\\"}, delimiter=\\\" \\\"\\n )\\n self.assertEqual({\\\"foo\\\": {\\\"bar\\\": {\\\"baz\\\": {\\\"qux\\\": \\\"quux\\\"}}}}, res)\",\n \"def update(d, u):\\n\\n for k, v in u.items():\\n if isinstance(v, collections.Mapping):\\n d[k] = update(d.get(k, {}), v)\\n else:\\n d[k] = v\\n return d\",\n \"def iteritemsdeep(dct):\\n for (key, val) in dct.items():\\n if isinstance(val, dict):\\n for (key_child, val_child) in iteritemsdeep(val):\\n yield ((key,) + key_child, val_child)\\n else:\\n yield ((key,), val)\",\n \"def update_double_dict(outer, inner):\\n for k, v in outer.items():\\n outer[k].update(inner[k])\",\n \"def make_recursive(obj):\\n if isinstance(obj, list):\\n for i, l in enumerate(obj):\\n obj[i] = AttrDict.make_recursive(l)\\n elif isinstance(obj, dict):\\n for k, v in obj.items():\\n obj[k] = AttrDict.make_recursive(v)\\n return AttrDict(obj)\\n return obj\",\n \"def flatten(self):\\n\\t\\treturn self.__flatten(self, '', {})\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6798054","0.6370052","0.63272715","0.62804824","0.6247005","0.6229685","0.6208201","0.62053543","0.6178594","0.61608326","0.6072516","0.6069942","0.5972645","0.5956857","0.59553653","0.5934359","0.59289074","0.59246","0.5923879","0.5918683","0.5888782","0.58628595","0.58316976","0.5830324","0.5785009","0.5784089","0.57744294","0.57217765","0.5720681","0.57092506","0.5694973","0.568997","0.56851536","0.5666754","0.5631165","0.5623161","0.5589364","0.5578051","0.55541193","0.5535597","0.5535481","0.55313575","0.5523933","0.5518091","0.5516226","0.55142254","0.5509534","0.5509031","0.5506756","0.55040133","0.5503414","0.5503154","0.5476414","0.54603213","0.54539144","0.54538935","0.54371125","0.543271","0.5430284","0.5405957","0.54053843","0.54049206","0.5404627","0.53922933","0.53919876","0.53884304","0.53838176","0.538152","0.5372462","0.53690493","0.5357907","0.5352539","0.53513175","0.53439516","0.5342529","0.5342046","0.5339607","0.5336307","0.5317404","0.5315418","0.5313176","0.5303315","0.5292259","0.52910715","0.5283915","0.5275621","0.52674985","0.52673936","0.52635175","0.52606606","0.525773","0.5255412","0.52531034","0.5250162","0.52465403","0.5246272","0.52458966","0.5242225","0.52368486","0.52231944"],"string":"[\n \"0.6798054\",\n \"0.6370052\",\n \"0.63272715\",\n \"0.62804824\",\n \"0.6247005\",\n \"0.6229685\",\n \"0.6208201\",\n \"0.62053543\",\n \"0.6178594\",\n \"0.61608326\",\n \"0.6072516\",\n \"0.6069942\",\n \"0.5972645\",\n \"0.5956857\",\n \"0.59553653\",\n \"0.5934359\",\n \"0.59289074\",\n \"0.59246\",\n \"0.5923879\",\n \"0.5918683\",\n \"0.5888782\",\n \"0.58628595\",\n \"0.58316976\",\n \"0.5830324\",\n \"0.5785009\",\n \"0.5784089\",\n \"0.57744294\",\n \"0.57217765\",\n \"0.5720681\",\n \"0.57092506\",\n \"0.5694973\",\n \"0.568997\",\n \"0.56851536\",\n \"0.5666754\",\n \"0.5631165\",\n \"0.5623161\",\n \"0.5589364\",\n \"0.5578051\",\n \"0.55541193\",\n \"0.5535597\",\n \"0.5535481\",\n \"0.55313575\",\n \"0.5523933\",\n \"0.5518091\",\n \"0.5516226\",\n \"0.55142254\",\n \"0.5509534\",\n \"0.5509031\",\n \"0.5506756\",\n \"0.55040133\",\n \"0.5503414\",\n \"0.5503154\",\n \"0.5476414\",\n \"0.54603213\",\n \"0.54539144\",\n \"0.54538935\",\n \"0.54371125\",\n \"0.543271\",\n \"0.5430284\",\n \"0.5405957\",\n \"0.54053843\",\n \"0.54049206\",\n \"0.5404627\",\n \"0.53922933\",\n \"0.53919876\",\n \"0.53884304\",\n \"0.53838176\",\n \"0.538152\",\n \"0.5372462\",\n \"0.53690493\",\n \"0.5357907\",\n \"0.5352539\",\n \"0.53513175\",\n \"0.53439516\",\n \"0.5342529\",\n \"0.5342046\",\n \"0.5339607\",\n \"0.5336307\",\n \"0.5317404\",\n \"0.5315418\",\n \"0.5313176\",\n \"0.5303315\",\n \"0.5292259\",\n \"0.52910715\",\n \"0.5283915\",\n \"0.5275621\",\n \"0.52674985\",\n \"0.52673936\",\n \"0.52635175\",\n \"0.52606606\",\n \"0.525773\",\n \"0.5255412\",\n \"0.52531034\",\n \"0.5250162\",\n \"0.52465403\",\n \"0.5246272\",\n \"0.52458966\",\n \"0.5242225\",\n \"0.52368486\",\n \"0.52231944\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6701361"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88387,"cells":{"query":{"kind":"string","value":"Logarithm of the hyperbolic cosine of the prediction error. `log(cosh(x))` is approximately equal to `(x 2) / 2` for small `x` and to `abs(x) log(2)` for large `x`. This means that 'logcosh' works mostly like the mean squared error, but will not be so strongly affected by the occasional wildly incorrect prediction."},"document":{"kind":"string","value":"def logcosh(y_true, y_pred):\n\n def _logcosh(x):\n return x + nn.softplus(-2. * x) - math_ops.log(2.)\n\n return K.mean(_logcosh(y_pred - y_true), axis=-1)"},"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 log_cosh(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n\n def _logcosh(x):\n return x + math_ops.softplus(-2. * x) - math_ops.cast(\n math_ops.log(2.), x.dtype)\n\n return backend.mean(_logcosh(y_pred - y_true), axis=-1)","def acosh(x):\n return math.log(x+math.sqrt(x*x-1))","def _log_cosh_error_compute(sum_log_cosh_error: Tensor, n_obs: Tensor) ->Tensor:\n return (sum_log_cosh_error / n_obs).squeeze()","def arcosh(x):\n return torch.log(x+torch.sqrt(x*x - 1))","def log_Schechter_log(self, logl, alpha, logls, logl0):\n phi = (logl - logls) * (alpha+1) * np.log(10.) - np.power(10., logl-logls)\n lik = phi.copy()\n lik [logl < logl0] = -1e99\n return lik","def h(x):\n h = -x*np.math.log(x, 2) - (1 - x)*np.math.log(1 - x, 2)\n return h","def h(self, X):\n if isinstance(X, int) or isinstance(X, float):\n if X < 1:\n x = max(0.001, X)\n a = np.log(x/2.)**2 - np.arccosh(1./x)**2\n elif X >= 1:\n a = np.log(X/2.)**2 + np.arccos(1./X)**2\n else:\n a=np.empty_like(X)\n X[X==0] = 0.001\n x = X[(X<1) & (X>0)]\n a[(X<1) & (X>0)] = np.log(x/2.)**2 - np.arccosh(1./x)**2\n x = X[X >= 1]\n a[X >= 1] = np.log(x/2.)**2 + np.arccos(1./x)**2\n return a","def cox_ph_loss_sorted(log_h: Tensor, events: Tensor, eps: float = 1e-7) -> Tensor:\n if events.dtype is torch.bool:\n events = events.float()\n events = events.view(-1)\n log_h = log_h.view(-1)\n gamma = log_h.max()\n log_cumsum_h = log_h.sub(gamma).exp().cumsum(0).add(eps).log().add(gamma)\n return - log_h.sub(log_cumsum_h).mul(events).sum().div(events.sum())","def shannon_entropy(probs):\n return -(\n math.sum([px * math.log2(px) if px != 0 and not (np.isclose(px, 0)) else 0 for px in probs])\n )","def shannon_entropy(counts):\n freq = np.array(counts) * 1.0 / np.sum(counts)\n return -np.sum([f * np.log2(f) for f in freq if f != 0])","def cost(h, y):\n\tm = y.shape[0]\n\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\n\treturn cost","def _log_cosh_error_update(preds: Tensor, target: Tensor, num_outputs: int) ->Tuple[Tensor, Tensor]:\n _check_same_shape(preds, target)\n _check_data_shape_to_num_outputs(preds, target, num_outputs)\n preds, target = _unsqueeze_tensors(preds, target)\n diff = preds - target\n sum_log_cosh_error = torch.log((torch.exp(diff) + torch.exp(-diff)) / 2).sum(0).squeeze()\n n_obs = torch.tensor(target.shape[0], device=preds.device)\n return sum_log_cosh_error, n_obs","def log_norm(log_x):\n c = np.max(log_x)\n\n if np.isinf(c):\n return c\n\n sum_exp = 0\n\n for x in log_x:\n sum_exp += np.exp(x - c)\n\n log_sum_exp = np.log(sum_exp)\n\n log_Z = log_sum_exp + c\n\n return log_Z","def smart_log(self, value: float) -> float:\n if value > 0:\n return math.log(value, self.log_scale)\n elif value == 0:\n return 0\n elif value < 0:\n return -(math.log(abs(value), self.log_scale))","def Schechter_log(self, logl, phis, alpha, logls):\n l = np.power(10., logl)\n ls = np.power(10., logls)\n phi = np.log(10) * phis * np.power(l / ls, (alpha + 1)) * np.exp(-l / ls)\n return phi","def safelog(x):\n #return np.log(x)\n return np.log(np.clip(x,floor,np.inf))","def cross_entropy_loss(predictions, targets, epsilon=1e-12):\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n N = predictions.shape[0]\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\n return ce","def cosh(x):\n return 0.0","def lognashsutcliffe(sim, obs, epsilon=1e-6, dim=\"time\"):\n obs = np.log(obs + epsilon)\n sim = np.log(sim + epsilon)\n # wrap numpy function\n kwargs = dict(\n input_core_dims=[[dim], [dim]], dask=\"parallelized\", output_dtypes=[float]\n )\n log_nse = xr.apply_ufunc(_nse, sim, obs, **kwargs)\n log_nse.name = \"log_nse\"\n return log_nse","def log_cust(x):\n if type(x) != str:\n if x < 0:\n return 0\n elif x == 0:\n return 0\n elif x > 0:\n return np.log(x)","def log2(x: float) -> float:\n return math.log2(x) if x > 0 else 0","def acosh(x):\n return 0.0","def acosh(self):\r\n getcontext().prec += 2\r\n arg = self + (self*self - 1).sqrt1()\r\n ans = arg.ln()\r\n getcontext().prec -= 2\r\n return +ans","def ShannonEntropy(self,s):\n e = s[np.nonzero(s)]**2 * np.log(s[np.nonzero(s)]**2)\n return np.sum(e)","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def log_hchg(x, a1, a2, mu1, mu2):\n assert np.alltrue(mu1 > 0) and np.alltrue(mu2 > 0)\n assert np.alltrue(a1 > 0) and np.alltrue(a2 > 0)\n \n out_shp = np.broadcast(x, a1, a2, mu1, mu2).shape\n if out_shp == ():\n out_shp = (1,)\n \n x = np.broadcast_to(x, out_shp).ravel()[:, np.newaxis]\n a1 = np.broadcast_to(a1, out_shp).ravel()[:, np.newaxis]\n a2 = np.broadcast_to(a2, out_shp).ravel()[:, np.newaxis]\n mu1 = np.broadcast_to(mu1, out_shp).ravel()[:, np.newaxis]\n mu2 = np.broadcast_to(mu2, out_shp).ravel()[:, np.newaxis]\n \n j = np.arange(250)\n \n out = j * np.log(mu1 * x) - sp.gammaln(j+1)\n out += log_poch(a1+a2, j) - log_poch(a1, j)\n out += np.log(sp.hyp1f1(a1+a2+j, a2, mu2*(1-x)))\n out = sp.logsumexp(out, axis=1)\n return out.reshape(out_shp) if out.size > 1 else float(out)","def logistic_pharm_curve(x,IC50,g_drugless,hill_coeff):\n if x == 0:\n g = g_drugless\n else:\n g = g_drugless/(1+np.exp((IC50-np.log10(x))/hill_coeff))\n\n return g","def _log_sub(logx: float, logy: float) -> float:\n if logx < logy:\n raise ValueError(\"The result of subtraction must be non-negative.\")\n if logy == -np.inf: # subtracting 0\n return logx\n if logx == logy:\n return -np.inf # 0 is represented as -np.inf in the log space.\n\n try:\n # Use exp(x) - exp(y) = (exp(x - y) - 1) * exp(y).\n return math.log(math.expm1(logx - logy)) + logy # expm1(x) = exp(x) - 1\n except OverflowError:\n return logx","def _logcdf(\n op: Op,\n value: TensorVariable,\n *inputs: TensorVariable,\n **kwargs,\n):\n raise NotImplementedError(f\"LogCDF method not implemented for {op}\")","def cross_entropy(targets, predictions, epsilon=1e-12):\n\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n\n N = predictions.shape[0]\n\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\n\n return ce","def log2(x):\n return math.log(x) / math.log(2)","def entropy_function(c, n):\n return -(c*1.0/n)*math.log(c*1.0/n,2)","def shannon_entropy(c):\n\n c_normalized = c / float(np.sum(c))\n c_normalized_nonzero = c_normalized[np.nonzero(c_normalized)] # gives 1D array\n entropy = -sum(c_normalized_nonzero * np.log2(c_normalized_nonzero)) # unit in bits\n return entropy","def log(self) -> np.ndarray:\n S = 0.5*(self.A-self.A.T) # Skew-symmetric matrix\n y = np.array([S[2, 1], -S[2, 0], S[1, 0]]) # Axis\n if np.allclose(np.zeros(3), y):\n return np.zeros(3)\n y2 = np.linalg.norm(y)\n return np.arcsin(y2)*y/y2","def score_loglike(data, covariance_matrix):\n inv_covariance_matrix = pinvh(covariance_matrix, check_finite=False)\n n_features = data.shape[1]\n log_like = -.5 * (data * (np.dot(data, inv_covariance_matrix))).sum(axis=1)\n log_like -= .5 * (n_features * log(2. * np.pi) - fast_logdet(inv_covariance_matrix))\n return log_like","def decayConst(hL):\n\tk = [math.log(2)/hL[i] for i in range(0, len(hL)) if (int(hL[i])!=0)]\n\treturn k","def coulog(Te,nev):\n return np.log(12.0*np.pi*nev*(Debye(Te,nev))**3)","def log_loss(actual, predicted):\n\n predicted, actual = np.array(predicted), np.array(actual)\n\n small_value = 1e-15\n predicted[predicted < small_value] = small_value\n predicted[predicted > 1 - small_value] = 1. - small_value\n return (-1. / len(actual)) * np.sum(\n actual * np.log(predicted) + (1. - actual) * np.log(1. - predicted))","def get_log_occr(self):\n if tf.is_tensor(self._occr_array):\n return tf.log(self._occr_array) / tf.log(10)\n else:\n return np.log10(self._occr_array)","def get_hc_co_occ_entropy(co_occs, v_repl_nan=None):\n\n return utils.get_row_entropy(co_occs.T, v_repl_nan)","def logistic_equation(conc,drugless_rate,ic50,hc=-0.6824968):\n \n # conc = conc/10**6\n f = drugless_rate/(1+np.exp((ic50-np.log10(conc))/hc))\n \n return f","def entropy(x):\n x_max, x_min = x.max(), x.min()\n assert (x_min >= 0) and (x_max <= 1)\n if x_min == x_max == 0:\n return np.float32(0.)\n # Take only non-zero values as log(0) = 0 :\n nnz_x = x[np.nonzero(x)]\n entr = -np.sum(nnz_x * np.log2(nnz_x))\n\n return entr","def log_prior(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return -np.inf\n\n if tf.is_tensor(self.occr):\n # Written in terms of occr for ease.\n value = tf.reduce_sum(0.5*tf.math.log(self.occr))\n else:\n # Written in terms of occr for ease.\n value = np.sum(0.5*np.log(self.occr))\n # At this point, it's still possible for occr to be so\n # small that it's underflowing, where value will be nan\n value = value if not np.isnan(value) else -np.inf\n\n return value","def diff_log(x):\n\n return np.diff(np.log(x)),np.log(x)[0]","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def _safe_xlogy(x: Tensor, y: Tensor) ->Tensor:\n res = x * torch.log(y)\n res[x == 0] = 0.0\n return res","def shannon(state_space):\n if isinstance(state_space, int) or len(state_space) == 1:\n return 0\n ws = sum(state_space.values())\n if ws == 0:\n print(state_space)\n return math.log(ws) - sum(map(lambda x: x * math.log(x), state_space.values())) / ws","def diff_log(x):\n \n return np.diff(np.log(x)),np.log(x)[0]","def log_so3(R):\n theta = np.arccos((np.trace(R) - 1) / 2)\n return (R - R.T) * theta / (2*np.sin(theta))","def jaccard_coef_logloss(y_true, y_pred, smooth=1e-10):\n y_true=tf.cast(y_true,tf.float32)\n y_pred=tf.cast(y_pred,tf.float32)\n y_true = K.flatten(y_true)\n y_pred = K.flatten(y_pred)\n truepos = K.sum(y_true * y_pred)\n falsepos = K.sum(y_pred) - truepos\n falseneg = K.sum(y_true) - truepos\n jaccard = (truepos + smooth) / (smooth + truepos + falseneg + falsepos)\n return 1-K.log(jaccard + smooth)","def test_log_con():\n c=14\n assert {'diff':EF.log(c).der, 'value': EF.log(c).val}=={'diff':0, 'value': math.log(c)}","def logistic(mu, hw, x): \n n = np.exp(- ((x-mu)/(.477*hw))**2)\n return (2. * n)/( 1 + n)","def logistic(v: float) -> float:\n v = clip(v, -50, 50) # Improve numerical stability.\n return 1 / (1 + math.exp(-v))","def get_cross_entropy(actual, expected):\n\n\t# use try except to handle overflow in the log\n\ttry:\t\n\t\t# formula -(y*log(a) + (1-y)log(1-a))\n\t\tones = np.ones(actual.shape) # used to subtract array from one\n\t\tcross_entropy_vec = np.multiply(expected, np.log(actual)) + np.multiply(ones - expected, np.log(ones - actual))\n\t\tcross_entropy = np.sum(cross_entropy_vec)\n\texcept:\n\t\treturn sys.maxsize\n\n\treturn -1.0*cross_entropy","def getGaussianEntropy(sigsq):\n return 0.5*log(2.0*pi*sigsq) + 0.5","def logistic(x):\n try:\n denom = (1 + math.e ** -x)\n except OverflowError:\n return 0.0\n return 1.0 / denom","def cost(self, h_theta, y):\n \n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def cross_entropy(self, yhat):\n n = len(self._y)\n c = 0.0\n for i in range(0, n):\n c += self._y[i] * log(\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\n\n return c","def log_transform(x, epsilon = 1e-4):\n if x.min() < 0: epsilon += np.abs(x.min())\n return (x.fillna(0).astype(float) + epsilon).apply(np.log)","def logistic_log_cdf(x: JaxArray, mean: JaxArray, scale: JaxArray) -> JaxArray:\n\n # change of variables\n z = (x - mean) / scale\n\n # log cdf\n log_cdf = log_sigmoid(z)\n\n return log_cdf","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def asigmoid(x):\n return -log(1 / x - 1)","def logp(value, mu, rowchol, colchol):\n\n if value.ndim != 2:\n raise ValueError(\"Value must be two dimensional.\")\n\n # Compute Tr[colcov^-1 @ (x - mu).T @ rowcov^-1 @ (x - mu)] and\n # the logdet of colcov and rowcov.\n delta = value - mu\n\n # Find exponent piece by piece\n right_quaddist = solve_lower(rowchol, delta)\n quaddist = pt.nlinalg.matrix_dot(right_quaddist.T, right_quaddist)\n quaddist = solve_lower(colchol, quaddist)\n quaddist = solve_upper(colchol.T, quaddist)\n trquaddist = pt.nlinalg.trace(quaddist)\n\n coldiag = pt.diag(colchol)\n rowdiag = pt.diag(rowchol)\n half_collogdet = pt.sum(pt.log(coldiag)) # logdet(M) = 2*Tr(log(L))\n half_rowlogdet = pt.sum(pt.log(rowdiag)) # Using Cholesky: M = L L^T\n\n m = rowchol.shape[0]\n n = colchol.shape[0]\n\n norm = -0.5 * m * n * pm.floatX(np.log(2 * np.pi))\n return norm - 0.5 * trquaddist - m * half_collogdet - n * half_rowlogdet","def ln(q):\n normq = amplitude(q)\n res = np.zeros_like(q)\n res[:,3:] = np.log(normq)\n res[:,:3] = norm(q[:,:3])\n res[:,:3] *= np.arccos(q[:,3:]/normq)\n return res","def logistic(val):\n return 1.0 / (1.0 + np.exp(-val))","def mean_squared_logarithmic_error(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n first_log = math_ops.log(backend.maximum(y_pred, backend.epsilon()) + 1.)\n second_log = math_ops.log(backend.maximum(y_true, backend.epsilon()) + 1.)\n return backend.mean(\n math_ops.squared_difference(first_log, second_log), axis=-1)","def gaussian_entropy(log_std):\n return tf.reduce_sum(log_std + 0.5 * np.log(2.0 * np.pi * np.e), axis=-1)","def log_likelihood(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return -np.inf\n\n # N_exp\n N_exp = self.calc_integral() * self._N_stars\n\n # Product terms\n # TODO:Check that the array broadcasting works here\n # Shape of s_terms should be [N_planets, NR, NP]\n s_terms = self.H_array * self.F_array * self.occr_grid\n\n if tf.is_tensor(self.occr):\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\n log_ll_value = product_term - N_exp\n else:\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\n log_ll_value = product_term - N_exp\n\n # BUG TODO\n if np.isnan(log_ll_value):\n warnings.warn(\".likelihood value is nan.\")\n import pdb; pdb.set_trace()\n\n # A nan value is possible when some of the occr are too high\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\n\n return log_ll_value","def log_prob_complement(log_prob: torch.Tensor) -> torch.Tensor:\n log_prob_zero_capped = torch.clamp(log_prob, max=0.)\n return torch.where(\n log_prob_zero_capped >= LN_HALF,\n torch.log(-torch.expm1(log_prob_zero_capped)),\n torch.log1p(-torch.exp(log_prob_zero_capped)))","def calculate_entropy(prob):\n return -(prob * math.log(prob,2))","def calculate_entropic_cost(self, log_prediction):\n\n log_prediction = tf.squeeze(log_prediction)\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\n\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\n\n return tf.reduce_sum(penalty)","def formula_0(x: np.ndarray) -> np.ndarray:\n logx = np.log(x)\n denom = x - 1\n k0 = (x - logx * x - 1) / denom\n return k0","def log_ess(log_weight):\n dim = 1 if log_weight.ndimension() == 2 else 0\n\n return 2 * torch.logsumexp(log_weight, dim=dim) - \\\n torch.logsumexp(2 * log_weight, dim=dim)","def logit_link(x):\n\n return 1 / (1 + math.exp(-0.05 * x))\n # return 1 / (1 + math.exp(-0.01 * x))","def log_likelihood(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return -np.inf\n\n # N_exp\n N_exp = self.calc_integral() * self._N_stars\n\n # Product terms\n # TODO:Check that the array broadcasting works here\n # Shape of s_terms should be [N_planets, NR, NP]\n s_terms = self.H_array * self.F_array * self.occr\n\n if tf.is_tensor(self.occr):\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\n log_ll_value = product_term - N_exp\n else:\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\n log_ll_value = product_term - N_exp\n\n # BUG TODO\n if np.isnan(log_ll_value):\n warnings.warn(\".likelihood value is nan.\")\n import pdb; pdb.set_trace()\n\n # A nan value is possible when some of the occr are too high\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\n\n return log_ll_value","def crossEntropy(p_m1):\n p_m2 = 1 - p_m1\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\n return D","def sequence_entropy(sequence):\n c = Counter(sequence.upper())\n tot = float(sum(c.values()))\n c = {k: v / tot for k, v in c.items()}\n return -1 * sum(c * np.log2(c) for b, c in c.items())","def getCrossEntropy(visible, PDF):\n\n\tndocs = visible.shape[0]\n\tCrossEnt = numpy.zeros((ndocs,))\n\tfor doc in xrange(ndocs):\n\t\tCrossEnt[doc] = numpy.dot(visible[doc], numpy.log(PDF[doc]))\n\n\treturn CrossEnt.mean()","def prior(self, log_occr_array=None):\n\n if log_occr_array is not None:\n # Catch invalid occurrence rates for zero likelihood\n try:\n self.log_occr = log_occr_array\n except InvalidOccurrenceRate:\n return 0.0\n\n # Written in terms of occr for ease, also same as:\n # sqrt(occr) = sqrt(10**self.log_occr)\n return np.prod(np.sqrt(self.occr))\n\n if tf.is_tensor(self.occr):\n # Written in terms of occr for ease.\n value = tf.reduce_prod(tf.math.sqrt(self.occr))\n else:\n # Written in terms of occr for ease.\n value = np.prod(np.sqrt(self.occr))\n # At this point, it's still possible for occr to be so\n # small that it's underflowing, where value will be nan\n value = value if not np.isnan(value) else 0.0\n\n return value","def logistic_function(self, real_value):\n return 1/(1+np.exp(-real_value))","def logm(C):\n theta_x = so2.logm(C[:2,:2])\n u = getVi(C).dot(C[:2,2])\n return np.concatenate((\n np.concatenate(( theta_x, u[:,np.newaxis]), axis=1),\n [[0, 0, 0]]\n ))\n\n # make matrix \n # tx = so2.logm(C[:2,:2])\n # t = so2.algi(tx)\n # # if np.abs(t)<1e-2: \n # # stt = lie.TaylorSinXoverX(t)\n # # ctt = lie.TaylorOneMinusCosXOverX(t)\n # # else:\n # # stt = np.sin(t)/t\n # # ctt = (1-np.cos(t))/t\n # #\n # # A = stt; B = ctt\n # # Vi = (1 / (A**2 + B**2)) * np.array([[A, B], [-B, A]])\n # Vi = getVi(C)\n #\n # d = C[:2,2]\n # u = Vi.dot(d)\n #\n # return alg(np.concatenate(( u, [t] )))","def log_likelihood(cosmo_param, pk_obs, inv_cov):\n pknlfid, kbins, kspace = fiducial_power(cosmo_param)\n \n x = pk_obs - pknlfid\n return -0.5* (x.T @ inv_cov @ x)","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def log2(tensor):\n return log(tensor, base=2)","def image_entropy(img):\r\n hist = img.histogram()\r\n hist_size = sum(hist)\r\n hist = [float(h) / hist_size for h in hist]\r\n\r\n return -sum([p * math.log(p, 2) for p in hist if p != 0])","def salomonfcn(x: np.ndarray) -> np.ndarray:\n x2 = x**2\n sumx2 = np.sum(x2, axis=1)\n sqrtsx2 = np.sqrt(sumx2)\n\n scores = 1 - np.cos(2 * np.pi * sqrtsx2) + (0.1 * sqrtsx2)\n\n return scores","def compute_log_ph3(ph3, x_ph3=None):\n if ph3.min() <= 0:\n ph3 += np.abs(ph3.min())\n if x_ph3 is None:\n #x_ph3 = np.arange(2.5, 8, 0.02)\n ph3_min = np.max((0, np.log10(ph3.min()+0.1) - 0.1))\n ph3_max = np.log10(ph3.max()) + 0.1\n x_ph3 = np.arange(ph3_min, ph3_max, 0.02)\n ph3_upper_bound = 10 ** x_ph3[-3]\n ph3_lower_bound = 10 ** x_ph3[2]\n ph3_upper_bounded = [d if d < ph3_upper_bound else ph3_upper_bound\n for d in ph3]\n ph3_bounded = [d if d > ph3_lower_bound else ph3_lower_bound\n for d in ph3_upper_bounded]\n log_ph3 = np.array([np.log10(d) for d in ph3_bounded])\n return log_ph3","def __loss(self, h, y):\n return (-y*np.log(h)-(1-y)*np.log(1-h)).mean()","def logTF(self, tf):\n return math.log(tf)","def mycos(x):\n return (\n 1\n - x ** 2 / 2\n + x ** 4 / 24\n - x ** 6 / 720\n + x ** 8 / 40320\n - x ** 10 / 3628800\n )","def safe_log(data):\n\n non_zero = data != 0\n result = numpy.zeros(data.shape, dtype=float)\n with numpy.errstate(invalid=\"raise\"):\n result[non_zero] = numpy.log2(data[non_zero])\n return result","def ln(x):\n return log(x, const.e)","def log_nse(self, epsilon=0.0) -> float:\n s, o = self.predicted + epsilon, self.true + epsilon # todo, check why s is here\n return float(1 - sum((np.log(o) - np.log(o)) ** 2) / sum((np.log(o) - np.mean(np.log(o))) ** 2))","def cross_entropy(predicted, target):\n batch_size, num_classes = predicted.shape\n\n e_x = predicted.exp()\n log_e_x = e_x.log()\n a = log_sum_x_trick(predicted)\n x_n_offset = predicted - a\n\n exp_xn_offset = x_n_offset.exp()\n\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\n denominator = a + log_sum_exp_xn_offset\n log_softmax = log_e_x - denominator\n\n labels = to_one_hot(target, num_classes)\n prod = log_softmax*labels\n total = prod.sum()\n batch_size = tensor.Tensor(-batch_size)\n\n total = total / batch_size\n\n return total","def log_pacc(xy, x, y, h):\n logp = log_q(xy, y, x, h)\n logp += xy.log_density(y)\n logp -= log_q(xy, x, y, h)\n logp -= xy.log_density(x)\n return logp","def entropy(data):\n strings, lens = Counter(data), np.float(len(data))\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))"],"string":"[\n \"def log_cosh(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n\\n def _logcosh(x):\\n return x + math_ops.softplus(-2. * x) - math_ops.cast(\\n math_ops.log(2.), x.dtype)\\n\\n return backend.mean(_logcosh(y_pred - y_true), axis=-1)\",\n \"def acosh(x):\\n return math.log(x+math.sqrt(x*x-1))\",\n \"def _log_cosh_error_compute(sum_log_cosh_error: Tensor, n_obs: Tensor) ->Tensor:\\n return (sum_log_cosh_error / n_obs).squeeze()\",\n \"def arcosh(x):\\n return torch.log(x+torch.sqrt(x*x - 1))\",\n \"def log_Schechter_log(self, logl, alpha, logls, logl0):\\n phi = (logl - logls) * (alpha+1) * np.log(10.) - np.power(10., logl-logls)\\n lik = phi.copy()\\n lik [logl < logl0] = -1e99\\n return lik\",\n \"def h(x):\\n h = -x*np.math.log(x, 2) - (1 - x)*np.math.log(1 - x, 2)\\n return h\",\n \"def h(self, X):\\n if isinstance(X, int) or isinstance(X, float):\\n if X < 1:\\n x = max(0.001, X)\\n a = np.log(x/2.)**2 - np.arccosh(1./x)**2\\n elif X >= 1:\\n a = np.log(X/2.)**2 + np.arccos(1./X)**2\\n else:\\n a=np.empty_like(X)\\n X[X==0] = 0.001\\n x = X[(X<1) & (X>0)]\\n a[(X<1) & (X>0)] = np.log(x/2.)**2 - np.arccosh(1./x)**2\\n x = X[X >= 1]\\n a[X >= 1] = np.log(x/2.)**2 + np.arccos(1./x)**2\\n return a\",\n \"def cox_ph_loss_sorted(log_h: Tensor, events: Tensor, eps: float = 1e-7) -> Tensor:\\n if events.dtype is torch.bool:\\n events = events.float()\\n events = events.view(-1)\\n log_h = log_h.view(-1)\\n gamma = log_h.max()\\n log_cumsum_h = log_h.sub(gamma).exp().cumsum(0).add(eps).log().add(gamma)\\n return - log_h.sub(log_cumsum_h).mul(events).sum().div(events.sum())\",\n \"def shannon_entropy(probs):\\n return -(\\n math.sum([px * math.log2(px) if px != 0 and not (np.isclose(px, 0)) else 0 for px in probs])\\n )\",\n \"def shannon_entropy(counts):\\n freq = np.array(counts) * 1.0 / np.sum(counts)\\n return -np.sum([f * np.log2(f) for f in freq if f != 0])\",\n \"def cost(h, y):\\n\\tm = y.shape[0]\\n\\tcost = (-1/m) * (y.T @ np.log(h) + (1 - y).T @ np.log(1 - h))\\n\\treturn cost\",\n \"def _log_cosh_error_update(preds: Tensor, target: Tensor, num_outputs: int) ->Tuple[Tensor, Tensor]:\\n _check_same_shape(preds, target)\\n _check_data_shape_to_num_outputs(preds, target, num_outputs)\\n preds, target = _unsqueeze_tensors(preds, target)\\n diff = preds - target\\n sum_log_cosh_error = torch.log((torch.exp(diff) + torch.exp(-diff)) / 2).sum(0).squeeze()\\n n_obs = torch.tensor(target.shape[0], device=preds.device)\\n return sum_log_cosh_error, n_obs\",\n \"def log_norm(log_x):\\n c = np.max(log_x)\\n\\n if np.isinf(c):\\n return c\\n\\n sum_exp = 0\\n\\n for x in log_x:\\n sum_exp += np.exp(x - c)\\n\\n log_sum_exp = np.log(sum_exp)\\n\\n log_Z = log_sum_exp + c\\n\\n return log_Z\",\n \"def smart_log(self, value: float) -> float:\\n if value > 0:\\n return math.log(value, self.log_scale)\\n elif value == 0:\\n return 0\\n elif value < 0:\\n return -(math.log(abs(value), self.log_scale))\",\n \"def Schechter_log(self, logl, phis, alpha, logls):\\n l = np.power(10., logl)\\n ls = np.power(10., logls)\\n phi = np.log(10) * phis * np.power(l / ls, (alpha + 1)) * np.exp(-l / ls)\\n return phi\",\n \"def safelog(x):\\n #return np.log(x)\\n return np.log(np.clip(x,floor,np.inf))\",\n \"def cross_entropy_loss(predictions, targets, epsilon=1e-12):\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n N = predictions.shape[0]\\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\\n return ce\",\n \"def cosh(x):\\n return 0.0\",\n \"def lognashsutcliffe(sim, obs, epsilon=1e-6, dim=\\\"time\\\"):\\n obs = np.log(obs + epsilon)\\n sim = np.log(sim + epsilon)\\n # wrap numpy function\\n kwargs = dict(\\n input_core_dims=[[dim], [dim]], dask=\\\"parallelized\\\", output_dtypes=[float]\\n )\\n log_nse = xr.apply_ufunc(_nse, sim, obs, **kwargs)\\n log_nse.name = \\\"log_nse\\\"\\n return log_nse\",\n \"def log_cust(x):\\n if type(x) != str:\\n if x < 0:\\n return 0\\n elif x == 0:\\n return 0\\n elif x > 0:\\n return np.log(x)\",\n \"def log2(x: float) -> float:\\n return math.log2(x) if x > 0 else 0\",\n \"def acosh(x):\\n return 0.0\",\n \"def acosh(self):\\r\\n getcontext().prec += 2\\r\\n arg = self + (self*self - 1).sqrt1()\\r\\n ans = arg.ln()\\r\\n getcontext().prec -= 2\\r\\n return +ans\",\n \"def ShannonEntropy(self,s):\\n e = s[np.nonzero(s)]**2 * np.log(s[np.nonzero(s)]**2)\\n return np.sum(e)\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def log_hchg(x, a1, a2, mu1, mu2):\\n assert np.alltrue(mu1 > 0) and np.alltrue(mu2 > 0)\\n assert np.alltrue(a1 > 0) and np.alltrue(a2 > 0)\\n \\n out_shp = np.broadcast(x, a1, a2, mu1, mu2).shape\\n if out_shp == ():\\n out_shp = (1,)\\n \\n x = np.broadcast_to(x, out_shp).ravel()[:, np.newaxis]\\n a1 = np.broadcast_to(a1, out_shp).ravel()[:, np.newaxis]\\n a2 = np.broadcast_to(a2, out_shp).ravel()[:, np.newaxis]\\n mu1 = np.broadcast_to(mu1, out_shp).ravel()[:, np.newaxis]\\n mu2 = np.broadcast_to(mu2, out_shp).ravel()[:, np.newaxis]\\n \\n j = np.arange(250)\\n \\n out = j * np.log(mu1 * x) - sp.gammaln(j+1)\\n out += log_poch(a1+a2, j) - log_poch(a1, j)\\n out += np.log(sp.hyp1f1(a1+a2+j, a2, mu2*(1-x)))\\n out = sp.logsumexp(out, axis=1)\\n return out.reshape(out_shp) if out.size > 1 else float(out)\",\n \"def logistic_pharm_curve(x,IC50,g_drugless,hill_coeff):\\n if x == 0:\\n g = g_drugless\\n else:\\n g = g_drugless/(1+np.exp((IC50-np.log10(x))/hill_coeff))\\n\\n return g\",\n \"def _log_sub(logx: float, logy: float) -> float:\\n if logx < logy:\\n raise ValueError(\\\"The result of subtraction must be non-negative.\\\")\\n if logy == -np.inf: # subtracting 0\\n return logx\\n if logx == logy:\\n return -np.inf # 0 is represented as -np.inf in the log space.\\n\\n try:\\n # Use exp(x) - exp(y) = (exp(x - y) - 1) * exp(y).\\n return math.log(math.expm1(logx - logy)) + logy # expm1(x) = exp(x) - 1\\n except OverflowError:\\n return logx\",\n \"def _logcdf(\\n op: Op,\\n value: TensorVariable,\\n *inputs: TensorVariable,\\n **kwargs,\\n):\\n raise NotImplementedError(f\\\"LogCDF method not implemented for {op}\\\")\",\n \"def cross_entropy(targets, predictions, epsilon=1e-12):\\n\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n\\n N = predictions.shape[0]\\n\\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\\n\\n return ce\",\n \"def log2(x):\\n return math.log(x) / math.log(2)\",\n \"def entropy_function(c, n):\\n return -(c*1.0/n)*math.log(c*1.0/n,2)\",\n \"def shannon_entropy(c):\\n\\n c_normalized = c / float(np.sum(c))\\n c_normalized_nonzero = c_normalized[np.nonzero(c_normalized)] # gives 1D array\\n entropy = -sum(c_normalized_nonzero * np.log2(c_normalized_nonzero)) # unit in bits\\n return entropy\",\n \"def log(self) -> np.ndarray:\\n S = 0.5*(self.A-self.A.T) # Skew-symmetric matrix\\n y = np.array([S[2, 1], -S[2, 0], S[1, 0]]) # Axis\\n if np.allclose(np.zeros(3), y):\\n return np.zeros(3)\\n y2 = np.linalg.norm(y)\\n return np.arcsin(y2)*y/y2\",\n \"def score_loglike(data, covariance_matrix):\\n inv_covariance_matrix = pinvh(covariance_matrix, check_finite=False)\\n n_features = data.shape[1]\\n log_like = -.5 * (data * (np.dot(data, inv_covariance_matrix))).sum(axis=1)\\n log_like -= .5 * (n_features * log(2. * np.pi) - fast_logdet(inv_covariance_matrix))\\n return log_like\",\n \"def decayConst(hL):\\n\\tk = [math.log(2)/hL[i] for i in range(0, len(hL)) if (int(hL[i])!=0)]\\n\\treturn k\",\n \"def coulog(Te,nev):\\n return np.log(12.0*np.pi*nev*(Debye(Te,nev))**3)\",\n \"def log_loss(actual, predicted):\\n\\n predicted, actual = np.array(predicted), np.array(actual)\\n\\n small_value = 1e-15\\n predicted[predicted < small_value] = small_value\\n predicted[predicted > 1 - small_value] = 1. - small_value\\n return (-1. / len(actual)) * np.sum(\\n actual * np.log(predicted) + (1. - actual) * np.log(1. - predicted))\",\n \"def get_log_occr(self):\\n if tf.is_tensor(self._occr_array):\\n return tf.log(self._occr_array) / tf.log(10)\\n else:\\n return np.log10(self._occr_array)\",\n \"def get_hc_co_occ_entropy(co_occs, v_repl_nan=None):\\n\\n return utils.get_row_entropy(co_occs.T, v_repl_nan)\",\n \"def logistic_equation(conc,drugless_rate,ic50,hc=-0.6824968):\\n \\n # conc = conc/10**6\\n f = drugless_rate/(1+np.exp((ic50-np.log10(conc))/hc))\\n \\n return f\",\n \"def entropy(x):\\n x_max, x_min = x.max(), x.min()\\n assert (x_min >= 0) and (x_max <= 1)\\n if x_min == x_max == 0:\\n return np.float32(0.)\\n # Take only non-zero values as log(0) = 0 :\\n nnz_x = x[np.nonzero(x)]\\n entr = -np.sum(nnz_x * np.log2(nnz_x))\\n\\n return entr\",\n \"def log_prior(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return -np.inf\\n\\n if tf.is_tensor(self.occr):\\n # Written in terms of occr for ease.\\n value = tf.reduce_sum(0.5*tf.math.log(self.occr))\\n else:\\n # Written in terms of occr for ease.\\n value = np.sum(0.5*np.log(self.occr))\\n # At this point, it's still possible for occr to be so\\n # small that it's underflowing, where value will be nan\\n value = value if not np.isnan(value) else -np.inf\\n\\n return value\",\n \"def diff_log(x):\\n\\n return np.diff(np.log(x)),np.log(x)[0]\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def _safe_xlogy(x: Tensor, y: Tensor) ->Tensor:\\n res = x * torch.log(y)\\n res[x == 0] = 0.0\\n return res\",\n \"def shannon(state_space):\\n if isinstance(state_space, int) or len(state_space) == 1:\\n return 0\\n ws = sum(state_space.values())\\n if ws == 0:\\n print(state_space)\\n return math.log(ws) - sum(map(lambda x: x * math.log(x), state_space.values())) / ws\",\n \"def diff_log(x):\\n \\n return np.diff(np.log(x)),np.log(x)[0]\",\n \"def log_so3(R):\\n theta = np.arccos((np.trace(R) - 1) / 2)\\n return (R - R.T) * theta / (2*np.sin(theta))\",\n \"def jaccard_coef_logloss(y_true, y_pred, smooth=1e-10):\\n y_true=tf.cast(y_true,tf.float32)\\n y_pred=tf.cast(y_pred,tf.float32)\\n y_true = K.flatten(y_true)\\n y_pred = K.flatten(y_pred)\\n truepos = K.sum(y_true * y_pred)\\n falsepos = K.sum(y_pred) - truepos\\n falseneg = K.sum(y_true) - truepos\\n jaccard = (truepos + smooth) / (smooth + truepos + falseneg + falsepos)\\n return 1-K.log(jaccard + smooth)\",\n \"def test_log_con():\\n c=14\\n assert {'diff':EF.log(c).der, 'value': EF.log(c).val}=={'diff':0, 'value': math.log(c)}\",\n \"def logistic(mu, hw, x): \\n n = np.exp(- ((x-mu)/(.477*hw))**2)\\n return (2. * n)/( 1 + n)\",\n \"def logistic(v: float) -> float:\\n v = clip(v, -50, 50) # Improve numerical stability.\\n return 1 / (1 + math.exp(-v))\",\n \"def get_cross_entropy(actual, expected):\\n\\n\\t# use try except to handle overflow in the log\\n\\ttry:\\t\\n\\t\\t# formula -(y*log(a) + (1-y)log(1-a))\\n\\t\\tones = np.ones(actual.shape) # used to subtract array from one\\n\\t\\tcross_entropy_vec = np.multiply(expected, np.log(actual)) + np.multiply(ones - expected, np.log(ones - actual))\\n\\t\\tcross_entropy = np.sum(cross_entropy_vec)\\n\\texcept:\\n\\t\\treturn sys.maxsize\\n\\n\\treturn -1.0*cross_entropy\",\n \"def getGaussianEntropy(sigsq):\\n return 0.5*log(2.0*pi*sigsq) + 0.5\",\n \"def logistic(x):\\n try:\\n denom = (1 + math.e ** -x)\\n except OverflowError:\\n return 0.0\\n return 1.0 / denom\",\n \"def cost(self, h_theta, y):\\n \\n return -y*np.log(h_theta) - (1. - y)*np.log(1. - h_theta)\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def cross_entropy(self, yhat):\\n n = len(self._y)\\n c = 0.0\\n for i in range(0, n):\\n c += self._y[i] * log(\\n yhat[i]) + (1 - self._y[i]) * log(1 - yhat[i])\\n\\n return c\",\n \"def log_transform(x, epsilon = 1e-4):\\n if x.min() < 0: epsilon += np.abs(x.min())\\n return (x.fillna(0).astype(float) + epsilon).apply(np.log)\",\n \"def logistic_log_cdf(x: JaxArray, mean: JaxArray, scale: JaxArray) -> JaxArray:\\n\\n # change of variables\\n z = (x - mean) / scale\\n\\n # log cdf\\n log_cdf = log_sigmoid(z)\\n\\n return log_cdf\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def asigmoid(x):\\n return -log(1 / x - 1)\",\n \"def logp(value, mu, rowchol, colchol):\\n\\n if value.ndim != 2:\\n raise ValueError(\\\"Value must be two dimensional.\\\")\\n\\n # Compute Tr[colcov^-1 @ (x - mu).T @ rowcov^-1 @ (x - mu)] and\\n # the logdet of colcov and rowcov.\\n delta = value - mu\\n\\n # Find exponent piece by piece\\n right_quaddist = solve_lower(rowchol, delta)\\n quaddist = pt.nlinalg.matrix_dot(right_quaddist.T, right_quaddist)\\n quaddist = solve_lower(colchol, quaddist)\\n quaddist = solve_upper(colchol.T, quaddist)\\n trquaddist = pt.nlinalg.trace(quaddist)\\n\\n coldiag = pt.diag(colchol)\\n rowdiag = pt.diag(rowchol)\\n half_collogdet = pt.sum(pt.log(coldiag)) # logdet(M) = 2*Tr(log(L))\\n half_rowlogdet = pt.sum(pt.log(rowdiag)) # Using Cholesky: M = L L^T\\n\\n m = rowchol.shape[0]\\n n = colchol.shape[0]\\n\\n norm = -0.5 * m * n * pm.floatX(np.log(2 * np.pi))\\n return norm - 0.5 * trquaddist - m * half_collogdet - n * half_rowlogdet\",\n \"def ln(q):\\n normq = amplitude(q)\\n res = np.zeros_like(q)\\n res[:,3:] = np.log(normq)\\n res[:,:3] = norm(q[:,:3])\\n res[:,:3] *= np.arccos(q[:,3:]/normq)\\n return res\",\n \"def logistic(val):\\n return 1.0 / (1.0 + np.exp(-val))\",\n \"def mean_squared_logarithmic_error(y_true, y_pred):\\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\\n y_true = math_ops.cast(y_true, y_pred.dtype)\\n first_log = math_ops.log(backend.maximum(y_pred, backend.epsilon()) + 1.)\\n second_log = math_ops.log(backend.maximum(y_true, backend.epsilon()) + 1.)\\n return backend.mean(\\n math_ops.squared_difference(first_log, second_log), axis=-1)\",\n \"def gaussian_entropy(log_std):\\n return tf.reduce_sum(log_std + 0.5 * np.log(2.0 * np.pi * np.e), axis=-1)\",\n \"def log_likelihood(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return -np.inf\\n\\n # N_exp\\n N_exp = self.calc_integral() * self._N_stars\\n\\n # Product terms\\n # TODO:Check that the array broadcasting works here\\n # Shape of s_terms should be [N_planets, NR, NP]\\n s_terms = self.H_array * self.F_array * self.occr_grid\\n\\n if tf.is_tensor(self.occr):\\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\\n log_ll_value = product_term - N_exp\\n else:\\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\\n log_ll_value = product_term - N_exp\\n\\n # BUG TODO\\n if np.isnan(log_ll_value):\\n warnings.warn(\\\".likelihood value is nan.\\\")\\n import pdb; pdb.set_trace()\\n\\n # A nan value is possible when some of the occr are too high\\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\\n\\n return log_ll_value\",\n \"def log_prob_complement(log_prob: torch.Tensor) -> torch.Tensor:\\n log_prob_zero_capped = torch.clamp(log_prob, max=0.)\\n return torch.where(\\n log_prob_zero_capped >= LN_HALF,\\n torch.log(-torch.expm1(log_prob_zero_capped)),\\n torch.log1p(-torch.exp(log_prob_zero_capped)))\",\n \"def calculate_entropy(prob):\\n return -(prob * math.log(prob,2))\",\n \"def calculate_entropic_cost(self, log_prediction):\\n\\n log_prediction = tf.squeeze(log_prediction)\\n mean, var_samples = tf.nn.moments(tf.exp(log_prediction), axes=0)\\n clip_min_variance = 1e-5 # Prevents 1 / 0 errors\\n var_samples = math_ops.maximum(var_samples, clip_min_variance)\\n\\n penalty = tf.reciprocal(var_samples) # Small variance across samples should be discouraged\\n\\n return tf.reduce_sum(penalty)\",\n \"def formula_0(x: np.ndarray) -> np.ndarray:\\n logx = np.log(x)\\n denom = x - 1\\n k0 = (x - logx * x - 1) / denom\\n return k0\",\n \"def log_ess(log_weight):\\n dim = 1 if log_weight.ndimension() == 2 else 0\\n\\n return 2 * torch.logsumexp(log_weight, dim=dim) - \\\\\\n torch.logsumexp(2 * log_weight, dim=dim)\",\n \"def logit_link(x):\\n\\n return 1 / (1 + math.exp(-0.05 * x))\\n # return 1 / (1 + math.exp(-0.01 * x))\",\n \"def log_likelihood(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return -np.inf\\n\\n # N_exp\\n N_exp = self.calc_integral() * self._N_stars\\n\\n # Product terms\\n # TODO:Check that the array broadcasting works here\\n # Shape of s_terms should be [N_planets, NR, NP]\\n s_terms = self.H_array * self.F_array * self.occr\\n\\n if tf.is_tensor(self.occr):\\n ps_terms = tf.reduce_sum(s_terms, axis=(-1, -2))\\n product_term = tf.reduce_sum(tf.math.log(ps_terms))\\n log_ll_value = product_term - N_exp\\n else:\\n product_term = np.log(s_terms.sum(axis=(-1, -2))).sum()\\n log_ll_value = product_term - N_exp\\n\\n # BUG TODO\\n if np.isnan(log_ll_value):\\n warnings.warn(\\\".likelihood value is nan.\\\")\\n import pdb; pdb.set_trace()\\n\\n # A nan value is possible when some of the occr are too high\\n log_ll_value = -np.inf if np.isnan(log_ll_value) else log_ll_value\\n\\n return log_ll_value\",\n \"def crossEntropy(p_m1):\\n p_m2 = 1 - p_m1\\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\\n return D\",\n \"def sequence_entropy(sequence):\\n c = Counter(sequence.upper())\\n tot = float(sum(c.values()))\\n c = {k: v / tot for k, v in c.items()}\\n return -1 * sum(c * np.log2(c) for b, c in c.items())\",\n \"def getCrossEntropy(visible, PDF):\\n\\n\\tndocs = visible.shape[0]\\n\\tCrossEnt = numpy.zeros((ndocs,))\\n\\tfor doc in xrange(ndocs):\\n\\t\\tCrossEnt[doc] = numpy.dot(visible[doc], numpy.log(PDF[doc]))\\n\\n\\treturn CrossEnt.mean()\",\n \"def prior(self, log_occr_array=None):\\n\\n if log_occr_array is not None:\\n # Catch invalid occurrence rates for zero likelihood\\n try:\\n self.log_occr = log_occr_array\\n except InvalidOccurrenceRate:\\n return 0.0\\n\\n # Written in terms of occr for ease, also same as:\\n # sqrt(occr) = sqrt(10**self.log_occr)\\n return np.prod(np.sqrt(self.occr))\\n\\n if tf.is_tensor(self.occr):\\n # Written in terms of occr for ease.\\n value = tf.reduce_prod(tf.math.sqrt(self.occr))\\n else:\\n # Written in terms of occr for ease.\\n value = np.prod(np.sqrt(self.occr))\\n # At this point, it's still possible for occr to be so\\n # small that it's underflowing, where value will be nan\\n value = value if not np.isnan(value) else 0.0\\n\\n return value\",\n \"def logistic_function(self, real_value):\\n return 1/(1+np.exp(-real_value))\",\n \"def logm(C):\\n theta_x = so2.logm(C[:2,:2])\\n u = getVi(C).dot(C[:2,2])\\n return np.concatenate((\\n np.concatenate(( theta_x, u[:,np.newaxis]), axis=1),\\n [[0, 0, 0]]\\n ))\\n\\n # make matrix \\n # tx = so2.logm(C[:2,:2])\\n # t = so2.algi(tx)\\n # # if np.abs(t)<1e-2: \\n # # stt = lie.TaylorSinXoverX(t)\\n # # ctt = lie.TaylorOneMinusCosXOverX(t)\\n # # else:\\n # # stt = np.sin(t)/t\\n # # ctt = (1-np.cos(t))/t\\n # #\\n # # A = stt; B = ctt\\n # # Vi = (1 / (A**2 + B**2)) * np.array([[A, B], [-B, A]])\\n # Vi = getVi(C)\\n #\\n # d = C[:2,2]\\n # u = Vi.dot(d)\\n #\\n # return alg(np.concatenate(( u, [t] )))\",\n \"def log_likelihood(cosmo_param, pk_obs, inv_cov):\\n pknlfid, kbins, kspace = fiducial_power(cosmo_param)\\n \\n x = pk_obs - pknlfid\\n return -0.5* (x.T @ inv_cov @ x)\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def log2(tensor):\\n return log(tensor, base=2)\",\n \"def image_entropy(img):\\r\\n hist = img.histogram()\\r\\n hist_size = sum(hist)\\r\\n hist = [float(h) / hist_size for h in hist]\\r\\n\\r\\n return -sum([p * math.log(p, 2) for p in hist if p != 0])\",\n \"def salomonfcn(x: np.ndarray) -> np.ndarray:\\n x2 = x**2\\n sumx2 = np.sum(x2, axis=1)\\n sqrtsx2 = np.sqrt(sumx2)\\n\\n scores = 1 - np.cos(2 * np.pi * sqrtsx2) + (0.1 * sqrtsx2)\\n\\n return scores\",\n \"def compute_log_ph3(ph3, x_ph3=None):\\n if ph3.min() <= 0:\\n ph3 += np.abs(ph3.min())\\n if x_ph3 is None:\\n #x_ph3 = np.arange(2.5, 8, 0.02)\\n ph3_min = np.max((0, np.log10(ph3.min()+0.1) - 0.1))\\n ph3_max = np.log10(ph3.max()) + 0.1\\n x_ph3 = np.arange(ph3_min, ph3_max, 0.02)\\n ph3_upper_bound = 10 ** x_ph3[-3]\\n ph3_lower_bound = 10 ** x_ph3[2]\\n ph3_upper_bounded = [d if d < ph3_upper_bound else ph3_upper_bound\\n for d in ph3]\\n ph3_bounded = [d if d > ph3_lower_bound else ph3_lower_bound\\n for d in ph3_upper_bounded]\\n log_ph3 = np.array([np.log10(d) for d in ph3_bounded])\\n return log_ph3\",\n \"def __loss(self, h, y):\\n return (-y*np.log(h)-(1-y)*np.log(1-h)).mean()\",\n \"def logTF(self, tf):\\n return math.log(tf)\",\n \"def mycos(x):\\n return (\\n 1\\n - x ** 2 / 2\\n + x ** 4 / 24\\n - x ** 6 / 720\\n + x ** 8 / 40320\\n - x ** 10 / 3628800\\n )\",\n \"def safe_log(data):\\n\\n non_zero = data != 0\\n result = numpy.zeros(data.shape, dtype=float)\\n with numpy.errstate(invalid=\\\"raise\\\"):\\n result[non_zero] = numpy.log2(data[non_zero])\\n return result\",\n \"def ln(x):\\n return log(x, const.e)\",\n \"def log_nse(self, epsilon=0.0) -> float:\\n s, o = self.predicted + epsilon, self.true + epsilon # todo, check why s is here\\n return float(1 - sum((np.log(o) - np.log(o)) ** 2) / sum((np.log(o) - np.mean(np.log(o))) ** 2))\",\n \"def cross_entropy(predicted, target):\\n batch_size, num_classes = predicted.shape\\n\\n e_x = predicted.exp()\\n log_e_x = e_x.log()\\n a = log_sum_x_trick(predicted)\\n x_n_offset = predicted - a\\n\\n exp_xn_offset = x_n_offset.exp()\\n\\n sum_exp_xn_offset = exp_xn_offset.sum(axis=1, keepdims=True)\\n log_sum_exp_xn_offset = sum_exp_xn_offset.log()\\n denominator = a + log_sum_exp_xn_offset\\n log_softmax = log_e_x - denominator\\n\\n labels = to_one_hot(target, num_classes)\\n prod = log_softmax*labels\\n total = prod.sum()\\n batch_size = tensor.Tensor(-batch_size)\\n\\n total = total / batch_size\\n\\n return total\",\n \"def log_pacc(xy, x, y, h):\\n logp = log_q(xy, y, x, h)\\n logp += xy.log_density(y)\\n logp -= log_q(xy, x, y, h)\\n logp -= xy.log_density(x)\\n return logp\",\n \"def entropy(data):\\n strings, lens = Counter(data), np.float(len(data))\\n return -sum(count / lens * np.log2(count / lens) for count in strings.values())\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76132387","0.72645205","0.70176494","0.6731372","0.6226951","0.62121165","0.6074388","0.6073056","0.59627014","0.5937668","0.5929191","0.5901009","0.58072233","0.5728377","0.5656887","0.5649234","0.5644657","0.5626796","0.56044716","0.55885035","0.5582695","0.55754864","0.5566196","0.55618685","0.5559817","0.5539665","0.55302185","0.5527566","0.5519898","0.5498663","0.54975015","0.5496996","0.54904956","0.54859674","0.54768914","0.54663885","0.5446792","0.5446344","0.54084885","0.54075396","0.54047865","0.5403553","0.5389143","0.53845054","0.5375253","0.53732693","0.5370365","0.5365568","0.5355921","0.5355269","0.5351671","0.5344049","0.5335644","0.53299576","0.5327183","0.5325186","0.53247344","0.53217137","0.5312765","0.53125185","0.5306625","0.52917874","0.5287206","0.5284187","0.52741086","0.5273076","0.5267041","0.52632904","0.526048","0.5256198","0.5247578","0.52442443","0.5239155","0.52348715","0.52337945","0.5230499","0.52218044","0.52207637","0.5217473","0.5213392","0.5213253","0.5207951","0.5200459","0.51947695","0.5189352","0.5173813","0.51706535","0.51685137","0.5167961","0.51657313","0.51653993","0.51590455","0.51521593","0.51498204","0.51455474","0.5137068","0.5128703","0.51270944","0.5126658","0.5126586"],"string":"[\n \"0.76132387\",\n \"0.72645205\",\n \"0.70176494\",\n \"0.6731372\",\n \"0.6226951\",\n \"0.62121165\",\n \"0.6074388\",\n \"0.6073056\",\n \"0.59627014\",\n \"0.5937668\",\n \"0.5929191\",\n \"0.5901009\",\n \"0.58072233\",\n \"0.5728377\",\n \"0.5656887\",\n \"0.5649234\",\n \"0.5644657\",\n \"0.5626796\",\n \"0.56044716\",\n \"0.55885035\",\n \"0.5582695\",\n \"0.55754864\",\n \"0.5566196\",\n \"0.55618685\",\n \"0.5559817\",\n \"0.5539665\",\n \"0.55302185\",\n \"0.5527566\",\n \"0.5519898\",\n \"0.5498663\",\n \"0.54975015\",\n \"0.5496996\",\n \"0.54904956\",\n \"0.54859674\",\n \"0.54768914\",\n \"0.54663885\",\n \"0.5446792\",\n \"0.5446344\",\n \"0.54084885\",\n \"0.54075396\",\n \"0.54047865\",\n \"0.5403553\",\n \"0.5389143\",\n \"0.53845054\",\n \"0.5375253\",\n \"0.53732693\",\n \"0.5370365\",\n \"0.5365568\",\n \"0.5355921\",\n \"0.5355269\",\n \"0.5351671\",\n \"0.5344049\",\n \"0.5335644\",\n \"0.53299576\",\n \"0.5327183\",\n \"0.5325186\",\n \"0.53247344\",\n \"0.53217137\",\n \"0.5312765\",\n \"0.53125185\",\n \"0.5306625\",\n \"0.52917874\",\n \"0.5287206\",\n \"0.5284187\",\n \"0.52741086\",\n \"0.5273076\",\n \"0.5267041\",\n \"0.52632904\",\n \"0.526048\",\n \"0.5256198\",\n \"0.5247578\",\n \"0.52442443\",\n \"0.5239155\",\n \"0.52348715\",\n \"0.52337945\",\n \"0.5230499\",\n \"0.52218044\",\n \"0.52207637\",\n \"0.5217473\",\n \"0.5213392\",\n \"0.5213253\",\n \"0.5207951\",\n \"0.5200459\",\n \"0.51947695\",\n \"0.5189352\",\n \"0.5173813\",\n \"0.51706535\",\n \"0.51685137\",\n \"0.5167961\",\n \"0.51657313\",\n \"0.51653993\",\n \"0.51590455\",\n \"0.51521593\",\n \"0.51498204\",\n \"0.51455474\",\n \"0.5137068\",\n \"0.5128703\",\n \"0.51270944\",\n \"0.5126658\",\n \"0.5126586\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74146074"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88388,"cells":{"query":{"kind":"string","value":"Restarts the current program."},"document":{"kind":"string","value":"def get(self):\r\n #python = sys.executable\r\n #os.execl(python, python, * sys.argv)\r\n os.execl(sys.executable, *([sys.executable] + sys.argv))"},"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 restart(self):\n print \"Restarting \" + executable + \" \" + str(argv) \n execl(executable, *([executable]+argv))","def restart_program():\r\n\tpython = sys.executable\r\n\tos.execl(python, python, * sys.argv)\r\n\troot = tk.Tk()","def Restart(self):\n handler = self.get_command_object(\"Restart\")\n handler()","def restart():\n stop()\n start()","def restart(self):\n\n self.stop()\n self.start()","def restart():\n log.info('restart')\n samuraix.restarting = True\n samuraix.app.stop()","def restart(self):\n self.stop()\n self.start()","def restart(self):\n self.stop()\n self.start()","def restart_program():\n # Asking user whether to restart the program?\n while True:\n print('----------------------------------------------')\n restart = input('\\nWould you like to restart? Enter:\\n1) yes\\n2) no\\n')\n restart = restart.lower()\n\n # Decoding mnemonic inputs and taking required actions\n if restart == '2' or restart == 'no' or restart == 'n':\n print('\\n******************THANK YOU*******************\\n')\n quit(0)\n elif restart == '1' or restart == 'yes' or restart == 'y':\n print(\"\\n\" * get_terminal_size().lines, end='')\n main()\n quit(0)\n else:\n print(\"Invalid Input. Please type 'y' or 'n'....\")","def restart(self):\n\t\treturn self.reset().start()","def restart(self):\n self.stop()\n self.start(init=False)","def restart(reason, *args, **kwargs):\n logging.info(\"Restarting: %s\" % reason)\n os.execv(sys.argv[0], sys.argv)","def restart_program():\n\n try:\n p = psutil.Process(os.getpid())\n for handler in p.get_open_files() + p.connections():\n os.close(handler.fd)\n except Exception as e:\n logging.error(e)\n\n python = sys.executable\n os.execl(python, python, *sys.argv)","def restart(self):\n pass","def restart(self) -> None:","def restart(self):\r\n pass","def _restart(self):\n pass","def restart(self):\n self.client.post(self.path+'/action', { 'restart': {} })\n return True","async def module_command_restart(self, ctx, parsed):\n if parsed.invoker != ctx.owner:\n return\n reason = \" \".join(parsed.args[\"msg\"] or []) or \"Restarting\"\n self.quit(reason)\n self._restarting = True","def restart(self):","def restart(self):\n self._start_time = None\n self.start()","def restart():\n require('PROJECT_NAME')\n\n sudo('supervisorctl restart {0}'.format(env.PROJECT_NAME))","def restart(self, **kwargs):\n return self.client.api.restart(self.id, **kwargs)","def restart(self):\n self.km.restart_kernel(now=True)","def restart(verbose=False, force=False):\n\n _prepare_execution(verbose)\n _validate_components_prepared('restart')\n _validate_force(force, 'restart')\n\n stop(verbose, force)\n start(verbose)\n _print_time()","def restart(self):\n global shouldRestart\n shouldRestart = True\n logging.info(\"Restarting bot\")\n self.die()","def restart(self):\r\n self._update('restart')\r\n\r\n self.supervisord.options.mood = SupervisorStates.RESTARTING\r\n return True","def stop_and_restart():\n U.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def restart_game(self):\n self.play()","def restart(self):\n\t\tself.destroy()\n\t\t\n\t\tself.resetBoard()\n\t\tself.i_play_again = 0\n\t\tself.adversary_play_again = 0\n\t\tself.isMyTurn = False\n\n\t\tself.initGame(self.parent)\n\n\t\t# Update the screen\n\t\tself.pack()","def cmd_restart(self, app_name=None):\n rc = self.socket_command_with_project('restart', app_name)\n return rc","def restart(verbose=False, force=False):\n\n _load_config_and_logger(verbose)\n _validate_manager_installed('restart')\n _validate_force(force, 'restart')\n\n stop(verbose, force)\n start(verbose)\n _print_time()","def restart(self):\n self.done()\n self.counter = 0\n self.start_time = time.time()","def attempt_restart(self):\n self.controller.publish(self, 'restart')","def repl_restart(restart: bool = True) -> None:","def restart(self):\n\t\treturn Job(SDK.PrlVm_Restart(self.handle)[0])","def restart(self):\n self.logger.info(\"Received graceful restart request\")\n self._restart = True\n self.stop()","def node_restart(ctx):\n ctx.obj['node'].attempt_restart()","def restart_supervisor():\n\n require('environment', provided_by=env.environments)\n supervisor.supervisor_command('restart %(environment)s:*' % env)","def restart(config):\n shutdown(config)\n startup(config)\n return","def restart():\n root.destroy()\n # Get list of locker room assignment files and send to main application for displaying\n lr_files = get_locker_room_assgnmnt_files_list()\n application(lr_files)","def restart(self):\r\n if self._engine:\r\n self._engine.repl.terminate()\r\n\r\n if \"OCTAVE_EXECUTABLE\" not in os.environ and \"OCTAVE\" in os.environ:\r\n os.environ[\"OCTAVE_EXECUTABLE\"] = os.environ[\"OCTAVE\"]\r\n\r\n try:\r\n self._engine = OctaveEngine(stdin_handler=self._handle_stdin, logger=self.logger)\r\n except Exception as e:\r\n raise Oct2PyError(str(e)) from None\r\n\r\n # Add local Octave scripts.\r\n self._engine.eval('addpath(\"%s\");' % HERE.replace(osp.sep, \"/\"))","def start_again():\n import functions\n functions.start_program()","def restart(self):\r\n self._safe_close()\r\n self._stopped.clear()\r\n self.reconnect()","def restart_salt():\n stop_salt()\n start_salt()","def restart():\n run('kill -HUP $(cat /tmp/pyar_web.pid)')","def stop_and_restart():\n logging.info(\"Restarting eduzen_bot...\\n\")\n bot.updater.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def restart():\n with cd(env.directory):\n sudo('./bin/supervisorctl restart all', user=env.deploy_user)","def restart():\n with cd(env.directory):\n sudo('./bin/supervisorctl restart all', user=env.deploy_user)","def restart(*args, **kwargs):\n return restart_type(args, kwargs)","def relaunchProg( self, progName, progConf, process ):\n if process['retries'] > 0:\n verbose = \"Program \" + progName + \" is being relaunched\\n\"\n if self.conf[\"args\"].verbose:\n print verbose\n self.printToLogfile(verbose)\n self.launchProg(progName, progConf, process['retries'] - 1, 1)\n progConf['processes'].remove(process)\n else:\n process['status'] = FAILED\n verbose = \"Program \" + progName + \" has been relaunched too many times\\n\"\n if self.conf[\"args\"].verbose:\n print verbose\n self.printToLogfile(verbose)","def restart():\n with cd('/apps/sharejs-rethinkdb-example'):\n run('fig -f prod.yml stop')\n run('fig -f prod.yml up -d')","def restart_game():\r\n restart = input(\"Would you like to play again?\\n(y/n):\")\r\n if restart.lower() == \"y\" or restart.lower() == \"yes\":\r\n print(\"\\nStarting New Game!\\n\")\r\n self.scores = {\"p1\": 0, \"p2\": 0} # Restarts scores\r\n self.play_game() # Restarts game\r\n elif restart.lower() == \"n\" or restart.lower() == \"no\":\r\n print(\"\\nThank you for playing!\")\r\n else: # Checks for valid input:\r\n print(\"Oops! Seems like you misspelled something.\"\r\n \"\\nMake sure your response is: y, yes, n or no.\")\r\n return restart_game()","def stop_and_restart():\n updater.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","async def restart(ctx):\n dev = ctx.message.author\n if bot.botdev_role in dev.roles or bot.owner_role in dev.roles:\n await ctx.send(\"`Restarting, please wait...`\")\n execv(\"python3 SchmuckBot\", argv)","def _RestartServer( self ):\n with self._gocode_lock:\n self._StopServer()\n self._StartServer()","async def do_force_restart(self):\n if self.config[\"allow_restart_requests\"]:\n os._exit(42)\n else:\n return self._rpc_failure(\"Restart disallowed by configuration\")","def finished_restarting():\n flags.restarting = False\n group_spawn(qtile.current_group)\n qtile.cmd_spawn(\"nitrogen --restore\")","def restart(self):\n self.stop()\n self.IA.restart()\n self._desintegrator = Desintegrator(background=self.IA.BG_MAP)\n self._desintegrator.increment_maximum_x_in(30)\n self.speed = 3.0\n self._run = True","def restart(name):\n ret = \"restart False\"\n if stop(name) and start(name):\n ret = \"restart True\"\n return ret","def _restart_workload(self, workload):\n self.log.info('%-20s RESTARTING', workload.name())\n workload.stop()\n workload.post_stop()\n workload.pre_start()\n workload.start()","def restart(self, device, platform, version, app, package, activity):\n self.quit()\n self.initialize(device, platform, version, app, package, activity)","def stop_and_restart():\n updater.stop()\n os.execl(sys.executable, sys.executable, *sys.argv)","def restart(self, command):\n author_id = command.message.author.id\n logger.info('Restart issued by %s, with ID %s', command.message.author.name, author_id)\n yield from command.send_typing()\n yield from command.reply('Restarting...')\n raise KeyboardInterrupt","def restartSystem(self):\n # save retry count between reboots\n try:\n self.notifyPut('Restarting System...')\n self.db = shelve.open(os.path.join(self.xlocal, 'Launch Manager Utils\\\\launch.data'))\n self.db['retry_count'] = self.retry_count\n self.db.close()\n except Exception, e:\n self.logQ.put('{0} - Unable to save retry count'.format(e))\n \n try:\n subprocess.call(['SHUTDOWN', '/f', '/r'])\n except Exception, e:\n self.logQ.put('{0} - Unable to restart Windows'.format(e))\n return","def supervisor_restart():\n log('restart supervisor', yellow)\n sudo('/etc/init.d/supervisor stop')\n sudo('/etc/init.d/supervisor start')\n # sudo('/etc/init.d/supervisor restart')","def restart(self, timestamp=0.0, **keywords):\n self.services.debug('restart() method called')\n pass","def restart_from_helper ( self, ):\r\n self.no_helper_restarts += 1\r\n self.logger.info( \"restart_from_helper\" )\r\n\r\n self.restart()","def message_restart():\n if dialog_yes_no(32014):\n xbmc.executebuiltin('RestartApp')","def restart(ctx, copy, file, u): # pylint:disable=redefined-builtin\n content = None\n update_code = None\n if file:\n content = '{}'.format(rhea.read(file))\n\n # Check if we need to upload\n if u:\n ctx.invoke(upload, sync=False)\n update_code = True\n\n user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('project'),\n ctx.obj.get('experiment'))\n try:\n if copy:\n response = PolyaxonClient().experiment.copy(\n user, project_name, _experiment, content=content, update_code=update_code)\n Printer.print_success('Experiment was copied with id {}'.format(response.id))\n else:\n response = PolyaxonClient().experiment.restart(\n user, project_name, _experiment, content=content, update_code=update_code)\n Printer.print_success('Experiment was restarted with id {}'.format(response.id))\n except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:\n Printer.print_error('Could not restart experiment `{}`.'.format(_experiment))\n Printer.print_error('Error message `{}`.'.format(e))\n sys.exit(1)","def restart(self):\n self.iic.set_flag(REG.CTRL_REG2.RST)\n time.sleep(0.01)\n self.conf = Configuration()","def restart():\n run_commands('python manage.py supervisor restart all')","def restart(self):\n\n #Kill processes\n print('Restarting scan...... \\n')\n self.kill()\n\n #Delete crawler\n del self.crawler\n self.crawler = self.generate_crawler()\n\n #Give ourselves a second\n time.sleep(2)","def RestartApp(argv_extra):\n\n p = psutil.Process(os.getpid())\n for handler in p.open_files() + p.connections():\n if handler.fd != -1:\n os.close(handler.fd)\n\n exe = sys.executable\n argv = list(sys.argv)\n argv.append(argv_extra)\n\n os.execl(exe, exe, *argv)","def _restartProcessNormal(self) -> None:\n\n if IS_WIN_SVC in sys.argv:\n reactor.callFromThread(reactor.stop)\n return\n\n python = sys.executable\n argv = list(sys.argv)\n\n def addExe(val):\n if not \"run_peek_\" in val:\n return val\n if isWindows and not val.lower().endswith(\".exe\"):\n return val + \".exe\"\n return val\n\n argv = map(addExe, argv)\n os.execl(python, python, *argv)","def restart(\n context,\n user=get_local_user(),\n remote=False,\n instance=None,\n stack=None,\n services=None,\n):\n command = \"restart\"\n run_command_with_services(context, user, remote, instance, stack, command, services)","def restart_with_reloader():\n while True:\n print(f'Restarting with reloader')\n args = [sys.executable] + ['-W%s' % o for o in sys.warnoptions] + sys.argv\n new_environ = os.environ.copy()\n new_environ[\"RUN_MAIN\"] = 'true'\n exit_code = os.spawnve(os.P_WAIT, sys.executable, args, new_environ)\n if exit_code != 3:\n return exit_code","def restart(self):\n self.__init__()\n return","def restart(self):\n # Note: No need to regenerate the data, just reset the idx\n self.prepare_for_use()","def restart(self):\n # Note: No need to regenerate the data, just reset the idx\n self.prepare_for_use()","def restart(self):\n # Note: No need to regenerate the data, just reset the idx\n self.prepare_for_use()","def restart_game(context: GameContext) -> None:\n left_spaceship, right_spaceship = create_spaceships()\n context.restart(left_spaceship, right_spaceship)","def run_restart(self, expanded, unexpanded) :\n\t\tif not self.HasRoles(self.__context.Control_Panel, 'Manager') :\n\t\t\treturn -1\n\t\tif expanded :\n\t\t\treturn self.errormessage(\"Doesn't need any argument\")\n\t\tself.__context.Control_Panel.manage_restart(self.__context.REQUEST.URL0)","def restart(self):\n \n # Set the previous time to be 0, we are starting the simulation\n self.oldtime = 0.0\n\n # Deep Copy of all of the initial conditions\n self.delt = copy.deepcopy(self.ic[0])\n self.odestep = copy.deepcopy(self.ic[1])\n self.species = copy.deepcopy(self.ic[2])\n self.cythonBool = copy.deepcopy(self.ic[3])\n self.resTime = copy.deepcopy(self.ic[4])\n\n # Update need enzyme Counts in the particle map\n self.species.update(self)\n\n print(\"Done with restart\")","def restart():\n \n while True:\n print(\"Spiel wurde beendet: Tippe 'r' zum Neustart oder 'q' zum Beenden\")\n user_input_3 = str(input(\"Erwarte Eingabe: \"))\n if user_input_3 == \"q\":\n quit()\n elif user_input_3 == \"r\":\n print()\n print()\n print(\"SPIEL-WURDE-NEUGESTARTET------------------------------------------------------\")\n print()\n sixteen_is_dead(set_players())\n else:\n print()\n print(\"ERROR: Falsche Eingabe - bitte versuchen Sie es erneut!\")\n print()","def Restart(self, request, global_params=None):\n config = self.GetMethodConfig('Restart')\n return self._RunMethod(\n config, request, global_params=global_params)","def restartGame(self):\n\t\tself.state = [[0 for x in range(3)] for y in range(3)]\n\t\tself.turn = self.whoGoesFirst()\n\t\tself.win = 0","def do_restart(self, timeSinceLastInterruption, noRestart=False):\n delta = self.ckptTime\n try:\n self.ProcLog(\"Attempting to restart from ckpt #%d, taken at %d\" % (self.numCkpts, self.lastCheckpointTime))\n self.lostWork += timeSinceLastInterruption\n if not noRestart:\n assert self.broken == True\n yield self.env.timeout(delta)\n # Done with restart without errors\n self.ProcLog(\"Restart successful... going back to compute\")\n except simpy.Interrupt as e:\n if (e.cause == \"failure\"):\n # TODO: Handle failures during a restart\n print(\"Failure in the middle of a restart... will attempt restart again\")\n exit(-1)\n #self.do_restart()","def restart():\n msg = messagebox.showinfo('YES!', \"You're Right\")\n window.destroy()\n game()","def restart(name, runas=None):\n return prlctl(\"restart\", salt.utils.data.decode(name), runas=runas)","def resetApp(self):\n python = sys.executable\n os.execl(python, python, * sys.argv)","def restarted(self):\n return self.reset(\n started=self.started + 1,\n starting=0,\n )","def restart(self):\n self.set_random_pos('starting')\n self.set_random_pos('finishing')\n self.game_loop()","def restart(self, sync=True):\n self.shutdown(sync=True)\n self.power_on(sync)","def restart(self):\n self.idx = 0","def restart_calculator():\n # Variables to ensure PEP8 convention pass (amount of characters in line)\n repeat = \"Do you want to repeat calculations?\"\n yes = \"Press 'y' than 'enter' to continue calculations\"\n no = \"Press 'n' than 'enter' to quit calculations\"\n # User decision y or n input\n restart = input(f\"\\033[1;32;10m\\n{repeat}\\n{yes}\\n{no}\\n\")\n # If user decide to restart calculation\n if restart == 'y':\n print('\\n\\033[1;33;10mCalculate again\\n')\n main()\n # If user decide to end calculation\n elif restart == 'n':\n print('\\n\\033[1;33;10mSee you next time')\n exit()\n # Else type incorrect value\n else:\n print(\"\\n\\033[1;31;10mIncorrect character, please type 'y' or 'n'\")\n restart_calculator()","def restart_llap(self, env):\n Logger.info(\"Custom Command to retart LLAP\")\n import params\n env.set_params(params)\n\n if params.security_enabled:\n self.do_kinit()\n\n self._llap_stop(env)\n self._llap_start(env)","async def restart_server(self):\n await self.stop_server()\n self._start()\n await self.send_tag('control', emoji.TRIGGERS['control'], 'Server restarted!')","def restart(self, relay):\n if self.stop():\n return self.start(relay)\n return False","def force_restart(self):\n\n logging.info(\"Force restarting the experiment...\")\n\n save_dir = os.path.join(self._dir_name)\n create_folder(save_dir)\n rmtree(save_dir)\n\n if self._logger is not None:\n self._logger.force_restart()","def restart_openvpn():\n cmd = 'service openvpn restart'\n result = call_command(cmd)"],"string":"[\n \"def restart(self):\\n print \\\"Restarting \\\" + executable + \\\" \\\" + str(argv) \\n execl(executable, *([executable]+argv))\",\n \"def restart_program():\\r\\n\\tpython = sys.executable\\r\\n\\tos.execl(python, python, * sys.argv)\\r\\n\\troot = tk.Tk()\",\n \"def Restart(self):\\n handler = self.get_command_object(\\\"Restart\\\")\\n handler()\",\n \"def restart():\\n stop()\\n start()\",\n \"def restart(self):\\n\\n self.stop()\\n self.start()\",\n \"def restart():\\n log.info('restart')\\n samuraix.restarting = True\\n samuraix.app.stop()\",\n \"def restart(self):\\n self.stop()\\n self.start()\",\n \"def restart(self):\\n self.stop()\\n self.start()\",\n \"def restart_program():\\n # Asking user whether to restart the program?\\n while True:\\n print('----------------------------------------------')\\n restart = input('\\\\nWould you like to restart? Enter:\\\\n1) yes\\\\n2) no\\\\n')\\n restart = restart.lower()\\n\\n # Decoding mnemonic inputs and taking required actions\\n if restart == '2' or restart == 'no' or restart == 'n':\\n print('\\\\n******************THANK YOU*******************\\\\n')\\n quit(0)\\n elif restart == '1' or restart == 'yes' or restart == 'y':\\n print(\\\"\\\\n\\\" * get_terminal_size().lines, end='')\\n main()\\n quit(0)\\n else:\\n print(\\\"Invalid Input. Please type 'y' or 'n'....\\\")\",\n \"def restart(self):\\n\\t\\treturn self.reset().start()\",\n \"def restart(self):\\n self.stop()\\n self.start(init=False)\",\n \"def restart(reason, *args, **kwargs):\\n logging.info(\\\"Restarting: %s\\\" % reason)\\n os.execv(sys.argv[0], sys.argv)\",\n \"def restart_program():\\n\\n try:\\n p = psutil.Process(os.getpid())\\n for handler in p.get_open_files() + p.connections():\\n os.close(handler.fd)\\n except Exception as e:\\n logging.error(e)\\n\\n python = sys.executable\\n os.execl(python, python, *sys.argv)\",\n \"def restart(self):\\n pass\",\n \"def restart(self) -> None:\",\n \"def restart(self):\\r\\n pass\",\n \"def _restart(self):\\n pass\",\n \"def restart(self):\\n self.client.post(self.path+'/action', { 'restart': {} })\\n return True\",\n \"async def module_command_restart(self, ctx, parsed):\\n if parsed.invoker != ctx.owner:\\n return\\n reason = \\\" \\\".join(parsed.args[\\\"msg\\\"] or []) or \\\"Restarting\\\"\\n self.quit(reason)\\n self._restarting = True\",\n \"def restart(self):\",\n \"def restart(self):\\n self._start_time = None\\n self.start()\",\n \"def restart():\\n require('PROJECT_NAME')\\n\\n sudo('supervisorctl restart {0}'.format(env.PROJECT_NAME))\",\n \"def restart(self, **kwargs):\\n return self.client.api.restart(self.id, **kwargs)\",\n \"def restart(self):\\n self.km.restart_kernel(now=True)\",\n \"def restart(verbose=False, force=False):\\n\\n _prepare_execution(verbose)\\n _validate_components_prepared('restart')\\n _validate_force(force, 'restart')\\n\\n stop(verbose, force)\\n start(verbose)\\n _print_time()\",\n \"def restart(self):\\n global shouldRestart\\n shouldRestart = True\\n logging.info(\\\"Restarting bot\\\")\\n self.die()\",\n \"def restart(self):\\r\\n self._update('restart')\\r\\n\\r\\n self.supervisord.options.mood = SupervisorStates.RESTARTING\\r\\n return True\",\n \"def stop_and_restart():\\n U.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def restart_game(self):\\n self.play()\",\n \"def restart(self):\\n\\t\\tself.destroy()\\n\\t\\t\\n\\t\\tself.resetBoard()\\n\\t\\tself.i_play_again = 0\\n\\t\\tself.adversary_play_again = 0\\n\\t\\tself.isMyTurn = False\\n\\n\\t\\tself.initGame(self.parent)\\n\\n\\t\\t# Update the screen\\n\\t\\tself.pack()\",\n \"def cmd_restart(self, app_name=None):\\n rc = self.socket_command_with_project('restart', app_name)\\n return rc\",\n \"def restart(verbose=False, force=False):\\n\\n _load_config_and_logger(verbose)\\n _validate_manager_installed('restart')\\n _validate_force(force, 'restart')\\n\\n stop(verbose, force)\\n start(verbose)\\n _print_time()\",\n \"def restart(self):\\n self.done()\\n self.counter = 0\\n self.start_time = time.time()\",\n \"def attempt_restart(self):\\n self.controller.publish(self, 'restart')\",\n \"def repl_restart(restart: bool = True) -> None:\",\n \"def restart(self):\\n\\t\\treturn Job(SDK.PrlVm_Restart(self.handle)[0])\",\n \"def restart(self):\\n self.logger.info(\\\"Received graceful restart request\\\")\\n self._restart = True\\n self.stop()\",\n \"def node_restart(ctx):\\n ctx.obj['node'].attempt_restart()\",\n \"def restart_supervisor():\\n\\n require('environment', provided_by=env.environments)\\n supervisor.supervisor_command('restart %(environment)s:*' % env)\",\n \"def restart(config):\\n shutdown(config)\\n startup(config)\\n return\",\n \"def restart():\\n root.destroy()\\n # Get list of locker room assignment files and send to main application for displaying\\n lr_files = get_locker_room_assgnmnt_files_list()\\n application(lr_files)\",\n \"def restart(self):\\r\\n if self._engine:\\r\\n self._engine.repl.terminate()\\r\\n\\r\\n if \\\"OCTAVE_EXECUTABLE\\\" not in os.environ and \\\"OCTAVE\\\" in os.environ:\\r\\n os.environ[\\\"OCTAVE_EXECUTABLE\\\"] = os.environ[\\\"OCTAVE\\\"]\\r\\n\\r\\n try:\\r\\n self._engine = OctaveEngine(stdin_handler=self._handle_stdin, logger=self.logger)\\r\\n except Exception as e:\\r\\n raise Oct2PyError(str(e)) from None\\r\\n\\r\\n # Add local Octave scripts.\\r\\n self._engine.eval('addpath(\\\"%s\\\");' % HERE.replace(osp.sep, \\\"/\\\"))\",\n \"def start_again():\\n import functions\\n functions.start_program()\",\n \"def restart(self):\\r\\n self._safe_close()\\r\\n self._stopped.clear()\\r\\n self.reconnect()\",\n \"def restart_salt():\\n stop_salt()\\n start_salt()\",\n \"def restart():\\n run('kill -HUP $(cat /tmp/pyar_web.pid)')\",\n \"def stop_and_restart():\\n logging.info(\\\"Restarting eduzen_bot...\\\\n\\\")\\n bot.updater.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def restart():\\n with cd(env.directory):\\n sudo('./bin/supervisorctl restart all', user=env.deploy_user)\",\n \"def restart():\\n with cd(env.directory):\\n sudo('./bin/supervisorctl restart all', user=env.deploy_user)\",\n \"def restart(*args, **kwargs):\\n return restart_type(args, kwargs)\",\n \"def relaunchProg( self, progName, progConf, process ):\\n if process['retries'] > 0:\\n verbose = \\\"Program \\\" + progName + \\\" is being relaunched\\\\n\\\"\\n if self.conf[\\\"args\\\"].verbose:\\n print verbose\\n self.printToLogfile(verbose)\\n self.launchProg(progName, progConf, process['retries'] - 1, 1)\\n progConf['processes'].remove(process)\\n else:\\n process['status'] = FAILED\\n verbose = \\\"Program \\\" + progName + \\\" has been relaunched too many times\\\\n\\\"\\n if self.conf[\\\"args\\\"].verbose:\\n print verbose\\n self.printToLogfile(verbose)\",\n \"def restart():\\n with cd('/apps/sharejs-rethinkdb-example'):\\n run('fig -f prod.yml stop')\\n run('fig -f prod.yml up -d')\",\n \"def restart_game():\\r\\n restart = input(\\\"Would you like to play again?\\\\n(y/n):\\\")\\r\\n if restart.lower() == \\\"y\\\" or restart.lower() == \\\"yes\\\":\\r\\n print(\\\"\\\\nStarting New Game!\\\\n\\\")\\r\\n self.scores = {\\\"p1\\\": 0, \\\"p2\\\": 0} # Restarts scores\\r\\n self.play_game() # Restarts game\\r\\n elif restart.lower() == \\\"n\\\" or restart.lower() == \\\"no\\\":\\r\\n print(\\\"\\\\nThank you for playing!\\\")\\r\\n else: # Checks for valid input:\\r\\n print(\\\"Oops! Seems like you misspelled something.\\\"\\r\\n \\\"\\\\nMake sure your response is: y, yes, n or no.\\\")\\r\\n return restart_game()\",\n \"def stop_and_restart():\\n updater.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"async def restart(ctx):\\n dev = ctx.message.author\\n if bot.botdev_role in dev.roles or bot.owner_role in dev.roles:\\n await ctx.send(\\\"`Restarting, please wait...`\\\")\\n execv(\\\"python3 SchmuckBot\\\", argv)\",\n \"def _RestartServer( self ):\\n with self._gocode_lock:\\n self._StopServer()\\n self._StartServer()\",\n \"async def do_force_restart(self):\\n if self.config[\\\"allow_restart_requests\\\"]:\\n os._exit(42)\\n else:\\n return self._rpc_failure(\\\"Restart disallowed by configuration\\\")\",\n \"def finished_restarting():\\n flags.restarting = False\\n group_spawn(qtile.current_group)\\n qtile.cmd_spawn(\\\"nitrogen --restore\\\")\",\n \"def restart(self):\\n self.stop()\\n self.IA.restart()\\n self._desintegrator = Desintegrator(background=self.IA.BG_MAP)\\n self._desintegrator.increment_maximum_x_in(30)\\n self.speed = 3.0\\n self._run = True\",\n \"def restart(name):\\n ret = \\\"restart False\\\"\\n if stop(name) and start(name):\\n ret = \\\"restart True\\\"\\n return ret\",\n \"def _restart_workload(self, workload):\\n self.log.info('%-20s RESTARTING', workload.name())\\n workload.stop()\\n workload.post_stop()\\n workload.pre_start()\\n workload.start()\",\n \"def restart(self, device, platform, version, app, package, activity):\\n self.quit()\\n self.initialize(device, platform, version, app, package, activity)\",\n \"def stop_and_restart():\\n updater.stop()\\n os.execl(sys.executable, sys.executable, *sys.argv)\",\n \"def restart(self, command):\\n author_id = command.message.author.id\\n logger.info('Restart issued by %s, with ID %s', command.message.author.name, author_id)\\n yield from command.send_typing()\\n yield from command.reply('Restarting...')\\n raise KeyboardInterrupt\",\n \"def restartSystem(self):\\n # save retry count between reboots\\n try:\\n self.notifyPut('Restarting System...')\\n self.db = shelve.open(os.path.join(self.xlocal, 'Launch Manager Utils\\\\\\\\launch.data'))\\n self.db['retry_count'] = self.retry_count\\n self.db.close()\\n except Exception, e:\\n self.logQ.put('{0} - Unable to save retry count'.format(e))\\n \\n try:\\n subprocess.call(['SHUTDOWN', '/f', '/r'])\\n except Exception, e:\\n self.logQ.put('{0} - Unable to restart Windows'.format(e))\\n return\",\n \"def supervisor_restart():\\n log('restart supervisor', yellow)\\n sudo('/etc/init.d/supervisor stop')\\n sudo('/etc/init.d/supervisor start')\\n # sudo('/etc/init.d/supervisor restart')\",\n \"def restart(self, timestamp=0.0, **keywords):\\n self.services.debug('restart() method called')\\n pass\",\n \"def restart_from_helper ( self, ):\\r\\n self.no_helper_restarts += 1\\r\\n self.logger.info( \\\"restart_from_helper\\\" )\\r\\n\\r\\n self.restart()\",\n \"def message_restart():\\n if dialog_yes_no(32014):\\n xbmc.executebuiltin('RestartApp')\",\n \"def restart(ctx, copy, file, u): # pylint:disable=redefined-builtin\\n content = None\\n update_code = None\\n if file:\\n content = '{}'.format(rhea.read(file))\\n\\n # Check if we need to upload\\n if u:\\n ctx.invoke(upload, sync=False)\\n update_code = True\\n\\n user, project_name, _experiment = get_project_experiment_or_local(ctx.obj.get('project'),\\n ctx.obj.get('experiment'))\\n try:\\n if copy:\\n response = PolyaxonClient().experiment.copy(\\n user, project_name, _experiment, content=content, update_code=update_code)\\n Printer.print_success('Experiment was copied with id {}'.format(response.id))\\n else:\\n response = PolyaxonClient().experiment.restart(\\n user, project_name, _experiment, content=content, update_code=update_code)\\n Printer.print_success('Experiment was restarted with id {}'.format(response.id))\\n except (PolyaxonHTTPError, PolyaxonShouldExitError, PolyaxonClientException) as e:\\n Printer.print_error('Could not restart experiment `{}`.'.format(_experiment))\\n Printer.print_error('Error message `{}`.'.format(e))\\n sys.exit(1)\",\n \"def restart(self):\\n self.iic.set_flag(REG.CTRL_REG2.RST)\\n time.sleep(0.01)\\n self.conf = Configuration()\",\n \"def restart():\\n run_commands('python manage.py supervisor restart all')\",\n \"def restart(self):\\n\\n #Kill processes\\n print('Restarting scan...... \\\\n')\\n self.kill()\\n\\n #Delete crawler\\n del self.crawler\\n self.crawler = self.generate_crawler()\\n\\n #Give ourselves a second\\n time.sleep(2)\",\n \"def RestartApp(argv_extra):\\n\\n p = psutil.Process(os.getpid())\\n for handler in p.open_files() + p.connections():\\n if handler.fd != -1:\\n os.close(handler.fd)\\n\\n exe = sys.executable\\n argv = list(sys.argv)\\n argv.append(argv_extra)\\n\\n os.execl(exe, exe, *argv)\",\n \"def _restartProcessNormal(self) -> None:\\n\\n if IS_WIN_SVC in sys.argv:\\n reactor.callFromThread(reactor.stop)\\n return\\n\\n python = sys.executable\\n argv = list(sys.argv)\\n\\n def addExe(val):\\n if not \\\"run_peek_\\\" in val:\\n return val\\n if isWindows and not val.lower().endswith(\\\".exe\\\"):\\n return val + \\\".exe\\\"\\n return val\\n\\n argv = map(addExe, argv)\\n os.execl(python, python, *argv)\",\n \"def restart(\\n context,\\n user=get_local_user(),\\n remote=False,\\n instance=None,\\n stack=None,\\n services=None,\\n):\\n command = \\\"restart\\\"\\n run_command_with_services(context, user, remote, instance, stack, command, services)\",\n \"def restart_with_reloader():\\n while True:\\n print(f'Restarting with reloader')\\n args = [sys.executable] + ['-W%s' % o for o in sys.warnoptions] + sys.argv\\n new_environ = os.environ.copy()\\n new_environ[\\\"RUN_MAIN\\\"] = 'true'\\n exit_code = os.spawnve(os.P_WAIT, sys.executable, args, new_environ)\\n if exit_code != 3:\\n return exit_code\",\n \"def restart(self):\\n self.__init__()\\n return\",\n \"def restart(self):\\n # Note: No need to regenerate the data, just reset the idx\\n self.prepare_for_use()\",\n \"def restart(self):\\n # Note: No need to regenerate the data, just reset the idx\\n self.prepare_for_use()\",\n \"def restart(self):\\n # Note: No need to regenerate the data, just reset the idx\\n self.prepare_for_use()\",\n \"def restart_game(context: GameContext) -> None:\\n left_spaceship, right_spaceship = create_spaceships()\\n context.restart(left_spaceship, right_spaceship)\",\n \"def run_restart(self, expanded, unexpanded) :\\n\\t\\tif not self.HasRoles(self.__context.Control_Panel, 'Manager') :\\n\\t\\t\\treturn -1\\n\\t\\tif expanded :\\n\\t\\t\\treturn self.errormessage(\\\"Doesn't need any argument\\\")\\n\\t\\tself.__context.Control_Panel.manage_restart(self.__context.REQUEST.URL0)\",\n \"def restart(self):\\n \\n # Set the previous time to be 0, we are starting the simulation\\n self.oldtime = 0.0\\n\\n # Deep Copy of all of the initial conditions\\n self.delt = copy.deepcopy(self.ic[0])\\n self.odestep = copy.deepcopy(self.ic[1])\\n self.species = copy.deepcopy(self.ic[2])\\n self.cythonBool = copy.deepcopy(self.ic[3])\\n self.resTime = copy.deepcopy(self.ic[4])\\n\\n # Update need enzyme Counts in the particle map\\n self.species.update(self)\\n\\n print(\\\"Done with restart\\\")\",\n \"def restart():\\n \\n while True:\\n print(\\\"Spiel wurde beendet: Tippe 'r' zum Neustart oder 'q' zum Beenden\\\")\\n user_input_3 = str(input(\\\"Erwarte Eingabe: \\\"))\\n if user_input_3 == \\\"q\\\":\\n quit()\\n elif user_input_3 == \\\"r\\\":\\n print()\\n print()\\n print(\\\"SPIEL-WURDE-NEUGESTARTET------------------------------------------------------\\\")\\n print()\\n sixteen_is_dead(set_players())\\n else:\\n print()\\n print(\\\"ERROR: Falsche Eingabe - bitte versuchen Sie es erneut!\\\")\\n print()\",\n \"def Restart(self, request, global_params=None):\\n config = self.GetMethodConfig('Restart')\\n return self._RunMethod(\\n config, request, global_params=global_params)\",\n \"def restartGame(self):\\n\\t\\tself.state = [[0 for x in range(3)] for y in range(3)]\\n\\t\\tself.turn = self.whoGoesFirst()\\n\\t\\tself.win = 0\",\n \"def do_restart(self, timeSinceLastInterruption, noRestart=False):\\n delta = self.ckptTime\\n try:\\n self.ProcLog(\\\"Attempting to restart from ckpt #%d, taken at %d\\\" % (self.numCkpts, self.lastCheckpointTime))\\n self.lostWork += timeSinceLastInterruption\\n if not noRestart:\\n assert self.broken == True\\n yield self.env.timeout(delta)\\n # Done with restart without errors\\n self.ProcLog(\\\"Restart successful... going back to compute\\\")\\n except simpy.Interrupt as e:\\n if (e.cause == \\\"failure\\\"):\\n # TODO: Handle failures during a restart\\n print(\\\"Failure in the middle of a restart... will attempt restart again\\\")\\n exit(-1)\\n #self.do_restart()\",\n \"def restart():\\n msg = messagebox.showinfo('YES!', \\\"You're Right\\\")\\n window.destroy()\\n game()\",\n \"def restart(name, runas=None):\\n return prlctl(\\\"restart\\\", salt.utils.data.decode(name), runas=runas)\",\n \"def resetApp(self):\\n python = sys.executable\\n os.execl(python, python, * sys.argv)\",\n \"def restarted(self):\\n return self.reset(\\n started=self.started + 1,\\n starting=0,\\n )\",\n \"def restart(self):\\n self.set_random_pos('starting')\\n self.set_random_pos('finishing')\\n self.game_loop()\",\n \"def restart(self, sync=True):\\n self.shutdown(sync=True)\\n self.power_on(sync)\",\n \"def restart(self):\\n self.idx = 0\",\n \"def restart_calculator():\\n # Variables to ensure PEP8 convention pass (amount of characters in line)\\n repeat = \\\"Do you want to repeat calculations?\\\"\\n yes = \\\"Press 'y' than 'enter' to continue calculations\\\"\\n no = \\\"Press 'n' than 'enter' to quit calculations\\\"\\n # User decision y or n input\\n restart = input(f\\\"\\\\033[1;32;10m\\\\n{repeat}\\\\n{yes}\\\\n{no}\\\\n\\\")\\n # If user decide to restart calculation\\n if restart == 'y':\\n print('\\\\n\\\\033[1;33;10mCalculate again\\\\n')\\n main()\\n # If user decide to end calculation\\n elif restart == 'n':\\n print('\\\\n\\\\033[1;33;10mSee you next time')\\n exit()\\n # Else type incorrect value\\n else:\\n print(\\\"\\\\n\\\\033[1;31;10mIncorrect character, please type 'y' or 'n'\\\")\\n restart_calculator()\",\n \"def restart_llap(self, env):\\n Logger.info(\\\"Custom Command to retart LLAP\\\")\\n import params\\n env.set_params(params)\\n\\n if params.security_enabled:\\n self.do_kinit()\\n\\n self._llap_stop(env)\\n self._llap_start(env)\",\n \"async def restart_server(self):\\n await self.stop_server()\\n self._start()\\n await self.send_tag('control', emoji.TRIGGERS['control'], 'Server restarted!')\",\n \"def restart(self, relay):\\n if self.stop():\\n return self.start(relay)\\n return False\",\n \"def force_restart(self):\\n\\n logging.info(\\\"Force restarting the experiment...\\\")\\n\\n save_dir = os.path.join(self._dir_name)\\n create_folder(save_dir)\\n rmtree(save_dir)\\n\\n if self._logger is not None:\\n self._logger.force_restart()\",\n \"def restart_openvpn():\\n cmd = 'service openvpn restart'\\n result = call_command(cmd)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.81809056","0.77184916","0.7704029","0.76525164","0.76247376","0.7567915","0.75503725","0.75503725","0.75476766","0.7467852","0.7454058","0.7446032","0.7443567","0.7435153","0.7336499","0.7296281","0.7243043","0.72082216","0.71947414","0.7190868","0.71697456","0.7108626","0.7099677","0.701946","0.7003277","0.6951631","0.69497985","0.68372285","0.68238825","0.68158203","0.6805769","0.677949","0.6771342","0.6771341","0.6732962","0.6729732","0.6728656","0.6721881","0.67084837","0.66867965","0.66687286","0.6654673","0.6650782","0.65924704","0.6592176","0.6559272","0.65473634","0.6540262","0.6540262","0.65355444","0.6525988","0.6499453","0.648838","0.6470112","0.64690113","0.64678806","0.6463414","0.6462766","0.64620304","0.6435454","0.6424376","0.6417659","0.6415802","0.63983893","0.6388071","0.63796484","0.6378595","0.6368168","0.6344649","0.6337171","0.6321031","0.63065195","0.6291266","0.6288025","0.6283976","0.6271341","0.62687564","0.6259636","0.6252048","0.6252048","0.6252048","0.6225657","0.6222253","0.6212154","0.620882","0.6205301","0.6187886","0.6174957","0.6173383","0.61705726","0.61561275","0.6152499","0.61504996","0.61389786","0.6127596","0.61270815","0.61182773","0.61143166","0.60810554","0.6074758","0.6067816"],"string":"[\n \"0.81809056\",\n \"0.77184916\",\n \"0.7704029\",\n \"0.76525164\",\n \"0.76247376\",\n \"0.7567915\",\n \"0.75503725\",\n \"0.75503725\",\n \"0.75476766\",\n \"0.7467852\",\n \"0.7454058\",\n \"0.7446032\",\n \"0.7443567\",\n \"0.7435153\",\n \"0.7336499\",\n \"0.7296281\",\n \"0.7243043\",\n \"0.72082216\",\n \"0.71947414\",\n \"0.7190868\",\n \"0.71697456\",\n \"0.7108626\",\n \"0.7099677\",\n \"0.701946\",\n \"0.7003277\",\n \"0.6951631\",\n \"0.69497985\",\n \"0.68372285\",\n \"0.68238825\",\n \"0.68158203\",\n \"0.6805769\",\n \"0.677949\",\n \"0.6771342\",\n \"0.6771341\",\n \"0.6732962\",\n \"0.6729732\",\n \"0.6728656\",\n \"0.6721881\",\n \"0.67084837\",\n \"0.66867965\",\n \"0.66687286\",\n \"0.6654673\",\n \"0.6650782\",\n \"0.65924704\",\n \"0.6592176\",\n \"0.6559272\",\n \"0.65473634\",\n \"0.6540262\",\n \"0.6540262\",\n \"0.65355444\",\n \"0.6525988\",\n \"0.6499453\",\n \"0.648838\",\n \"0.6470112\",\n \"0.64690113\",\n \"0.64678806\",\n \"0.6463414\",\n \"0.6462766\",\n \"0.64620304\",\n \"0.6435454\",\n \"0.6424376\",\n \"0.6417659\",\n \"0.6415802\",\n \"0.63983893\",\n \"0.6388071\",\n \"0.63796484\",\n \"0.6378595\",\n \"0.6368168\",\n \"0.6344649\",\n \"0.6337171\",\n \"0.6321031\",\n \"0.63065195\",\n \"0.6291266\",\n \"0.6288025\",\n \"0.6283976\",\n \"0.6271341\",\n \"0.62687564\",\n \"0.6259636\",\n \"0.6252048\",\n \"0.6252048\",\n \"0.6252048\",\n \"0.6225657\",\n \"0.6222253\",\n \"0.6212154\",\n \"0.620882\",\n \"0.6205301\",\n \"0.6187886\",\n \"0.6174957\",\n \"0.6173383\",\n \"0.61705726\",\n \"0.61561275\",\n \"0.6152499\",\n \"0.61504996\",\n \"0.61389786\",\n \"0.6127596\",\n \"0.61270815\",\n \"0.61182773\",\n \"0.61143166\",\n \"0.60810554\",\n \"0.6074758\",\n \"0.6067816\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88389,"cells":{"query":{"kind":"string","value":"Returns the pascal triangle of n."},"document":{"kind":"string","value":"def pascal_triangle(n):\n\n if n <= 0:\n return []\n\n l = [[0 for x in range(i + 1)] for i in range(n)]\n l[0] = [1]\n\n for i in range(1, n):\n l[i][0] = 1\n for j in range(1, i + 1):\n if j < len(l[i - 1]):\n l[i][j] = l[i - 1][j - 1] + l[i - 1][j]\n else:\n l[i][j] = l[i - 1][0]\n return l"},"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 create_pascal_triangle(self, n):\r\n if n == 0:\r\n return list()\r\n\r\n return [self.gen_triangle_level(i)\r\n for i\r\n in range(1, n + 1, 1)]","def pascal_triangle(n):\n if n <= 0:\n return []\n\n a = [[1 for i in range(1, j + 1)] for j in range(1, n + 1)]\n for i in range(2, n):\n for j in range(1, i):\n a[i][j] = a[i - 1][j - 1] + a[i - 1][j]\n\n return a","def pascal_triangle(n):\n triangle = []\n begin = 1\n for y in range(0, n):\n row = []\n for x in range(0, y + 1):\n if y == 0 or x == 0 or (y > 0 and x == y):\n row.append(begin)\n else:\n row.append(triangle[y - 1][x] + triangle[y - 1][x - 1])\n triangle.append(row)\n return triangle","def pascal_triangle(n):\n my_list = []\n if n <= 0:\n return my_list\n for i in range(1, n + 1):\n value = 1\n tmp_list = []\n for j in range(1, i + 1):\n tmp_list.append(str(value))\n value = value * (i - j) // j\n my_list.append(tmp_list)\n return my_list","def pascal_triangle(n):\n if n > 0:\n triangle_rows = [[1]]\n for i in range(1, n):\n middle_numbers_list = []\n for pair in zip(triangle_rows[-1], triangle_rows[-1][1:]):\n middle_numbers_list.append(sum(pair))\n triangle_rows.append([1] + middle_numbers_list + [1])\n return print(triangle_rows)\n else:\n return print([])","def pascal_triangle(n):\n ans = []\n if n <= 0:\n return ans\n ans.append([1])\n if n == 1:\n return ans\n ans.append([1, 1])\n if n == 2:\n return ans\n for i in range(2, n):\n newlist = []\n newlist.append(1)\n fill = [ans[i-1][k] + ans[i-1][k+1] for k in range(len(ans) - 1)]\n newlist += fill\n newlist.append(1)\n ans.append(newlist)\n return ans","def pascal_triangle(n: int, r: int):\n if n==0\n return 1\n elif r ==0:\n return 1\n elif n==r:\n return 1\n else\n return pascal_triangle(n-1,r) + pascal_triangle(n-1, r-1)","def triangle(n):\n return n*(n+1)/2","def triangle_number(n):\n return n * (n + 1) / 2","def triangle(n):\n return (n * (n + 1)) / 2","def triangle(n: int) -> int:\n return int(n * (n + 1) / 2)","def triangle_number(n):\n return n * (n + 1) // 2","def create_pascal_triangle(self, n):\r\n if n == 0:\r\n return list()\r\n\r\n # Initialize full cache array\r\n c = [[None] * i\r\n for i\r\n in range(1, n + 1, 1)]\r\n\r\n for i in range(0, n, 1):\r\n for j in range(0, i + 1, 1):\r\n # Iterate over level-depth \"i\" and node position \"j\"\r\n\r\n if (j == 0 or\r\n j == i):\r\n # Evaluate as outer triangle edge\r\n c[i][j] = 1\r\n\r\n else:\r\n # Evaluate as sum of corresponding previous elements\r\n c[i][j] = c[i - 1][j - 1] + c[i - 1][j]\r\n\r\n return c","def triangle(n):\n j = 1\n k = 1\n result = []\n for num in range(1, n + 1):\n result.append(num)\n j = j + 1\n k = k + j\n\n return result","def triangleNumber(n):\n return sum(range(n+1))","def triangle(n):\n\n accumulator = 0\n\n for i in range(1,n+1):\n accumulator += i\n\n return accumulator","def triangular_number(n):\n return n*(n+1) / 2","def print_triangular_numbers(n):\r\n\r\n\tfor i in range(1, n+1):\r\n\t\tsum = int((i / 2)*(1 + i))\r\n\t\tprint(i, \"\\t\", sum)","def get_triangle_numbers(n):\n r = []\n for i in xrange(1, n + 1):\n t = ((i * (i + 1)) / 2)\n r.append(t)\n return r","def triangle(num):\n a = list(numbers(num))\n m = len(' '.join(map(str, a[-1])))\n for x in a:\n print(' '.join(map(str, x)).center(m)+'\\n')","def pascal_triangle(row, col):\n gray_theory = lambda last, row, col: last * ((row + 1) - col) / col\n p = 1\n for i in range(1, col):\n p = gray_theory(p, row, i)\n return p","def triangular(n_list):\n length = len(n_list)\n prod_list = [1]\n for n in n_list:\n prod_list.append(prod_list[-1] * n)\n prod_list = prod_list\n\n def key(case):\n return sum(n * i for n, i in zip(prod_list, case))\n\n combinations = {0: [[0] * length]}\n for m in range(prod_list[-1]):\n if m not in combinations:\n permutation = [\n case[:j] + [case[j] + 1] + case[j + 1:]\n for case in combinations[m - 1] for j in range(length)\n if case[j] + 1 < n_list[j]\n ]\n combinations[m] = []\n for case in permutation:\n if case not in combinations[m]:\n combinations[m].append(case)\n for case in combinations[m]:\n yield key(case)","def generate_diagonal_factors(n):\n\tfactors = np.array([1, -1]) # Initialize the diag terms with the diagonal of the Z Pauli matrix\n\tfor _ in range(n - 1): # Iterate n - 1 times\n\t\tfactors = np.hstack([factors, factors * -1]) # Append the same array multiplied by -1\n\treturn factors","def triangle_shape(n, fillchar=\"x\", spacechar=\" \"):\n width = 2 * n - 1\n return \"\\n\".join(\n (fillchar * (2 * i + 1)).center(width, spacechar) for i in range(n)\n )","def landau2(n):\n\n factors = primish(n)\n\n # TODO: I have no idea here...\n\n #assert sum(factors) <= n\n return product(factors)","def triangle(self):\n \n R = Householder.triangle_operation(self)[0] \n \n return(R.round(10))","def triangle(self):\n [r,c] = self.D\n m = min(r,c)\n S = self\n T = zeros(r,c)\n while m > 0:\n NoLigne = 0\n while S[NoLigne, 0] == 0 and (NoLigne < m - 1):\n NoLigne += 1\n S = S.swap(NoLigne,0)\n if S[0, 0] != 0:\n pivot = S[0,0]\n for k in range(1,m):\n if S[k,0] != 0:\n S = S.comb_lignes(pivot, -S[k,0],k,0)\n #print(\"pivot = \"+str(pivot))\n #print(\"S dans for :\")\n #print(S)\n T = T.remplace_ligned(r - m,S.F)\n #print(\"Évolution de T :\")\n #print(T)\n S = S.decoupe()\n m -= 1\n return T","def triangle(t):\n if int(t) % 2 == 0:\n y = t - int(t)\n else:\n y = 2 - (t - int(t) + 1)\n return abs(y)","def pascal(row, column):\n \"*** YOUR CODE HERE ***\"\n try:\n return fact(row)//(fact(row-column)*fact(column))\n except ZeroDivisionError:\n return 0","def rangoli(n):\r\n alphabet = string.ascii_lowercase\r\n pad = 4*n-3\r\n filler = '-'\r\n initial = [alphabet[n-1]]\r\n top = [alphabet[n-1].center(pad, filler)]\r\n\r\n for i in range(n-2, -1, -1):\r\n initial.append(alphabet[i])\r\n sub_list = initial[:-1]+[alphabet[i]]+list(reversed(initial[:-1]))\r\n sub_seq = filler.join(sub_list).center(pad, filler)\r\n top.append(sub_seq)\r\n\r\n bot = list(reversed(top[:-1]))\r\n result = '\\n'.join(top + bot)\r\n print(result)\r\n return","def for_isosceles_triangle():\r\n\r\n for row in range(7):\r\n print(' '*(7-row), '* '*row)","def triangle(height):\n for row in range(height):\n for column in range(1,row+2):\n print(CHAR, end = '')\n print()","def lucas(n):\n\tif n == 0:\n\t\treturn 0\n\telif n == 1:\n\t\treturn 2\n\telif n == 2:\n\t\treturn 1\n\telse:\n\t\treturn lucas(n-1) + lucas(n-2)","def pascal_case_count(n):\n saveText = _get_clipboard_text()\n cutText = _select_and_cut_text(n)\n if cutText:\n endSpace = cutText.endswith(' ')\n text = _cleanup_text(cutText)\n newText = text.title().replace(' ', '')\n if endSpace:\n newText = newText + ' '\n newText = newText.replace(\"%\", \"%%\") # Escape any format chars.\n Text(newText).execute()\n else: # Failed to get text from clipboard.\n Key('c-v').execute() # Restore cut out text.\n _set_clipboard_text(saveText)","def is_triangle_number(n):\n _, x = quadratic.solve(1, 1, -2*n)\n return is_number(x) and x.is_integer()","def lucas(n):\n if n <= 1:\n return 2 - n \n else:\n return lucas(n-1) + lucas(n-2)","def Birkhoff_polytope(self, n):\n perms = permutations(range(1,n+1))\n verts = []\n for p in perms:\n verts += [ [Polytopes._pfunc(i,j,p) for j in range(1,n+1) \n for i in range(1,n+1) ] ]\n return Polyhedron(vertices = verts)","def lucas(n):\n if n == 0:\n return 2\n elif n == 1:\n return n\n else:\n return lucas(n-1) + lucas(n-2)","def causal_poly(n, N):\n # Check input parameters\n assert np.all(np.array(n, dtype=int) == n), 'causal_poly: n should be an integer or an array of integers.'\n assert int(N) == N, 'causalpol: The provided polynomial degree is not an integer.'\n assert N >= 1, 'causalpol: The polynomial degree should be bigger than 0.'\n N = int(N)\n # Construct plynomial array where each row corresponds to an n value and each column corresponds to an N value\n A = np.zeros((len(n), N))\n A[:][n>=0] = np.linspace(1, N, N)\n A.T[:, n>=0] += n[n>=0]\n # Calculate product over rows and normalize\n return np.prod(A, axis=1) / np.math.factorial(N)","def triangle(self, freq: int, /) -> None:","def lucas(n):\n if n == 0:\n return 2\n elif n == 1:\n return 1\n else:\n return lucas(n - 1) + lucas(n - 2)","def lucas(n):\n if n == 0:\n return 2\n elif n == 1:\n return 1\n else:\n return lucas(n - 1) + lucas(n - 2)","def lucas(n):\n\n if (n == 0):\n return 2\n elif (n == 1):\n return 1\n else:\n return lucas(n - 1) + lucas(n - 2)","def euler_phi(n):\r\n\t# For each prime factor p with multiplicity n, a factor of (p**(n-1))*(p-1)\r\n\treturn reduce(lambda a,x:a*(x[0]**(x[1]-1))*(x[0]-1),factor(n),1)","def _generate(self, n):\n # See https://en.wikipedia.org/wiki/De_Bruijn_sequence\n\n k = len(self.alphabet)\n a = [0] * k * n\n sequence = []\n\n def db(t, p):\n if t > n:\n if n % p == 0:\n sequence.extend(a[1:p + 1])\n else:\n a[t] = a[t - p]\n db(t + 1, p)\n for j in range(a[t - p] + 1, k):\n a[t] = j\n db(t + 1, t)\n db(1, 1)\n return ''.join(self.alphabet[i] for i in sequence)","def pentagon(n) -> int:\n\n return (n * (3 * n - 1)) // 2","def lucas(n):\n if n == 0:\n return 2\n elif n == 1:\n return 1\n else:\n nth = lucas(n-1) + lucas(n-2)\n return nth","def generateParenthesis(self, n):\n sol = []\n \n def dfs(cur_str, o, c):\n if o==n and o==c:\n sol.append(cur_str)\n else:\n if o < n:\n dfs(cur_str + \"(\", o + 1, c)\n if c < o:\n dfs(cur_str + \")\", o, c+1)\n dfs(\"\", 0, 0)\n return sol","def triple_step_simplified(n):\n\ta = 0\n\tb = 0\n\tc = 1\n\tfor i in range(n):\n\t\ttemp = a + b + c\n\t\ta, b, c = b, c, temp\n\treturn temp","def pentagonal(n: int) -> int:\n return int(n * (3 * n - 1) / 2)","def lucas(n):\n if n==0:\n return 2\n elif n==1:\n return 1\n else:\n return lucas(n-1) + lucas(n-2)","def lucas(n):\n if n == 1:\n return 2\n elif n == 2:\n return 1\n else:\n return lucas(n-2) + lucas(n-1)","def triangle_shape(height):\n mot = str()\n if height == 0:\n return str()\n else :\n for i in range (height):\n esp = height-1-i\n mot = mot+ esp*\" \" + (2*i+1)*\"x\" +esp*\" \"\n if i!=height-1:\n mot = mot+ \"\\n\"\n return(mot)","def triangle_number_sieve(n):\n triangle_numbers = [False] * (n + 1)\n tn = i = 1\n while tn < n:\n triangle_numbers[triangle_number(i)] = True\n i += 1\n tn = triangle_number(i)\n return triangle_numbers","def generateParenthesis(self, n):\n # Write your code here\n result = []\n\n def helper(cur, left, right):\n if left == right == 0:\n result.append(cur)\n if left > 0:\n helper(cur + '(', left - 1, right)\n if left < right:\n helper(cur + ')', left, right - 1)\n helper(\"\", n, n)\n return result","def lucas(n):\n\n if n == 1:\n v = 2\n elif n == 2:\n v = 1\n else:\n v = lucas(n - 2) + lucas(n - 1)\n\n return v","def triangle_numbers():\n counter, tri_number = 1, 1\n while True:\n yield tri_number\n counter += 1\n tri_number += counter","def triangleFunction(self):\n \n w = np.zeros((self.N))\n l = self.l\n for i in range(self.r.shape[0]):\n r = np.abs(self.r[i])\n if r <= l:\n tf = lambda r,l : 1 - r/l\n w[i] = tf(r,l)\n else:\n w[i] = 0\n self.w = w","def PN(self, n):\n if not self.isVaild():\n pass\n if n < self.C:\n return self.P0()*(self.r()**n)/math.factorial(n)\n else:\n return self.P0()*(self.r()**n)/(math.factorial(self.C)*self.C**(n-self.C))","def pentagonal(n):\n return (n * ((3 * n) - 1)) / 2","def lucas(n:int):\n\n # Special Cases\n if n < 0:\n return (\"n has to be a positive integer\")\n \n if n == 0:\n return 2\n\n if n == 1:\n return 1\n\n if n == 2:\n return 3\n\n # Return Value\n return (lucas(n-1) + lucas(n-2))","def luc(n):\r\n if n==1:\r\n return 2\r\n elif n==2:\r\n return 1\r\n else:\r\n return luc(n-1)+luc(n-2)","def triangular_number_solution():\n return 5 * partial_sum(199) + 3 * partial_sum(333) - 15 * partial_sum(66)","def lesp(n):\n x = np.arange(2., n + 1)\n y = -(2. * np.arange(2, n + 2) + 1)\n t = tridiag(1 / x, y, x).todense()\n\n return t","def fn(n):\n if n == 0: return [\"\"]\n ans = []\n for k in range(n): \n for x in fn(k): \n for y in fn(n-k-1): \n ans.append(f\"{x}({y})\")\n return ans","def euler_phi(n):\n\tif n == 1: return 1\n\tif n <= 0: return 0\n\t# For each prime factor p with multiplicity n, a factor of (p**(n-1))*(p-1)\n\treturn functools.reduce(lambda a,x:a*(x[0]**(x[1]-1))*(x[0]-1),factor(n),1)","def zernike_num_coeff(n):\n \n\tif not (n>=0):\n\t\tprint('Input parameter must be >= 0')\n\t\traise AssertionError() \n \n\treturn sum(xrange(n+1)) + n+1","def print_table(n):\n \n numbers = list(range(1, n + 1))\n\n #处理第一行\n s = ''\n for i in numbers:\n s = s + '\\t' + str(i)\n print(s)\n\n for i in numbers:\n s = str(i)\n for j in numbers:\n s = s + '\\t' + str(i * j)\n print(s)","def findTriangles(p):\n triangleCount = 0\n for a in range(3, p//3 + 1):\n for b in range(a+1, p//2):\n c = p - (a+b)\n if (a**2 + b**2) == c**2:\n triangleCount += 1\n return triangleCount","def f(n):\n\tnstr = ''\n\tfor i in range(1, n + 1):\n\t\tnstr = nstr + str(i)\n\treturn nstr","def collatz_step(n):\n if n<1:\n raise ValueError('Input must be greater than 0')\n elif n==1:\n return 1\n elif n%2==0:\n return (n/2)\n elif n%2==1:\n return(3*n+1)","def while_isosceles_triangle():\r\n row = 0\r\n while row<7:\r\n print(' '*(7-row), '* '*row)\r\n row += 1","def distinct_partition(n: int):\n p_list = [1] + [0]*n\n for i in range(1, n+1):\n for j in reversed(range(i, n+1)):\n p_list[j] += p_list[j - i]\n return p_list[n] - 1","def eulerphi(n):\r\n\treturn euler_phi(n)","def formula_n(self, n: int, x: np.ndarray) -> np.ndarray:\n\n # express x as z = x/(x-1)\n z = x / (x - 1)\n\n # special case @n=0\n if n == 0:\n kn = 1 - self._vlerchphi(1 / z, n + 1)\n else:\n kn = 1 / n - self._vzlerchphi(1 / z, n + 1)\n\n # return\n return kn","def cross_polytope(self, dim_n):\n verts = permutations([0 for i in range(dim_n-1)] + [1])\n verts = verts + permutations([0 for i in range(dim_n-1)] + [-1])\n return Polyhedron(vertices = verts)","def generateParenthesis(self, n):\n if n == 0:\n return ['']\n if n == 1:\n return ['()']\n s = ''\n result = []\n for i in range (n):\n l1 = self.generateParenthesis(i)\n l2 = self.generateParenthesis(n-i-1)\n for x in l1:\n s = '(' + x + ')'\n s1 = ''\n for y in l2:\n s1 = s + y\n result.append(s1)\n return result","def obter_diagonal(tab, n): \r\n if not eh_tabuleiro(tab) or not (n in [1,2] and type(n)==int):\r\n raise ValueError('obter_diagonal: algum dos argumentos e invalido')\r\n else:\r\n if n==1:\r\n return (tab[0][0],tab[1][1],tab[2][2])\r\n else:\r\n return (tab[2][0],tab[1][1],tab[0][2])","def zeropad_to_length(self, n):\n oldn = self.nt\n assert n >= oldn\n return self.zeropad(0, n - oldn)","def euler_phi(n):\n\n if n == 1:\n return 1\n\n phi = n\n for p, a in factorize(n):\n phi -= phi // p\n\n return phi","def triangular_area():\n print(1*1/2, 2*2/2, 3*3/2, 4*4/2, 5*5/2, 6*6/2, 7*7/2, 8*8/2, 9*9/2,\n 10*10/2)","def draw_3(n: int):\n\n # Top half + middle\n for row in range(n // 2):\n for col in range(row + 1):\n print('*', end='')\n print()\n\n # Bottom half\n for row in range(n // 2, n):\n for col in range(n - row):\n print('*', end='')\n print()","def cube(n):\n result = [num*num*num for num in range(n)]\n\n return result[1:]","def eulerphi(n):\n\treturn euler_phi(n)","def multtable(n):\n for i in range(1,n+1):\n for x in range(1, n+1):\n result = print(i * x, end =' ')\n print ()\n return result","def triangle(x, period, var):\r\n if period == 0:\r\n return x\r\n else:\r\n x = x % period\r\n frac = 2*abs(0.5 - (x/period))\r\n y = (1-2*frac)*var\r\n return y","def nth_permutation(elems, n):\n pos, summ = 0, 0\n permutation = \"\"\n for i in reversed(range(1,len(elems))):\n fact_i = fact(i)\n while summ+fact_i < n:\n summ += fact_i\n pos += 1\n permutation += str(elems[pos])\n del(elems[pos])\n pos = 0\n return permutation + str(elems[0])","def triangle(row):\n if len(row) == 0:\n raise ValidationError(\"Row empty\")\n if len(row) == 1:\n return row\n if len(row) < 8:\n return small_triangles(row)\n make_steps()\n while len(row) > 50:\n streams = defaultdict(list)\n j = 0\n streams[j] = list(row)\n for i in range(len(row) - 4):\n for j in range(10):\n step = j * 4\n if i >= step:\n streams[j + 1].append(do_row(streams[j], i - step))\n row = streams[j]\n return small_triangles(row)","def factorial(n):\n product = 1\n for i in range(n, 1, -1):\n product *= i\n return product","def polygonal_number(s, n):\n return (n*n*(s-2)-n*(s-4))/2","def tutte(n):\n if(n!=int(n) or n<1):\n raise ValueError(\n \"n must be positive integer\"\n )\n catalan_val = catalan(n)\n return int((2*(math.pow(3,n))*catalan_val)/(n+3))","def cube(n):\n return n**3","def factorial(n):\n return product(range(1, n + 1))","def generateParenthesis(self, n):\n # Write your code here\n lists = [[\"\"]]\n for i in range(1, n + 1):\n f = []\n for j in range(i):\n for m in lists[j]:\n for n in lists[i - 1 - j]:\n f.append('(' + m + ')' + n)\n lists.append(f)\n return lists[-1]","def lucas(n):\n if n == 0:\n return 2\n elif n == 1:\n return 1\n else:\n return (lucas(n-1) + lucas(n-2))","def quadRes(p, n):\n\n lamb = 1\n alpha = (n - 1) // 2\n p = p % n\n\n while alpha != 0:\n if alpha % 2:\n alpha -= 1\n lamb = (lamb * p) % n\n else:\n p = (p ** 2) % n\n alpha = alpha // 2\n\n return lamb","def draw_poly(t, n, sz):\r\n angle = 180 - (n - 2) * 180 / n\r\n for i in range(n):\r\n t.forward(sz)\r\n t.left(angle)","def multtable(n):\n for i in range(1, n+1):\n for j in range(1, n+1):\n print(i * j, end=' ')\n print()","def solve(num_divisor):\n\n ordinal = 1\n triangle_number = 1\n num_factors = 1\n\n while num_factors <= num_divisor:\n ordinal += 1\n triangle_number += ordinal\n num_factors = len(get_factors(triangle_number))\n\n return triangle_number","def permutahedron(self, n, project = True):\n verts = range(1,n+1)\n verts = permutations(verts)\n if project: \n verts = [Polytopes.project_1(x) for x in verts]\n p = Polyhedron(vertices = verts)\n return p"],"string":"[\n \"def create_pascal_triangle(self, n):\\r\\n if n == 0:\\r\\n return list()\\r\\n\\r\\n return [self.gen_triangle_level(i)\\r\\n for i\\r\\n in range(1, n + 1, 1)]\",\n \"def pascal_triangle(n):\\n if n <= 0:\\n return []\\n\\n a = [[1 for i in range(1, j + 1)] for j in range(1, n + 1)]\\n for i in range(2, n):\\n for j in range(1, i):\\n a[i][j] = a[i - 1][j - 1] + a[i - 1][j]\\n\\n return a\",\n \"def pascal_triangle(n):\\n triangle = []\\n begin = 1\\n for y in range(0, n):\\n row = []\\n for x in range(0, y + 1):\\n if y == 0 or x == 0 or (y > 0 and x == y):\\n row.append(begin)\\n else:\\n row.append(triangle[y - 1][x] + triangle[y - 1][x - 1])\\n triangle.append(row)\\n return triangle\",\n \"def pascal_triangle(n):\\n my_list = []\\n if n <= 0:\\n return my_list\\n for i in range(1, n + 1):\\n value = 1\\n tmp_list = []\\n for j in range(1, i + 1):\\n tmp_list.append(str(value))\\n value = value * (i - j) // j\\n my_list.append(tmp_list)\\n return my_list\",\n \"def pascal_triangle(n):\\n if n > 0:\\n triangle_rows = [[1]]\\n for i in range(1, n):\\n middle_numbers_list = []\\n for pair in zip(triangle_rows[-1], triangle_rows[-1][1:]):\\n middle_numbers_list.append(sum(pair))\\n triangle_rows.append([1] + middle_numbers_list + [1])\\n return print(triangle_rows)\\n else:\\n return print([])\",\n \"def pascal_triangle(n):\\n ans = []\\n if n <= 0:\\n return ans\\n ans.append([1])\\n if n == 1:\\n return ans\\n ans.append([1, 1])\\n if n == 2:\\n return ans\\n for i in range(2, n):\\n newlist = []\\n newlist.append(1)\\n fill = [ans[i-1][k] + ans[i-1][k+1] for k in range(len(ans) - 1)]\\n newlist += fill\\n newlist.append(1)\\n ans.append(newlist)\\n return ans\",\n \"def pascal_triangle(n: int, r: int):\\n if n==0\\n return 1\\n elif r ==0:\\n return 1\\n elif n==r:\\n return 1\\n else\\n return pascal_triangle(n-1,r) + pascal_triangle(n-1, r-1)\",\n \"def triangle(n):\\n return n*(n+1)/2\",\n \"def triangle_number(n):\\n return n * (n + 1) / 2\",\n \"def triangle(n):\\n return (n * (n + 1)) / 2\",\n \"def triangle(n: int) -> int:\\n return int(n * (n + 1) / 2)\",\n \"def triangle_number(n):\\n return n * (n + 1) // 2\",\n \"def create_pascal_triangle(self, n):\\r\\n if n == 0:\\r\\n return list()\\r\\n\\r\\n # Initialize full cache array\\r\\n c = [[None] * i\\r\\n for i\\r\\n in range(1, n + 1, 1)]\\r\\n\\r\\n for i in range(0, n, 1):\\r\\n for j in range(0, i + 1, 1):\\r\\n # Iterate over level-depth \\\"i\\\" and node position \\\"j\\\"\\r\\n\\r\\n if (j == 0 or\\r\\n j == i):\\r\\n # Evaluate as outer triangle edge\\r\\n c[i][j] = 1\\r\\n\\r\\n else:\\r\\n # Evaluate as sum of corresponding previous elements\\r\\n c[i][j] = c[i - 1][j - 1] + c[i - 1][j]\\r\\n\\r\\n return c\",\n \"def triangle(n):\\n j = 1\\n k = 1\\n result = []\\n for num in range(1, n + 1):\\n result.append(num)\\n j = j + 1\\n k = k + j\\n\\n return result\",\n \"def triangleNumber(n):\\n return sum(range(n+1))\",\n \"def triangle(n):\\n\\n accumulator = 0\\n\\n for i in range(1,n+1):\\n accumulator += i\\n\\n return accumulator\",\n \"def triangular_number(n):\\n return n*(n+1) / 2\",\n \"def print_triangular_numbers(n):\\r\\n\\r\\n\\tfor i in range(1, n+1):\\r\\n\\t\\tsum = int((i / 2)*(1 + i))\\r\\n\\t\\tprint(i, \\\"\\\\t\\\", sum)\",\n \"def get_triangle_numbers(n):\\n r = []\\n for i in xrange(1, n + 1):\\n t = ((i * (i + 1)) / 2)\\n r.append(t)\\n return r\",\n \"def triangle(num):\\n a = list(numbers(num))\\n m = len(' '.join(map(str, a[-1])))\\n for x in a:\\n print(' '.join(map(str, x)).center(m)+'\\\\n')\",\n \"def pascal_triangle(row, col):\\n gray_theory = lambda last, row, col: last * ((row + 1) - col) / col\\n p = 1\\n for i in range(1, col):\\n p = gray_theory(p, row, i)\\n return p\",\n \"def triangular(n_list):\\n length = len(n_list)\\n prod_list = [1]\\n for n in n_list:\\n prod_list.append(prod_list[-1] * n)\\n prod_list = prod_list\\n\\n def key(case):\\n return sum(n * i for n, i in zip(prod_list, case))\\n\\n combinations = {0: [[0] * length]}\\n for m in range(prod_list[-1]):\\n if m not in combinations:\\n permutation = [\\n case[:j] + [case[j] + 1] + case[j + 1:]\\n for case in combinations[m - 1] for j in range(length)\\n if case[j] + 1 < n_list[j]\\n ]\\n combinations[m] = []\\n for case in permutation:\\n if case not in combinations[m]:\\n combinations[m].append(case)\\n for case in combinations[m]:\\n yield key(case)\",\n \"def generate_diagonal_factors(n):\\n\\tfactors = np.array([1, -1]) # Initialize the diag terms with the diagonal of the Z Pauli matrix\\n\\tfor _ in range(n - 1): # Iterate n - 1 times\\n\\t\\tfactors = np.hstack([factors, factors * -1]) # Append the same array multiplied by -1\\n\\treturn factors\",\n \"def triangle_shape(n, fillchar=\\\"x\\\", spacechar=\\\" \\\"):\\n width = 2 * n - 1\\n return \\\"\\\\n\\\".join(\\n (fillchar * (2 * i + 1)).center(width, spacechar) for i in range(n)\\n )\",\n \"def landau2(n):\\n\\n factors = primish(n)\\n\\n # TODO: I have no idea here...\\n\\n #assert sum(factors) <= n\\n return product(factors)\",\n \"def triangle(self):\\n \\n R = Householder.triangle_operation(self)[0] \\n \\n return(R.round(10))\",\n \"def triangle(self):\\n [r,c] = self.D\\n m = min(r,c)\\n S = self\\n T = zeros(r,c)\\n while m > 0:\\n NoLigne = 0\\n while S[NoLigne, 0] == 0 and (NoLigne < m - 1):\\n NoLigne += 1\\n S = S.swap(NoLigne,0)\\n if S[0, 0] != 0:\\n pivot = S[0,0]\\n for k in range(1,m):\\n if S[k,0] != 0:\\n S = S.comb_lignes(pivot, -S[k,0],k,0)\\n #print(\\\"pivot = \\\"+str(pivot))\\n #print(\\\"S dans for :\\\")\\n #print(S)\\n T = T.remplace_ligned(r - m,S.F)\\n #print(\\\"Évolution de T :\\\")\\n #print(T)\\n S = S.decoupe()\\n m -= 1\\n return T\",\n \"def triangle(t):\\n if int(t) % 2 == 0:\\n y = t - int(t)\\n else:\\n y = 2 - (t - int(t) + 1)\\n return abs(y)\",\n \"def pascal(row, column):\\n \\\"*** YOUR CODE HERE ***\\\"\\n try:\\n return fact(row)//(fact(row-column)*fact(column))\\n except ZeroDivisionError:\\n return 0\",\n \"def rangoli(n):\\r\\n alphabet = string.ascii_lowercase\\r\\n pad = 4*n-3\\r\\n filler = '-'\\r\\n initial = [alphabet[n-1]]\\r\\n top = [alphabet[n-1].center(pad, filler)]\\r\\n\\r\\n for i in range(n-2, -1, -1):\\r\\n initial.append(alphabet[i])\\r\\n sub_list = initial[:-1]+[alphabet[i]]+list(reversed(initial[:-1]))\\r\\n sub_seq = filler.join(sub_list).center(pad, filler)\\r\\n top.append(sub_seq)\\r\\n\\r\\n bot = list(reversed(top[:-1]))\\r\\n result = '\\\\n'.join(top + bot)\\r\\n print(result)\\r\\n return\",\n \"def for_isosceles_triangle():\\r\\n\\r\\n for row in range(7):\\r\\n print(' '*(7-row), '* '*row)\",\n \"def triangle(height):\\n for row in range(height):\\n for column in range(1,row+2):\\n print(CHAR, end = '')\\n print()\",\n \"def lucas(n):\\n\\tif n == 0:\\n\\t\\treturn 0\\n\\telif n == 1:\\n\\t\\treturn 2\\n\\telif n == 2:\\n\\t\\treturn 1\\n\\telse:\\n\\t\\treturn lucas(n-1) + lucas(n-2)\",\n \"def pascal_case_count(n):\\n saveText = _get_clipboard_text()\\n cutText = _select_and_cut_text(n)\\n if cutText:\\n endSpace = cutText.endswith(' ')\\n text = _cleanup_text(cutText)\\n newText = text.title().replace(' ', '')\\n if endSpace:\\n newText = newText + ' '\\n newText = newText.replace(\\\"%\\\", \\\"%%\\\") # Escape any format chars.\\n Text(newText).execute()\\n else: # Failed to get text from clipboard.\\n Key('c-v').execute() # Restore cut out text.\\n _set_clipboard_text(saveText)\",\n \"def is_triangle_number(n):\\n _, x = quadratic.solve(1, 1, -2*n)\\n return is_number(x) and x.is_integer()\",\n \"def lucas(n):\\n if n <= 1:\\n return 2 - n \\n else:\\n return lucas(n-1) + lucas(n-2)\",\n \"def Birkhoff_polytope(self, n):\\n perms = permutations(range(1,n+1))\\n verts = []\\n for p in perms:\\n verts += [ [Polytopes._pfunc(i,j,p) for j in range(1,n+1) \\n for i in range(1,n+1) ] ]\\n return Polyhedron(vertices = verts)\",\n \"def lucas(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return n\\n else:\\n return lucas(n-1) + lucas(n-2)\",\n \"def causal_poly(n, N):\\n # Check input parameters\\n assert np.all(np.array(n, dtype=int) == n), 'causal_poly: n should be an integer or an array of integers.'\\n assert int(N) == N, 'causalpol: The provided polynomial degree is not an integer.'\\n assert N >= 1, 'causalpol: The polynomial degree should be bigger than 0.'\\n N = int(N)\\n # Construct plynomial array where each row corresponds to an n value and each column corresponds to an N value\\n A = np.zeros((len(n), N))\\n A[:][n>=0] = np.linspace(1, N, N)\\n A.T[:, n>=0] += n[n>=0]\\n # Calculate product over rows and normalize\\n return np.prod(A, axis=1) / np.math.factorial(N)\",\n \"def triangle(self, freq: int, /) -> None:\",\n \"def lucas(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return 1\\n else:\\n return lucas(n - 1) + lucas(n - 2)\",\n \"def lucas(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return 1\\n else:\\n return lucas(n - 1) + lucas(n - 2)\",\n \"def lucas(n):\\n\\n if (n == 0):\\n return 2\\n elif (n == 1):\\n return 1\\n else:\\n return lucas(n - 1) + lucas(n - 2)\",\n \"def euler_phi(n):\\r\\n\\t# For each prime factor p with multiplicity n, a factor of (p**(n-1))*(p-1)\\r\\n\\treturn reduce(lambda a,x:a*(x[0]**(x[1]-1))*(x[0]-1),factor(n),1)\",\n \"def _generate(self, n):\\n # See https://en.wikipedia.org/wiki/De_Bruijn_sequence\\n\\n k = len(self.alphabet)\\n a = [0] * k * n\\n sequence = []\\n\\n def db(t, p):\\n if t > n:\\n if n % p == 0:\\n sequence.extend(a[1:p + 1])\\n else:\\n a[t] = a[t - p]\\n db(t + 1, p)\\n for j in range(a[t - p] + 1, k):\\n a[t] = j\\n db(t + 1, t)\\n db(1, 1)\\n return ''.join(self.alphabet[i] for i in sequence)\",\n \"def pentagon(n) -> int:\\n\\n return (n * (3 * n - 1)) // 2\",\n \"def lucas(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return 1\\n else:\\n nth = lucas(n-1) + lucas(n-2)\\n return nth\",\n \"def generateParenthesis(self, n):\\n sol = []\\n \\n def dfs(cur_str, o, c):\\n if o==n and o==c:\\n sol.append(cur_str)\\n else:\\n if o < n:\\n dfs(cur_str + \\\"(\\\", o + 1, c)\\n if c < o:\\n dfs(cur_str + \\\")\\\", o, c+1)\\n dfs(\\\"\\\", 0, 0)\\n return sol\",\n \"def triple_step_simplified(n):\\n\\ta = 0\\n\\tb = 0\\n\\tc = 1\\n\\tfor i in range(n):\\n\\t\\ttemp = a + b + c\\n\\t\\ta, b, c = b, c, temp\\n\\treturn temp\",\n \"def pentagonal(n: int) -> int:\\n return int(n * (3 * n - 1) / 2)\",\n \"def lucas(n):\\n if n==0:\\n return 2\\n elif n==1:\\n return 1\\n else:\\n return lucas(n-1) + lucas(n-2)\",\n \"def lucas(n):\\n if n == 1:\\n return 2\\n elif n == 2:\\n return 1\\n else:\\n return lucas(n-2) + lucas(n-1)\",\n \"def triangle_shape(height):\\n mot = str()\\n if height == 0:\\n return str()\\n else :\\n for i in range (height):\\n esp = height-1-i\\n mot = mot+ esp*\\\" \\\" + (2*i+1)*\\\"x\\\" +esp*\\\" \\\"\\n if i!=height-1:\\n mot = mot+ \\\"\\\\n\\\"\\n return(mot)\",\n \"def triangle_number_sieve(n):\\n triangle_numbers = [False] * (n + 1)\\n tn = i = 1\\n while tn < n:\\n triangle_numbers[triangle_number(i)] = True\\n i += 1\\n tn = triangle_number(i)\\n return triangle_numbers\",\n \"def generateParenthesis(self, n):\\n # Write your code here\\n result = []\\n\\n def helper(cur, left, right):\\n if left == right == 0:\\n result.append(cur)\\n if left > 0:\\n helper(cur + '(', left - 1, right)\\n if left < right:\\n helper(cur + ')', left, right - 1)\\n helper(\\\"\\\", n, n)\\n return result\",\n \"def lucas(n):\\n\\n if n == 1:\\n v = 2\\n elif n == 2:\\n v = 1\\n else:\\n v = lucas(n - 2) + lucas(n - 1)\\n\\n return v\",\n \"def triangle_numbers():\\n counter, tri_number = 1, 1\\n while True:\\n yield tri_number\\n counter += 1\\n tri_number += counter\",\n \"def triangleFunction(self):\\n \\n w = np.zeros((self.N))\\n l = self.l\\n for i in range(self.r.shape[0]):\\n r = np.abs(self.r[i])\\n if r <= l:\\n tf = lambda r,l : 1 - r/l\\n w[i] = tf(r,l)\\n else:\\n w[i] = 0\\n self.w = w\",\n \"def PN(self, n):\\n if not self.isVaild():\\n pass\\n if n < self.C:\\n return self.P0()*(self.r()**n)/math.factorial(n)\\n else:\\n return self.P0()*(self.r()**n)/(math.factorial(self.C)*self.C**(n-self.C))\",\n \"def pentagonal(n):\\n return (n * ((3 * n) - 1)) / 2\",\n \"def lucas(n:int):\\n\\n # Special Cases\\n if n < 0:\\n return (\\\"n has to be a positive integer\\\")\\n \\n if n == 0:\\n return 2\\n\\n if n == 1:\\n return 1\\n\\n if n == 2:\\n return 3\\n\\n # Return Value\\n return (lucas(n-1) + lucas(n-2))\",\n \"def luc(n):\\r\\n if n==1:\\r\\n return 2\\r\\n elif n==2:\\r\\n return 1\\r\\n else:\\r\\n return luc(n-1)+luc(n-2)\",\n \"def triangular_number_solution():\\n return 5 * partial_sum(199) + 3 * partial_sum(333) - 15 * partial_sum(66)\",\n \"def lesp(n):\\n x = np.arange(2., n + 1)\\n y = -(2. * np.arange(2, n + 2) + 1)\\n t = tridiag(1 / x, y, x).todense()\\n\\n return t\",\n \"def fn(n):\\n if n == 0: return [\\\"\\\"]\\n ans = []\\n for k in range(n): \\n for x in fn(k): \\n for y in fn(n-k-1): \\n ans.append(f\\\"{x}({y})\\\")\\n return ans\",\n \"def euler_phi(n):\\n\\tif n == 1: return 1\\n\\tif n <= 0: return 0\\n\\t# For each prime factor p with multiplicity n, a factor of (p**(n-1))*(p-1)\\n\\treturn functools.reduce(lambda a,x:a*(x[0]**(x[1]-1))*(x[0]-1),factor(n),1)\",\n \"def zernike_num_coeff(n):\\n \\n\\tif not (n>=0):\\n\\t\\tprint('Input parameter must be >= 0')\\n\\t\\traise AssertionError() \\n \\n\\treturn sum(xrange(n+1)) + n+1\",\n \"def print_table(n):\\n \\n numbers = list(range(1, n + 1))\\n\\n #处理第一行\\n s = ''\\n for i in numbers:\\n s = s + '\\\\t' + str(i)\\n print(s)\\n\\n for i in numbers:\\n s = str(i)\\n for j in numbers:\\n s = s + '\\\\t' + str(i * j)\\n print(s)\",\n \"def findTriangles(p):\\n triangleCount = 0\\n for a in range(3, p//3 + 1):\\n for b in range(a+1, p//2):\\n c = p - (a+b)\\n if (a**2 + b**2) == c**2:\\n triangleCount += 1\\n return triangleCount\",\n \"def f(n):\\n\\tnstr = ''\\n\\tfor i in range(1, n + 1):\\n\\t\\tnstr = nstr + str(i)\\n\\treturn nstr\",\n \"def collatz_step(n):\\n if n<1:\\n raise ValueError('Input must be greater than 0')\\n elif n==1:\\n return 1\\n elif n%2==0:\\n return (n/2)\\n elif n%2==1:\\n return(3*n+1)\",\n \"def while_isosceles_triangle():\\r\\n row = 0\\r\\n while row<7:\\r\\n print(' '*(7-row), '* '*row)\\r\\n row += 1\",\n \"def distinct_partition(n: int):\\n p_list = [1] + [0]*n\\n for i in range(1, n+1):\\n for j in reversed(range(i, n+1)):\\n p_list[j] += p_list[j - i]\\n return p_list[n] - 1\",\n \"def eulerphi(n):\\r\\n\\treturn euler_phi(n)\",\n \"def formula_n(self, n: int, x: np.ndarray) -> np.ndarray:\\n\\n # express x as z = x/(x-1)\\n z = x / (x - 1)\\n\\n # special case @n=0\\n if n == 0:\\n kn = 1 - self._vlerchphi(1 / z, n + 1)\\n else:\\n kn = 1 / n - self._vzlerchphi(1 / z, n + 1)\\n\\n # return\\n return kn\",\n \"def cross_polytope(self, dim_n):\\n verts = permutations([0 for i in range(dim_n-1)] + [1])\\n verts = verts + permutations([0 for i in range(dim_n-1)] + [-1])\\n return Polyhedron(vertices = verts)\",\n \"def generateParenthesis(self, n):\\n if n == 0:\\n return ['']\\n if n == 1:\\n return ['()']\\n s = ''\\n result = []\\n for i in range (n):\\n l1 = self.generateParenthesis(i)\\n l2 = self.generateParenthesis(n-i-1)\\n for x in l1:\\n s = '(' + x + ')'\\n s1 = ''\\n for y in l2:\\n s1 = s + y\\n result.append(s1)\\n return result\",\n \"def obter_diagonal(tab, n): \\r\\n if not eh_tabuleiro(tab) or not (n in [1,2] and type(n)==int):\\r\\n raise ValueError('obter_diagonal: algum dos argumentos e invalido')\\r\\n else:\\r\\n if n==1:\\r\\n return (tab[0][0],tab[1][1],tab[2][2])\\r\\n else:\\r\\n return (tab[2][0],tab[1][1],tab[0][2])\",\n \"def zeropad_to_length(self, n):\\n oldn = self.nt\\n assert n >= oldn\\n return self.zeropad(0, n - oldn)\",\n \"def euler_phi(n):\\n\\n if n == 1:\\n return 1\\n\\n phi = n\\n for p, a in factorize(n):\\n phi -= phi // p\\n\\n return phi\",\n \"def triangular_area():\\n print(1*1/2, 2*2/2, 3*3/2, 4*4/2, 5*5/2, 6*6/2, 7*7/2, 8*8/2, 9*9/2,\\n 10*10/2)\",\n \"def draw_3(n: int):\\n\\n # Top half + middle\\n for row in range(n // 2):\\n for col in range(row + 1):\\n print('*', end='')\\n print()\\n\\n # Bottom half\\n for row in range(n // 2, n):\\n for col in range(n - row):\\n print('*', end='')\\n print()\",\n \"def cube(n):\\n result = [num*num*num for num in range(n)]\\n\\n return result[1:]\",\n \"def eulerphi(n):\\n\\treturn euler_phi(n)\",\n \"def multtable(n):\\n for i in range(1,n+1):\\n for x in range(1, n+1):\\n result = print(i * x, end =' ')\\n print ()\\n return result\",\n \"def triangle(x, period, var):\\r\\n if period == 0:\\r\\n return x\\r\\n else:\\r\\n x = x % period\\r\\n frac = 2*abs(0.5 - (x/period))\\r\\n y = (1-2*frac)*var\\r\\n return y\",\n \"def nth_permutation(elems, n):\\n pos, summ = 0, 0\\n permutation = \\\"\\\"\\n for i in reversed(range(1,len(elems))):\\n fact_i = fact(i)\\n while summ+fact_i < n:\\n summ += fact_i\\n pos += 1\\n permutation += str(elems[pos])\\n del(elems[pos])\\n pos = 0\\n return permutation + str(elems[0])\",\n \"def triangle(row):\\n if len(row) == 0:\\n raise ValidationError(\\\"Row empty\\\")\\n if len(row) == 1:\\n return row\\n if len(row) < 8:\\n return small_triangles(row)\\n make_steps()\\n while len(row) > 50:\\n streams = defaultdict(list)\\n j = 0\\n streams[j] = list(row)\\n for i in range(len(row) - 4):\\n for j in range(10):\\n step = j * 4\\n if i >= step:\\n streams[j + 1].append(do_row(streams[j], i - step))\\n row = streams[j]\\n return small_triangles(row)\",\n \"def factorial(n):\\n product = 1\\n for i in range(n, 1, -1):\\n product *= i\\n return product\",\n \"def polygonal_number(s, n):\\n return (n*n*(s-2)-n*(s-4))/2\",\n \"def tutte(n):\\n if(n!=int(n) or n<1):\\n raise ValueError(\\n \\\"n must be positive integer\\\"\\n )\\n catalan_val = catalan(n)\\n return int((2*(math.pow(3,n))*catalan_val)/(n+3))\",\n \"def cube(n):\\n return n**3\",\n \"def factorial(n):\\n return product(range(1, n + 1))\",\n \"def generateParenthesis(self, n):\\n # Write your code here\\n lists = [[\\\"\\\"]]\\n for i in range(1, n + 1):\\n f = []\\n for j in range(i):\\n for m in lists[j]:\\n for n in lists[i - 1 - j]:\\n f.append('(' + m + ')' + n)\\n lists.append(f)\\n return lists[-1]\",\n \"def lucas(n):\\n if n == 0:\\n return 2\\n elif n == 1:\\n return 1\\n else:\\n return (lucas(n-1) + lucas(n-2))\",\n \"def quadRes(p, n):\\n\\n lamb = 1\\n alpha = (n - 1) // 2\\n p = p % n\\n\\n while alpha != 0:\\n if alpha % 2:\\n alpha -= 1\\n lamb = (lamb * p) % n\\n else:\\n p = (p ** 2) % n\\n alpha = alpha // 2\\n\\n return lamb\",\n \"def draw_poly(t, n, sz):\\r\\n angle = 180 - (n - 2) * 180 / n\\r\\n for i in range(n):\\r\\n t.forward(sz)\\r\\n t.left(angle)\",\n \"def multtable(n):\\n for i in range(1, n+1):\\n for j in range(1, n+1):\\n print(i * j, end=' ')\\n print()\",\n \"def solve(num_divisor):\\n\\n ordinal = 1\\n triangle_number = 1\\n num_factors = 1\\n\\n while num_factors <= num_divisor:\\n ordinal += 1\\n triangle_number += ordinal\\n num_factors = len(get_factors(triangle_number))\\n\\n return triangle_number\",\n \"def permutahedron(self, n, project = True):\\n verts = range(1,n+1)\\n verts = permutations(verts)\\n if project: \\n verts = [Polytopes.project_1(x) for x in verts]\\n p = Polyhedron(vertices = verts)\\n return p\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.83876556","0.8313631","0.8303543","0.82191485","0.8042562","0.8002575","0.7965688","0.7950681","0.7875324","0.7869357","0.78521544","0.7814328","0.7648985","0.7577198","0.7450272","0.7302716","0.71677047","0.7041317","0.6824642","0.6618727","0.659417","0.6318858","0.619653","0.6092524","0.59715307","0.59567046","0.5951465","0.5948116","0.59130585","0.5899992","0.5849844","0.58486503","0.58249605","0.5817469","0.579624","0.57885015","0.5772806","0.57431406","0.5728123","0.57234204","0.5709634","0.5709634","0.569758","0.5696046","0.56938165","0.5690118","0.5688912","0.5683138","0.5660779","0.5651593","0.56413454","0.56328666","0.56295884","0.56215817","0.5617795","0.5612262","0.56074095","0.56073993","0.55957115","0.55652606","0.5555419","0.5552424","0.55405885","0.55381656","0.5526921","0.5524269","0.55209893","0.5515488","0.5515246","0.5514873","0.54974127","0.5495047","0.5482693","0.54681075","0.5451959","0.54451764","0.5443524","0.5438794","0.54320353","0.5431621","0.54277694","0.54268205","0.5410099","0.54073864","0.5402323","0.5399764","0.5397535","0.5386372","0.5382923","0.5372448","0.53624755","0.5362362","0.5361137","0.5360539","0.5346015","0.5339355","0.53291523","0.5323714","0.53197914","0.5317062"],"string":"[\n \"0.83876556\",\n \"0.8313631\",\n \"0.8303543\",\n \"0.82191485\",\n \"0.8042562\",\n \"0.8002575\",\n \"0.7965688\",\n \"0.7950681\",\n \"0.7875324\",\n \"0.7869357\",\n \"0.78521544\",\n \"0.7814328\",\n \"0.7648985\",\n \"0.7577198\",\n \"0.7450272\",\n \"0.7302716\",\n \"0.71677047\",\n \"0.7041317\",\n \"0.6824642\",\n \"0.6618727\",\n \"0.659417\",\n \"0.6318858\",\n \"0.619653\",\n \"0.6092524\",\n \"0.59715307\",\n \"0.59567046\",\n \"0.5951465\",\n \"0.5948116\",\n \"0.59130585\",\n \"0.5899992\",\n \"0.5849844\",\n \"0.58486503\",\n \"0.58249605\",\n \"0.5817469\",\n \"0.579624\",\n \"0.57885015\",\n \"0.5772806\",\n \"0.57431406\",\n \"0.5728123\",\n \"0.57234204\",\n \"0.5709634\",\n \"0.5709634\",\n \"0.569758\",\n \"0.5696046\",\n \"0.56938165\",\n \"0.5690118\",\n \"0.5688912\",\n \"0.5683138\",\n \"0.5660779\",\n \"0.5651593\",\n \"0.56413454\",\n \"0.56328666\",\n \"0.56295884\",\n \"0.56215817\",\n \"0.5617795\",\n \"0.5612262\",\n \"0.56074095\",\n \"0.56073993\",\n \"0.55957115\",\n \"0.55652606\",\n \"0.5555419\",\n \"0.5552424\",\n \"0.55405885\",\n \"0.55381656\",\n \"0.5526921\",\n \"0.5524269\",\n \"0.55209893\",\n \"0.5515488\",\n \"0.5515246\",\n \"0.5514873\",\n \"0.54974127\",\n \"0.5495047\",\n \"0.5482693\",\n \"0.54681075\",\n \"0.5451959\",\n \"0.54451764\",\n \"0.5443524\",\n \"0.5438794\",\n \"0.54320353\",\n \"0.5431621\",\n \"0.54277694\",\n \"0.54268205\",\n \"0.5410099\",\n \"0.54073864\",\n \"0.5402323\",\n \"0.5399764\",\n \"0.5397535\",\n \"0.5386372\",\n \"0.5382923\",\n \"0.5372448\",\n \"0.53624755\",\n \"0.5362362\",\n \"0.5361137\",\n \"0.5360539\",\n \"0.5346015\",\n \"0.5339355\",\n \"0.53291523\",\n \"0.5323714\",\n \"0.53197914\",\n \"0.5317062\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.83408237"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":88390,"cells":{"query":{"kind":"string","value":"Read simulation parameters and coordinate file"},"document":{"kind":"string","value":"def __init__(self):\n\n self.read_input_file()\n self.read_simulation_files()"},"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 read_simulation_files(self):\n\n # Check if simulation files exist in current directory, if not kill process\n if not os.path.isfile('{}.xyz'.format(self.prefix)):\n print('Cannot find simulation file \"{}.xyz\"'.format(self.prefix))\n sys.exit()\n if not os.path.isfile('{}_vis2d.dat'.format(self.prefix)):\n print('Cannot find simulation file \"{}_vis2d.dat\"'.format(self.prefix))\n sys.exit()\n if not os.path.isfile('{}_dia.dat'.format(self.prefix)):\n print('Cannot find simulation file \"{}_dia.dat\"'.format(self.prefix))\n sys.exit()\n\n # Read coordinate file\n print('Reading simulation xyz file')\n with open('{}.xyz'.format(self.prefix),'r') as f:\n self.n = int(f.readline().split()[0])\n self.crds = np.zeros((self.n,2))\n f.seek(0,0)\n for i in range(self.frame):\n for j in range(2+self.n):\n f.readline()\n f.readline()\n f.readline()\n for j in range(self.n):\n self.crds[j,:] = np.array([float(c) for c in f.readline().split()[1:3]])\n\n # Read rings file\n print('Reading simulation ring file')\n with open('{}_vis2d.dat'.format(self.prefix),'r') as f:\n self.rings = []\n if self.vis_vortype != 0:\n while True:\n frame = int(f.readline().split()[0])\n vor_type = int(f.readline().split()[0])\n self.param = float(f.readline().split()[0])\n self.m = int(f.readline().split()[0])\n if frame==self.frame and vor_type==self.vis_vortype:\n for i in range(self.m):\n ring = np.array([float(c) for c in f.readline().split()])\n self.rings.append(ring.reshape(ring.shape[0]//2,2))\n break\n else:\n for i in range(self.m):\n f.readline()\n\n # Read diameter file\n print('Reading simulation radii and weights file')\n data = np.genfromtxt('{}_dia.dat'.format(self.prefix)).astype(float)\n self.radii = data[:self.n]/2\n self.weights = data[self.n:]","def readParams(path):\n tiles = open(path, \"r\")\n #--- Starting date\n tiles.readline()\n index = tiles.readline()[:-1]\n \n #--- Starting date\n tiles.readline()\n B_date = tiles.readline()[:-1]\n \n #--- Stopping date\n tiles.readline()\n E_date = tiles.readline()[:-1]\n \n #--- DATA \n tiles.readline()\n DATA_path = tiles.readline()[:-1]\n \n #--- Csv \n tiles.readline()\n out = tiles.readline()[:-1]\n \n #--- Shapefile\n tiles.readline()\n shp = tiles.readline()[:-1]\n \n #--- Water mask\n water = DATA_path + '/waterMask'\n \n return index, B_date, E_date, DATA_path, out, shp, water","def read_mesa(self, filename=None):\n\n if filename is None:\n filename = self.model_file\n\n with open(filename, 'r') as f:\n # count number of lines\n npts_file = sum([1 for line in f])\n\n # go back to start and read first line in file to get number of parameters\n f.seek(0)\n l = f.readline()\n nparams_file = int(l.split(' ')[-1])\n\n # skip lines 2-4\n for i in range(3):\n f.readline()\n\n # the fifth line will give us the number of variables\n l = f.readline()\n nvars_file = int(l.split(' ')[-1])\n\n # subtract header rows\n npts_file -= 6\n\n print(f'{nvars_file} variables found in the initial model file')\n print(f'{npts_file} points found in the initial model file')\n\n var_idx_map = {}\n logR_idx = -1\n\n # read in the names of the variables\n for i in range(nvars_file):\n var_name_file = f.readline().strip()\n if var_name_file.lower() == 'n':\n var_name_file = 'neut'\n elif var_name_file == 'p':\n var_name_file = 'prot'\n\n if var_name_file == 'logR':\n logR_idx = i\n continue\n\n # create map of file indices to model indices\n try:\n var_idx_map[self.idx[var_name_file]] = i\n except KeyError:\n var_idx_map[self.idx['spec'] - 1 + network_module.network_species_index(var_name_file.lower())] = i\n\n base_r = np.zeros(npts_file)\n base_state = np.zeros((npts_file, self.nvar))\n\n # read in model data\n for i, line in enumerate(f):\n variables = [float(v) for v in line.split(' ')]\n\n # need to reverse the inputs file here\n\n n = npts_file - i - 1\n\n base_r[n] = R_solar * 10**variables[logR_idx]\n\n for j in range(self.nvar):\n if j in var_idx_map:\n base_state[n, j] = variables[var_idx_map[j]]\n\n return npts_file, base_r, base_state","def readParams(file_name):\n try:\n info = np.load(file_name,allow_pickle=True)[()]\n except FileNotFoundError:\n if file_name.split('/')[-2] == 'checkpoint':\n lfc_id_dir = '/expres/extracted/lfc_cal/lfc_id/'\n file_name = lfc_id_dir + os.path.basename(file_name)\n info = np.load(file_name,allow_pickle=True)[()]\n else:\n raise FileNotFoundError\n # Assemble information into \"fit-able\" form\n num_orders = len(info['params'])\n lines = [p[:,1] for p in info['params'] if p is not None]\n errs = [np.sqrt(cov[:,1,1]) for cov in info['cov'] if cov is not None]\n ordrs = [o for o in np.arange(86) if info['params'][o] is not None]\n waves = [w for w in info['wvln'] if w is not None]\n # I believe, but am not sure, that the wavelengths are multiplied by order\n # to separate them from when orders overlap at the edges\n waves = [wvln for order, wvln in zip(ordrs,waves)]\n ordrs = [np.ones_like(x) * m for m,x in zip(ordrs, lines)]\n\n x = np.concatenate(lines)\n y = np.concatenate(ordrs)\n e = np.concatenate(errs)\n w = np.concatenate(waves)\n # Note: default of pipeline includes ThAr lines, which we're not including here\n \n return (x,y,w,e)","def read_from(self, filename):\n if os.path.exists(filename):\n logger.info(\"Reading parameters from file {0}\".format(filename))\n cl, icoord, ispec, ireg, xori, yori, dx, dy, nx,\\\n ny, valex, snr, varbak = np.loadtxt(filename, comments='#', unpack=True)\n\n self.cl = cl\n self.icoordchange = int(icoord)\n self.ispec = int(ispec)\n self.ireg = int(ireg)\n self.xori = xori\n self.yori = yori\n self.dx = dx\n self.dy = dy\n self.nx = int(nx)\n self.ny = int(ny)\n self.valex = valex\n self.snr = snr\n self.varbak = varbak\n\n # Compute domain limits for later use\n self.xend = self.xori + (self.nx - 1) * self.dx\n self.yend = self.yori + (self.ny - 1) * self.dy\n\n return self\n else:\n logger.error(\"File {0} does not exist\".format(filename))\n raise FileNotFoundError('File does not exist')","def read_simulation_results(self,\n fname_sims, \n fname_pareto = None, \n fname_cull = None):\n\n \n self.fname_sims = fname_sims\n self.__read_file(fname_sims, 'sim_results')\n \n if fname_pareto is not None:\n self.fname_pareto = fname_pareto\n self.__read_file(fname_in, 'pareto')\n \n if fname_cull is not None:\n self.fname_cull = fname_cull\n self.__read_file(fname_in, 'cull')","def _read_parameter_file():\n if not os.path.exists(\"./config.txt\"):\n raise FileNotFoundError(\"Can't find the configuration file \"\n \"./config.txt\")\n\n required = ['compiler_suite', 'project_name', 'scratch_path',\n 'specfem_root', 'lasif_path', 'iteration_name']\n\n # Read parameters into dictionary.\n parameters = {}\n file = open(\"./config.txt\", \"r\")\n for line in file:\n if line.startswith(\"#\"):\n continue\n fields = line.split()\n parameters.update({fields[0]: fields[1]})\n\n # Ensure all parameters are there.\n for param in required:\n if param not in parameters.keys():\n raise ParameterError(\"Parameter \" + param + \" not in parameter \"\n \"file\")\n\n # Build full paths.\n parameters['scratch_path'] = os.path.abspath(parameters['scratch_path'])\n parameters['specfem_root'] = os.path.abspath(parameters['specfem_root'])\n parameters['lasif_path'] = os.path.abspath(parameters['lasif_path'])\n\n # Derived parameters.\n forward_stage_dir = os.path.join(\n parameters['scratch_path'],\n parameters['project_name'])\n forward_run_dir = os.path.join(\n forward_stage_dir,\n parameters['iteration_name'])\n lasif_scratch_path = os.path.join(\n parameters['scratch_path'],\n os.path.basename(\n parameters['lasif_path']))\n\n # Get list of all event names.\n try:\n iteration_xml_path = os.path.join(\n parameters['lasif_path'],\n 'ITERATIONS',\n 'ITERATION_%s.xml' %\n (parameters['iteration_name']))\n tree = ET.parse(iteration_xml_path)\n except:\n iteration_xml_path = os.path.join(\n lasif_scratch_path,\n 'ITERATIONS',\n 'ITERATION_%s.xml' %\n (parameters['iteration_name']))\n tree = ET.parse(iteration_xml_path) \n \n root = tree.getroot()\n event_list = []\n for name in root.findall('event'):\n for event in name.findall('event_name'):\n event_list.append(event.text)\n\n parameters.update({'forward_stage_dir': forward_stage_dir})\n parameters.update({'forward_run_dir': forward_run_dir})\n parameters.update({'iteration_xml_path': iteration_xml_path})\n parameters.update({'event_list': sorted(event_list)})\n parameters.update({'lasif_scratch_path': lasif_scratch_path})\n\n return parameters","def readCrystParam(crystfile):\n \n # Default values\n ccell1 = np.eye(3)\n ccell2 = np.eye(3)\n planehkl = [1,0,0]\n diruvw = [0,1,0]\n \n try:\n with open(crystfile,\"r\") as f:\n content = f.readlines()\n except FileNotFoundError:\n content = []\n\n for l in content:\n if l[0].rstrip() == \"#\":\n continue\n line = l.split('=')\n if len(line) == 2:\n if line[0].rstrip()==\"ccell1\":\n ccell1 = eval(line[1].rstrip())\n elif line[0].rstrip()==\"ccell2\":\n ccell2 = eval(line[1].rstrip())\n elif line[0].rstrip()==\"planehkl\":\n planehkl = eval(line[1].rstrip())\n elif line[0].rstrip()==\"diruvw\":\n diruvw = eval(line[1].rstrip())\n else:\n print(\"WARNING: %s is not a supported input\"%(line[0].rstrip()))\n elif len(line) > 2:\n raise SyntaxError(l)\n\n return ccell1, ccell2, planehkl, diruvw","def readFile(file_name):\n if file_name.split('.')[-1] == 'thid':\n x,m,w = readThid(file_name)\n e = np.empty_like(x)\n e[:] = np.nan\n return x,m,w,e\n else:\n return readParams(file_name)","def readVP(self,species): \n f = open('VPparams.txt', 'rU')\n lines = f.readlines()\n f.close()\n \n parsing = False\n for i in np.arange(len(lines)):\n if lines[i].startswith(species):\n parsing = True\n else:\n parsing = False\n if parsing:\n data = lines[i].split()\n \n lnC, L0, Rv, da, db = data[1:len(data)]\n self.lnC, self.L0, self.Rv, self.da, self.db = \\\n float(lnC), float(L0), float(Rv), float(da), float(db)","def read_positions():\n return np.genfromtxt(\"POSITIONS.OUT\").transpose()","def read_sim_par(file):\n simu_info = read_simu_info_merged_hdf5(file)\n emin = simu_info.energy_range_min\n emax = simu_info.energy_range_max\n sp_idx = simu_info.spectral_index\n sim_ev = simu_info.n_showers * simu_info.shower_reuse\n area_sim = (simu_info.max_scatter_range - simu_info.min_scatter_range) ** 2 * np.pi\n cone = simu_info.max_viewcone_radius\n\n par_var = [emin, emax, sp_idx, sim_ev, area_sim, cone]\n par_dic = ['emin', 'emax', 'sp_idx', 'sim_ev', 'area_sim', 'cone']\n par = dict(zip(par_dic, par_var))\n\n # Pass units to TeV and cm2\n par['emin'] = par['emin'].to(u.TeV)\n par['emax'] = par['emax'].to(u.TeV)\n par['area_sim'] = par['area_sim'].to(u.cm ** 2)\n\n return par","def read_file(self, filename=None):\n print(f'reading file')\n\n if filename is None:\n filename = self.model_file\n\n with open(filename, 'r') as f:\n # count number of lines\n npts_file = sum([1 for line in f])\n\n # go back to start and read second line in file to get number of variables\n f.seek(0)\n f.readline()\n l = f.readline()\n nvars_file = int(l.split(' ')[-1])\n\n # subtract header rows\n npts_file -= (nvars_file + 2)\n\n print(f'{nvars_file} variables found in the initial model file')\n print(f'{npts_file} points found in the initial model file')\n\n var_idx_map = {}\n\n # read in the names of the variables\n for i in range(nvars_file):\n var_name_file = f.readline().strip()\n if var_name_file.lower() == 'n':\n var_name_file = 'neut'\n elif var_name_file == 'p':\n var_name_file = 'prot'\n\n # create map of file indices to model indices\n try:\n var_idx_map[self.idx[var_name_file]] = i+1\n except KeyError:\n pass\n\n base_r = np.zeros(npts_file)\n base_state = np.zeros((npts_file, self.nvar))\n\n # read in model data\n for i, line in enumerate(f):\n variables = [float(v) for v in line.split(' ')]\n\n base_r[i] = variables[2]\n\n for j in range(self.nvar):\n if j in var_idx_map:\n base_state[i, j] = variables[var_idx_map[j]]\n\n return npts_file, base_r, base_state","def _read_input_file(self):\n file_type = 'np.array'\n with open(self._file_properties['file_name'], 'r') as in_file:\n for line in in_file.readlines():\n if line[0:5] == '$$SOE':\n file_type = 'Horizons'\n break\n\n if not isfile(self._file_properties['file_name']):\n msg = 'Horizons files {:} does not exists.'\n message = msg.format(self._file_properties['file_name'])\n raise FileExistsError(message)\n if file_type == 'Horizons':\n self._read_horizons_file()\n else:\n (time, x, y, z) = np.loadtxt(\n self._file_properties['file_name'],\n usecols=(0, 1, 2, 3), unpack=True)\n self._time = time\n if int(astropy_version[0]) >= 4:\n self._xyz = SkyCoord(x=x, y=y, z=z,\n representation_type='cartesian')\n else:\n self._xyz = SkyCoord(x=x, y=y, z=z,\n representation='cartesian')","def read(f):\n \n if isinstance(f, basestring):\n # If the input is a string, treat as file name\n with open(f) as fh: # Ensure file is closed\n return read(fh) # Call again with file object\n \n # First line contains the date\n date = f.readline()\n if not date:\n raise IOError(\"Cannot read from input file \"+str(filename))\n \n # Second is description\n desc = f.readline()\n \n token = file_numbers(f)\n \n # Third contains number of mesh points\n try:\n npsi = int(token.next())\n ntheta = int(token.next())\n isym = int(token.next())\n except StopIteration:\n raise IOError(\"Unexpected end of file while reading grid size\")\n except ValueError:\n raise IOError(\"Third line should contain npsi, ntheta and isym\")\n \n # Check values\n if (isym < 0) or (isym > 1):\n raise IOError(\"isym must be either 0 or 1\")\n if (npsi < 1) or (ntheta < 1):\n raise IOError(\"Invalid npsi=\"+str(npsi)+\" or ntheta=\" + str(ntheta))\n \n # Read normalisation factors\n\n try:\n rcnt = float(token.next())\n xma = float(token.next())\n zma = float(token.next())\n btor = float(token.next())\n curtot = float(token.next())\n eaxe = float(token.next())\n dnorm = float(token.next())\n except:\n raise IOError(\"Couldn't read normalisation factors\")\n \n def read_array(n, name=\"Unknown\"):\n data = np.zeros([n])\n try:\n for i in np.arange(n):\n data[i] = float(token.next())\n except:\n raise IOError(\"Failed reading array '\"+name+\"' of size \", n)\n return data\n\n def read_2d(nx, ny, name=\"Unknown\"):\n data = np.zeros([nx, ny])\n for i in np.arange(nx):\n data[i,:] = read_array(ny, name+\"[\"+str(i)+\"]\")\n return data\n\n # Read 1D arrays\n psiflux = read_array(npsi, \"psiflux\")\n fnorm = read_array(npsi, \"fnorm\")\n ffpnorm = read_array(npsi, \"ffpnorm\")\n ponly = read_array(npsi, \"ponly\")\n pponly = read_array(npsi, \"pponly\")\n qsf = read_array(npsi, \"qsf\")\n d = read_array(npsi, \"d\")\n \n dpdz = read_array(ntheta, \"dpdz\")\n dpdr = read_array(ntheta, \"dpdr\")\n \n # 2D arrays\n \n xnorm = read_2d(ntheta, npsi, \"xnorm\")\n znorm = read_2d(ntheta, npsi, \"znorm\")\n \n # Try to read Br and Bz (may be present)\n try:\n Br = read_2d(ntheta, npsi, \"Br\")\n Bz = read_2d(ntheta, npsi, \"Bz\")\n except:\n Br = Bz = None\n \n ny = ntheta\n\n if isym == 1:\n # Fill in values for up-down symmetric case\n print(\"Grid is up-down symmetric. Reflecting grid about midplane\")\n ny = tsize = 2*(ntheta - 1) + 1\n \n def reflect(data, mapfunc = lambda x:x):\n \"\"\" Reflect a variable about midplane\n Optionally supply a mapping function\"\"\"\n data2 = np.zeros([tsize, npsi])\n # Copy the original data\n for i in np.arange(ntheta):\n data2[i,:] = data[i,:]\n # Now fill in the remainder\n for i in np.arange(ntheta, tsize):\n t0 = tsize - 1 - i\n data2[i,:] = mapfunc(data[t0,:])\n return data2\n \n xnorm = reflect(xnorm)\n znorm = reflect(znorm, lambda x: 2.*zma - x) # Reflect about zma\n if Br != None:\n Br = reflect(Br, lambda x:-x) # Br reverses\n if Bz != None:\n Bz = reflect(Bz) # Bz remains the same\n theta = tsize\n\n # Make sure we have Br, Bz and Bpol\n\n if (Br == None) or (Bz == None):\n # Calculate Bpol from psi then Br and Bz from Bpol\n # Use dpsi = R*Bp dx (for now)\n Bpol = np.zeros([ny, npsi])\n \n def deriv(f):\n n = np.size(f)\n dfdi = np.zeros(n)\n dfdi[1:-1] = (f[2:n] - f[0:-2])/2. # Central difference in the middle\n dfdi[0] = f[1] - f[0]\n dfdi[-1] = f[-1] - f[-2]\n return dfdi\n \n for i in np.arange(ntheta):\n drdi = deriv(xnorm[i, :])\n dzdi = deriv(znorm[i, :])\n dldi = sqrt(drdi**2 + dzdi**2) # Arc length\n dpsidi = deriv(psiflux)\n \n Bpol[i, :] = dpsidi / (dldi * xnorm[i,:])\n else:\n Bpol = np.sqrt(Br**2 + Bz**2)\n \n # Calculate toroidal field\n Btor = fnorm / xnorm\n \n #########################################\n # Create a dictionary of values to return\n # \n # Need to transpose 2D arrays to [psi, theta] \n # to be consistent with elite inputs\n \n var = {\"npsi\":npsi, \"npol\":ny, # Sizes\n \n \"psi\":psiflux,\n \"f(psi)\":fnorm,\n \"p\":ponly,\n \n \"R\": np.transpose(xnorm),\n \"Z\": np.transpose(znorm),\n\n \"Bp\":np.transpose(Bpol),\n \"Bt\":np.transpose(Btor),\n\n \"q\":qsf,\n\n \"ffprime\":ffpnorm,\n \"pprime\":pponly}\n\n if Br != None:\n var['Br'] = np.transpose(Br)\n if Bz != None:\n var['Bz'] = np.transpose(Bz)\n \n return var","def read_body(filepath, **kwargs):\n with open(filepath, 'r') as infile:\n coords = numpy.loadtxt(infile, unpack=True, **kwargs)\n return coords","def process(path):\n # get parameter value:\n with open('config.cym', 'r') as f:\n line = f.readline()\n #print(line)\n pam = float(line[1:])\n f.close()\n # get position of aster:\n with open('aster.txt', 'r') as f:\n for line in f:\n if len(line)>3 and not line[0]=='%':\n #print(line)\n val = line.split()\n x = float(val[2])\n y = float(val[3])\n #z = float(val[4])\n #pos = math.sqrt(x*x+y*y+z*z)\n pos = math.sqrt(x*x+y*y)\n\n f.close()\n return (pam, pos)","def read_parameters_diff_file(coords):\n param_map = hp.read_map(source +\n \"kids_data/\"\n \"COM_CompMap_Compton-SZMap-milca-\"\n \"ymaps_2048_R2.00.fits\")\n params = []\n for point in coords:\n ra, dec = point\n index = declratoindex(dec, ra)\n params.append(param_map[index])\n return params","def read_data(self):\n data = np.genfromtxt(self.__file) # Planck SED\n self.__nu = 10.0**data[:,0]\n self.__nuF = 10.0**data[:,2]\n self.__err = 10.0**data[:,3]\n #self.__W = 10.0**data[:,4]\n self.__yerr = [ self.__nuF - self.__nuF / self.__err, \\\n self.__nuF * self.__err - self.__nuF ]\n self.__maxY = max( self.__nuF )\n self.__minY = min( self.__nuF )","def loadParameters(self, parmfile=''):\n if not parmfile:\n raise IOError(\"You need to specify a parameter filename\")\n parmdir = os.getenv('ATMOSPHERE_PARAMETERS_DIR')\n parmpath = os.join.path(parmdir, parmfile)\n # Read from file\n with open(parmpath, 'r') as parmf:\n data = pickle.load(parmf)\n # Dictionary list\n self.modtran_visits = data[0]\n # Tuple list\n self.aerosol_visits = data[1]\n # seed value\n nruns = len(self.modtran_visits)\n print('Parameters for {1} runs computed with seed = {0}'.format(data[2],\n nruns))\n # Init transmission array\n self.initTransmissionArray(nruns)","def read_xyz(filename):\n\n config = {}\n\n with open(filename, 'r') as f:\n # number of atoms (spins)\n config['nat'] = int(re.findall('\\S+', f.readline())[0])\n\n # box parameters (type, dimension, shape, periodicity)\n sarr = re.findall('\\S+', f.readline())\n config['latt_type'] = sarr[0]\n dims = list(map(int, sarr[1:4]))\n config['latt_box'] = np.array(dims)\n config['box'] = np.diag(dims)\n config['pbc'] = list(map(int, sarr[4:7]))\n if len(sarr) > 7:\n dim_intra = len(sarr) - 7\n\n atom_types = []\n xyz = []\n config['latt_i'] = np.zeros(dims, dtype=int)\n config['latt_atoms'] = np.zeros(dims, dtype=int)\n config['latt_intra'] = np.zeros(tuple(dims) + (dim_intra,), dtype='float64')\n for i in range(config['nat']):\n sarr = re.findall('\\S+', f.readline())\n t = int(sarr[0])\n r = tuple(map(int, sarr[1:4]))\n\n atom_types.append(t)\n xyz.append(r)\n\n config['latt_i'][r] = i\n config['latt_atoms'][r] = t\n\n for j in range(dim_intra):\n ci = float(sarr[4 + j])\n config['latt_intra'][r[0], r[1], r[2], j] = ci\n\n config['atom_types'] = np.array(atom_types)\n config['xyz'] = np.array(xyz)\n \n return config","def readin():\r\n nodes = np.loadtxt('Vnodes.txt', ndmin=2)\r\n mats = np.loadtxt('Vmater.txt', ndmin=2)\r\n elements = np.loadtxt('Veles.txt', ndmin=2)\r\n loads = np.loadtxt('Vloads.txt', ndmin=2)\r\n return nodes, mats, elements, loads","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 test_open_file(self):\n\t\tposition, potential = schrodinger.open_file('potential_energy.dat')\n\t\tself.assertEqual(position, [0.0, 1.57079, 3.14159, 4.71238, 6.28318, 7.85398, 9.42477])\n\t\tself.assertEqual(potential, [0.0, 6.0, 0.0, -6.0, 0.0, 6.0, 0.0])","def read_parameters():\n hdulist1 = pf.open(source+'/kids_data/KiDS_DR3.1_G9_ugri_shear.fits')\n param1 = hdulist1[1].data['e1'][:sample]\n param2 = hdulist1[1].data['e2'][:sample]\n weights = hdulist1[1].data['weight'][:sample]\n return param1, param2, weights","def load_simulation_mass(self, file_name):\n \n data = np.genfromtxt(file_name, names=True)\n \n if not hasattr(self, 'simulation_data'):\n self.simulation_data = {}\n \n \n self.simulation_data['mass'] = data['m'] # assuming in solar masses\n self.simulation_data['time'] = data['t'] # assuming in millions of years","def read_input_file(self):\n\n # Check if input file exists in current directory, if not kill process\n if not os.path.isfile('./visualise.inpt'):\n print('Cannot find input file \"visualise.inpt\" in current directory')\n sys.exit()\n\n # Read input file and analysis options and parameters\n print('Reading input file')\n with open('visualise.inpt','r') as f:\n f.readline()\n self.prefix = f.readline().split()[0]\n f.readline()\n f.readline()\n self.frame = int(f.readline().split()[0])\n f.readline()\n f.readline()\n self.vis_particles = int(f.readline().split()[0])\n self.vis_vortype = int(f.readline().split()[0])\n self.vis_cellcolour = int(f.readline().split()[0])\n self.vis_save = int(f.readline().split()[0])","def read_setup(inifile):\n # inifile = os.path.join(spathy_path, inifile)\n print(inifile)\n cfg = configparser.ConfigParser()\n cfg.read(inifile)\n\n pp = {}\n for s in cfg.sections():\n section = s.encode('ascii', 'ignore')\n pp[section] = {}\n for k, v in cfg.items(section):\n key = k.encode('ascii', 'ignore')\n val = v.encode('ascii', 'ignore')\n if section == 'General': # 'general' section\n pp[section][key] = val\n else:\n pp[section][key] = float(val)\n pp['General']['dt'] = float(pp['General']['dt'])\n\n pgen = pp['General']\n pcpy = pp['CanopyGrid']\n pbu = pp['BucketGrid']\n ptop = pp['Topmodel']\n\n return pgen, pcpy, pbu, ptop","def read_results():\r\n with open(\"packing.nfo\", \"r\") as fin:\r\n fin.readline()\r\n fin.readline()\r\n por_theory = float(fin.readline().split()[2])\r\n por_final = float(fin.readline().split()[2])\r\n print('Theoretical porosity:', por_theory)\r\n print('Final porosity:', por_final)\r\n with open(\"packing.xyzd\", \"rb\") as fin:\r\n btxt = fin.read()\r\n txt = list(struct.unpack(\"<\" + \"d\" * (len(btxt) // 8), btxt))\r\n data = array(zip(*[iter(txt)] * 4))\r\n data[:, 3] = data[:, 3] * \\\r\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\r\n return data","def read_parameters(self, entry=None):\n if entry:\n self.entry = entry\n with self.entry.nxfile:\n self.name = self.entry.nxroot.nxname + \"/\" + self.entry.nxname\n if 'unit_cell' in self.entry['sample']:\n lattice_parameters = self.read_parameter('sample/unit_cell')\n if lattice_parameters is not None:\n self.a, self.b, self.c = lattice_parameters[:3]\n self.alpha, self.beta, self.gamma = lattice_parameters[3:]\n elif 'unit_cell_abc' in self.entry['sample']:\n lattice_parameters = self.read_parameter(\n 'sample/unit_cell_abc')\n if lattice_parameters is not None:\n self.a, self.b, self.c = lattice_parameters\n lattice_parameters = self.read_parameter(\n 'sample/unit_cell_alphabetagamma')\n if lattice_parameters is not None:\n self.alpha, self.beta, self.gamma = lattice_parameters\n else:\n self.a = self.read_parameter('sample/unitcell_a', self.a)\n self.b = self.read_parameter('sample/unitcell_b', self.b)\n self.c = self.read_parameter('sample/unitcell_c', self.c)\n self.alpha = self.read_parameter(\n 'sample/unitcell_alpha', self.alpha)\n self.beta = self.read_parameter(\n 'sample/unitcell_beta', self.beta)\n self.gamma = self.read_parameter(\n 'sample/unitcell_gamma', self.gamma)\n self.formula = self.read_parameter('sample/chemical_formula',\n self.formula)\n self.space_group = self.read_parameter(\n 'sample/space_group', self.space_group)\n self.laue_group = self.read_parameter(\n 'sample/laue_group', self.laue_group)\n self.wavelength = self.read_parameter(\n 'instrument/monochromator/wavelength', self.wavelength)\n self.distance = self.read_parameter('instrument/detector/distance',\n self.distance)\n self.yaw = self.read_parameter('instrument/detector/yaw', self.yaw)\n self.pitch = self.read_parameter('instrument/detector/pitch',\n self.pitch)\n self.roll = self.read_parameter(\n 'instrument/detector/roll', self.roll)\n self.xc = self.read_parameter('instrument/detector/beam_center_x',\n self.xc)\n self.yc = self.read_parameter('instrument/detector/beam_center_y',\n self.yc)\n self.xd = self.read_parameter('instrument/detector/translation_x',\n self.xd)\n self.yd = self.read_parameter('instrument/detector/translation_y',\n self.yd)\n self.frame_time = self.read_parameter(\n 'instrument/detector/frame_time', self.frame_time)\n self.shape = self.read_parameter(\n 'instrument/detector/shape', self.shape)\n phi = self.read_parameter('instrument/goniometer/phi', self.phi)\n if isinstance(phi, np.ndarray) and len(phi) > 1:\n self.phi = phi[0]\n self.phi_step = phi[1] - phi[0]\n else:\n self.phi = phi\n try:\n self.phi_step = self.read_parameter(\n 'instrument/goniometer/phi', self.phi, attr='step')\n except Exception:\n pass\n self.chi = self.read_parameter(\n 'instrument/goniometer/chi', self.chi)\n self.omega = self.read_parameter('instrument/goniometer/omega',\n self.omega)\n if 'instrument/goniometer' in self.entry:\n if 'theta' in self.entry['instrument/goniometer']:\n self.theta = self.read_parameter(\n 'instrument/goniometer/theta', self.theta)\n elif 'goniometer_pitch' in self.entry['instrument/goniometer']:\n self.theta = self.read_parameter(\n 'instrument/goniometer/goniometer_pitch', self.theta)\n elif 'gonpitch' in self.entry['instrument/goniometer']:\n self.theta = self.read_parameter(\n 'instrument/goniometer/gonpitch', self.theta)\n self.symmetry = self.read_parameter('sample/unit_cell_group',\n self.symmetry)\n self.centring = self.read_parameter('sample/lattice_centring',\n self.centring)\n self.xp = self.read_parameter('peaks/x')\n self.yp = self.read_parameter('peaks/y')\n self.zp = self.read_parameter('peaks/z')\n self.polar_angle = self.read_parameter('peaks/polar_angle')\n self.azimuthal_angle = self.read_parameter('peaks/azimuthal_angle')\n self.intensity = self.read_parameter('peaks/intensity')\n self.pixel_size = self.read_parameter(\n 'instrument/detector/pixel_size', self.pixel_size)\n self.pixel_mask = self.read_parameter(\n 'instrument/detector/pixel_mask')\n self.pixel_mask_applied = self.read_parameter(\n 'instrument/detector/pixel_mask_applied')\n self.rotation_angle = self.read_parameter('peaks/rotation_angle')\n self.primary = self.read_parameter('peaks/primary_reflection')\n self.secondary = self.read_parameter('peaks/secondary_reflection')\n self.Umat = self.read_parameter(\n 'instrument/detector/orientation_matrix')\n if isinstance(self.polar_angle, np.ndarray):\n try:\n self.set_polar_max(np.sort(self.polar_angle)[200] + 0.1)\n except IndexError:\n self.set_polar_max(self.polar_angle.max())\n else:\n self.set_polar_max(10.0)\n self.Qh = self.read_parameter('transform/Qh')\n self.Qk = self.read_parameter('transform/Qk')\n self.Ql = self.read_parameter('transform/Ql')\n self.initialize_peaks()","def read_params():\n \n # Get the input list\n params = argv\n params.pop(0)\n \n #Check if quoting is necessary\n params = check_double_quote(params)\n \n # Declare input file\n fin = read_item(params, '-s=', './opt_probl.txt')\n # Find standard output directory\n fout = read_item(params, '-d=', './opt_sol.txt')\n \n return ( fin, fout )","def read_from(self, filename):\n self.x, self.y = np.loadtxt(filename, unpack=True, usecols=(0, 1))","def _read_config_file(self):\n wcec = 0\n deadline = 0\n jitter = 0\n init_freq = 0\n freqs_volt = {}\n freqs = []\n volts = []\n config_file_name = self._find_file('sim_simple.config')\n with open(config_file_name, 'rU') as f:\n lines = f.readlines()\n try:\n for freq in lines[0].split():\n freqs.append(float(freq))\n\n for volt in lines[1].split():\n volts.append(float(volt))\n\n for i in range(0, len(freqs)):\n freqs_volt[freqs[i]] = volts[i]\n\n data = lines[2].split()\n wcec = float(data[0])\n deadline = float(data[1])\n period = float(data[2])\n jitter = float(data[3])\n init_freq = float(data[4])\n except ValueError, IndexError:\n print 'Invalid data in config file'\n sys.exit(1)\n\n return wcec, deadline, period, jitter, init_freq, freqs_volt","def read_params(fname):\n f = open(fname, 'r')\n par = {} #output\n for i in range(10): # esta dentro de las primeras 10 lineas\n l = f.readline().split()\n #print \" ---> \", l\n number = u'%s' % l[-1] # presumably a number\n if not number.replace('.','').replace('-','').isnumeric():\n if l[0]=='#####':\n break\n else:\n continue # we proceed ONLY IF this is numeric string\n #print ' FIRST: ', l[0]\n if l[0]=='#####':\n #print \"IM I HERE????\"\n break # end of header\n\n name = l[1][:-1] # l[0] es '#', y -1 para comernos el \":\"\n value = np.float(l[2]) # l[2] es el valor\n par[name] = value\n\n return par","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=4,\n task=4,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.01,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"fat-tail\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(\n params[key],\n actual_sim_parameters[key],\n msg=\"Error in {}: {}!={}\".format(key, params[key], actual_sim_parameters[key]),\n )\n self.assertEqual(self.tree.get_job()[0], 4, msg=\"Job number not stored correctly.\")\n self.assertEqual(self.tree.get_job()[1], 4, msg=\"Job number not stored correctly.\")","def ReadParameterFile(pf):\n f = open(pf, \"r\")\n pf_dict = SetDefaultParameterValues()\n for line in f:\n if not line.split(): \n continue\n if line.split()[0][0] == \"#\": \n continue\n \n # This will prevent crashes if there is not a blank line at the end of the parameter file\n if line[-1] != '\\n': \n line += '\\n'\n \n # Cleave off end-of-line comments.\n line = line[:line.rfind(\"#\")].strip()\n \n # Read in the parameter name and the parameter value(s).\n parname, eq, parval = line.partition(\"=\")\n \n # Else, actually read in the parameter \n try: \n parval = float(parval)\n except ValueError:\n if re.search('/', parval): # For directory with more than one level\n parval = str(parval.strip())\n elif parval.strip().isalnum(): \n parval = str(parval.strip())\n elif parval.replace('_', '').strip().isalnum():\n parval = parval.strip()\n elif parval.partition('.')[-1] in ['dat', 'hdf5', 'h5', 'txt']:\n parval = str(parval.strip())\n else:\n parval = parval.strip().split(\",\")\n tmp = [] \n if parval[0][0] == '(':\n for element in parval: \n if element.strip(\" (,)\").isdigit(): \n tmp.append(float(element.strip(\"(,)\")))\n else: \n tmp.append(element.strip(\" (,)\"))\n parval = tuple(tmp) \n elif parval[0][0] == '[':\n for element in parval: \n tmp.append(float(element.strip(\"[,]\")))\n parval = list(tmp)\n else:\n print(parname, parval)\n raise ValueError('The format of this parameter is not understood.')\n \n pf_dict[parname.strip()] = parval\n \n return pf_dict","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=3,\n task=3,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"none\",\n coarse_map_x=13,\n coarse_map_y=13,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 3)\n self.assertEqual(self.tree.get_job()[1], 3)","def load_params():\n with open('params.p', mode='rb') as in_file:\n return pickle.load(in_file)","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=1,\n task=30,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"tiled_coarse\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 1)\n self.assertEqual(self.tree.get_job()[1], 30)","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=7,\n task=4,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=1.0,\n deme=0.01,\n sample_size=1.5,\n max_time=3600.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(\n params[key],\n actual_sim_parameters[key],\n msg=\"Error in {}: {}!={}\".format(key, params[key], actual_sim_parameters[key]),\n )\n self.assertEqual(self.tree.get_job()[0], 7, msg=\"Seed not stored correctly.\")\n self.assertEqual(self.tree.get_job()[1], 4, msg=\"Job number not stored correctly.\")","def load_dat(file_name):\n data = loadmat(file_name)\n y = data['y']\n X = data['X']\n return X,y","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=5,\n task=4,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=1.0,\n deme=0.25,\n sample_size=1.0,\n max_time=3600.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(\n params[key],\n actual_sim_parameters[key],\n msg=\"Error in {}: {}!={}\".format(key, params[key], actual_sim_parameters[key]),\n )\n self.assertEqual(self.tree.get_job()[0], 5, msg=\"Seed not stored correctly.\")\n self.assertEqual(self.tree.get_job()[1], 4, msg=\"Job number not stored correctly.\")","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=2,\n task=2,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=1.0,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"null\",\n coarse_map_x=20,\n coarse_map_y=20,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"null\",\n fine_map_x=10,\n fine_map_y=10,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=10,\n grid_y=10,\n sample_x=10,\n sample_y=10,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=1.0,\n cutoff=0.0,\n landscape_type=\"infinite\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 2)\n self.assertEqual(self.tree.get_job()[1], 2)","def read_config_file():\n config = ConfigParser()\n config.read('config.ini')\n\n # Get the model parameters as correct type\n batch_size = config.getint('model params', 'batch_size')\n resize_to = config.getint('model params', 'resize_to')\n train_prop = config.getfloat('model params', 'train_prop')\n\n return batch_size, resize_to, train_prop","def read_xyz(self, filename):\n # first line contains number of atoms\n self.numatom = int(filename.readline().split()[0])\n # second line contains a comment\n self.comment = filename.readline()[:-3]\n # rest of the lines contain coordinates structured Element X Y Z\n string = \"Element X Y Z \\n\" + filename.read()\n self.contents = pd.read_table(StringIO(string), sep=r'\\s+')","def read_seed_parameters():\n\n with open(\"../../output/seed.tmp\", \"r\") as f:\n seed = int(f.readline())\n samples = int(f.readline())\n return (seed, samples)","def readInput(in_file_name):\n in_file = open(in_file_name, 'r')\n positions = []\n samples = []\n M = []; P = [];\n MC = []; PC = [];\n while True:\n line = in_file.readline()\n if not line: break\n if line[0] == '#': continue #skip comment\n line = line.rstrip('\\n').split('\\t')\n \n #genomic positions and allele support in plasma samples\n positions.append(int(line[0]))\n samples.append(tuple(map(int, line[1:5])))\n \n #maternal and paternal alleles\n M.append(tuple(line[5:7]))\n MC.append(tuple(map(float, line[7:9])))\n \n P.append(tuple(line[9:11]))\n PC.append(tuple(map(float, line[11:13]))) \n \n in_file.close()\n return positions, samples, M, P, MC, PC","def readInstance(self):\n file = open(self.fName, 'r')\n self.genSize = int(file.readline())\n self.data = {}\n for line in file:\n (id, x, y) = line.split()\n self.data[int(id)] = (int(x), int(y))\n file.close()","def readOutputfile(filename, verbose=False):\n\n # -----------------------------------------------------------------------------\n # Defining the classes for data structure\n T_Simulation = namedtuple('Simulation', ['step'])\n T_Step = namedtuple('Step', ['element', 'node'])\n\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\n\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\n T_GP = namedtuple('GP', ['stress', 'strain'])\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\n # -----------------------------------------------------------------------------\n\n nSteps = 0 # Simulation step counter\n\n SimData = T_Simulation(list())\n\n with open(filename) as f:\n line = f.readline() # Read in the first line of the input file\n while True: # Loop over all lines of the input file\n # Read the nodes displacements\n #line = f.readline()\n #print(line)\n if line == 'DofManager output:\\n': # String starts a list of nodes displacement information\n nSteps += 1 # The above string starts a new simulation step\n line = f.readline() # Cancel ---------- seperator\n line = f.readline()\n Nodes = list() # Initialize/clear list of nodes\n\n while line != '\\n' and line != 'Element output:\\n': # Strings that finish the list\n #\t\t\t\tnNode = int(line.strip().split()[1]) # Node id\n line = f.readline()\n dim1 = float(line.strip().split()[3]) # Displacement dim1\n line = f.readline()\n dim2 = float(line.strip().split()[3]) # Displacement dim2\n Nodes.append(\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\n line = f.readline()\n\n\n if verbose:\n print('Step {}: Dofs completed.\\n'.format(nSteps))\n print('---------------------------------\\n')\n\n # Read the stresses an strains at Gauss points\n elif line == 'Element output:\\n': # String starts a list elements, GPs, strains and stresses\n line = f.readline() # Cancel ---------- seperator\n line = f.readline()\n Elements = list() # Initialize/clear list of elements\n\n while line != '\\n' and line != '\\tR E A C T I O N S O U T P U T:\\n': # Strings that finish the list\n #\t\t\t\t\tnElement = line.strip().split()[2] # Element id\n line = f.readline()\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\n\n while line != '\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\n #\t\t\t\t\t\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\n line = f.readline()\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\n GPs.gp.append(\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\n line = f.readline()\n\n\n Elements.append(GPs) # Append GP list of the current element to the element list\n\n if verbose:\n print('Step {}: GPs completed.\\n'.format(nSteps))\n print('---------------------------------\\n')\n\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\n #print('the file input ends')\n #print(nSteps)\n # only needed with a while loop\n # Jump over the lines until we reach the next time step (Caught by if-clause)\n try:\n line = f.readline() # Will generate an error if files end is reached\n if line == \"\":\n raise EOFError\n except:\n if verbose: print(\"End of file reached.\\n\")\n break # Break the 'while True' loop\n\n # -----------------------------------------------------------------------------\n\n\n print('averaging the stress')\n # Averaging of strains and stress of GPs of each element\n for istep in range(len(SimData.step)):\n\n for ielement in range(len(SimData.step[istep].element)):\n print(len)\n # Initialization before each element\n stresses = np.array([0., 0., 0., 0., 0., 0.])\n strains = np.array([0., 0., 0., 0., 0., 0.])\n\n for igp in range(len(SimData.step[istep].element[ielement])):\n print(igp)\n # Add up all data of all GPs\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\n\n # Divide GP sum by number of GPs\n stresses /= len(SimData.step[istep].element[ielement])\n strains /= len(SimData.step[istep].element[ielement])\n # Replace the field (initialized with 0) with new information\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\n print('Analysis finished')\n return SimData","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=1,\n task=29,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"none\",\n coarse_map_x=13,\n coarse_map_y=13,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"tiled_fine\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\"Error in {}\".format(key))\n self.assertEqual(self.tree.get_job()[0], 1)\n self.assertEqual(self.tree.get_job()[1], 29)","def loadNodes(self, fname):\r\n with open(fname, \"r\") as fp:\r\n\r\n # Read in the header\r\n for line in fp:\r\n item = line.split()\r\n if len(item) > 0:\r\n if item[0] == \"SPECGRID\":\r\n self.SPECGRID = np.array(fp.readline().split()[0:3], dtype=int)\r\n if item[0] == \"COORDSYS\":\r\n self.COORDSYS = fp.readline().split()\r\n if item[0] == \"COORD\":\r\n break\r\n\r\n # Read in the coordinates\r\n self.coords = []\r\n for line in fp:\r\n if line.split()[-1] != \"/\":\r\n item = line.split()\r\n for c in item:\r\n if '*' in c:\r\n cc = c.split('*')\r\n for i in range(int(cc[0])):\r\n self.coords.append(cc[-1])\r\n else:\r\n self.coords.append(c)\r\n else:\r\n if len(line.split()) > 1:\r\n item = line.split()\r\n for i in range(len(item) - 1):\r\n cc = item[i]\r\n if '*' in cc:\r\n ccc = cc.split('*')\r\n for j in range(int(ccc[0])):\r\n self.coords.append(ccc[-1])\r\n else:\r\n self.coords.append(c)\r\n break\r\n else:\r\n break\r\n\r\n # Read in ZCORN\r\n self.zcorn = []\r\n i = 0\r\n for line in fp:\r\n item = line.split()\r\n if len(item) > 0:\r\n if item[0] == \"ZCORN\":\r\n for line in fp:\r\n if line.split():\r\n if line.split()[-1] != \"/\":\r\n self.zcorn += line.split()\r\n else:\r\n self.zcorn += line.split()[0:-1]\r\n break\r\n if len(self.zcorn) > 0:\r\n break\r\n\r\n # Read in (in)active cells\r\n self.active = []\r\n for line in fp:\r\n item = line.split()\r\n if len(item) > 0:\r\n if item[0] == \"ACTNUM\":\r\n for line in fp:\r\n if line.split():\r\n if line.split()[-1] != \"/\":\r\n c = line.split()\r\n if '*' in c:\r\n cc = c.split('*')\r\n for i in range(float(cc[0])):\r\n self.active += cc[-1]\r\n else:\r\n self.active += c\r\n else:\r\n self.active += line.split()[0:-1]\r\n break\r\n\r\n self.coords = np.array(self.coords, dtype=float)\r\n print(self.coords)\r\n\r\n # In Petrel...\r\n self.ne = self.SPECGRID[0] # x i\r\n self.nn = self.SPECGRID[1] # y j\r\n self.nz = self.SPECGRID[2] # z k\r\n\r\n # build grid\r\n self.buildGrid(plot=False)\r\n self.buildActiveCells(plot=False)\r\n self.buildZGrid(plot=False)\r\n # self.calculateVolumes(plot=False)\r\n #\r\n # Convert to VTK\r\n self.GridType = \"vtkStructuredGrid\"\r\n self.Grid = vtk.vtkStructuredGrid()\r\n self.Grid.SetDimensions(self.ne+1, self.nn+1, self.nz+1)\r\n vtk_points = vtk.vtkPoints()\r\n ve = 1.\r\n\r\n for iz in range(self.nz):\r\n if iz == 0:\r\n for iy in range(self.nn+1):\r\n for ix in range(self.ne+1):\r\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\r\n self.Y0[ix,iy], \\\r\n ve * self.ZZT[iz][ix,iy] )\r\n for iy in range(self.nn+1):\r\n for ix in range(self.ne+1):\r\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\r\n self.Y0[ix,iy], \\\r\n ve * self.ZZB[iz][ix,iy] )\r\n self.Grid.SetPoints(vtk_points)\r\n\r\n # Add in active cells\r\n ac = vtk.vtkIntArray()\r\n ac.SetName( \"ActiveCells\" )\r\n for iac in self.ActiveCells.flatten( order='F' ):\r\n ac.InsertNextTuple1( iac )\r\n self.Grid.GetCellData().AddArray(ac)","def read_data(self,filename):\n self.x = [] #Input values\n self.t = [] #Target values\n\n with open(filename, \"r\") as infile:\n lines = infile.readlines()\n self.n = len(lines)\n for line in lines:\n words = line.split()\n self.x.append(float(words[0]))\n self.t.append(float(words[1]))\n\n self.x = np.array(self.x)\n self.t = np.array(self.t)\n self.create_design_matrix()","def readParameterfile(self, filename):\n return None","def read_input_file():\n \n global input\n \n config = ConfigParser.RawConfigParser()\n config.read(os.path.join(os.getcwd(), 'INPUT.cfg'))\n\n input = {}\n input['datapath'] = config.get('Address_info', 'datapath')\n input['inter_address'] = config.get('Address_info', 'interactive_address')\n input['target_folder'] = config.get('Address_info', 'target_folder')\n input['save_folder'] = config.get('Address_info', 'save_folder')\n \n if not os.path.isabs(input['datapath']):\n input['datapath'] = os.path.join(os.getcwd(), input['datapath'])\n \n if not os.path.isabs(input['inter_address']):\n input['inter_address'] = os.path.join(os.getcwd(), input['inter_address'])\n \n if not os.path.isabs(input['target_folder']):\n input['target_folder'] = os.path.join(os.getcwd(), input['target_folder'])\n \n if not os.path.isabs(input['save_folder']):\n input['save_folder'] = os.path.join(os.getcwd(), input['save_folder'])\n \n \n input['min_date'] = str(eval(config.get('Event_Request', 'min_datetime')))\n input['max_date'] = str(eval(config.get('Event_Request', 'max_datetime')))\n input['min_mag'] = config.getfloat('Event_Request', 'min_magnitude')\n input['max_mag'] = config.getfloat('Event_Request', 'max_magnitude')\n input['min_depth'] = config.getfloat('Event_Request', 'min_depth')\n input['max_depth'] = config.getfloat('Event_Request', 'max_depth')\n input['evlonmin'] = config.getfloat('Event_Request', 'evlonmin')\n input['evlonmax'] = config.getfloat('Event_Request', 'evlonmax')\n input['evlatmin'] = config.getfloat('Event_Request', 'evlatmin')\n input['evlatmax'] = config.getfloat('Event_Request', 'evlatmax')\n input['preset'] = config.getfloat('Event_Request', 'preset')\n input['offset'] = config.getfloat('Event_Request', 'offset')\n input['max_result'] = config.getint('Event_Request', 'max_results')\n \n input['get_events'] = config.get('Request', 'get_events')\n input['input_period'] = config.get('Parallel', 'input_period')\n input['IRIS'] = config.get('Request', 'IRIS')\n input['ArcLink'] = config.get('Request', 'ArcLink')\n input['time_iris'] = config.get('Request', 'time_iris')\n input['time_arc'] = config.get('Request', 'time_arc')\n \n input['nodes'] = config.get('Parallel', 'nodes')\n\n input['waveform'] = config.get('Request', 'waveform')\n input['response'] = config.get('Request', 'response')\n input['SAC'] = config.get('Request', 'SAC')\n \n input['net'] = config.get('specifications_request', 'network')\n input['sta'] = config.get('specifications_request', 'station')\n \n if config.get('specifications_request', 'location') == \"''\":\n input['loc'] = ''\n elif config.get('specifications_request', 'location') == '\"\"':\n input['loc'] = ''\n else:\n input['loc'] = config.get('specifications_request', 'location')\n \n input['cha'] = config.get('specifications_request', 'channel')\n\n if config.get('specifications_request', 'lat') == 'None':\n input['lat_cba'] = None\n else:\n input['lat_cba'] = config.get('specifications_request', 'lat')\n \n if config.get('specifications_request', 'lon') == 'None':\n input['lon_cba'] = None\n else:\n input['lon_cba'] = config.get('specifications_request', 'lon')\n \n if config.get('specifications_request', 'minradius') == 'None':\n input['mr_cba'] = None\n else:\n input['mr_cba'] = config.get('specifications_request', 'minradius')\n \n if config.get('specifications_request', 'maxradius') == 'None':\n input['Mr_cba'] = None\n else:\n input['Mr_cba'] = config.get('specifications_request', 'maxradius')\n \n \n if config.get('specifications_request', 'minlat') == 'None':\n input['mlat_rbb'] = None\n else:\n input['mlat_rbb'] = config.get('specifications_request', 'minlat')\n \n if config.get('specifications_request', 'maxlat') == 'None':\n input['Mlat_rbb'] = None\n else:\n input['Mlat_rbb'] = config.get('specifications_request', 'maxlat')\n \n if config.get('specifications_request', 'minlon') == 'None':\n input['mlon_rbb'] = None\n else:\n input['mlon_rbb'] = config.get('specifications_request', 'minlon')\n \n if config.get('specifications_request', 'maxlon') == 'None':\n input['Mlon_rbb'] = None\n else:\n input['Mlon_rbb'] = config.get('specifications_request', 'maxlon')\n\n \n input['test'] = config.get('test', 'test')\n input['test_num'] = config.getint('test', 'test_num')\n \n input['update_interactive'] = config.get('update', 'update_interactive')\n input['iris_update'] = config.get('update', 'iris_update')\n input['arc_update'] = config.get('update', 'arc_update')\n\n input['QC_IRIS'] = config.get('QC', 'QC_IRIS')\n input['QC_ARC'] = config.get('QC', 'QC_ARC')\n \n input['email'] = config.get('email', 'email')\n input['email_address'] = config.get('email', 'email_address')\n \n input['report'] = config.get('report', 'report')\n \n input['corr_unit'] = config.get('instrument_correction', 'corr_unit')\n input['pre_filt'] = config.get('instrument_correction', 'pre_filter')\n \n input['plt_event'] = config.get('ObsPyPT', 'plot_event')\n input['plt_sta'] = config.get('ObsPyPT', 'plot_sta')\n input['plt_ray'] = config.get('ObsPyPT', 'plot_ray')\n\n input['llcrnrlon'] = config.getfloat('ObsPyPT', 'llcrnrlon')\n input['urcrnrlon'] = config.getfloat('ObsPyPT', 'urcrnrlon')\n input['llcrnrlat'] = config.getfloat('ObsPyPT', 'llcrnrlat')\n input['urcrnrlat'] = config.getfloat('ObsPyPT', 'urcrnrlat')\n \n input['lon_0'] = config.getfloat('ObsPyPT', 'lon_0')\n input['lat_0'] = config.getfloat('ObsPyPT', 'lat_0')","def get_params(param_file_path):\n\n config = ConfigParser.SafeConfigParser()\n config.read(param_file_path)\n\n # Get \"raw\" dictionaries from `config` object\n raw_params = dict(config.items('general'))\n raw_cosmo_params = dict(config.items('cosmology'))\n raw_io_params = dict(config.items('io'))\n raw_binning_params = dict(config.items('binning'))\n raw_maps_to_stack_params = dict(config.items('maps_to_stack'))\n raw_map_path_params = dict(config.items('map_path'))\n raw_map_file_params = dict(config.items('map_file'))\n raw_noise_path_params = dict(config.items('map_path'))\n raw_noise_file_params = dict(config.items('noise_file'))\n raw_beams_params = dict(config.items('beams'))\n raw_color_correction_params = dict(config.items('color_correction'))\n raw_catalogs_params = dict(config.items('catalogs'))\n\n raw_io_params['param_file_path'] = os.path.abspath(param_file_path) # Store parameter file path\n\n # Convert \"raw\" config dictionary to \"organized\" dictionary `params`\n params = get_general_params(raw_params) \n params['io'] = get_io_parameters(raw_io_params)\n params['cosmo'] = get_cosmology_parameters(raw_cosmo_params)\n params['map_files'] = get_maps_parameters(raw_maps_to_stack_params,raw_map_path_params,raw_map_file_params)\n params['noise_files'] = get_maps_parameters(raw_maps_to_stack_params,raw_noise_path_params,raw_noise_file_params)\n params['wavelength'] = get_wavelength_parameters(raw_maps_to_stack_params)\n params['psfs'] = get_beams_parameters(raw_maps_to_stack_params,raw_beams_params)\n params['color_correction'] = get_color_correction_parameters(raw_maps_to_stack_params,raw_color_correction_params)\n params['catalogs'] = get_catalogs_parameters(raw_catalogs_params)\n params['bins'] = get_binning_parameters(raw_binning_params)\n params['library_keys'] = params['map_files'].keys()\n\n logging.info(\"---------- PARAMETER VALUES ----------\")\n logging.info(\"======================================\")\n logging.info(\"\\n\" + pprint.pformat(params, indent=4) + \"\\n\")\n\n #pdb.set_trace()\n return params","def load_info():\n data = np.loadtxt(\"u_sol_meta.txt\", dtype=int)\n return data","def read_velocities(filename, return_grid=True, return_proj=False):\n ds = gdal.Open(filename)\n #Get dimensions\n nc = ds.RasterXSize\n nr = ds.RasterYSize\n \n geotransform = ds.GetGeoTransform()\n xOrigin = geotransform[0]\n xPix = geotransform[1] #pixel width in x-direction\n yOrigin = geotransform[3]\n yPix = geotransform[5] #pixel height in y-direction\n \n lons = xOrigin + np.arange(0, nc)*xPix\n lats = yOrigin + np.arange(0, nr)*yPix\n \n x, y = np.meshgrid(lons, lats)\n \n vband = ds.GetRasterBand(1)\n varr = vband.ReadAsArray()\n \n if return_grid and return_proj:\n return x, y, varr, ds.GetProjection()\n elif return_grid:\n return x, y, varr\n else: \n return varr","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=1,\n task=1,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=1.0,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"null\",\n coarse_map_x=20,\n coarse_map_y=20,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"null\",\n fine_map_x=10,\n fine_map_y=10,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=10,\n grid_y=10,\n sample_x=10,\n sample_y=10,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"fat-tail\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"infinite\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key])\n self.assertEqual(self.tree.get_job()[0], 1)\n self.assertEqual(self.tree.get_job()[1], 1)","def loadSimData(datafile):\n \n global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \\\n dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure \n\n datafile = open(datafile,\"r\")\n for line in datafile:\n A = line.split()\n if A[0] == \"dt\": # Time interval between MD steps\n dt = float(A[-1])\n elif A[0] == \"ti\": # Beginning time for data acquisition\n ti = float(A[-1])\n elif A[0] == \"Lx\": # Box size in x\n Lx = float(A[-1]) \n elif A[0] == \"Ly\": # Box size in y\n Ly = float(A[-1])\n elif A[0] == \"totalStep\": # Total MD steps\n totalStep = float(A[-1])\n elif A[0] == \"nsamp\": # Data sampling frequency\n nsamp = float(A[-1])\n elif A[0] == \"nfil\": # Number of particles per polymer\n N = float(A[-1])\n elif A[0] == \"L\": # Number of particles\n L = float(A[-1])\n elif A[0] == \"B\": # Bond length between particles of a body\n B = float(A[-1])\n elif A[0] == \"kT\": # Boltzmann constant*Temperature\n kT = float(A[-1])\n elif A[0] == \"Fmc\": # Self propulsion force constant\n Fmc = float(A[-1]) \n elif A[0] == \"Kbend\": # Bending constant\n Kbend = float(A[-1])\n \n Lx /= B\n Ly /= B\n M = L/N\n dtSamp = dt*nsamp\n T = totalStep - ti\n nt = T/nsamp\n box_area = Lx*Ly\n body_length = B*(N-1)\n Pe = Fmc*body_length**2/kT\n persistence = Kbend/(kT*body_length)\n flexure = Pe/persistence","def loadSimData(datafile):\n \n global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \\\n dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure \n\n datafile = open(datafile,\"r\")\n for line in datafile:\n A = line.split()\n if A[0] == \"dt\": # Time interval between MD steps\n dt = float(A[-1])\n elif A[0] == \"ti\": # Beginning time for data acquisition\n ti = float(A[-1])\n elif A[0] == \"Lx\": # Box size in x\n Lx = float(A[-1]) \n elif A[0] == \"Ly\": # Box size in y\n Ly = float(A[-1])\n elif A[0] == \"totalStep\": # Total MD steps\n totalStep = float(A[-1])\n elif A[0] == \"nsamp\": # Data sampling frequency\n nsamp = float(A[-1])\n elif A[0] == \"nfil\": # Number of particles per polymer\n N = float(A[-1])\n elif A[0] == \"L\": # Number of particles\n L = float(A[-1])\n elif A[0] == \"B\": # Bond length between particles of a body\n B = float(A[-1])\n elif A[0] == \"kT\": # Boltzmann constant*Temperature\n kT = float(A[-1])\n elif A[0] == \"Fmc\": # Self propulsion force constant\n Fmc = float(A[-1]) \n elif A[0] == \"Kbend\": # Bending constant\n Kbend = float(A[-1])\n \n L = int(L)\n N = int(N)\n Lx /= B\n Ly /= B\n M = L/N\n dtSamp = dt*nsamp\n T = totalStep - ti\n nt = T/nsamp\n box_area = Lx*Ly\n body_length = B*(N-1)\n Pe = Fmc*body_length**2/kT\n persistence = Kbend/(kT*body_length)\n flexure = Pe/persistence\n \n return","def read(self, **kwargs):\n\n if not os.path.isfile(self.file_name):\n self.build()\n elif 'clobber' in self.kwargs.keys():\n if self.kwargs['clobber']: \n self.build()\n\n # read dLOS file from parent class\n super(DlosPhotoz, self).read()\n\n self.dlos, self.dlos_photoz = np.loadtxt(\n self.file_name, \n skiprows=1, \n unpack=True, \n usecols=[0, 1]\n )\n return None","def loadSimData(datafile):\n \n global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \\\n dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure \n\n datafile = open(datafile,\"r\")\n for line in datafile:\n A = line.split()\n if A[0] == \"dt\": # Time interval between MD steps\n dt = float(A[-1])\n elif A[0] == \"ti\": # Beginning time for data acquisition\n ti = float(A[-1])\n elif A[0] == \"Lx\": # Box size in x\n Lx = float(A[-1]) \n elif A[0] == \"Ly\": # Box size in y\n Ly = float(A[-1])\n elif A[0] == \"totalStep\": # Total MD steps\n totalStep = float(A[-1])\n elif A[0] == \"nsamp\": # Data sampling frequency\n nsamp = float(A[-1])\n elif A[0] == \"nfil\": # Number of particles per polymer\n N = int(float(A[-1]))\n elif A[0] == \"L\": # Number of particles\n L = int(float(A[-1]))\n elif A[0] == \"B\": # Bond length between particles of a body\n B = float(A[-1])\n elif A[0] == \"kT\": # Boltzmann constant*Temperature\n kT = float(A[-1])\n elif A[0] == \"Fmc\": # Self propulsion force constant\n Fmc = float(A[-1]) \n elif A[0] == \"Kbend\": # Bending constant\n Kbend = float(A[-1])\n \n Lx /= B\n Ly /= B\n M = L/N\n dtSamp = dt*nsamp\n T = totalStep - ti\n nt = T/nsamp\n box_area = Lx*Ly\n body_length = B*(N-1)\n Pe = Fmc*body_length**2/kT\n persistence = Kbend/(kT*body_length)\n flexure = Pe/persistence","def read_from_file(self,grd_fn):\n self.grd_fn = grd_fn\n self.fp = open(self.grd_fn,'rt')\n hdr = self.fp.readline().strip() #header &GRD_2008 or &LISTGRD\n\n if hdr == self.hdr_08:\n print( \"Will read 2008 format for grid\" )\n n_parms = 11\n elif hdr == self.hdr_old:\n print( \"Will read old UnTRIM grid format\" )\n n_parms = 10\n\n for i in range(n_parms): # ignore TNE and TNS in new format files\n l = self.fp.readline()\n lhs,rhs = l.split('=')\n val = rhs.strip().strip(',')\n varname = lhs.strip()\n print( \"%s=%s\"%(varname,val) )\n\n if varname=='NV':\n Nvertices = int(val)\n elif varname=='NE':\n Npolys = int(val)\n elif varname=='NS':\n Nsides = int(val)\n elif varname=='NBC':\n Nboundary_poly = int(val)\n elif varname=='NSI':\n Ninternal_sides = int(val)\n elif varname=='NSF':\n Nflow_sides = int(val)\n elif varname=='NBC':\n Nbc = int(val)\n elif varname=='ANGLE':\n self.angle = float(val)\n elif varname=='LOCATION':\n self.location = val\n elif varname=='NR': ## these are read, but not used\n Nred = int(val)\n elif varname=='TNE':\n TNE=int(val)\n elif varname=='TNS':\n TNS=int(val)\n # others: HLAND for older fmt.\n \n while 1:\n s = self.fp.readline().strip() # header: /\n if s == '/':\n break\n\n # We know the size of everything, and can ask UnstructuredGrid to allocate\n # arrays now, with the 'special' meaning that passing an integer means allocate\n # the array of that size, full of zeros.\n # this allocates\n # self.nodes, self.edges, self.cells\n self.from_simple_data(points = Nvertices,edges = Nsides, cells = Npolys)\n\n for v in range(Nvertices):\n Cv = self.fp.readline().split()\n if hdr == self.hdr_08:\n vertex_num = int(Cv.pop(0))\n if vertex_num != v+1:\n print( \"Mismatched vertex numbering: %d != %d\"%(vertex_num,v+1) )\n self.nodes['x'][v,0] = float(Cv[0])\n self.nodes['x'][v,1] = float(Cv[1])\n \n print( \"Npolys\",Npolys )\n self.cells['edges'] = self.UNKNOWN # initialize all\n self.cells['nodes'] = self.UNKNOWN\n \n for c in range(Npolys):\n l = self.fp.readline()\n Cp = l.split()\n if hdr == self.hdr_08:\n poly_num = int(Cp.pop(0))\n if poly_num-1 != c:\n print( \"Mismatched polygon id: %fd != %d\"%(poly_num,c+1) )\n \n numsides = int(Cp[0])\n\n self.cells['_center'][c,0] = float(Cp[1])\n self.cells['_center'][c,1] = float(Cp[2])\n\n if hdr == self.hdr_old:\n # vertex index is Cp[3,5,7,9]\n # the others, 4,6,8,10, are edges, right?\n # convert to 0 based indices here\n\n # This is probably wrong! I think it's actually reading the\n # sides\n self.cells['edges'][c,0] = int(Cp[4]) - 1\n self.cells['edges'][c,1] = int(Cp[6]) - 1 \n self.cells['edges'][c,2] = int(Cp[8]) - 1\n if numsides == 4:\n self.cells['edges'][c,3] = int(Cp[10]) - 1 \n else:\n self.cells['edges'][c,3]=self.UNDEFINED\n #HERE - need to copy that to self.cells['nodes']\n else:\n for ei in range(numsides):\n self.cells['nodes'][c,ei] = int(Cp[3+ei]) - 1\n self.cells['edges'][c,ei] = int(Cp[3+numsides+ei]) - 1\n self.cells['nodes'][c,numsides:]=self.UNDEFINED\n self.cells['edges'][c,numsides:]=self.UNDEFINED\n \n # choose some large, above-sea-level depth\n self.cells['depth_mean'] = -1000 # not sure this is doing anything...\n\n for e in range(Nsides):\n Cs = self.fp.readline().split()\n if hdr == self.hdr_08:\n # side num = int(Cs.pop(0))\n Cs.pop(0)\n elif hdr == self.hdr_old:\n # side depth?\n edge_depth = self.edges['depth_mean'][e] = float(Cs.pop(0))\n \n self.edges['nodes'][e,0] = int(Cs[0])-1 # vertex indices\n self.edges['nodes'][e,1] = int(Cs[1])-1\n \n self.edges['cells'][e,0] = int(Cs[2])-1 # cell neighbors\n self.edges['cells'][e,1] = int(Cs[3])-1\n\n if hdr == self.hdr_old:\n for nc in self.edges['cells'][e]:\n if nc >= 0 and edge_depth > self.cells['depth_mean'][nc]:\n self.cells['depth_mean'][nc] = edge_depth\n\n if hdr==self.hdr_old:\n # old format - have to infer cell nodes from edges\n self.make_cell_nodes_from_edge_nodes()\n\n # Try to make sense of the marks and red/black:\n self.cells['red'][:Nred] = True\n self.cells['mark'][:Nboundary_poly] = self.BOUNDARY\n self.edges['mark'][:Ninternal_sides] = 0\n self.edges['mark'][Ninternal_sides:Nflow_sides] = self.FLOW\n self.edges['mark'][Nflow_sides:] = self.LAND\n\n # Bathymetry:\n if hdr == self.hdr_08:\n # make a cheap tokenizer to read floats across lines\n # note that it's up to the user to know that all values from\n # the line are read, and not to get the iterator until you're\n # ready for some values to be read\n def tokenizer():\n while True:\n for item in self.fp.readline().split():\n yield item\n for c in range(Npolys):\n check_c,nis = [int(s) for s in self.fp.readline().split()]\n if check_c != c+1:\n print(\"ERROR: while reading cell subgrid, cell index mismatch: %s vs. %d\"%(c+1,check_c))\n \n next_token = tokenizer().next\n areas = np.array( [float(next_token()) for sg in range(nis)] )\n depths = np.array( [float(next_token()) for sg in range(nis)] )\n \n self.cells['depth_mean'][c] = np.sum(areas*depths) / np.sum(areas)\n self.cells['_area'][c] = np.sum(areas)\n self.cells['depth_max'][c] = depths.max()\n self.cells['subgrid'][c] = (areas,depths)\n for e in range(Nflow_sides):\n l = self.fp.readline()\n # print \"%d/%d - Read line: %s\"%(e,self.Nsides,l)\n check_e,nis = [int(s) for s in l.split()]\n if check_e != e+1:\n print( \"ERROR: While reading edge subgrid, edge index mismatch: %s vs. %s\"%(e+1,check_e) )\n next_token = tokenizer().next\n lengths = np.array( [float(next_token()) for sg in range(nis)] )\n depths = np.array( [float(next_token()) for sg in range(nis)] )\n if sum(lengths)<=0:\n print( \"edge %d has bad lengths\"%e )\n self.edges['depth_mean'][e] = np.sum(lengths*depths) / sum(lengths)\n self.edges['depth_max'][e] = depths.max()\n self.edges['subgrid'][e] = (lengths,depths)\n # and land boundaries get zeros.\n for e in range(Nflow_sides,Nsides):\n self.edges['depth_mean'][e] = 0.0\n self.edges['depth_max'][e] = 0.0\n self.edges['subgrid'][e] = ([],[])","def read_opal(self, file_name, step_number=None, species_name = 'Species'):\n \n # opal coordinates are as follows:\n # x -- horizontal offset, m\n # xp -- horizontal momentum, beta*gamma\n # y -- vertical offset, m\n # yp -- vertical momentum, beta*gamma\n # z -- Position relative to ? (some sort of reference), m\n # p -- total momentum, beta*gamma\n # TODO: We really need to be able to pull from screens too but we'll settle for standard distribution output for now\n # TODO: We don't currently handle particle specific weight/charge in Species\n \n with h5.File(file_name, 'r') as pcdata:\n if not step_number:\n step_number = len(pcdata) - 1\n loc = 'Step#{}'.format(step_number)\n mp_count = pcdata[loc+'/z'].shape[0]\n particle_data = np.empty((mp_count, 6))\n for i, coord in enumerate(['x', 'px', 'y', 'py', 'z', 'pz']):\n print(loc+'/'+coord)\n particle_data[:, i] = pcdata[loc+'/'+coord]\n total_charge = pcdata[loc].attrs['CHARGE']\n \n # TODO: This needs to be a function --- it is used many times\n # probably just make a species instantiation function\n if species_name == 'Species':\n spec_name = species_name+'_'+str(len(self.species.keys()))\n else:\n spec_name = species_name\n\n # TODO: This shouldn't be specific to electrons\n self.species[spec_name] = Species(particle_data, charge=-1, mass=0.511e6, total_charge=total_charge)\n \n return 0","def ParseParameters(self, parameters_file_name):\n\n print(datetime.now().strftime(\"%H:%M:%S\") + \": Reading file \" + parameters_file_name + \"...\")\n\n parameters_file = open(parameters_file_name, \"r\")\n\n for line in parameters_file:\n line_parts = re.split(r'\\t+', line) # split elements of the line separated by tabs\n if(len(line_parts) == 2):\n self.AddParameter(line_parts[0], float(line_parts[1].strip()))\n else: # we want 2 elements per line\n raise Exception(\"Invalid format for the line \" + line)\n \n parameters_file.close()\n\n # check that all the mandatory parameters are correctly set\n if(self.npop1_1 == \"N/A\" or\n self.npop1_2 == \"N/A\" or\n self.npop2_1 == \"N/A\" or\n self.npop2_2 == \"N/A\" or\n self.t_div == \"N/A\" or\n self.npop_a == \"N/A\" or\n self.mu == \"N/A\"):\n raise Exception(\"One of mandatory parameters is missing!\")\n\n # check that introgression-related parameters are correctly set (either both equal 1 or both equal 0)\n if(self.t_i == 1 and self.p_i == 1): # introgression\n self.number_of_parameters = 9\n elif(self.t_i == 0 and self.p_i == 0): # no introgression\n self.number_of_parameters = 7\n else:\n raise Exception(\"Inconsistent values provided for parameters T_I and P_I!\")\n\n print(datetime.now().strftime(\"%H:%M:%S\") + \": Reading file done.\")","def load_params_from_file(self, input_file):\n\n ### FILL IN ###","def conf_load_location(fin):\n err_msg = \"Expected two numbers separeted by comma.\"\n line = fin.readline().split(',')\n if len(line) != 2:\n raise EnvironmentError(err_msg)\n try:\n x,y = float(line[0]), float(line[1])\n except:\n raise EnvironmentError(err_msg)\n return np.array([x,y])","def load_simulation_attributes_from_args(args):\n simulation_attributes = SimulationAttributes()\n if hasattr(args,'output_file'):\n simulation_attributes.id_name = args.output_file\n simulation_attributes.locations = load_locations_from_args(args.senzory_map_file)\n simulation_attributes.dprime_fnc = load_dprime_fnc_from_args(args)\n simulation_attributes.next_fixation = args.algorithm\n simulation_attributes.num_of_searches = args.num_of_searches\n simulation_attributes.threshold = args.threshold\n return simulation_attributes","def config():\n file_path = None # path to the input file\n db_path = None # path to the output db\n atomic_properties = (\n \"Properties=species:S:1:pos:R:3\"\n ) # atomic properties of the input file\n molecular_properties = [\"energy\"] # molecular properties of the input file\n overwrite = False","def SPdat(species):\n f = open('VPparams.txt', 'rU')\n lines = f.readlines()\n f.close()\n \n parsing = False\n for i in np.arange(len(lines)):\n if lines[i].startswith(species):\n parsing = True\n else:\n parsing = False\n if parsing:\n data = lines[i].split()\n \n lnC, L0, Rv, da, db = data[1:len(data)]\n return float(lnC), float(L0), float(Rv), float(da), float(db)","def read_xyz(filename):\n #print('Reading geom from:'),filename\n atoms = []\n coordinates = []\n\t\n xyz = open(filename)\n n_atoms = int(xyz.readline())\n title = xyz.readline()\n for line in xyz:\n\tif len(line.strip()) == 0:\n\t\tpass\n\t\tbreak\t\n\tatom,x,y,z = line.split()\n\tatoms.append(atom)\n\tcoordinates.append([float(x), float(y), float(z)])\n xyz.close()\n coordinates = [[w * angtobh for w in ww] for ww in coordinates] #ang to bh\n\n if n_atoms != len(coordinates):\n \tprint('Number of atoms in xyz file doesnt equal to the number of lines.')\n\tsys.exit(1)\n \n return atoms, coordinates","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 read_values_from_file(input_file, debug = True):\n with open(input_file, 'r') as infile:\n #Read the data from the file\n input_data = infile.readline()\n\n #And extract the required parameters\n n = int(input_data.split()[0]) #number of months to run experiment\n m = int(input_data.split()[1]) #maximum age of rabbits\n \n if debug:\n print(\"From file %s I have read the following data:\" % input_file)\n print(\"n = %s\\tm = %s\\n\" % (n, m))\n \n return(n, m)","def readsol(self,filename):\n\t\tf = file(filename)\n\t\tfor i in range(6): f.readline()\n\t\tl = f.readline().split()\n\n\t\trows = int(l[2])\n\t\tcols = int(l[5])\n\t\tfor i in range(3): f.readline()\n\t\tstatusString = f.readline().split()[0]\n\t\txpressStatus = {\n\t\t\t\"Optimal\":LpStatusOptimal,\n\t\t\t}\n\t\tif statusString not in xpressStatus:\n\t\t\traise ValueError, \"Unknow status returned by XPRESS: \"+statusString\n\t\tstatus = xpressStatus[statusString]\n\t\tvalues = {}\n\t\twhile 1:\n\t\t\tl = f.readline()\n\t\t\tif l == \"\": break\n\t\t\tline = l.split()\n\t\t\tif len(line) and line[0] == 'C':\n\t\t\t\tname = line[2]\n\t\t\t\tvalue = float(line[4])\n\t\t\t\tvalues[name] = value\n\t\treturn status, values","def testSimulationParametersStored(self):\n simulation_parameters = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=6,\n task=6,\n output_dir=\"output\",\n speciation_rate=0.5,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=0.1,\n max_time=10.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"set\",\n coarse_map_file=\"sample/SA_sample_coarse.tif\",\n coarse_map_x=35,\n coarse_map_y=41,\n coarse_map_x_offset=11,\n coarse_map_y_offset=14,\n coarse_map_scale=1.0,\n fine_map_file=\"sample/SA_sample_fine.tif\",\n fine_map_x=13,\n fine_map_y=13,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=13,\n grid_y=13,\n sample_x=13,\n sample_y=13,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in simulation_parameters.keys():\n self.assertEqual(simulation_parameters[key], actual_sim_parameters[key])\n self.assertDictEqual(simulation_parameters, actual_sim_parameters)\n # self.assertListEqual(simulation_parameters, actual_sim_parameters)\n self.assertEqual(self.tree.get_job()[0], 6)\n self.assertEqual(self.tree.get_job()[1], 6)","def read_settings(self, settings_file):\n import configparser\n import itertools\n cfg = configparser.ConfigParser()\n filename = settings_file\n with open(filename) as fp:\n cfg.read_file(itertools.chain(['[global]'], fp), source=filename)\n d = {}\n for c in cfg.items('global'):\n try:\n d[c[0]] = eval(c[1].strip(';'))\n except Exception:\n pass\n self.distance = d['parameters.distance']\n self.a, self.b, self.c, alpha, beta, gamma = d['parameters.unitcell']\n self.alpha, self.beta, self.gamma = (\n alpha*degrees, beta*degrees, gamma*degrees)\n ubmat = np.matrix(d['parameters.ubmat'])\n self.Umat = ubmat * self.Bimat\n self.xc = d['parameters.det0x']\n self.yc = d['parameters.det0y']\n self.pitch = d['parameters.orienterrordetpitch'] * degrees\n self.roll = d['parameters.orienterrordetroll'] * degrees\n self.yaw = d['parameters.orienterrordetyaw'] * degrees\n self.theta = d['parameters.orienterrorgonpitch'] * degrees\n self.omega = d['parameters.omeganom'] * degrees\n self.chi = d['parameters.chinom'] * degrees\n self.phi = d['parameters.phinom'] * degrees\n self.phi_step = d['parameters.phistep'] * degrees\n self.h_start, self.k_start, self.l_start = d['parameters.gridorigin']\n self.h_stop, self.k_stop, self.l_stop = [-v\n for v in d\n ['parameters.gridorigin']]\n hs, ks, ls = d['parameters.griddim']\n self.h_step, self.k_step, self.l_step = [1.0/hs, 1.0/ks, 1.0/ls]\n self.h_shape, self.k_shape, self.l_shape = d['outputdata.dimensions']","def read_from_grid(filename):\n\n x=[]\n y=[]\n z=[]\n\n fid=open(filename,'r')\n\n for point in fid:\n x.append(float(point.split()[0]))\n y.append(float(point.split()[1]))\n z.append(float(point.split()[2]))\n\n fid.close()\n\n return x, y, z","def _read(self):\n # initializng data dictionary\n self.data={}\n\n f = FortranFile(self.filename)\n # Default omnivor binary header\n self.data['MK'] = f.readInts('i')\n self.data['itime'] = f.readInts('i')\n self.data['version'] = f.readString()\n self.data['file_id'] = f.readInts('i')\n self.data['sversion'] = f.readString()\n # Velocity field\n self.data['stype'] = f.readString()\n self.data['is_grid'] = f.readInts('i')\n nCPs = f.readInts('i')\n self.data['nCPs'] = nCPs\n if self.data['MK'] == 8:\n real_char='d'\n else:\n real_char='f'\n if self.data['is_grid']:\n #print('File is a velocity grid file')\n n1 = f.readInts('i')\n n2 = f.readInts('i')\n n3 = f.readInts('i')\n self.data['n1'] = n1\n self.data['n2'] = n2\n self.data['n3'] = n3\n self.data['is_straight'] = f.readInts('i')\n self.data['v1'] = f.readReals(real_char)\n self.data['v2'] = f.readReals(real_char)\n self.data['v3'] = f.readReals(real_char)\n\n CPs_raw = f.readReals(real_char)\n Utot_raw = f.readReals(real_char)\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\n\n acc=-1\n CPsTab = np.zeros((3, n1,n2,n3))\n UtotTab = np.zeros((3, n1,n2,n3))\n # Reshaping the nasty way (this is natural order). \n for i in range(0,n1):\n for j in range(0,n2):\n for k in range(0,n3):\n acc=acc+1\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\n\n self.data['CPs'] = CPs\n self.data['CPsTab'] = CPsTab\n self.data['Utot'] = Utot\n self.data['UtotTab'] = UtotTab","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 readWrite_gpt2_1w(xdir, station, site_lat, site_lon):\n# this should use the environment variable\n outfile = xdir + '/input/' + station + '_refr.txt'\n if os.path.isfile(outfile):\n print('refraction file for this station already exists')\n else:\n print('refraction output file will be written to ', outfile)\n\n# change to radians\n dlat = site_lat*np.pi/180 \n dlon = site_lon*np.pi/180 \n\n# read VMF gridfile in pickle format \n pname = xdir + '/input/' + 'gpt_1wA.pickle'\n print('large refraction file is stored here:', pname)\n try:\n f = open(pname, 'rb')\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\n f.close()\n except:\n print('I did not find the large refraction file where it is supposed to be, but I will try looking in your home directory')\n try:\n pname = 'gpt_1wA.pickle'\n f = open(pname, 'rb')\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\n f.close()\n except:\n print('hmm, failed again. Go into gnssIR_lomb.py, set RefractionCorrection to false, and rerun the code.... ')\n sys.exit()\n\n# print(np.shape(All_pgrid))\n# really should e zero to four, but whatever\n indx = np.zeros(4,dtype=int)\n indx_lat = np.zeros(4,dtype=int)\n indx_lon = np.zeros(4,dtype=int)\n\n\n#figure out grid index\n# % only positive longitude in degrees\n if (dlon < 0):\n plon = (dlon + 2*np.pi)*180/np.pi;\n else:\n plon = dlon*180/np.pi \n#\n# transform to polar distance in degrees\n ppod = (-dlat + np.pi/2)*180/np.pi \n\n#% find the index (line in the grid file) of the nearest point\n# % changed for the 1 degree grid (GP)\n ipod = np.floor(ppod+1) \n ilon = np.floor(plon+1) \n \n# % normalized (to one) differences, can be positive or negative\n# % changed for the 1 degree grid (GP)\n diffpod = (ppod - (ipod - 0.5)) \n difflon = (plon - (ilon - 0.5)) \n# % added by HCY\n# % changed for the 1 degree grid (GP)\n if (ipod == 181):\n ipod = 180 \n if (ilon == 361):\n ilon = 1 \n if (ilon == 0):\n ilon = 360\n\n# get the number of the corresponding line\n#\t changed for the 1 degree grid (GP)\n indx[0] = (ipod - 1)*360 + ilon \n# save the lat lon of the grid points\n indx_lat[0] = 90-ipod+1 \n indx_lon[0] = ilon-1 \n# % near the poles: nearest neighbour interpolation, otherwise: bilinear\n# % with the 1 degree grid the limits are lower and upper (GP)\n\n bilinear = 0 \n max_ind = 1 \n if (ppod > 0.5) and (ppod < 179.5):\n bilinear = 1 \n if (bilinear == 1):\n max_ind =4 \n\n# % bilinear interpolation\n# % get the other indexes \n \n ipod1 = ipod + np.sign(diffpod) \n ilon1 = ilon + np.sign(difflon) \n# % changed for the 1 degree grid (GP)\n if (ilon1 == 361):\n ilon1 = 1 \n if (ilon1 == 0):\n ilon1 = 360 \n# get the number of the line\n# changed for the 1 degree grid (GP)\n# four indices ???\n indx[1] = (ipod1 - 1)*360 + ilon; # % along same longitude\n indx[2] = (ipod - 1)*360 + ilon1;# % along same polar distance\n indx[3] = (ipod1 - 1)*360 + ilon1;# % diagonal\n#\n# save the lat lon of the grid points lat between [-90 ;90] lon [0 360] \n indx_lat[1] = 90 - ipod1+np.sign(diffpod) \n indx_lon[1] = ilon-1 \n indx_lat[2] = 90-ipod +1\n indx_lon[2] = ilon1 - np.sign(difflon) \n indx_lat[3] = 90 -ipod1+np.sign(diffpod) \n indx_lon[3] = ilon1- np.sign(difflon);\n\n# extract the new grid\n# will need to do 0-4 instead of 1-5 because stored that way in python\n# which values to use in the bigger array\n# assign the correct values\n indx = indx - 1\n indx_list = indx.tolist()\n# print(indx_list)\n# print(indx)\n#print(np.shape(indx_lat))\n#print(np.shape(indx_lon))\n w = 0\n# need to write values for a given station to a plain text file\n#\n fout = open(outfile, 'w+')\n for a in indx_list:\n for k in [0,1,2,3,4]:\n fout.write(\" {0:4.0f} {1:5.0f} {2:13.4f} {3:10.4f} {4:10.6f} {5:10.4f} {6:12.5f} {7:12.5f} {8:10.6f} {9:10.6f} {10:10.6f} {11:10.4f} \\n\".format( indx_lat[w], indx_lon[w],All_pgrid[a,k],All_Tgrid[a,k],All_Qgrid[a,k]*1000,All_dTgrid[a,k]*1000,All_U[a,0],All_Hs[a,0], All_ahgrid[a,k]*1000, All_awgrid[a,k]*1000, All_lagrid[a,k], All_Tmgrid[a,k] ))\n\n w+=1\n fout.close()\n print('file written')","def ReadBasicInfo():\r\n\r\n EquilibriumStep, ProductionStep,HEPCP,HEPCE,Multiple=10000000,10000000,100,100,2\r\n InputPath,OutputPath,AtomParameterPath,TaskSuffix,MaterialInputFormat='..','..','..','','mol'\r\n GasType,GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,\\\r\n TorqueSetting,MuSiCSetting,Nodes=[],[],[],[],[],[],[],[],['1:ppn=1']\r\n CutOff,GridSpacingP,GridSpacingE=12.8,2.0,2.0\r\n MakeGCMC,UsePmap,UseEmap,UsePost,MakePmap,MakeEmap,MakeTorque,KeyOne,KeyTwo,\\\r\n PDBCharges = False,False,False,False,False,False,False,False,False,False\r\n\r\n with open('GlueParameters', 'r') as File:\r\n for Line in File.readlines():\r\n if Line.strip():\r\n WordList = Line.strip().split()\r\n if len(WordList)>1 or KeyOne==True or KeyTwo==True:\r\n if WordList[0]=='#':\r\n continue\r\n\r\n # Controlled part\r\n elif WordList[0] == 'MakeGCMC:' and WordList[1] == 'open':\r\n MakeGCMC = True\r\n elif WordList[0] == 'UsePmap:' and WordList[1] == 'yes':\r\n UsePmap = True\r\n elif WordList[0] == 'UseEmap:' and WordList[1] == 'yes':\r\n UseEmap = True\r\n elif WordList[0] == 'UsePost:' and WordList[1] == 'yes':\r\n UsePost = True\r\n elif WordList[0] == 'MakePmap:' and WordList[1] == 'open':\r\n MakePmap = True\r\n elif WordList[0] == 'MakeEmap:' and WordList[1] == 'open':\r\n MakeEmap = True\r\n elif WordList[0] == 'MakeTorque:' and WordList[1] == 'open':\r\n MakeTorque = True\r\n elif WordList[0] == 'UseChargesFromPDBFile:' and WordList[1] == 'yes':\r\n PDBCharges = True\r\n\r\n # Basic part\r\n elif WordList[0]=='InputPath:':\r\n InputPath=WordList[1]\r\n elif WordList[0]=='MaterialInputFormat:':\r\n MaterialInputFormat=WordList[1]\r\n elif WordList[0]=='OutputPath:':\r\n OutputPath=WordList[1]\r\n elif WordList[0]=='AtomParameterPath:':\r\n AtomParameterPath=WordList[1]\r\n elif WordList[0] == 'GasType:':\r\n GasType = list(WordList[1:])\r\n elif WordList[0] == 'GasAtomTypeNum:':\r\n\r\n for i in WordList[1:]:\r\n GasAtomTypeNum.append(int(i))\r\n\r\n elif WordList[0] == 'GasAtomType:':\r\n GasAtomType = list(WordList[1:])\r\n elif WordList[0] == 'Multiple:':\r\n Multiple = int(WordList[1])\r\n elif WordList[0] == 'CutOff:':\r\n CutOff = float(WordList[1])\r\n\r\n # GCMC part\r\n\r\n elif WordList[0] == 'GasPartialPressure:':\r\n\r\n for j in WordList[1:]:\r\n GasPartialPressure.append(str(j))\r\n\r\n elif WordList[0] == 'TemperatureList(K):':\r\n\r\n for l in WordList[1:]:\r\n TemperatureList.append(float(l))\r\n\r\n elif WordList[0] == 'PressureList(kPa):':\r\n\r\n for k in WordList[1:]:\r\n PressureList.append(float(k))\r\n\r\n elif WordList[0] == 'EquilibriumStep:':\r\n EquilibriumStep = int(WordList[1])\r\n elif WordList[0] == 'ProductionStep:':\r\n ProductionStep = int(WordList[1])\r\n\r\n # Pmap part\r\n elif WordList[0] == 'GridSpacingP(Ang):':\r\n GridSpacingP = float(WordList[1])\r\n elif WordList[0] == 'HighEndPotentialCutoffP(kJ/mol):':\r\n HEPCP = int(WordList[1])\r\n\r\n # Emap part\r\n elif WordList[0] == 'GridSpacingE(Ang):':\r\n GridSpacingE = float(WordList[1])\r\n elif WordList[0] == 'HighEndPotentialCutoffE(kJ/mol):':\r\n HEPCE = int(WordList[1])\r\n\r\n # Torque part\r\n elif WordList[0] == 'Nodes:':\r\n Nodes = WordList[1:]\r\n elif WordList[0] == 'TaskSuffix:':\r\n TaskSuffix = WordList[1]\r\n elif WordList[0] == 'TorqueSetting:':\r\n KeyOne = True\r\n elif WordList[0] == 'MuSiCSetting:':\r\n KeyOne = False\r\n KeyTwo = True\r\n elif WordList[0] == 'END':\r\n KeyTwo = False\r\n elif KeyOne == True:\r\n TorqueSetting.append(Line)\r\n elif KeyTwo == True:\r\n MuSiCSetting.append(Line)\r\n\r\n return (InputPath,OutputPath,AtomParameterPath,MakeTorque,GasType,\r\n GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,CutOff,MakeGCMC,UsePmap,\r\n UseEmap,UsePost,MakePmap,MakeEmap,EquilibriumStep,ProductionStep,GridSpacingP,HEPCP,GridSpacingE,HEPCE,\r\n Multiple,TorqueSetting,MuSiCSetting,Nodes,TaskSuffix,PDBCharges,MaterialInputFormat)","def testSimParamsStored(self):\n params = self.tree.get_simulation_parameters()\n actual_sim_parameters = dict(\n seed=2,\n task=5,\n output_dir=\"output\",\n speciation_rate=0.1,\n sigma=4.0,\n tau=4.0,\n deme=1,\n sample_size=1.0,\n max_time=2.0,\n dispersal_relative_cost=1.0,\n min_num_species=1,\n habitat_change_rate=0.0,\n gen_since_historical=0.0,\n time_config_file=\"null\",\n coarse_map_file=\"null\",\n coarse_map_x=20,\n coarse_map_y=20,\n coarse_map_x_offset=0,\n coarse_map_y_offset=0,\n coarse_map_scale=1.0,\n fine_map_file=\"null\",\n fine_map_x=10,\n fine_map_y=10,\n fine_map_x_offset=0,\n fine_map_y_offset=0,\n sample_file=\"null\",\n grid_x=10,\n grid_y=10,\n sample_x=10,\n sample_y=10,\n sample_x_offset=0,\n sample_y_offset=0,\n historical_coarse_map=\"none\",\n historical_fine_map=\"none\",\n sim_complete=1,\n dispersal_method=\"normal\",\n m_probability=0.0,\n cutoff=0.0,\n landscape_type=\"closed\",\n protracted=0,\n min_speciation_gen=0.0,\n max_speciation_gen=0.0,\n dispersal_map=\"none\",\n )\n for key in params.keys():\n self.assertEqual(params[key], actual_sim_parameters[key])\n # self.assertDictEqual(params, actual_sim_parameters)\n self.assertEqual(self.tree.get_job()[0], 2)\n self.assertEqual(self.tree.get_job()[1], 5)","def fixture_coord():\n\tEXAMPLE_FILE_FOLDER = str(MODULE_DIR) + \"/data/nail1/\"\n\tcoord_x, coord_y, coord = read.load_coord(EXAMPLE_FILE_FOLDER)\n\treturn coord","def general_simulation_data(self):\n iterations = {}\n nstates = {}\n natoms = {}\n for phase in self.phases:\n positions = self.ncfiles[phase].variables['positions']\n iterations[phase], nstates[phase], natoms[phase], spatial = positions.shape\n\n leniter = max(len('Iterations'), *[len(str(i)) for i in iterations.values()]) + 2\n lenstates = max(len('States'), *[len(str(i)) for i in nstates.values()]) + 2\n lennatoms = max(len('Num Atoms'), *[len(str(i)) for i in natoms.values()]) + 2\n lenleftcol = max(len('Phase'), *[len(phase) for phase in self.phases]) + 2\n\n lines = []\n headstring = ''\n headstring += ('{:^' + '{}'.format(lenleftcol) + '}').format('Phase') + '|'\n headstring += ('{:^' + '{}'.format(leniter) + '}').format('Iterations') + '|'\n headstring += ('{:^' + '{}'.format(lenstates) + '}').format('States') + '|'\n headstring += ('{:^' + '{}'.format(lennatoms) + '}').format('Num Atoms')\n lines.append(headstring)\n lenline = len(headstring)\n topdiv = '=' * lenline\n lines.append(topdiv)\n for phase in self.phases:\n phasestring = ''\n phasestring += ('{:^' + '{}'.format(lenleftcol) + '}').format(phase) + '|'\n phasestring += ('{:^' + '{}'.format(leniter) + '}').format(iterations[phase]) + '|'\n phasestring += ('{:^' + '{}'.format(lenstates) + '}').format(nstates[phase]) + '|'\n phasestring += ('{:^' + '{}'.format(lennatoms) + '}').format(natoms[phase])\n lines.append(phasestring)\n lines.append('-' * lenline)\n\n for line in lines:\n print(line)\n self.iterations = iterations\n self._general_run = True","def read_from(self, filename):\n\n lon, lat, field, weight = [], [], [], []\n\n if os.path.exists(filename):\n logger.info(\"Reading data from file {0}\".format(filename))\n with open(filename, 'r') as f:\n line = f.readline()\n ncols = len(line.split())\n while ncols >= 3:\n lon.append(float(line.split()[0]))\n lat.append(float(line.split()[1]))\n field.append(float(line.split()[2]))\n if ncols >= 4:\n weight.append(float(line.split()[3]))\n else:\n weight.append(1.)\n line = f.readline()\n ncols = len(line.split())\n\n self.x = np.array(lon)\n self.y = np.array(lat)\n self.field = np.array(field)\n self.weight = np.array(weight)\n return self\n else:\n logger.error(\"File {0} does not exist\".format(filename))\n raise FileNotFoundError('File does not exist')","def read_sim_info(folder, filen):\n \n ### file path\n \n fpath = folder + filen + '.h5'\n assert os.path.exists(fpath), \"The out.h5 file does NOT exist for \" + fpath\n fl = h5py.File(fpath, 'r') \n \n ### simulation information\n \n lx = fl['/info/box/x'][...]\n ly = fl['/info/box/y'][...]\n dt = fl['/info/dt'][...]\n nsteps = fl['/info/nsteps'][...]\n nfils = fl['/info/nfils'][...]\n nbeads = fl['/info/nbeads'][...]\n nsamp = fl['/info/nsamp'][...]\n nbpf = fl['/info/nbpf'][...]\n \n ### simulation parameters\n \n density = fl['/param/density'][...]\n kappa = fl['/param/kappa'][...]\n km = fl['/param/km'][...]\n pa = fl['/param/pa'][...]\n pp = fl['/param/pp'][...]\n bl = fl['/param/bl'][...]\n sigma = fl['/param/sigma'][...]\n \n fl.close()\n \n ### generate classes to submerge data\n \n sim = misc_tools.Simulation(lx, ly, dt, nsteps, nfils, nbeads, nsamp, nbpf, \\\n density, kappa, km, pa, pp, bl, sigma)\n \n return sim","def get_params(path = 'INPUT/conv_params'):\n\n # cd to Input, read the conv_params file in and pass each line to file reader\n list = file_reader(path)\n\n Ecuts = list[0] # first element returned from filereader is the energies\n start = int(Ecuts[0][0]) # the first element of this is the lower energy to start from. convert to integer for maths\n multiplier = int(Ecuts[1][0]) # middle element is the step size\n end = int(Ecuts[2][0]) # last element is upper bound on energy\n E_range = (end - start)//multiplier +1 # the number of energies you will create\n Es = [i*multiplier for i in range(E_range)] # take steps in the E_range of step size multiplier\n Ecuts = [[str(i+start)] for i in Es] # add the start energy to all these steps to shift them to correct energies\n # convert the numbers to strings for ease of file writing later\n\n kpts = list[1] # kpoints list is first element returned\n def_E = list[2] # default energy\n def_k = list[3] # default kpoints\n params = Settings(Ecuts, kpts, def_E, def_k) # create the settings object\n\n return params # return the object","def __read_job_params_file__(self):\n # | - __read_job_params_file__\n job_params = {}\n\n # file_path = self.full_path + \"/\" + \"job_parameters.json\"\n\n file_exists = False\n\n file_path = os.path.join(\n self.full_path,\n \"job_parameters.json\")\n if os.path.exists(file_path):\n file_exists = True\n with open(file_path, \"r\") as fle:\n job_params = json.load(fle)\n\n\n ind_i = self.full_path.rfind(self.full_path.split(\"/\")[-1])\n path_i_rt = self.full_path[:ind_i - 1]\n\n file_path = os.path.join(\n # self.full_path[0:-2],\n path_i_rt,\n \"job_parameters.json\",\n )\n if os.path.exists(file_path):\n file_exists = True\n with open(file_path, \"r\") as fle:\n job_params = json.load(fle)\n\n\n file_path = os.path.join(\n # self.full_path[0:-2],\n path_i_rt,\n \"job_params.json\",\n )\n if os.path.exists(file_path):\n file_exists = True\n with open(file_path, \"r\") as fle:\n job_params = json.load(fle)\n\n if not file_exists:\n print(\"No job_params file found for following job:\")\n print(self.full_path)\n\n return(job_params)\n # __|","def Data_init(**kwargs):\n if 'file' in kwargs:\n print \"Reading the file\"\n else:\n print \"Randomizing the initial data\"\n XV = np.random.rand(kwargs['particles'],kwargs['dimensions']*2) * 2 - 1\n M = np.random.rand(kwargs['particles'])\n\n t_f,num = kwargs['time']\n t = np.linspace(0,t_f,num)\n\n return XV,M,t","def load_params():\r\n return pickle.load(open('params.p', mode='rb'))","def vars_ifile(ifile):\n\n site = None\n year = None\n actual = None\n doy = None\n Ndays = None\n params = None\n Nsteps = None\n models = None\n resolution = None\n fopt = None\n window = None\n tag = None\n photo = None\n plot = None\n project = None\n\n with open(ifile, 'r') as f:\n\n for line in f:\n\n ll = line.strip()\n\n if not ll.startswith(\"#\"):\n ll = ll.rstrip()\n\n if site is None:\n site = read_var('site', ll)\n\n if year is None:\n year = read_var('year', ll)\n\n if actual is None:\n actual = read_var('actual', ll)\n\n if doy is None:\n doy = read_var('doy', ll)\n\n if Ndays is None:\n Ndays = read_var('Ndays', ll)\n\n if params is None:\n params = read_var('params', ll)\n\n if Nsteps is None:\n Nsteps = read_var('Nsteps', ll)\n\n if models is None:\n models = read_var('models', ll)\n\n if resolution is None:\n resolution = read_var('resolution', ll)\n\n if fopt is None:\n fopt = read_var('fopt', ll)\n\n if window is None:\n window = read_var('window', ll)\n\n if tag is None:\n tag = read_var('tag', ll)\n\n if photo is None:\n photo = read_var('photo', ll)\n\n if plot is None:\n plot = read_var('plot', ll)\n\n if project is None:\n project = read_var('project', ll)\n\n if actual is None: # make sure the spinup only runs for the Control\n models = 'Control'\n\n return (site, year, actual, doy, Ndays, params, Nsteps, models, resolution,\n fopt, window, tag, photo, plot, project)","def read_params(self):\n detector_params = namedtuple('params', ['image_path', 'circle_region',\n 'vis_circle_det',\n 'template_path', 'score_thres',\n 'vis_det'])\n with open(self.yaml_path, 'r') as stream:\n try:\n parameters = yaml.load(stream)\n except:\n raise FileNotFoundError\n\n detector_params.image_path = parameters.get('image_path', None)\n if detector_params.image_path is None:\n raise ValueError('Please provide path to image.')\n\n detector_params.circle_region = read_circle_region_params(parameters)\n detector_params.vis_circle_det = read_vis_circle_det(parameters)\n\n detector_params.template_path = parameters.get('template_path', None)\n if detector_params.template_path is None:\n raise ValueError('Please provide path to template image.')\n\n detector_params.vis_det = parameters.get('vis_det', True)\n detector_params.score_thres = parameters.get('score_thres', 0.3)\n\n return detector_params","def readTestFile(self, filename):\n size = 0\n agentNum = 0\n block = {}\n agentList = []\n f = open(filename, 'r')\n for line in f:\n if line[0] != '#':\n c = line.split(' ')\n if c[0] == 'grid':\n size = int(line[5:7])\n elif c[0] =='block':\n block[(int(c[2]), int(c[1]))] = (int(c[3]) - int(c[1]) + 1, int(c[4]) - int(c[2]) + 1)\n elif c[0] == 'nets':\n agentNum = int(c[1])\n elif c[0] == 'net' or c[0] == 'xet':\n print(c)\n agentList.append([int(c[1]), (int(c[3]), int(c[2])), (int(c[6]), int(c[5]))])\n f.close()\n print(size)\n print(block)\n print(agentNum)\n print(agentList)\n return size, block, agentNum, agentList","def read_genesis(self, file_name):\n \n # genesis coordinates are as follows:\n # x -- horizontal coordinate, m\n # px -- horizontal momentum, beta_x gamma\n # y -- vertical coordinate, m\n # py -- vertical momentum, beta_y gamma\n # th -- theta, the ponderomotive phase at fixed z\n # t -- time of arrival at fixed z, sec\n # gamma -- particle gamma\n\n return 0","def readParameters(paramFile):\n try:\n with open(paramFile,\"r\") as infile:\n contents = infile.read()\n jsonfile = json.loads(contents)\n print(\"Local parameter file found, returning saved parameters\")\n paramWindDirection = jsonfile[\"parameters\"][\"windDirection\"]\n paramWindSpeed = jsonfile[\"parameters\"][\"windSpeed\"]\n paramWaterHeight = jsonfile[\"parameters\"][\"waterHeight\"]\n paramRainFall = jsonfile[\"parameters\"][\"rainFall\"]\n print(paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall)\n except IOError:\n print(\"Local parameter file could not be found, returning default parameters.\")\n paramWindDirection = \"270\"\n paramWindSpeed = \"20\"\n paramWaterHeight = \"50\"\n paramRainFall = \"150\"\n print(paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall)\n return paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall","def readDriverFile(self, input_file):\n\n\n fid = open(self.basePath + input_file,'r')\n\n # Line 1\n line = fid.readline()\n l_input = line.split('!')\n mshfile = l_input[0].rstrip()\n\n # Line 2\n line = fid.readline()\n l_input = line.split('!')\n obsfile = l_input[0].rstrip()\n\n # Line 3\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input=='null':\n topofile = []\n\n else:\n topofile = l_input[0].rstrip()\n\n\n # Line 4\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n mstart = float(l_input[1])\n\n else:\n mstart = l_input[0].rstrip()\n\n # Line 5\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n mref = float(l_input[1])\n\n else:\n mref = l_input[0].rstrip()\n\n # Line 6\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n staticInput = float(l_input[1])\n\n elif l_input[0]=='DEFAULT':\n staticInput = None\n\n else:\n staticInput = l_input[0].rstrip()\n\n\n # Line 7\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input=='DEFAULT':\n magfile = []\n\n else:\n magfile = l_input[0].rstrip()\n\n # Line 8\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input=='DEFAULT':\n wgtfile = []\n\n else:\n wgtfile = l_input[0].rstrip()\n\n # Line 9\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n chi = float(l_input[0])\n\n # Line 10\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n val = np.array(l_input[0:4])\n alphas = val.astype(np.float)\n\n # Line 11\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n val = np.array(l_input[1:3])\n bounds = val.astype(np.float)\n\n else:\n bounds = l_input[0].rstrip()\n\n # Line 12\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n val = np.array(l_input[1:6])\n lpnorms = val.astype(np.float)\n\n else:\n lpnorms = l_input[0].rstrip()\n\n # Line 13\n line = fid.readline()\n l_input = re.split('[!\\s]',line)\n if l_input[0]=='VALUE':\n val = np.array(l_input[1:3])\n eps = val.astype(np.float)\n\n else:\n eps = [None,None]\n\n self.mshfile = mshfile\n self.obsfile = obsfile\n self.topofile = topofile\n self.mstart = mstart\n self._mrefInput = mref\n self._staticInput = staticInput\n self.magfile = magfile\n self.wgtfile = wgtfile\n self.chi = chi\n self.alphas = alphas\n self.bounds = bounds\n self.lpnorms = lpnorms\n self.eps = eps","def read_plot_config(config_file_name,input_filename, d,\\\n call_time, call_lon, call_lat,\\\n call_storm_name,\\\n call_add_lon = 4., call_add_lat = 4,\\\n call_var = None,\\\n var_name = None,\\\n call_units = '',\\\n call_storm_num = None,\\\n call_storm_basin = None,\\\n lon0 = None, lat0 = None,\\\n plt_type = 'barbs',\\\n barbs_subplot_type = 'scatter',\\\n plot_out_dir = '.',\\\n call_var2 = None,\\\n call_var3 = None):\n\n # --- lenght in km of 1 degree lat\n LATKM = 111.\n\n try:\n config_file = open(config_file_name,'r')\n except IOError:\n error_msg = 'Cannot open file '+ config_file_name\n LOGGER.exception(error_msg)\n sys.exit(error_codes.EX_IOERR)\n\n try:\n data_block = False\n for read_line in iter(config_file):\n strip_line = read_line.strip()\n if len(strip_line) > 1:\n # --- read non-empty line\n curr_line = strip_line.split(';')\n\n # --- parse non-empty line\n if data_block is False and re.match('^ *#',curr_line[0]):\n # --- skip comments\n continue\n\n elif data_block is False and curr_line[0] == 'data':\n var_name = curr_line[1].strip()\n num_id = curr_line[2].strip()\n read_press = curr_line[3].strip()\n press = [int(x) for x in read_press.split(\",\")]\n data_block = True\n elif data_block:\n if num_id == '1': #plot_data_lonlat \n \n call_time = d.var_dict[curr_line[0].strip()] \n for ipress in press: \n \n call_var = d.var_dict[curr_line[1].strip()] \n if ipress == 'none':\n #MUST be 'none' for 2d variables\n pass\n else: \n #3d variables\n call_var = d.get_pressure_slice(call_var,ipress,var_name)\n\n call_lon = d.var_dict[curr_line[2].strip()]\n call_lat = d.var_dict[curr_line[3].strip()]\n call_storm_num = d.var_dict[curr_line[4].strip()]\n call_storm_basin = d.var_dict[curr_line[5].strip()]\n\n\n for ikw in curr_line[6:len(curr_line)]:\n if re.match(' *add_lon', ikw): call_add_lon = float(ikw.split('=')[-1])\n if re.match(' *add_lat', ikw): call_add_lat = float(ikw.split('=')[-1])\n if re.match(' *storm_name', ikw): \n call_storm_name = d.var_dict[ikw.split('=')[-1].strip()]\n if re.match(' *units', ikw): call_units = ikw.split('=')[-1].strip()\n if re.match(' *pos', ikw): call_pos = ikw.split('=')[-1].strip()\n if re.match(' *rmax', ikw): call_rmax = ikw.split('=')[-1].strip()\n if re.match(' *plot_var2', ikw): \n plot_var2 = d.var_dict[ikw.split('=')[-1].strip()]\n call_var2= d.get_pressure_slice(plot_var2,ipress,'var2')\n if re.match(' *plot_var3', ikw): \n plot_var3 = d.var_dict[ikw.split('=')[-1].strip()]\n call_var3= d.get_pressure_slice(plot_var3,ipress,'var3')\n if re.match(' *plt_type', ikw): \n plt_type = ikw.split('=')[-1].strip()\n if re.match(' *barbs_subplot_type', ikw): \n barbs_subplot_type = ikw.split('=')[-1].strip()\n \n if ipress != 'none':\n call_p_lev = ipress\n else:\n call_p_lev = 'none'\n\n if re.match(' *savefig', ikw): \n savefig_str = ikw.split('=')[-1] \n if savefig_str == 'True': call_savefig = True\n else: call_savefig = False\n if re.match(' *showfig', ikw): \n show_str = ikw.split('=')[-1] \n if show_str == 'True': call_show = True\n else: call_show = False\n if re.match(' *plot_out_dir', ikw): plot_out_dir = ikw.split('=')[-1].strip()\n \n LOGGER.info( \"plotting variable \"+var_name.strip()+', pressure_level = %d mb' % call_p_lev)\n try: \n plot_data_lonlat(call_time,call_var,call_lon,call_lat,\\\n call_storm_num, call_storm_basin,\\\n lon0 = lon0, lat0 = lat0,\\\n add_lon = call_add_lon, add_lat = call_add_lat,\\\n storm_name = call_storm_name,\\\n p_lev = call_p_lev,var_name = var_name,\\\n units = call_units,\\\n filename_var = var_name,\\\n plot_var2 = call_var2,\\\n plot_var3 = call_var3,\\\n plt_type = plt_type,\\\n plot_out_dir = plot_out_dir,\\\n input_filename = input_filename,\\\n barbs_subplot_type = barbs_subplot_type,\\\n savefig = True,showfig =False)\n except:\n error_msg = 'unable to make plot using values from config file'\n raise ValueError(error_msg)\n data_block = False\n\n #-----------------------------------------------------------------------------------\n else: \n data_block = False\n else: \n # ---error in config file\n raise ValueError('Incorrect data format in config file '+config_file_name)\n\n else:\n # --- skip empty lines\n continue\n except:\n error_msg = 'Error encountered while reading config file '+config_file_name\n LOGGER.exception(error_msg)\n sys.exit(error_codes.EX_CONFIG) \n \n config_file.close()","def read_from_ascii(self, filename):\n self.ascii_filename = filename\n # read file content into a string\n f=open(filename,'r')\n file_str=f.read()\n f.close()\n # make dictionary with file content\n reg_exp_data_groups=re.compile(r'^#>>(\\w+):.*\\n',re.M)\n file_dict=self.make_data_dict_from_str(reg_exp_data_groups,file_str)\n # read arrays ------------------------------\n self.x=np.loadtxt(StringIO.StringIO(file_dict['x']))\n self.p=np.loadtxt(StringIO.StringIO(file_dict['p']))\n self.fmci_XP=np.loadtxt(StringIO.StringIO(file_dict['XP']))\n # regular expression for extracting parameter=value\n reg_exp_param_val=re.compile(r'\\n*(\\w+)=',re.M)\n # read params_physics -----------------------\n params_physics_dict=self.make_data_dict_from_str(reg_exp_param_val,file_dict['params_physics'])\n self.name=self.__get_particle_name(params_physics_dict['particle'])\n self.time=float(params_physics_dict['time'])\n # read params_TDC ---------------------------\n params_TDC_dict=self.make_data_dict_from_str(reg_exp_param_val,file_dict['params_TDC'])\n self.calc_id=params_TDC_dict['calc_id']\n self.i_ts=int(params_TDC_dict['i_ts'])","def read_settings():\n # open file for reading\n ifile = open(infilename, 'r')\n # skip comment line\n ifile.readline()\n # char-file name\n line = ifile.readline()\n line = line.split()\n charfile = line[-1]\n # header-file name\n line = ifile.readline()\n line = line.split()\n headerfile = line[-1]\n # output folder\n line = ifile.readline()\n line = line.split()\n ofname = line[-1]\n # length of the filaments\n line = ifile.readline()\n line = line.split()\n nfil = int(line[-1])\n # number of snapshots to skip\n line = ifile.readline()\n line = line.split()\n nskip = int(line[-1])\n # number of bins\n line = ifile.readline()\n line = line.split()\n nbin = int(line[-1])\n # maximum cutoff\n line = ifile.readline()\n line = line.split()\n rmax = float(line[-1])\n # overall number of snapshots to use in the analysis\n line = ifile.readline()\n line = line.split()\n ntotal = int(line[-1])\n # close file\n ifile.close()\n # return input values\n return charfile, headerfile, ofname, nfil, nskip, nbin, rmax, ntotal","def load_params_from_file(path):\n save_dict = mx.nd.load(path)\n arg_params = {}\n aux_params = {}\n for k, v in save_dict.items():\n tp, name = k.split(':', 1)\n if tp == 'arg':\n arg_params[name] = v\n if tp == 'aux':\n aux_params[name] = v\n return arg_params, aux_params"],"string":"[\n \"def read_simulation_files(self):\\n\\n # Check if simulation files exist in current directory, if not kill process\\n if not os.path.isfile('{}.xyz'.format(self.prefix)):\\n print('Cannot find simulation file \\\"{}.xyz\\\"'.format(self.prefix))\\n sys.exit()\\n if not os.path.isfile('{}_vis2d.dat'.format(self.prefix)):\\n print('Cannot find simulation file \\\"{}_vis2d.dat\\\"'.format(self.prefix))\\n sys.exit()\\n if not os.path.isfile('{}_dia.dat'.format(self.prefix)):\\n print('Cannot find simulation file \\\"{}_dia.dat\\\"'.format(self.prefix))\\n sys.exit()\\n\\n # Read coordinate file\\n print('Reading simulation xyz file')\\n with open('{}.xyz'.format(self.prefix),'r') as f:\\n self.n = int(f.readline().split()[0])\\n self.crds = np.zeros((self.n,2))\\n f.seek(0,0)\\n for i in range(self.frame):\\n for j in range(2+self.n):\\n f.readline()\\n f.readline()\\n f.readline()\\n for j in range(self.n):\\n self.crds[j,:] = np.array([float(c) for c in f.readline().split()[1:3]])\\n\\n # Read rings file\\n print('Reading simulation ring file')\\n with open('{}_vis2d.dat'.format(self.prefix),'r') as f:\\n self.rings = []\\n if self.vis_vortype != 0:\\n while True:\\n frame = int(f.readline().split()[0])\\n vor_type = int(f.readline().split()[0])\\n self.param = float(f.readline().split()[0])\\n self.m = int(f.readline().split()[0])\\n if frame==self.frame and vor_type==self.vis_vortype:\\n for i in range(self.m):\\n ring = np.array([float(c) for c in f.readline().split()])\\n self.rings.append(ring.reshape(ring.shape[0]//2,2))\\n break\\n else:\\n for i in range(self.m):\\n f.readline()\\n\\n # Read diameter file\\n print('Reading simulation radii and weights file')\\n data = np.genfromtxt('{}_dia.dat'.format(self.prefix)).astype(float)\\n self.radii = data[:self.n]/2\\n self.weights = data[self.n:]\",\n \"def readParams(path):\\n tiles = open(path, \\\"r\\\")\\n #--- Starting date\\n tiles.readline()\\n index = tiles.readline()[:-1]\\n \\n #--- Starting date\\n tiles.readline()\\n B_date = tiles.readline()[:-1]\\n \\n #--- Stopping date\\n tiles.readline()\\n E_date = tiles.readline()[:-1]\\n \\n #--- DATA \\n tiles.readline()\\n DATA_path = tiles.readline()[:-1]\\n \\n #--- Csv \\n tiles.readline()\\n out = tiles.readline()[:-1]\\n \\n #--- Shapefile\\n tiles.readline()\\n shp = tiles.readline()[:-1]\\n \\n #--- Water mask\\n water = DATA_path + '/waterMask'\\n \\n return index, B_date, E_date, DATA_path, out, shp, water\",\n \"def read_mesa(self, filename=None):\\n\\n if filename is None:\\n filename = self.model_file\\n\\n with open(filename, 'r') as f:\\n # count number of lines\\n npts_file = sum([1 for line in f])\\n\\n # go back to start and read first line in file to get number of parameters\\n f.seek(0)\\n l = f.readline()\\n nparams_file = int(l.split(' ')[-1])\\n\\n # skip lines 2-4\\n for i in range(3):\\n f.readline()\\n\\n # the fifth line will give us the number of variables\\n l = f.readline()\\n nvars_file = int(l.split(' ')[-1])\\n\\n # subtract header rows\\n npts_file -= 6\\n\\n print(f'{nvars_file} variables found in the initial model file')\\n print(f'{npts_file} points found in the initial model file')\\n\\n var_idx_map = {}\\n logR_idx = -1\\n\\n # read in the names of the variables\\n for i in range(nvars_file):\\n var_name_file = f.readline().strip()\\n if var_name_file.lower() == 'n':\\n var_name_file = 'neut'\\n elif var_name_file == 'p':\\n var_name_file = 'prot'\\n\\n if var_name_file == 'logR':\\n logR_idx = i\\n continue\\n\\n # create map of file indices to model indices\\n try:\\n var_idx_map[self.idx[var_name_file]] = i\\n except KeyError:\\n var_idx_map[self.idx['spec'] - 1 + network_module.network_species_index(var_name_file.lower())] = i\\n\\n base_r = np.zeros(npts_file)\\n base_state = np.zeros((npts_file, self.nvar))\\n\\n # read in model data\\n for i, line in enumerate(f):\\n variables = [float(v) for v in line.split(' ')]\\n\\n # need to reverse the inputs file here\\n\\n n = npts_file - i - 1\\n\\n base_r[n] = R_solar * 10**variables[logR_idx]\\n\\n for j in range(self.nvar):\\n if j in var_idx_map:\\n base_state[n, j] = variables[var_idx_map[j]]\\n\\n return npts_file, base_r, base_state\",\n \"def readParams(file_name):\\n try:\\n info = np.load(file_name,allow_pickle=True)[()]\\n except FileNotFoundError:\\n if file_name.split('/')[-2] == 'checkpoint':\\n lfc_id_dir = '/expres/extracted/lfc_cal/lfc_id/'\\n file_name = lfc_id_dir + os.path.basename(file_name)\\n info = np.load(file_name,allow_pickle=True)[()]\\n else:\\n raise FileNotFoundError\\n # Assemble information into \\\"fit-able\\\" form\\n num_orders = len(info['params'])\\n lines = [p[:,1] for p in info['params'] if p is not None]\\n errs = [np.sqrt(cov[:,1,1]) for cov in info['cov'] if cov is not None]\\n ordrs = [o for o in np.arange(86) if info['params'][o] is not None]\\n waves = [w for w in info['wvln'] if w is not None]\\n # I believe, but am not sure, that the wavelengths are multiplied by order\\n # to separate them from when orders overlap at the edges\\n waves = [wvln for order, wvln in zip(ordrs,waves)]\\n ordrs = [np.ones_like(x) * m for m,x in zip(ordrs, lines)]\\n\\n x = np.concatenate(lines)\\n y = np.concatenate(ordrs)\\n e = np.concatenate(errs)\\n w = np.concatenate(waves)\\n # Note: default of pipeline includes ThAr lines, which we're not including here\\n \\n return (x,y,w,e)\",\n \"def read_from(self, filename):\\n if os.path.exists(filename):\\n logger.info(\\\"Reading parameters from file {0}\\\".format(filename))\\n cl, icoord, ispec, ireg, xori, yori, dx, dy, nx,\\\\\\n ny, valex, snr, varbak = np.loadtxt(filename, comments='#', unpack=True)\\n\\n self.cl = cl\\n self.icoordchange = int(icoord)\\n self.ispec = int(ispec)\\n self.ireg = int(ireg)\\n self.xori = xori\\n self.yori = yori\\n self.dx = dx\\n self.dy = dy\\n self.nx = int(nx)\\n self.ny = int(ny)\\n self.valex = valex\\n self.snr = snr\\n self.varbak = varbak\\n\\n # Compute domain limits for later use\\n self.xend = self.xori + (self.nx - 1) * self.dx\\n self.yend = self.yori + (self.ny - 1) * self.dy\\n\\n return self\\n else:\\n logger.error(\\\"File {0} does not exist\\\".format(filename))\\n raise FileNotFoundError('File does not exist')\",\n \"def read_simulation_results(self,\\n fname_sims, \\n fname_pareto = None, \\n fname_cull = None):\\n\\n \\n self.fname_sims = fname_sims\\n self.__read_file(fname_sims, 'sim_results')\\n \\n if fname_pareto is not None:\\n self.fname_pareto = fname_pareto\\n self.__read_file(fname_in, 'pareto')\\n \\n if fname_cull is not None:\\n self.fname_cull = fname_cull\\n self.__read_file(fname_in, 'cull')\",\n \"def _read_parameter_file():\\n if not os.path.exists(\\\"./config.txt\\\"):\\n raise FileNotFoundError(\\\"Can't find the configuration file \\\"\\n \\\"./config.txt\\\")\\n\\n required = ['compiler_suite', 'project_name', 'scratch_path',\\n 'specfem_root', 'lasif_path', 'iteration_name']\\n\\n # Read parameters into dictionary.\\n parameters = {}\\n file = open(\\\"./config.txt\\\", \\\"r\\\")\\n for line in file:\\n if line.startswith(\\\"#\\\"):\\n continue\\n fields = line.split()\\n parameters.update({fields[0]: fields[1]})\\n\\n # Ensure all parameters are there.\\n for param in required:\\n if param not in parameters.keys():\\n raise ParameterError(\\\"Parameter \\\" + param + \\\" not in parameter \\\"\\n \\\"file\\\")\\n\\n # Build full paths.\\n parameters['scratch_path'] = os.path.abspath(parameters['scratch_path'])\\n parameters['specfem_root'] = os.path.abspath(parameters['specfem_root'])\\n parameters['lasif_path'] = os.path.abspath(parameters['lasif_path'])\\n\\n # Derived parameters.\\n forward_stage_dir = os.path.join(\\n parameters['scratch_path'],\\n parameters['project_name'])\\n forward_run_dir = os.path.join(\\n forward_stage_dir,\\n parameters['iteration_name'])\\n lasif_scratch_path = os.path.join(\\n parameters['scratch_path'],\\n os.path.basename(\\n parameters['lasif_path']))\\n\\n # Get list of all event names.\\n try:\\n iteration_xml_path = os.path.join(\\n parameters['lasif_path'],\\n 'ITERATIONS',\\n 'ITERATION_%s.xml' %\\n (parameters['iteration_name']))\\n tree = ET.parse(iteration_xml_path)\\n except:\\n iteration_xml_path = os.path.join(\\n lasif_scratch_path,\\n 'ITERATIONS',\\n 'ITERATION_%s.xml' %\\n (parameters['iteration_name']))\\n tree = ET.parse(iteration_xml_path) \\n \\n root = tree.getroot()\\n event_list = []\\n for name in root.findall('event'):\\n for event in name.findall('event_name'):\\n event_list.append(event.text)\\n\\n parameters.update({'forward_stage_dir': forward_stage_dir})\\n parameters.update({'forward_run_dir': forward_run_dir})\\n parameters.update({'iteration_xml_path': iteration_xml_path})\\n parameters.update({'event_list': sorted(event_list)})\\n parameters.update({'lasif_scratch_path': lasif_scratch_path})\\n\\n return parameters\",\n \"def readCrystParam(crystfile):\\n \\n # Default values\\n ccell1 = np.eye(3)\\n ccell2 = np.eye(3)\\n planehkl = [1,0,0]\\n diruvw = [0,1,0]\\n \\n try:\\n with open(crystfile,\\\"r\\\") as f:\\n content = f.readlines()\\n except FileNotFoundError:\\n content = []\\n\\n for l in content:\\n if l[0].rstrip() == \\\"#\\\":\\n continue\\n line = l.split('=')\\n if len(line) == 2:\\n if line[0].rstrip()==\\\"ccell1\\\":\\n ccell1 = eval(line[1].rstrip())\\n elif line[0].rstrip()==\\\"ccell2\\\":\\n ccell2 = eval(line[1].rstrip())\\n elif line[0].rstrip()==\\\"planehkl\\\":\\n planehkl = eval(line[1].rstrip())\\n elif line[0].rstrip()==\\\"diruvw\\\":\\n diruvw = eval(line[1].rstrip())\\n else:\\n print(\\\"WARNING: %s is not a supported input\\\"%(line[0].rstrip()))\\n elif len(line) > 2:\\n raise SyntaxError(l)\\n\\n return ccell1, ccell2, planehkl, diruvw\",\n \"def readFile(file_name):\\n if file_name.split('.')[-1] == 'thid':\\n x,m,w = readThid(file_name)\\n e = np.empty_like(x)\\n e[:] = np.nan\\n return x,m,w,e\\n else:\\n return readParams(file_name)\",\n \"def readVP(self,species): \\n f = open('VPparams.txt', 'rU')\\n lines = f.readlines()\\n f.close()\\n \\n parsing = False\\n for i in np.arange(len(lines)):\\n if lines[i].startswith(species):\\n parsing = True\\n else:\\n parsing = False\\n if parsing:\\n data = lines[i].split()\\n \\n lnC, L0, Rv, da, db = data[1:len(data)]\\n self.lnC, self.L0, self.Rv, self.da, self.db = \\\\\\n float(lnC), float(L0), float(Rv), float(da), float(db)\",\n \"def read_positions():\\n return np.genfromtxt(\\\"POSITIONS.OUT\\\").transpose()\",\n \"def read_sim_par(file):\\n simu_info = read_simu_info_merged_hdf5(file)\\n emin = simu_info.energy_range_min\\n emax = simu_info.energy_range_max\\n sp_idx = simu_info.spectral_index\\n sim_ev = simu_info.n_showers * simu_info.shower_reuse\\n area_sim = (simu_info.max_scatter_range - simu_info.min_scatter_range) ** 2 * np.pi\\n cone = simu_info.max_viewcone_radius\\n\\n par_var = [emin, emax, sp_idx, sim_ev, area_sim, cone]\\n par_dic = ['emin', 'emax', 'sp_idx', 'sim_ev', 'area_sim', 'cone']\\n par = dict(zip(par_dic, par_var))\\n\\n # Pass units to TeV and cm2\\n par['emin'] = par['emin'].to(u.TeV)\\n par['emax'] = par['emax'].to(u.TeV)\\n par['area_sim'] = par['area_sim'].to(u.cm ** 2)\\n\\n return par\",\n \"def read_file(self, filename=None):\\n print(f'reading file')\\n\\n if filename is None:\\n filename = self.model_file\\n\\n with open(filename, 'r') as f:\\n # count number of lines\\n npts_file = sum([1 for line in f])\\n\\n # go back to start and read second line in file to get number of variables\\n f.seek(0)\\n f.readline()\\n l = f.readline()\\n nvars_file = int(l.split(' ')[-1])\\n\\n # subtract header rows\\n npts_file -= (nvars_file + 2)\\n\\n print(f'{nvars_file} variables found in the initial model file')\\n print(f'{npts_file} points found in the initial model file')\\n\\n var_idx_map = {}\\n\\n # read in the names of the variables\\n for i in range(nvars_file):\\n var_name_file = f.readline().strip()\\n if var_name_file.lower() == 'n':\\n var_name_file = 'neut'\\n elif var_name_file == 'p':\\n var_name_file = 'prot'\\n\\n # create map of file indices to model indices\\n try:\\n var_idx_map[self.idx[var_name_file]] = i+1\\n except KeyError:\\n pass\\n\\n base_r = np.zeros(npts_file)\\n base_state = np.zeros((npts_file, self.nvar))\\n\\n # read in model data\\n for i, line in enumerate(f):\\n variables = [float(v) for v in line.split(' ')]\\n\\n base_r[i] = variables[2]\\n\\n for j in range(self.nvar):\\n if j in var_idx_map:\\n base_state[i, j] = variables[var_idx_map[j]]\\n\\n return npts_file, base_r, base_state\",\n \"def _read_input_file(self):\\n file_type = 'np.array'\\n with open(self._file_properties['file_name'], 'r') as in_file:\\n for line in in_file.readlines():\\n if line[0:5] == '$$SOE':\\n file_type = 'Horizons'\\n break\\n\\n if not isfile(self._file_properties['file_name']):\\n msg = 'Horizons files {:} does not exists.'\\n message = msg.format(self._file_properties['file_name'])\\n raise FileExistsError(message)\\n if file_type == 'Horizons':\\n self._read_horizons_file()\\n else:\\n (time, x, y, z) = np.loadtxt(\\n self._file_properties['file_name'],\\n usecols=(0, 1, 2, 3), unpack=True)\\n self._time = time\\n if int(astropy_version[0]) >= 4:\\n self._xyz = SkyCoord(x=x, y=y, z=z,\\n representation_type='cartesian')\\n else:\\n self._xyz = SkyCoord(x=x, y=y, z=z,\\n representation='cartesian')\",\n \"def read(f):\\n \\n if isinstance(f, basestring):\\n # If the input is a string, treat as file name\\n with open(f) as fh: # Ensure file is closed\\n return read(fh) # Call again with file object\\n \\n # First line contains the date\\n date = f.readline()\\n if not date:\\n raise IOError(\\\"Cannot read from input file \\\"+str(filename))\\n \\n # Second is description\\n desc = f.readline()\\n \\n token = file_numbers(f)\\n \\n # Third contains number of mesh points\\n try:\\n npsi = int(token.next())\\n ntheta = int(token.next())\\n isym = int(token.next())\\n except StopIteration:\\n raise IOError(\\\"Unexpected end of file while reading grid size\\\")\\n except ValueError:\\n raise IOError(\\\"Third line should contain npsi, ntheta and isym\\\")\\n \\n # Check values\\n if (isym < 0) or (isym > 1):\\n raise IOError(\\\"isym must be either 0 or 1\\\")\\n if (npsi < 1) or (ntheta < 1):\\n raise IOError(\\\"Invalid npsi=\\\"+str(npsi)+\\\" or ntheta=\\\" + str(ntheta))\\n \\n # Read normalisation factors\\n\\n try:\\n rcnt = float(token.next())\\n xma = float(token.next())\\n zma = float(token.next())\\n btor = float(token.next())\\n curtot = float(token.next())\\n eaxe = float(token.next())\\n dnorm = float(token.next())\\n except:\\n raise IOError(\\\"Couldn't read normalisation factors\\\")\\n \\n def read_array(n, name=\\\"Unknown\\\"):\\n data = np.zeros([n])\\n try:\\n for i in np.arange(n):\\n data[i] = float(token.next())\\n except:\\n raise IOError(\\\"Failed reading array '\\\"+name+\\\"' of size \\\", n)\\n return data\\n\\n def read_2d(nx, ny, name=\\\"Unknown\\\"):\\n data = np.zeros([nx, ny])\\n for i in np.arange(nx):\\n data[i,:] = read_array(ny, name+\\\"[\\\"+str(i)+\\\"]\\\")\\n return data\\n\\n # Read 1D arrays\\n psiflux = read_array(npsi, \\\"psiflux\\\")\\n fnorm = read_array(npsi, \\\"fnorm\\\")\\n ffpnorm = read_array(npsi, \\\"ffpnorm\\\")\\n ponly = read_array(npsi, \\\"ponly\\\")\\n pponly = read_array(npsi, \\\"pponly\\\")\\n qsf = read_array(npsi, \\\"qsf\\\")\\n d = read_array(npsi, \\\"d\\\")\\n \\n dpdz = read_array(ntheta, \\\"dpdz\\\")\\n dpdr = read_array(ntheta, \\\"dpdr\\\")\\n \\n # 2D arrays\\n \\n xnorm = read_2d(ntheta, npsi, \\\"xnorm\\\")\\n znorm = read_2d(ntheta, npsi, \\\"znorm\\\")\\n \\n # Try to read Br and Bz (may be present)\\n try:\\n Br = read_2d(ntheta, npsi, \\\"Br\\\")\\n Bz = read_2d(ntheta, npsi, \\\"Bz\\\")\\n except:\\n Br = Bz = None\\n \\n ny = ntheta\\n\\n if isym == 1:\\n # Fill in values for up-down symmetric case\\n print(\\\"Grid is up-down symmetric. Reflecting grid about midplane\\\")\\n ny = tsize = 2*(ntheta - 1) + 1\\n \\n def reflect(data, mapfunc = lambda x:x):\\n \\\"\\\"\\\" Reflect a variable about midplane\\n Optionally supply a mapping function\\\"\\\"\\\"\\n data2 = np.zeros([tsize, npsi])\\n # Copy the original data\\n for i in np.arange(ntheta):\\n data2[i,:] = data[i,:]\\n # Now fill in the remainder\\n for i in np.arange(ntheta, tsize):\\n t0 = tsize - 1 - i\\n data2[i,:] = mapfunc(data[t0,:])\\n return data2\\n \\n xnorm = reflect(xnorm)\\n znorm = reflect(znorm, lambda x: 2.*zma - x) # Reflect about zma\\n if Br != None:\\n Br = reflect(Br, lambda x:-x) # Br reverses\\n if Bz != None:\\n Bz = reflect(Bz) # Bz remains the same\\n theta = tsize\\n\\n # Make sure we have Br, Bz and Bpol\\n\\n if (Br == None) or (Bz == None):\\n # Calculate Bpol from psi then Br and Bz from Bpol\\n # Use dpsi = R*Bp dx (for now)\\n Bpol = np.zeros([ny, npsi])\\n \\n def deriv(f):\\n n = np.size(f)\\n dfdi = np.zeros(n)\\n dfdi[1:-1] = (f[2:n] - f[0:-2])/2. # Central difference in the middle\\n dfdi[0] = f[1] - f[0]\\n dfdi[-1] = f[-1] - f[-2]\\n return dfdi\\n \\n for i in np.arange(ntheta):\\n drdi = deriv(xnorm[i, :])\\n dzdi = deriv(znorm[i, :])\\n dldi = sqrt(drdi**2 + dzdi**2) # Arc length\\n dpsidi = deriv(psiflux)\\n \\n Bpol[i, :] = dpsidi / (dldi * xnorm[i,:])\\n else:\\n Bpol = np.sqrt(Br**2 + Bz**2)\\n \\n # Calculate toroidal field\\n Btor = fnorm / xnorm\\n \\n #########################################\\n # Create a dictionary of values to return\\n # \\n # Need to transpose 2D arrays to [psi, theta] \\n # to be consistent with elite inputs\\n \\n var = {\\\"npsi\\\":npsi, \\\"npol\\\":ny, # Sizes\\n \\n \\\"psi\\\":psiflux,\\n \\\"f(psi)\\\":fnorm,\\n \\\"p\\\":ponly,\\n \\n \\\"R\\\": np.transpose(xnorm),\\n \\\"Z\\\": np.transpose(znorm),\\n\\n \\\"Bp\\\":np.transpose(Bpol),\\n \\\"Bt\\\":np.transpose(Btor),\\n\\n \\\"q\\\":qsf,\\n\\n \\\"ffprime\\\":ffpnorm,\\n \\\"pprime\\\":pponly}\\n\\n if Br != None:\\n var['Br'] = np.transpose(Br)\\n if Bz != None:\\n var['Bz'] = np.transpose(Bz)\\n \\n return var\",\n \"def read_body(filepath, **kwargs):\\n with open(filepath, 'r') as infile:\\n coords = numpy.loadtxt(infile, unpack=True, **kwargs)\\n return coords\",\n \"def process(path):\\n # get parameter value:\\n with open('config.cym', 'r') as f:\\n line = f.readline()\\n #print(line)\\n pam = float(line[1:])\\n f.close()\\n # get position of aster:\\n with open('aster.txt', 'r') as f:\\n for line in f:\\n if len(line)>3 and not line[0]=='%':\\n #print(line)\\n val = line.split()\\n x = float(val[2])\\n y = float(val[3])\\n #z = float(val[4])\\n #pos = math.sqrt(x*x+y*y+z*z)\\n pos = math.sqrt(x*x+y*y)\\n\\n f.close()\\n return (pam, pos)\",\n \"def read_parameters_diff_file(coords):\\n param_map = hp.read_map(source +\\n \\\"kids_data/\\\"\\n \\\"COM_CompMap_Compton-SZMap-milca-\\\"\\n \\\"ymaps_2048_R2.00.fits\\\")\\n params = []\\n for point in coords:\\n ra, dec = point\\n index = declratoindex(dec, ra)\\n params.append(param_map[index])\\n return params\",\n \"def read_data(self):\\n data = np.genfromtxt(self.__file) # Planck SED\\n self.__nu = 10.0**data[:,0]\\n self.__nuF = 10.0**data[:,2]\\n self.__err = 10.0**data[:,3]\\n #self.__W = 10.0**data[:,4]\\n self.__yerr = [ self.__nuF - self.__nuF / self.__err, \\\\\\n self.__nuF * self.__err - self.__nuF ]\\n self.__maxY = max( self.__nuF )\\n self.__minY = min( self.__nuF )\",\n \"def loadParameters(self, parmfile=''):\\n if not parmfile:\\n raise IOError(\\\"You need to specify a parameter filename\\\")\\n parmdir = os.getenv('ATMOSPHERE_PARAMETERS_DIR')\\n parmpath = os.join.path(parmdir, parmfile)\\n # Read from file\\n with open(parmpath, 'r') as parmf:\\n data = pickle.load(parmf)\\n # Dictionary list\\n self.modtran_visits = data[0]\\n # Tuple list\\n self.aerosol_visits = data[1]\\n # seed value\\n nruns = len(self.modtran_visits)\\n print('Parameters for {1} runs computed with seed = {0}'.format(data[2],\\n nruns))\\n # Init transmission array\\n self.initTransmissionArray(nruns)\",\n \"def read_xyz(filename):\\n\\n config = {}\\n\\n with open(filename, 'r') as f:\\n # number of atoms (spins)\\n config['nat'] = int(re.findall('\\\\S+', f.readline())[0])\\n\\n # box parameters (type, dimension, shape, periodicity)\\n sarr = re.findall('\\\\S+', f.readline())\\n config['latt_type'] = sarr[0]\\n dims = list(map(int, sarr[1:4]))\\n config['latt_box'] = np.array(dims)\\n config['box'] = np.diag(dims)\\n config['pbc'] = list(map(int, sarr[4:7]))\\n if len(sarr) > 7:\\n dim_intra = len(sarr) - 7\\n\\n atom_types = []\\n xyz = []\\n config['latt_i'] = np.zeros(dims, dtype=int)\\n config['latt_atoms'] = np.zeros(dims, dtype=int)\\n config['latt_intra'] = np.zeros(tuple(dims) + (dim_intra,), dtype='float64')\\n for i in range(config['nat']):\\n sarr = re.findall('\\\\S+', f.readline())\\n t = int(sarr[0])\\n r = tuple(map(int, sarr[1:4]))\\n\\n atom_types.append(t)\\n xyz.append(r)\\n\\n config['latt_i'][r] = i\\n config['latt_atoms'][r] = t\\n\\n for j in range(dim_intra):\\n ci = float(sarr[4 + j])\\n config['latt_intra'][r[0], r[1], r[2], j] = ci\\n\\n config['atom_types'] = np.array(atom_types)\\n config['xyz'] = np.array(xyz)\\n \\n return config\",\n \"def readin():\\r\\n nodes = np.loadtxt('Vnodes.txt', ndmin=2)\\r\\n mats = np.loadtxt('Vmater.txt', ndmin=2)\\r\\n elements = np.loadtxt('Veles.txt', ndmin=2)\\r\\n loads = np.loadtxt('Vloads.txt', ndmin=2)\\r\\n return nodes, mats, elements, loads\",\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 test_open_file(self):\\n\\t\\tposition, potential = schrodinger.open_file('potential_energy.dat')\\n\\t\\tself.assertEqual(position, [0.0, 1.57079, 3.14159, 4.71238, 6.28318, 7.85398, 9.42477])\\n\\t\\tself.assertEqual(potential, [0.0, 6.0, 0.0, -6.0, 0.0, 6.0, 0.0])\",\n \"def read_parameters():\\n hdulist1 = pf.open(source+'/kids_data/KiDS_DR3.1_G9_ugri_shear.fits')\\n param1 = hdulist1[1].data['e1'][:sample]\\n param2 = hdulist1[1].data['e2'][:sample]\\n weights = hdulist1[1].data['weight'][:sample]\\n return param1, param2, weights\",\n \"def load_simulation_mass(self, file_name):\\n \\n data = np.genfromtxt(file_name, names=True)\\n \\n if not hasattr(self, 'simulation_data'):\\n self.simulation_data = {}\\n \\n \\n self.simulation_data['mass'] = data['m'] # assuming in solar masses\\n self.simulation_data['time'] = data['t'] # assuming in millions of years\",\n \"def read_input_file(self):\\n\\n # Check if input file exists in current directory, if not kill process\\n if not os.path.isfile('./visualise.inpt'):\\n print('Cannot find input file \\\"visualise.inpt\\\" in current directory')\\n sys.exit()\\n\\n # Read input file and analysis options and parameters\\n print('Reading input file')\\n with open('visualise.inpt','r') as f:\\n f.readline()\\n self.prefix = f.readline().split()[0]\\n f.readline()\\n f.readline()\\n self.frame = int(f.readline().split()[0])\\n f.readline()\\n f.readline()\\n self.vis_particles = int(f.readline().split()[0])\\n self.vis_vortype = int(f.readline().split()[0])\\n self.vis_cellcolour = int(f.readline().split()[0])\\n self.vis_save = int(f.readline().split()[0])\",\n \"def read_setup(inifile):\\n # inifile = os.path.join(spathy_path, inifile)\\n print(inifile)\\n cfg = configparser.ConfigParser()\\n cfg.read(inifile)\\n\\n pp = {}\\n for s in cfg.sections():\\n section = s.encode('ascii', 'ignore')\\n pp[section] = {}\\n for k, v in cfg.items(section):\\n key = k.encode('ascii', 'ignore')\\n val = v.encode('ascii', 'ignore')\\n if section == 'General': # 'general' section\\n pp[section][key] = val\\n else:\\n pp[section][key] = float(val)\\n pp['General']['dt'] = float(pp['General']['dt'])\\n\\n pgen = pp['General']\\n pcpy = pp['CanopyGrid']\\n pbu = pp['BucketGrid']\\n ptop = pp['Topmodel']\\n\\n return pgen, pcpy, pbu, ptop\",\n \"def read_results():\\r\\n with open(\\\"packing.nfo\\\", \\\"r\\\") as fin:\\r\\n fin.readline()\\r\\n fin.readline()\\r\\n por_theory = float(fin.readline().split()[2])\\r\\n por_final = float(fin.readline().split()[2])\\r\\n print('Theoretical porosity:', por_theory)\\r\\n print('Final porosity:', por_final)\\r\\n with open(\\\"packing.xyzd\\\", \\\"rb\\\") as fin:\\r\\n btxt = fin.read()\\r\\n txt = list(struct.unpack(\\\"<\\\" + \\\"d\\\" * (len(btxt) // 8), btxt))\\r\\n data = array(zip(*[iter(txt)] * 4))\\r\\n data[:, 3] = data[:, 3] * \\\\\\r\\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\\r\\n return data\",\n \"def read_parameters(self, entry=None):\\n if entry:\\n self.entry = entry\\n with self.entry.nxfile:\\n self.name = self.entry.nxroot.nxname + \\\"/\\\" + self.entry.nxname\\n if 'unit_cell' in self.entry['sample']:\\n lattice_parameters = self.read_parameter('sample/unit_cell')\\n if lattice_parameters is not None:\\n self.a, self.b, self.c = lattice_parameters[:3]\\n self.alpha, self.beta, self.gamma = lattice_parameters[3:]\\n elif 'unit_cell_abc' in self.entry['sample']:\\n lattice_parameters = self.read_parameter(\\n 'sample/unit_cell_abc')\\n if lattice_parameters is not None:\\n self.a, self.b, self.c = lattice_parameters\\n lattice_parameters = self.read_parameter(\\n 'sample/unit_cell_alphabetagamma')\\n if lattice_parameters is not None:\\n self.alpha, self.beta, self.gamma = lattice_parameters\\n else:\\n self.a = self.read_parameter('sample/unitcell_a', self.a)\\n self.b = self.read_parameter('sample/unitcell_b', self.b)\\n self.c = self.read_parameter('sample/unitcell_c', self.c)\\n self.alpha = self.read_parameter(\\n 'sample/unitcell_alpha', self.alpha)\\n self.beta = self.read_parameter(\\n 'sample/unitcell_beta', self.beta)\\n self.gamma = self.read_parameter(\\n 'sample/unitcell_gamma', self.gamma)\\n self.formula = self.read_parameter('sample/chemical_formula',\\n self.formula)\\n self.space_group = self.read_parameter(\\n 'sample/space_group', self.space_group)\\n self.laue_group = self.read_parameter(\\n 'sample/laue_group', self.laue_group)\\n self.wavelength = self.read_parameter(\\n 'instrument/monochromator/wavelength', self.wavelength)\\n self.distance = self.read_parameter('instrument/detector/distance',\\n self.distance)\\n self.yaw = self.read_parameter('instrument/detector/yaw', self.yaw)\\n self.pitch = self.read_parameter('instrument/detector/pitch',\\n self.pitch)\\n self.roll = self.read_parameter(\\n 'instrument/detector/roll', self.roll)\\n self.xc = self.read_parameter('instrument/detector/beam_center_x',\\n self.xc)\\n self.yc = self.read_parameter('instrument/detector/beam_center_y',\\n self.yc)\\n self.xd = self.read_parameter('instrument/detector/translation_x',\\n self.xd)\\n self.yd = self.read_parameter('instrument/detector/translation_y',\\n self.yd)\\n self.frame_time = self.read_parameter(\\n 'instrument/detector/frame_time', self.frame_time)\\n self.shape = self.read_parameter(\\n 'instrument/detector/shape', self.shape)\\n phi = self.read_parameter('instrument/goniometer/phi', self.phi)\\n if isinstance(phi, np.ndarray) and len(phi) > 1:\\n self.phi = phi[0]\\n self.phi_step = phi[1] - phi[0]\\n else:\\n self.phi = phi\\n try:\\n self.phi_step = self.read_parameter(\\n 'instrument/goniometer/phi', self.phi, attr='step')\\n except Exception:\\n pass\\n self.chi = self.read_parameter(\\n 'instrument/goniometer/chi', self.chi)\\n self.omega = self.read_parameter('instrument/goniometer/omega',\\n self.omega)\\n if 'instrument/goniometer' in self.entry:\\n if 'theta' in self.entry['instrument/goniometer']:\\n self.theta = self.read_parameter(\\n 'instrument/goniometer/theta', self.theta)\\n elif 'goniometer_pitch' in self.entry['instrument/goniometer']:\\n self.theta = self.read_parameter(\\n 'instrument/goniometer/goniometer_pitch', self.theta)\\n elif 'gonpitch' in self.entry['instrument/goniometer']:\\n self.theta = self.read_parameter(\\n 'instrument/goniometer/gonpitch', self.theta)\\n self.symmetry = self.read_parameter('sample/unit_cell_group',\\n self.symmetry)\\n self.centring = self.read_parameter('sample/lattice_centring',\\n self.centring)\\n self.xp = self.read_parameter('peaks/x')\\n self.yp = self.read_parameter('peaks/y')\\n self.zp = self.read_parameter('peaks/z')\\n self.polar_angle = self.read_parameter('peaks/polar_angle')\\n self.azimuthal_angle = self.read_parameter('peaks/azimuthal_angle')\\n self.intensity = self.read_parameter('peaks/intensity')\\n self.pixel_size = self.read_parameter(\\n 'instrument/detector/pixel_size', self.pixel_size)\\n self.pixel_mask = self.read_parameter(\\n 'instrument/detector/pixel_mask')\\n self.pixel_mask_applied = self.read_parameter(\\n 'instrument/detector/pixel_mask_applied')\\n self.rotation_angle = self.read_parameter('peaks/rotation_angle')\\n self.primary = self.read_parameter('peaks/primary_reflection')\\n self.secondary = self.read_parameter('peaks/secondary_reflection')\\n self.Umat = self.read_parameter(\\n 'instrument/detector/orientation_matrix')\\n if isinstance(self.polar_angle, np.ndarray):\\n try:\\n self.set_polar_max(np.sort(self.polar_angle)[200] + 0.1)\\n except IndexError:\\n self.set_polar_max(self.polar_angle.max())\\n else:\\n self.set_polar_max(10.0)\\n self.Qh = self.read_parameter('transform/Qh')\\n self.Qk = self.read_parameter('transform/Qk')\\n self.Ql = self.read_parameter('transform/Ql')\\n self.initialize_peaks()\",\n \"def read_params():\\n \\n # Get the input list\\n params = argv\\n params.pop(0)\\n \\n #Check if quoting is necessary\\n params = check_double_quote(params)\\n \\n # Declare input file\\n fin = read_item(params, '-s=', './opt_probl.txt')\\n # Find standard output directory\\n fout = read_item(params, '-d=', './opt_sol.txt')\\n \\n return ( fin, fout )\",\n \"def read_from(self, filename):\\n self.x, self.y = np.loadtxt(filename, unpack=True, usecols=(0, 1))\",\n \"def _read_config_file(self):\\n wcec = 0\\n deadline = 0\\n jitter = 0\\n init_freq = 0\\n freqs_volt = {}\\n freqs = []\\n volts = []\\n config_file_name = self._find_file('sim_simple.config')\\n with open(config_file_name, 'rU') as f:\\n lines = f.readlines()\\n try:\\n for freq in lines[0].split():\\n freqs.append(float(freq))\\n\\n for volt in lines[1].split():\\n volts.append(float(volt))\\n\\n for i in range(0, len(freqs)):\\n freqs_volt[freqs[i]] = volts[i]\\n\\n data = lines[2].split()\\n wcec = float(data[0])\\n deadline = float(data[1])\\n period = float(data[2])\\n jitter = float(data[3])\\n init_freq = float(data[4])\\n except ValueError, IndexError:\\n print 'Invalid data in config file'\\n sys.exit(1)\\n\\n return wcec, deadline, period, jitter, init_freq, freqs_volt\",\n \"def read_params(fname):\\n f = open(fname, 'r')\\n par = {} #output\\n for i in range(10): # esta dentro de las primeras 10 lineas\\n l = f.readline().split()\\n #print \\\" ---> \\\", l\\n number = u'%s' % l[-1] # presumably a number\\n if not number.replace('.','').replace('-','').isnumeric():\\n if l[0]=='#####':\\n break\\n else:\\n continue # we proceed ONLY IF this is numeric string\\n #print ' FIRST: ', l[0]\\n if l[0]=='#####':\\n #print \\\"IM I HERE????\\\"\\n break # end of header\\n\\n name = l[1][:-1] # l[0] es '#', y -1 para comernos el \\\":\\\"\\n value = np.float(l[2]) # l[2] es el valor\\n par[name] = value\\n\\n return par\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=4,\\n task=4,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.01,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"fat-tail\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(\\n params[key],\\n actual_sim_parameters[key],\\n msg=\\\"Error in {}: {}!={}\\\".format(key, params[key], actual_sim_parameters[key]),\\n )\\n self.assertEqual(self.tree.get_job()[0], 4, msg=\\\"Job number not stored correctly.\\\")\\n self.assertEqual(self.tree.get_job()[1], 4, msg=\\\"Job number not stored correctly.\\\")\",\n \"def ReadParameterFile(pf):\\n f = open(pf, \\\"r\\\")\\n pf_dict = SetDefaultParameterValues()\\n for line in f:\\n if not line.split(): \\n continue\\n if line.split()[0][0] == \\\"#\\\": \\n continue\\n \\n # This will prevent crashes if there is not a blank line at the end of the parameter file\\n if line[-1] != '\\\\n': \\n line += '\\\\n'\\n \\n # Cleave off end-of-line comments.\\n line = line[:line.rfind(\\\"#\\\")].strip()\\n \\n # Read in the parameter name and the parameter value(s).\\n parname, eq, parval = line.partition(\\\"=\\\")\\n \\n # Else, actually read in the parameter \\n try: \\n parval = float(parval)\\n except ValueError:\\n if re.search('/', parval): # For directory with more than one level\\n parval = str(parval.strip())\\n elif parval.strip().isalnum(): \\n parval = str(parval.strip())\\n elif parval.replace('_', '').strip().isalnum():\\n parval = parval.strip()\\n elif parval.partition('.')[-1] in ['dat', 'hdf5', 'h5', 'txt']:\\n parval = str(parval.strip())\\n else:\\n parval = parval.strip().split(\\\",\\\")\\n tmp = [] \\n if parval[0][0] == '(':\\n for element in parval: \\n if element.strip(\\\" (,)\\\").isdigit(): \\n tmp.append(float(element.strip(\\\"(,)\\\")))\\n else: \\n tmp.append(element.strip(\\\" (,)\\\"))\\n parval = tuple(tmp) \\n elif parval[0][0] == '[':\\n for element in parval: \\n tmp.append(float(element.strip(\\\"[,]\\\")))\\n parval = list(tmp)\\n else:\\n print(parname, parval)\\n raise ValueError('The format of this parameter is not understood.')\\n \\n pf_dict[parname.strip()] = parval\\n \\n return pf_dict\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=3,\\n task=3,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"none\\\",\\n coarse_map_x=13,\\n coarse_map_y=13,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 3)\\n self.assertEqual(self.tree.get_job()[1], 3)\",\n \"def load_params():\\n with open('params.p', mode='rb') as in_file:\\n return pickle.load(in_file)\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=1,\\n task=30,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"tiled_coarse\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 1)\\n self.assertEqual(self.tree.get_job()[1], 30)\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=7,\\n task=4,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=1.0,\\n deme=0.01,\\n sample_size=1.5,\\n max_time=3600.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(\\n params[key],\\n actual_sim_parameters[key],\\n msg=\\\"Error in {}: {}!={}\\\".format(key, params[key], actual_sim_parameters[key]),\\n )\\n self.assertEqual(self.tree.get_job()[0], 7, msg=\\\"Seed not stored correctly.\\\")\\n self.assertEqual(self.tree.get_job()[1], 4, msg=\\\"Job number not stored correctly.\\\")\",\n \"def load_dat(file_name):\\n data = loadmat(file_name)\\n y = data['y']\\n X = data['X']\\n return X,y\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=5,\\n task=4,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=1.0,\\n deme=0.25,\\n sample_size=1.0,\\n max_time=3600.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(\\n params[key],\\n actual_sim_parameters[key],\\n msg=\\\"Error in {}: {}!={}\\\".format(key, params[key], actual_sim_parameters[key]),\\n )\\n self.assertEqual(self.tree.get_job()[0], 5, msg=\\\"Seed not stored correctly.\\\")\\n self.assertEqual(self.tree.get_job()[1], 4, msg=\\\"Job number not stored correctly.\\\")\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=2,\\n task=2,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=1.0,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"null\\\",\\n coarse_map_x=20,\\n coarse_map_y=20,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"null\\\",\\n fine_map_x=10,\\n fine_map_y=10,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=10,\\n grid_y=10,\\n sample_x=10,\\n sample_y=10,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=1.0,\\n cutoff=0.0,\\n landscape_type=\\\"infinite\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 2)\\n self.assertEqual(self.tree.get_job()[1], 2)\",\n \"def read_config_file():\\n config = ConfigParser()\\n config.read('config.ini')\\n\\n # Get the model parameters as correct type\\n batch_size = config.getint('model params', 'batch_size')\\n resize_to = config.getint('model params', 'resize_to')\\n train_prop = config.getfloat('model params', 'train_prop')\\n\\n return batch_size, resize_to, train_prop\",\n \"def read_xyz(self, filename):\\n # first line contains number of atoms\\n self.numatom = int(filename.readline().split()[0])\\n # second line contains a comment\\n self.comment = filename.readline()[:-3]\\n # rest of the lines contain coordinates structured Element X Y Z\\n string = \\\"Element X Y Z \\\\n\\\" + filename.read()\\n self.contents = pd.read_table(StringIO(string), sep=r'\\\\s+')\",\n \"def read_seed_parameters():\\n\\n with open(\\\"../../output/seed.tmp\\\", \\\"r\\\") as f:\\n seed = int(f.readline())\\n samples = int(f.readline())\\n return (seed, samples)\",\n \"def readInput(in_file_name):\\n in_file = open(in_file_name, 'r')\\n positions = []\\n samples = []\\n M = []; P = [];\\n MC = []; PC = [];\\n while True:\\n line = in_file.readline()\\n if not line: break\\n if line[0] == '#': continue #skip comment\\n line = line.rstrip('\\\\n').split('\\\\t')\\n \\n #genomic positions and allele support in plasma samples\\n positions.append(int(line[0]))\\n samples.append(tuple(map(int, line[1:5])))\\n \\n #maternal and paternal alleles\\n M.append(tuple(line[5:7]))\\n MC.append(tuple(map(float, line[7:9])))\\n \\n P.append(tuple(line[9:11]))\\n PC.append(tuple(map(float, line[11:13]))) \\n \\n in_file.close()\\n return positions, samples, M, P, MC, PC\",\n \"def readInstance(self):\\n file = open(self.fName, 'r')\\n self.genSize = int(file.readline())\\n self.data = {}\\n for line in file:\\n (id, x, y) = line.split()\\n self.data[int(id)] = (int(x), int(y))\\n file.close()\",\n \"def readOutputfile(filename, verbose=False):\\n\\n # -----------------------------------------------------------------------------\\n # Defining the classes for data structure\\n T_Simulation = namedtuple('Simulation', ['step'])\\n T_Step = namedtuple('Step', ['element', 'node'])\\n\\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\\n\\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\\n T_GP = namedtuple('GP', ['stress', 'strain'])\\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n # -----------------------------------------------------------------------------\\n\\n nSteps = 0 # Simulation step counter\\n\\n SimData = T_Simulation(list())\\n\\n with open(filename) as f:\\n line = f.readline() # Read in the first line of the input file\\n while True: # Loop over all lines of the input file\\n # Read the nodes displacements\\n #line = f.readline()\\n #print(line)\\n if line == 'DofManager output:\\\\n': # String starts a list of nodes displacement information\\n nSteps += 1 # The above string starts a new simulation step\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Nodes = list() # Initialize/clear list of nodes\\n\\n while line != '\\\\n' and line != 'Element output:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\tnNode = int(line.strip().split()[1]) # Node id\\n line = f.readline()\\n dim1 = float(line.strip().split()[3]) # Displacement dim1\\n line = f.readline()\\n dim2 = float(line.strip().split()[3]) # Displacement dim2\\n Nodes.append(\\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\\n line = f.readline()\\n\\n\\n if verbose:\\n print('Step {}: Dofs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n # Read the stresses an strains at Gauss points\\n elif line == 'Element output:\\\\n': # String starts a list elements, GPs, strains and stresses\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Elements = list() # Initialize/clear list of elements\\n\\n while line != '\\\\n' and line != '\\\\tR E A C T I O N S O U T P U T:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\t\\tnElement = line.strip().split()[2] # Element id\\n line = f.readline()\\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\\n\\n while line != '\\\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\\n #\\t\\t\\t\\t\\t\\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n line = f.readline()\\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n GPs.gp.append(\\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\\n line = f.readline()\\n\\n\\n Elements.append(GPs) # Append GP list of the current element to the element list\\n\\n if verbose:\\n print('Step {}: GPs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\\n #print('the file input ends')\\n #print(nSteps)\\n # only needed with a while loop\\n # Jump over the lines until we reach the next time step (Caught by if-clause)\\n try:\\n line = f.readline() # Will generate an error if files end is reached\\n if line == \\\"\\\":\\n raise EOFError\\n except:\\n if verbose: print(\\\"End of file reached.\\\\n\\\")\\n break # Break the 'while True' loop\\n\\n # -----------------------------------------------------------------------------\\n\\n\\n print('averaging the stress')\\n # Averaging of strains and stress of GPs of each element\\n for istep in range(len(SimData.step)):\\n\\n for ielement in range(len(SimData.step[istep].element)):\\n print(len)\\n # Initialization before each element\\n stresses = np.array([0., 0., 0., 0., 0., 0.])\\n strains = np.array([0., 0., 0., 0., 0., 0.])\\n\\n for igp in range(len(SimData.step[istep].element[ielement])):\\n print(igp)\\n # Add up all data of all GPs\\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\\n\\n # Divide GP sum by number of GPs\\n stresses /= len(SimData.step[istep].element[ielement])\\n strains /= len(SimData.step[istep].element[ielement])\\n # Replace the field (initialized with 0) with new information\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\\n print('Analysis finished')\\n return SimData\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=1,\\n task=29,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"none\\\",\\n coarse_map_x=13,\\n coarse_map_y=13,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"tiled_fine\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key], msg=\\\"Error in {}\\\".format(key))\\n self.assertEqual(self.tree.get_job()[0], 1)\\n self.assertEqual(self.tree.get_job()[1], 29)\",\n \"def loadNodes(self, fname):\\r\\n with open(fname, \\\"r\\\") as fp:\\r\\n\\r\\n # Read in the header\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"SPECGRID\\\":\\r\\n self.SPECGRID = np.array(fp.readline().split()[0:3], dtype=int)\\r\\n if item[0] == \\\"COORDSYS\\\":\\r\\n self.COORDSYS = fp.readline().split()\\r\\n if item[0] == \\\"COORD\\\":\\r\\n break\\r\\n\\r\\n # Read in the coordinates\\r\\n self.coords = []\\r\\n for line in fp:\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n item = line.split()\\r\\n for c in item:\\r\\n if '*' in c:\\r\\n cc = c.split('*')\\r\\n for i in range(int(cc[0])):\\r\\n self.coords.append(cc[-1])\\r\\n else:\\r\\n self.coords.append(c)\\r\\n else:\\r\\n if len(line.split()) > 1:\\r\\n item = line.split()\\r\\n for i in range(len(item) - 1):\\r\\n cc = item[i]\\r\\n if '*' in cc:\\r\\n ccc = cc.split('*')\\r\\n for j in range(int(ccc[0])):\\r\\n self.coords.append(ccc[-1])\\r\\n else:\\r\\n self.coords.append(c)\\r\\n break\\r\\n else:\\r\\n break\\r\\n\\r\\n # Read in ZCORN\\r\\n self.zcorn = []\\r\\n i = 0\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"ZCORN\\\":\\r\\n for line in fp:\\r\\n if line.split():\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n self.zcorn += line.split()\\r\\n else:\\r\\n self.zcorn += line.split()[0:-1]\\r\\n break\\r\\n if len(self.zcorn) > 0:\\r\\n break\\r\\n\\r\\n # Read in (in)active cells\\r\\n self.active = []\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"ACTNUM\\\":\\r\\n for line in fp:\\r\\n if line.split():\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n c = line.split()\\r\\n if '*' in c:\\r\\n cc = c.split('*')\\r\\n for i in range(float(cc[0])):\\r\\n self.active += cc[-1]\\r\\n else:\\r\\n self.active += c\\r\\n else:\\r\\n self.active += line.split()[0:-1]\\r\\n break\\r\\n\\r\\n self.coords = np.array(self.coords, dtype=float)\\r\\n print(self.coords)\\r\\n\\r\\n # In Petrel...\\r\\n self.ne = self.SPECGRID[0] # x i\\r\\n self.nn = self.SPECGRID[1] # y j\\r\\n self.nz = self.SPECGRID[2] # z k\\r\\n\\r\\n # build grid\\r\\n self.buildGrid(plot=False)\\r\\n self.buildActiveCells(plot=False)\\r\\n self.buildZGrid(plot=False)\\r\\n # self.calculateVolumes(plot=False)\\r\\n #\\r\\n # Convert to VTK\\r\\n self.GridType = \\\"vtkStructuredGrid\\\"\\r\\n self.Grid = vtk.vtkStructuredGrid()\\r\\n self.Grid.SetDimensions(self.ne+1, self.nn+1, self.nz+1)\\r\\n vtk_points = vtk.vtkPoints()\\r\\n ve = 1.\\r\\n\\r\\n for iz in range(self.nz):\\r\\n if iz == 0:\\r\\n for iy in range(self.nn+1):\\r\\n for ix in range(self.ne+1):\\r\\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\\\\r\\n self.Y0[ix,iy], \\\\\\r\\n ve * self.ZZT[iz][ix,iy] )\\r\\n for iy in range(self.nn+1):\\r\\n for ix in range(self.ne+1):\\r\\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\\\\r\\n self.Y0[ix,iy], \\\\\\r\\n ve * self.ZZB[iz][ix,iy] )\\r\\n self.Grid.SetPoints(vtk_points)\\r\\n\\r\\n # Add in active cells\\r\\n ac = vtk.vtkIntArray()\\r\\n ac.SetName( \\\"ActiveCells\\\" )\\r\\n for iac in self.ActiveCells.flatten( order='F' ):\\r\\n ac.InsertNextTuple1( iac )\\r\\n self.Grid.GetCellData().AddArray(ac)\",\n \"def read_data(self,filename):\\n self.x = [] #Input values\\n self.t = [] #Target values\\n\\n with open(filename, \\\"r\\\") as infile:\\n lines = infile.readlines()\\n self.n = len(lines)\\n for line in lines:\\n words = line.split()\\n self.x.append(float(words[0]))\\n self.t.append(float(words[1]))\\n\\n self.x = np.array(self.x)\\n self.t = np.array(self.t)\\n self.create_design_matrix()\",\n \"def readParameterfile(self, filename):\\n return None\",\n \"def read_input_file():\\n \\n global input\\n \\n config = ConfigParser.RawConfigParser()\\n config.read(os.path.join(os.getcwd(), 'INPUT.cfg'))\\n\\n input = {}\\n input['datapath'] = config.get('Address_info', 'datapath')\\n input['inter_address'] = config.get('Address_info', 'interactive_address')\\n input['target_folder'] = config.get('Address_info', 'target_folder')\\n input['save_folder'] = config.get('Address_info', 'save_folder')\\n \\n if not os.path.isabs(input['datapath']):\\n input['datapath'] = os.path.join(os.getcwd(), input['datapath'])\\n \\n if not os.path.isabs(input['inter_address']):\\n input['inter_address'] = os.path.join(os.getcwd(), input['inter_address'])\\n \\n if not os.path.isabs(input['target_folder']):\\n input['target_folder'] = os.path.join(os.getcwd(), input['target_folder'])\\n \\n if not os.path.isabs(input['save_folder']):\\n input['save_folder'] = os.path.join(os.getcwd(), input['save_folder'])\\n \\n \\n input['min_date'] = str(eval(config.get('Event_Request', 'min_datetime')))\\n input['max_date'] = str(eval(config.get('Event_Request', 'max_datetime')))\\n input['min_mag'] = config.getfloat('Event_Request', 'min_magnitude')\\n input['max_mag'] = config.getfloat('Event_Request', 'max_magnitude')\\n input['min_depth'] = config.getfloat('Event_Request', 'min_depth')\\n input['max_depth'] = config.getfloat('Event_Request', 'max_depth')\\n input['evlonmin'] = config.getfloat('Event_Request', 'evlonmin')\\n input['evlonmax'] = config.getfloat('Event_Request', 'evlonmax')\\n input['evlatmin'] = config.getfloat('Event_Request', 'evlatmin')\\n input['evlatmax'] = config.getfloat('Event_Request', 'evlatmax')\\n input['preset'] = config.getfloat('Event_Request', 'preset')\\n input['offset'] = config.getfloat('Event_Request', 'offset')\\n input['max_result'] = config.getint('Event_Request', 'max_results')\\n \\n input['get_events'] = config.get('Request', 'get_events')\\n input['input_period'] = config.get('Parallel', 'input_period')\\n input['IRIS'] = config.get('Request', 'IRIS')\\n input['ArcLink'] = config.get('Request', 'ArcLink')\\n input['time_iris'] = config.get('Request', 'time_iris')\\n input['time_arc'] = config.get('Request', 'time_arc')\\n \\n input['nodes'] = config.get('Parallel', 'nodes')\\n\\n input['waveform'] = config.get('Request', 'waveform')\\n input['response'] = config.get('Request', 'response')\\n input['SAC'] = config.get('Request', 'SAC')\\n \\n input['net'] = config.get('specifications_request', 'network')\\n input['sta'] = config.get('specifications_request', 'station')\\n \\n if config.get('specifications_request', 'location') == \\\"''\\\":\\n input['loc'] = ''\\n elif config.get('specifications_request', 'location') == '\\\"\\\"':\\n input['loc'] = ''\\n else:\\n input['loc'] = config.get('specifications_request', 'location')\\n \\n input['cha'] = config.get('specifications_request', 'channel')\\n\\n if config.get('specifications_request', 'lat') == 'None':\\n input['lat_cba'] = None\\n else:\\n input['lat_cba'] = config.get('specifications_request', 'lat')\\n \\n if config.get('specifications_request', 'lon') == 'None':\\n input['lon_cba'] = None\\n else:\\n input['lon_cba'] = config.get('specifications_request', 'lon')\\n \\n if config.get('specifications_request', 'minradius') == 'None':\\n input['mr_cba'] = None\\n else:\\n input['mr_cba'] = config.get('specifications_request', 'minradius')\\n \\n if config.get('specifications_request', 'maxradius') == 'None':\\n input['Mr_cba'] = None\\n else:\\n input['Mr_cba'] = config.get('specifications_request', 'maxradius')\\n \\n \\n if config.get('specifications_request', 'minlat') == 'None':\\n input['mlat_rbb'] = None\\n else:\\n input['mlat_rbb'] = config.get('specifications_request', 'minlat')\\n \\n if config.get('specifications_request', 'maxlat') == 'None':\\n input['Mlat_rbb'] = None\\n else:\\n input['Mlat_rbb'] = config.get('specifications_request', 'maxlat')\\n \\n if config.get('specifications_request', 'minlon') == 'None':\\n input['mlon_rbb'] = None\\n else:\\n input['mlon_rbb'] = config.get('specifications_request', 'minlon')\\n \\n if config.get('specifications_request', 'maxlon') == 'None':\\n input['Mlon_rbb'] = None\\n else:\\n input['Mlon_rbb'] = config.get('specifications_request', 'maxlon')\\n\\n \\n input['test'] = config.get('test', 'test')\\n input['test_num'] = config.getint('test', 'test_num')\\n \\n input['update_interactive'] = config.get('update', 'update_interactive')\\n input['iris_update'] = config.get('update', 'iris_update')\\n input['arc_update'] = config.get('update', 'arc_update')\\n\\n input['QC_IRIS'] = config.get('QC', 'QC_IRIS')\\n input['QC_ARC'] = config.get('QC', 'QC_ARC')\\n \\n input['email'] = config.get('email', 'email')\\n input['email_address'] = config.get('email', 'email_address')\\n \\n input['report'] = config.get('report', 'report')\\n \\n input['corr_unit'] = config.get('instrument_correction', 'corr_unit')\\n input['pre_filt'] = config.get('instrument_correction', 'pre_filter')\\n \\n input['plt_event'] = config.get('ObsPyPT', 'plot_event')\\n input['plt_sta'] = config.get('ObsPyPT', 'plot_sta')\\n input['plt_ray'] = config.get('ObsPyPT', 'plot_ray')\\n\\n input['llcrnrlon'] = config.getfloat('ObsPyPT', 'llcrnrlon')\\n input['urcrnrlon'] = config.getfloat('ObsPyPT', 'urcrnrlon')\\n input['llcrnrlat'] = config.getfloat('ObsPyPT', 'llcrnrlat')\\n input['urcrnrlat'] = config.getfloat('ObsPyPT', 'urcrnrlat')\\n \\n input['lon_0'] = config.getfloat('ObsPyPT', 'lon_0')\\n input['lat_0'] = config.getfloat('ObsPyPT', 'lat_0')\",\n \"def get_params(param_file_path):\\n\\n config = ConfigParser.SafeConfigParser()\\n config.read(param_file_path)\\n\\n # Get \\\"raw\\\" dictionaries from `config` object\\n raw_params = dict(config.items('general'))\\n raw_cosmo_params = dict(config.items('cosmology'))\\n raw_io_params = dict(config.items('io'))\\n raw_binning_params = dict(config.items('binning'))\\n raw_maps_to_stack_params = dict(config.items('maps_to_stack'))\\n raw_map_path_params = dict(config.items('map_path'))\\n raw_map_file_params = dict(config.items('map_file'))\\n raw_noise_path_params = dict(config.items('map_path'))\\n raw_noise_file_params = dict(config.items('noise_file'))\\n raw_beams_params = dict(config.items('beams'))\\n raw_color_correction_params = dict(config.items('color_correction'))\\n raw_catalogs_params = dict(config.items('catalogs'))\\n\\n raw_io_params['param_file_path'] = os.path.abspath(param_file_path) # Store parameter file path\\n\\n # Convert \\\"raw\\\" config dictionary to \\\"organized\\\" dictionary `params`\\n params = get_general_params(raw_params) \\n params['io'] = get_io_parameters(raw_io_params)\\n params['cosmo'] = get_cosmology_parameters(raw_cosmo_params)\\n params['map_files'] = get_maps_parameters(raw_maps_to_stack_params,raw_map_path_params,raw_map_file_params)\\n params['noise_files'] = get_maps_parameters(raw_maps_to_stack_params,raw_noise_path_params,raw_noise_file_params)\\n params['wavelength'] = get_wavelength_parameters(raw_maps_to_stack_params)\\n params['psfs'] = get_beams_parameters(raw_maps_to_stack_params,raw_beams_params)\\n params['color_correction'] = get_color_correction_parameters(raw_maps_to_stack_params,raw_color_correction_params)\\n params['catalogs'] = get_catalogs_parameters(raw_catalogs_params)\\n params['bins'] = get_binning_parameters(raw_binning_params)\\n params['library_keys'] = params['map_files'].keys()\\n\\n logging.info(\\\"---------- PARAMETER VALUES ----------\\\")\\n logging.info(\\\"======================================\\\")\\n logging.info(\\\"\\\\n\\\" + pprint.pformat(params, indent=4) + \\\"\\\\n\\\")\\n\\n #pdb.set_trace()\\n return params\",\n \"def load_info():\\n data = np.loadtxt(\\\"u_sol_meta.txt\\\", dtype=int)\\n return data\",\n \"def read_velocities(filename, return_grid=True, return_proj=False):\\n ds = gdal.Open(filename)\\n #Get dimensions\\n nc = ds.RasterXSize\\n nr = ds.RasterYSize\\n \\n geotransform = ds.GetGeoTransform()\\n xOrigin = geotransform[0]\\n xPix = geotransform[1] #pixel width in x-direction\\n yOrigin = geotransform[3]\\n yPix = geotransform[5] #pixel height in y-direction\\n \\n lons = xOrigin + np.arange(0, nc)*xPix\\n lats = yOrigin + np.arange(0, nr)*yPix\\n \\n x, y = np.meshgrid(lons, lats)\\n \\n vband = ds.GetRasterBand(1)\\n varr = vband.ReadAsArray()\\n \\n if return_grid and return_proj:\\n return x, y, varr, ds.GetProjection()\\n elif return_grid:\\n return x, y, varr\\n else: \\n return varr\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=1,\\n task=1,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=1.0,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"null\\\",\\n coarse_map_x=20,\\n coarse_map_y=20,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"null\\\",\\n fine_map_x=10,\\n fine_map_y=10,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=10,\\n grid_y=10,\\n sample_x=10,\\n sample_y=10,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"fat-tail\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"infinite\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key])\\n self.assertEqual(self.tree.get_job()[0], 1)\\n self.assertEqual(self.tree.get_job()[1], 1)\",\n \"def loadSimData(datafile):\\n \\n global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \\\\\\n dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure \\n\\n datafile = open(datafile,\\\"r\\\")\\n for line in datafile:\\n A = line.split()\\n if A[0] == \\\"dt\\\": # Time interval between MD steps\\n dt = float(A[-1])\\n elif A[0] == \\\"ti\\\": # Beginning time for data acquisition\\n ti = float(A[-1])\\n elif A[0] == \\\"Lx\\\": # Box size in x\\n Lx = float(A[-1]) \\n elif A[0] == \\\"Ly\\\": # Box size in y\\n Ly = float(A[-1])\\n elif A[0] == \\\"totalStep\\\": # Total MD steps\\n totalStep = float(A[-1])\\n elif A[0] == \\\"nsamp\\\": # Data sampling frequency\\n nsamp = float(A[-1])\\n elif A[0] == \\\"nfil\\\": # Number of particles per polymer\\n N = float(A[-1])\\n elif A[0] == \\\"L\\\": # Number of particles\\n L = float(A[-1])\\n elif A[0] == \\\"B\\\": # Bond length between particles of a body\\n B = float(A[-1])\\n elif A[0] == \\\"kT\\\": # Boltzmann constant*Temperature\\n kT = float(A[-1])\\n elif A[0] == \\\"Fmc\\\": # Self propulsion force constant\\n Fmc = float(A[-1]) \\n elif A[0] == \\\"Kbend\\\": # Bending constant\\n Kbend = float(A[-1])\\n \\n Lx /= B\\n Ly /= B\\n M = L/N\\n dtSamp = dt*nsamp\\n T = totalStep - ti\\n nt = T/nsamp\\n box_area = Lx*Ly\\n body_length = B*(N-1)\\n Pe = Fmc*body_length**2/kT\\n persistence = Kbend/(kT*body_length)\\n flexure = Pe/persistence\",\n \"def loadSimData(datafile):\\n \\n global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \\\\\\n dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure \\n\\n datafile = open(datafile,\\\"r\\\")\\n for line in datafile:\\n A = line.split()\\n if A[0] == \\\"dt\\\": # Time interval between MD steps\\n dt = float(A[-1])\\n elif A[0] == \\\"ti\\\": # Beginning time for data acquisition\\n ti = float(A[-1])\\n elif A[0] == \\\"Lx\\\": # Box size in x\\n Lx = float(A[-1]) \\n elif A[0] == \\\"Ly\\\": # Box size in y\\n Ly = float(A[-1])\\n elif A[0] == \\\"totalStep\\\": # Total MD steps\\n totalStep = float(A[-1])\\n elif A[0] == \\\"nsamp\\\": # Data sampling frequency\\n nsamp = float(A[-1])\\n elif A[0] == \\\"nfil\\\": # Number of particles per polymer\\n N = float(A[-1])\\n elif A[0] == \\\"L\\\": # Number of particles\\n L = float(A[-1])\\n elif A[0] == \\\"B\\\": # Bond length between particles of a body\\n B = float(A[-1])\\n elif A[0] == \\\"kT\\\": # Boltzmann constant*Temperature\\n kT = float(A[-1])\\n elif A[0] == \\\"Fmc\\\": # Self propulsion force constant\\n Fmc = float(A[-1]) \\n elif A[0] == \\\"Kbend\\\": # Bending constant\\n Kbend = float(A[-1])\\n \\n L = int(L)\\n N = int(N)\\n Lx /= B\\n Ly /= B\\n M = L/N\\n dtSamp = dt*nsamp\\n T = totalStep - ti\\n nt = T/nsamp\\n box_area = Lx*Ly\\n body_length = B*(N-1)\\n Pe = Fmc*body_length**2/kT\\n persistence = Kbend/(kT*body_length)\\n flexure = Pe/persistence\\n \\n return\",\n \"def read(self, **kwargs):\\n\\n if not os.path.isfile(self.file_name):\\n self.build()\\n elif 'clobber' in self.kwargs.keys():\\n if self.kwargs['clobber']: \\n self.build()\\n\\n # read dLOS file from parent class\\n super(DlosPhotoz, self).read()\\n\\n self.dlos, self.dlos_photoz = np.loadtxt(\\n self.file_name, \\n skiprows=1, \\n unpack=True, \\n usecols=[0, 1]\\n )\\n return None\",\n \"def loadSimData(datafile):\\n \\n global dt, ti, Lx, Ly, nsamp, N, M, L, B, totalStep, Fmc, Kbend, kT, \\\\\\n dtSamp, T, box_area, nt, body_length, Pe, persistence, flexure \\n\\n datafile = open(datafile,\\\"r\\\")\\n for line in datafile:\\n A = line.split()\\n if A[0] == \\\"dt\\\": # Time interval between MD steps\\n dt = float(A[-1])\\n elif A[0] == \\\"ti\\\": # Beginning time for data acquisition\\n ti = float(A[-1])\\n elif A[0] == \\\"Lx\\\": # Box size in x\\n Lx = float(A[-1]) \\n elif A[0] == \\\"Ly\\\": # Box size in y\\n Ly = float(A[-1])\\n elif A[0] == \\\"totalStep\\\": # Total MD steps\\n totalStep = float(A[-1])\\n elif A[0] == \\\"nsamp\\\": # Data sampling frequency\\n nsamp = float(A[-1])\\n elif A[0] == \\\"nfil\\\": # Number of particles per polymer\\n N = int(float(A[-1]))\\n elif A[0] == \\\"L\\\": # Number of particles\\n L = int(float(A[-1]))\\n elif A[0] == \\\"B\\\": # Bond length between particles of a body\\n B = float(A[-1])\\n elif A[0] == \\\"kT\\\": # Boltzmann constant*Temperature\\n kT = float(A[-1])\\n elif A[0] == \\\"Fmc\\\": # Self propulsion force constant\\n Fmc = float(A[-1]) \\n elif A[0] == \\\"Kbend\\\": # Bending constant\\n Kbend = float(A[-1])\\n \\n Lx /= B\\n Ly /= B\\n M = L/N\\n dtSamp = dt*nsamp\\n T = totalStep - ti\\n nt = T/nsamp\\n box_area = Lx*Ly\\n body_length = B*(N-1)\\n Pe = Fmc*body_length**2/kT\\n persistence = Kbend/(kT*body_length)\\n flexure = Pe/persistence\",\n \"def read_from_file(self,grd_fn):\\n self.grd_fn = grd_fn\\n self.fp = open(self.grd_fn,'rt')\\n hdr = self.fp.readline().strip() #header &GRD_2008 or &LISTGRD\\n\\n if hdr == self.hdr_08:\\n print( \\\"Will read 2008 format for grid\\\" )\\n n_parms = 11\\n elif hdr == self.hdr_old:\\n print( \\\"Will read old UnTRIM grid format\\\" )\\n n_parms = 10\\n\\n for i in range(n_parms): # ignore TNE and TNS in new format files\\n l = self.fp.readline()\\n lhs,rhs = l.split('=')\\n val = rhs.strip().strip(',')\\n varname = lhs.strip()\\n print( \\\"%s=%s\\\"%(varname,val) )\\n\\n if varname=='NV':\\n Nvertices = int(val)\\n elif varname=='NE':\\n Npolys = int(val)\\n elif varname=='NS':\\n Nsides = int(val)\\n elif varname=='NBC':\\n Nboundary_poly = int(val)\\n elif varname=='NSI':\\n Ninternal_sides = int(val)\\n elif varname=='NSF':\\n Nflow_sides = int(val)\\n elif varname=='NBC':\\n Nbc = int(val)\\n elif varname=='ANGLE':\\n self.angle = float(val)\\n elif varname=='LOCATION':\\n self.location = val\\n elif varname=='NR': ## these are read, but not used\\n Nred = int(val)\\n elif varname=='TNE':\\n TNE=int(val)\\n elif varname=='TNS':\\n TNS=int(val)\\n # others: HLAND for older fmt.\\n \\n while 1:\\n s = self.fp.readline().strip() # header: /\\n if s == '/':\\n break\\n\\n # We know the size of everything, and can ask UnstructuredGrid to allocate\\n # arrays now, with the 'special' meaning that passing an integer means allocate\\n # the array of that size, full of zeros.\\n # this allocates\\n # self.nodes, self.edges, self.cells\\n self.from_simple_data(points = Nvertices,edges = Nsides, cells = Npolys)\\n\\n for v in range(Nvertices):\\n Cv = self.fp.readline().split()\\n if hdr == self.hdr_08:\\n vertex_num = int(Cv.pop(0))\\n if vertex_num != v+1:\\n print( \\\"Mismatched vertex numbering: %d != %d\\\"%(vertex_num,v+1) )\\n self.nodes['x'][v,0] = float(Cv[0])\\n self.nodes['x'][v,1] = float(Cv[1])\\n \\n print( \\\"Npolys\\\",Npolys )\\n self.cells['edges'] = self.UNKNOWN # initialize all\\n self.cells['nodes'] = self.UNKNOWN\\n \\n for c in range(Npolys):\\n l = self.fp.readline()\\n Cp = l.split()\\n if hdr == self.hdr_08:\\n poly_num = int(Cp.pop(0))\\n if poly_num-1 != c:\\n print( \\\"Mismatched polygon id: %fd != %d\\\"%(poly_num,c+1) )\\n \\n numsides = int(Cp[0])\\n\\n self.cells['_center'][c,0] = float(Cp[1])\\n self.cells['_center'][c,1] = float(Cp[2])\\n\\n if hdr == self.hdr_old:\\n # vertex index is Cp[3,5,7,9]\\n # the others, 4,6,8,10, are edges, right?\\n # convert to 0 based indices here\\n\\n # This is probably wrong! I think it's actually reading the\\n # sides\\n self.cells['edges'][c,0] = int(Cp[4]) - 1\\n self.cells['edges'][c,1] = int(Cp[6]) - 1 \\n self.cells['edges'][c,2] = int(Cp[8]) - 1\\n if numsides == 4:\\n self.cells['edges'][c,3] = int(Cp[10]) - 1 \\n else:\\n self.cells['edges'][c,3]=self.UNDEFINED\\n #HERE - need to copy that to self.cells['nodes']\\n else:\\n for ei in range(numsides):\\n self.cells['nodes'][c,ei] = int(Cp[3+ei]) - 1\\n self.cells['edges'][c,ei] = int(Cp[3+numsides+ei]) - 1\\n self.cells['nodes'][c,numsides:]=self.UNDEFINED\\n self.cells['edges'][c,numsides:]=self.UNDEFINED\\n \\n # choose some large, above-sea-level depth\\n self.cells['depth_mean'] = -1000 # not sure this is doing anything...\\n\\n for e in range(Nsides):\\n Cs = self.fp.readline().split()\\n if hdr == self.hdr_08:\\n # side num = int(Cs.pop(0))\\n Cs.pop(0)\\n elif hdr == self.hdr_old:\\n # side depth?\\n edge_depth = self.edges['depth_mean'][e] = float(Cs.pop(0))\\n \\n self.edges['nodes'][e,0] = int(Cs[0])-1 # vertex indices\\n self.edges['nodes'][e,1] = int(Cs[1])-1\\n \\n self.edges['cells'][e,0] = int(Cs[2])-1 # cell neighbors\\n self.edges['cells'][e,1] = int(Cs[3])-1\\n\\n if hdr == self.hdr_old:\\n for nc in self.edges['cells'][e]:\\n if nc >= 0 and edge_depth > self.cells['depth_mean'][nc]:\\n self.cells['depth_mean'][nc] = edge_depth\\n\\n if hdr==self.hdr_old:\\n # old format - have to infer cell nodes from edges\\n self.make_cell_nodes_from_edge_nodes()\\n\\n # Try to make sense of the marks and red/black:\\n self.cells['red'][:Nred] = True\\n self.cells['mark'][:Nboundary_poly] = self.BOUNDARY\\n self.edges['mark'][:Ninternal_sides] = 0\\n self.edges['mark'][Ninternal_sides:Nflow_sides] = self.FLOW\\n self.edges['mark'][Nflow_sides:] = self.LAND\\n\\n # Bathymetry:\\n if hdr == self.hdr_08:\\n # make a cheap tokenizer to read floats across lines\\n # note that it's up to the user to know that all values from\\n # the line are read, and not to get the iterator until you're\\n # ready for some values to be read\\n def tokenizer():\\n while True:\\n for item in self.fp.readline().split():\\n yield item\\n for c in range(Npolys):\\n check_c,nis = [int(s) for s in self.fp.readline().split()]\\n if check_c != c+1:\\n print(\\\"ERROR: while reading cell subgrid, cell index mismatch: %s vs. %d\\\"%(c+1,check_c))\\n \\n next_token = tokenizer().next\\n areas = np.array( [float(next_token()) for sg in range(nis)] )\\n depths = np.array( [float(next_token()) for sg in range(nis)] )\\n \\n self.cells['depth_mean'][c] = np.sum(areas*depths) / np.sum(areas)\\n self.cells['_area'][c] = np.sum(areas)\\n self.cells['depth_max'][c] = depths.max()\\n self.cells['subgrid'][c] = (areas,depths)\\n for e in range(Nflow_sides):\\n l = self.fp.readline()\\n # print \\\"%d/%d - Read line: %s\\\"%(e,self.Nsides,l)\\n check_e,nis = [int(s) for s in l.split()]\\n if check_e != e+1:\\n print( \\\"ERROR: While reading edge subgrid, edge index mismatch: %s vs. %s\\\"%(e+1,check_e) )\\n next_token = tokenizer().next\\n lengths = np.array( [float(next_token()) for sg in range(nis)] )\\n depths = np.array( [float(next_token()) for sg in range(nis)] )\\n if sum(lengths)<=0:\\n print( \\\"edge %d has bad lengths\\\"%e )\\n self.edges['depth_mean'][e] = np.sum(lengths*depths) / sum(lengths)\\n self.edges['depth_max'][e] = depths.max()\\n self.edges['subgrid'][e] = (lengths,depths)\\n # and land boundaries get zeros.\\n for e in range(Nflow_sides,Nsides):\\n self.edges['depth_mean'][e] = 0.0\\n self.edges['depth_max'][e] = 0.0\\n self.edges['subgrid'][e] = ([],[])\",\n \"def read_opal(self, file_name, step_number=None, species_name = 'Species'):\\n \\n # opal coordinates are as follows:\\n # x -- horizontal offset, m\\n # xp -- horizontal momentum, beta*gamma\\n # y -- vertical offset, m\\n # yp -- vertical momentum, beta*gamma\\n # z -- Position relative to ? (some sort of reference), m\\n # p -- total momentum, beta*gamma\\n # TODO: We really need to be able to pull from screens too but we'll settle for standard distribution output for now\\n # TODO: We don't currently handle particle specific weight/charge in Species\\n \\n with h5.File(file_name, 'r') as pcdata:\\n if not step_number:\\n step_number = len(pcdata) - 1\\n loc = 'Step#{}'.format(step_number)\\n mp_count = pcdata[loc+'/z'].shape[0]\\n particle_data = np.empty((mp_count, 6))\\n for i, coord in enumerate(['x', 'px', 'y', 'py', 'z', 'pz']):\\n print(loc+'/'+coord)\\n particle_data[:, i] = pcdata[loc+'/'+coord]\\n total_charge = pcdata[loc].attrs['CHARGE']\\n \\n # TODO: This needs to be a function --- it is used many times\\n # probably just make a species instantiation function\\n if species_name == 'Species':\\n spec_name = species_name+'_'+str(len(self.species.keys()))\\n else:\\n spec_name = species_name\\n\\n # TODO: This shouldn't be specific to electrons\\n self.species[spec_name] = Species(particle_data, charge=-1, mass=0.511e6, total_charge=total_charge)\\n \\n return 0\",\n \"def ParseParameters(self, parameters_file_name):\\n\\n print(datetime.now().strftime(\\\"%H:%M:%S\\\") + \\\": Reading file \\\" + parameters_file_name + \\\"...\\\")\\n\\n parameters_file = open(parameters_file_name, \\\"r\\\")\\n\\n for line in parameters_file:\\n line_parts = re.split(r'\\\\t+', line) # split elements of the line separated by tabs\\n if(len(line_parts) == 2):\\n self.AddParameter(line_parts[0], float(line_parts[1].strip()))\\n else: # we want 2 elements per line\\n raise Exception(\\\"Invalid format for the line \\\" + line)\\n \\n parameters_file.close()\\n\\n # check that all the mandatory parameters are correctly set\\n if(self.npop1_1 == \\\"N/A\\\" or\\n self.npop1_2 == \\\"N/A\\\" or\\n self.npop2_1 == \\\"N/A\\\" or\\n self.npop2_2 == \\\"N/A\\\" or\\n self.t_div == \\\"N/A\\\" or\\n self.npop_a == \\\"N/A\\\" or\\n self.mu == \\\"N/A\\\"):\\n raise Exception(\\\"One of mandatory parameters is missing!\\\")\\n\\n # check that introgression-related parameters are correctly set (either both equal 1 or both equal 0)\\n if(self.t_i == 1 and self.p_i == 1): # introgression\\n self.number_of_parameters = 9\\n elif(self.t_i == 0 and self.p_i == 0): # no introgression\\n self.number_of_parameters = 7\\n else:\\n raise Exception(\\\"Inconsistent values provided for parameters T_I and P_I!\\\")\\n\\n print(datetime.now().strftime(\\\"%H:%M:%S\\\") + \\\": Reading file done.\\\")\",\n \"def load_params_from_file(self, input_file):\\n\\n ### FILL IN ###\",\n \"def conf_load_location(fin):\\n err_msg = \\\"Expected two numbers separeted by comma.\\\"\\n line = fin.readline().split(',')\\n if len(line) != 2:\\n raise EnvironmentError(err_msg)\\n try:\\n x,y = float(line[0]), float(line[1])\\n except:\\n raise EnvironmentError(err_msg)\\n return np.array([x,y])\",\n \"def load_simulation_attributes_from_args(args):\\n simulation_attributes = SimulationAttributes()\\n if hasattr(args,'output_file'):\\n simulation_attributes.id_name = args.output_file\\n simulation_attributes.locations = load_locations_from_args(args.senzory_map_file)\\n simulation_attributes.dprime_fnc = load_dprime_fnc_from_args(args)\\n simulation_attributes.next_fixation = args.algorithm\\n simulation_attributes.num_of_searches = args.num_of_searches\\n simulation_attributes.threshold = args.threshold\\n return simulation_attributes\",\n \"def config():\\n file_path = None # path to the input file\\n db_path = None # path to the output db\\n atomic_properties = (\\n \\\"Properties=species:S:1:pos:R:3\\\"\\n ) # atomic properties of the input file\\n molecular_properties = [\\\"energy\\\"] # molecular properties of the input file\\n overwrite = False\",\n \"def SPdat(species):\\n f = open('VPparams.txt', 'rU')\\n lines = f.readlines()\\n f.close()\\n \\n parsing = False\\n for i in np.arange(len(lines)):\\n if lines[i].startswith(species):\\n parsing = True\\n else:\\n parsing = False\\n if parsing:\\n data = lines[i].split()\\n \\n lnC, L0, Rv, da, db = data[1:len(data)]\\n return float(lnC), float(L0), float(Rv), float(da), float(db)\",\n \"def read_xyz(filename):\\n #print('Reading geom from:'),filename\\n atoms = []\\n coordinates = []\\n\\t\\n xyz = open(filename)\\n n_atoms = int(xyz.readline())\\n title = xyz.readline()\\n for line in xyz:\\n\\tif len(line.strip()) == 0:\\n\\t\\tpass\\n\\t\\tbreak\\t\\n\\tatom,x,y,z = line.split()\\n\\tatoms.append(atom)\\n\\tcoordinates.append([float(x), float(y), float(z)])\\n xyz.close()\\n coordinates = [[w * angtobh for w in ww] for ww in coordinates] #ang to bh\\n\\n if n_atoms != len(coordinates):\\n \\tprint('Number of atoms in xyz file doesnt equal to the number of lines.')\\n\\tsys.exit(1)\\n \\n return atoms, coordinates\",\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 read_values_from_file(input_file, debug = True):\\n with open(input_file, 'r') as infile:\\n #Read the data from the file\\n input_data = infile.readline()\\n\\n #And extract the required parameters\\n n = int(input_data.split()[0]) #number of months to run experiment\\n m = int(input_data.split()[1]) #maximum age of rabbits\\n \\n if debug:\\n print(\\\"From file %s I have read the following data:\\\" % input_file)\\n print(\\\"n = %s\\\\tm = %s\\\\n\\\" % (n, m))\\n \\n return(n, m)\",\n \"def readsol(self,filename):\\n\\t\\tf = file(filename)\\n\\t\\tfor i in range(6): f.readline()\\n\\t\\tl = f.readline().split()\\n\\n\\t\\trows = int(l[2])\\n\\t\\tcols = int(l[5])\\n\\t\\tfor i in range(3): f.readline()\\n\\t\\tstatusString = f.readline().split()[0]\\n\\t\\txpressStatus = {\\n\\t\\t\\t\\\"Optimal\\\":LpStatusOptimal,\\n\\t\\t\\t}\\n\\t\\tif statusString not in xpressStatus:\\n\\t\\t\\traise ValueError, \\\"Unknow status returned by XPRESS: \\\"+statusString\\n\\t\\tstatus = xpressStatus[statusString]\\n\\t\\tvalues = {}\\n\\t\\twhile 1:\\n\\t\\t\\tl = f.readline()\\n\\t\\t\\tif l == \\\"\\\": break\\n\\t\\t\\tline = l.split()\\n\\t\\t\\tif len(line) and line[0] == 'C':\\n\\t\\t\\t\\tname = line[2]\\n\\t\\t\\t\\tvalue = float(line[4])\\n\\t\\t\\t\\tvalues[name] = value\\n\\t\\treturn status, values\",\n \"def testSimulationParametersStored(self):\\n simulation_parameters = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=6,\\n task=6,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.5,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=0.1,\\n max_time=10.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"set\\\",\\n coarse_map_file=\\\"sample/SA_sample_coarse.tif\\\",\\n coarse_map_x=35,\\n coarse_map_y=41,\\n coarse_map_x_offset=11,\\n coarse_map_y_offset=14,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"sample/SA_sample_fine.tif\\\",\\n fine_map_x=13,\\n fine_map_y=13,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=13,\\n grid_y=13,\\n sample_x=13,\\n sample_y=13,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in simulation_parameters.keys():\\n self.assertEqual(simulation_parameters[key], actual_sim_parameters[key])\\n self.assertDictEqual(simulation_parameters, actual_sim_parameters)\\n # self.assertListEqual(simulation_parameters, actual_sim_parameters)\\n self.assertEqual(self.tree.get_job()[0], 6)\\n self.assertEqual(self.tree.get_job()[1], 6)\",\n \"def read_settings(self, settings_file):\\n import configparser\\n import itertools\\n cfg = configparser.ConfigParser()\\n filename = settings_file\\n with open(filename) as fp:\\n cfg.read_file(itertools.chain(['[global]'], fp), source=filename)\\n d = {}\\n for c in cfg.items('global'):\\n try:\\n d[c[0]] = eval(c[1].strip(';'))\\n except Exception:\\n pass\\n self.distance = d['parameters.distance']\\n self.a, self.b, self.c, alpha, beta, gamma = d['parameters.unitcell']\\n self.alpha, self.beta, self.gamma = (\\n alpha*degrees, beta*degrees, gamma*degrees)\\n ubmat = np.matrix(d['parameters.ubmat'])\\n self.Umat = ubmat * self.Bimat\\n self.xc = d['parameters.det0x']\\n self.yc = d['parameters.det0y']\\n self.pitch = d['parameters.orienterrordetpitch'] * degrees\\n self.roll = d['parameters.orienterrordetroll'] * degrees\\n self.yaw = d['parameters.orienterrordetyaw'] * degrees\\n self.theta = d['parameters.orienterrorgonpitch'] * degrees\\n self.omega = d['parameters.omeganom'] * degrees\\n self.chi = d['parameters.chinom'] * degrees\\n self.phi = d['parameters.phinom'] * degrees\\n self.phi_step = d['parameters.phistep'] * degrees\\n self.h_start, self.k_start, self.l_start = d['parameters.gridorigin']\\n self.h_stop, self.k_stop, self.l_stop = [-v\\n for v in d\\n ['parameters.gridorigin']]\\n hs, ks, ls = d['parameters.griddim']\\n self.h_step, self.k_step, self.l_step = [1.0/hs, 1.0/ks, 1.0/ls]\\n self.h_shape, self.k_shape, self.l_shape = d['outputdata.dimensions']\",\n \"def read_from_grid(filename):\\n\\n x=[]\\n y=[]\\n z=[]\\n\\n fid=open(filename,'r')\\n\\n for point in fid:\\n x.append(float(point.split()[0]))\\n y.append(float(point.split()[1]))\\n z.append(float(point.split()[2]))\\n\\n fid.close()\\n\\n return x, y, z\",\n \"def _read(self):\\n # initializng data dictionary\\n self.data={}\\n\\n f = FortranFile(self.filename)\\n # Default omnivor binary header\\n self.data['MK'] = f.readInts('i')\\n self.data['itime'] = f.readInts('i')\\n self.data['version'] = f.readString()\\n self.data['file_id'] = f.readInts('i')\\n self.data['sversion'] = f.readString()\\n # Velocity field\\n self.data['stype'] = f.readString()\\n self.data['is_grid'] = f.readInts('i')\\n nCPs = f.readInts('i')\\n self.data['nCPs'] = nCPs\\n if self.data['MK'] == 8:\\n real_char='d'\\n else:\\n real_char='f'\\n if self.data['is_grid']:\\n #print('File is a velocity grid file')\\n n1 = f.readInts('i')\\n n2 = f.readInts('i')\\n n3 = f.readInts('i')\\n self.data['n1'] = n1\\n self.data['n2'] = n2\\n self.data['n3'] = n3\\n self.data['is_straight'] = f.readInts('i')\\n self.data['v1'] = f.readReals(real_char)\\n self.data['v2'] = f.readReals(real_char)\\n self.data['v3'] = f.readReals(real_char)\\n\\n CPs_raw = f.readReals(real_char)\\n Utot_raw = f.readReals(real_char)\\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\\n\\n acc=-1\\n CPsTab = np.zeros((3, n1,n2,n3))\\n UtotTab = np.zeros((3, n1,n2,n3))\\n # Reshaping the nasty way (this is natural order). \\n for i in range(0,n1):\\n for j in range(0,n2):\\n for k in range(0,n3):\\n acc=acc+1\\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\\n\\n self.data['CPs'] = CPs\\n self.data['CPsTab'] = CPsTab\\n self.data['Utot'] = Utot\\n self.data['UtotTab'] = UtotTab\",\n \"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')\",\n \"def readWrite_gpt2_1w(xdir, station, site_lat, site_lon):\\n# this should use the environment variable\\n outfile = xdir + '/input/' + station + '_refr.txt'\\n if os.path.isfile(outfile):\\n print('refraction file for this station already exists')\\n else:\\n print('refraction output file will be written to ', outfile)\\n\\n# change to radians\\n dlat = site_lat*np.pi/180 \\n dlon = site_lon*np.pi/180 \\n\\n# read VMF gridfile in pickle format \\n pname = xdir + '/input/' + 'gpt_1wA.pickle'\\n print('large refraction file is stored here:', pname)\\n try:\\n f = open(pname, 'rb')\\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\\n f.close()\\n except:\\n print('I did not find the large refraction file where it is supposed to be, but I will try looking in your home directory')\\n try:\\n pname = 'gpt_1wA.pickle'\\n f = open(pname, 'rb')\\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\\n f.close()\\n except:\\n print('hmm, failed again. Go into gnssIR_lomb.py, set RefractionCorrection to false, and rerun the code.... ')\\n sys.exit()\\n\\n# print(np.shape(All_pgrid))\\n# really should e zero to four, but whatever\\n indx = np.zeros(4,dtype=int)\\n indx_lat = np.zeros(4,dtype=int)\\n indx_lon = np.zeros(4,dtype=int)\\n\\n\\n#figure out grid index\\n# % only positive longitude in degrees\\n if (dlon < 0):\\n plon = (dlon + 2*np.pi)*180/np.pi;\\n else:\\n plon = dlon*180/np.pi \\n#\\n# transform to polar distance in degrees\\n ppod = (-dlat + np.pi/2)*180/np.pi \\n\\n#% find the index (line in the grid file) of the nearest point\\n# % changed for the 1 degree grid (GP)\\n ipod = np.floor(ppod+1) \\n ilon = np.floor(plon+1) \\n \\n# % normalized (to one) differences, can be positive or negative\\n# % changed for the 1 degree grid (GP)\\n diffpod = (ppod - (ipod - 0.5)) \\n difflon = (plon - (ilon - 0.5)) \\n# % added by HCY\\n# % changed for the 1 degree grid (GP)\\n if (ipod == 181):\\n ipod = 180 \\n if (ilon == 361):\\n ilon = 1 \\n if (ilon == 0):\\n ilon = 360\\n\\n# get the number of the corresponding line\\n#\\t changed for the 1 degree grid (GP)\\n indx[0] = (ipod - 1)*360 + ilon \\n# save the lat lon of the grid points\\n indx_lat[0] = 90-ipod+1 \\n indx_lon[0] = ilon-1 \\n# % near the poles: nearest neighbour interpolation, otherwise: bilinear\\n# % with the 1 degree grid the limits are lower and upper (GP)\\n\\n bilinear = 0 \\n max_ind = 1 \\n if (ppod > 0.5) and (ppod < 179.5):\\n bilinear = 1 \\n if (bilinear == 1):\\n max_ind =4 \\n\\n# % bilinear interpolation\\n# % get the other indexes \\n \\n ipod1 = ipod + np.sign(diffpod) \\n ilon1 = ilon + np.sign(difflon) \\n# % changed for the 1 degree grid (GP)\\n if (ilon1 == 361):\\n ilon1 = 1 \\n if (ilon1 == 0):\\n ilon1 = 360 \\n# get the number of the line\\n# changed for the 1 degree grid (GP)\\n# four indices ???\\n indx[1] = (ipod1 - 1)*360 + ilon; # % along same longitude\\n indx[2] = (ipod - 1)*360 + ilon1;# % along same polar distance\\n indx[3] = (ipod1 - 1)*360 + ilon1;# % diagonal\\n#\\n# save the lat lon of the grid points lat between [-90 ;90] lon [0 360] \\n indx_lat[1] = 90 - ipod1+np.sign(diffpod) \\n indx_lon[1] = ilon-1 \\n indx_lat[2] = 90-ipod +1\\n indx_lon[2] = ilon1 - np.sign(difflon) \\n indx_lat[3] = 90 -ipod1+np.sign(diffpod) \\n indx_lon[3] = ilon1- np.sign(difflon);\\n\\n# extract the new grid\\n# will need to do 0-4 instead of 1-5 because stored that way in python\\n# which values to use in the bigger array\\n# assign the correct values\\n indx = indx - 1\\n indx_list = indx.tolist()\\n# print(indx_list)\\n# print(indx)\\n#print(np.shape(indx_lat))\\n#print(np.shape(indx_lon))\\n w = 0\\n# need to write values for a given station to a plain text file\\n#\\n fout = open(outfile, 'w+')\\n for a in indx_list:\\n for k in [0,1,2,3,4]:\\n fout.write(\\\" {0:4.0f} {1:5.0f} {2:13.4f} {3:10.4f} {4:10.6f} {5:10.4f} {6:12.5f} {7:12.5f} {8:10.6f} {9:10.6f} {10:10.6f} {11:10.4f} \\\\n\\\".format( indx_lat[w], indx_lon[w],All_pgrid[a,k],All_Tgrid[a,k],All_Qgrid[a,k]*1000,All_dTgrid[a,k]*1000,All_U[a,0],All_Hs[a,0], All_ahgrid[a,k]*1000, All_awgrid[a,k]*1000, All_lagrid[a,k], All_Tmgrid[a,k] ))\\n\\n w+=1\\n fout.close()\\n print('file written')\",\n \"def ReadBasicInfo():\\r\\n\\r\\n EquilibriumStep, ProductionStep,HEPCP,HEPCE,Multiple=10000000,10000000,100,100,2\\r\\n InputPath,OutputPath,AtomParameterPath,TaskSuffix,MaterialInputFormat='..','..','..','','mol'\\r\\n GasType,GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,\\\\\\r\\n TorqueSetting,MuSiCSetting,Nodes=[],[],[],[],[],[],[],[],['1:ppn=1']\\r\\n CutOff,GridSpacingP,GridSpacingE=12.8,2.0,2.0\\r\\n MakeGCMC,UsePmap,UseEmap,UsePost,MakePmap,MakeEmap,MakeTorque,KeyOne,KeyTwo,\\\\\\r\\n PDBCharges = False,False,False,False,False,False,False,False,False,False\\r\\n\\r\\n with open('GlueParameters', 'r') as File:\\r\\n for Line in File.readlines():\\r\\n if Line.strip():\\r\\n WordList = Line.strip().split()\\r\\n if len(WordList)>1 or KeyOne==True or KeyTwo==True:\\r\\n if WordList[0]=='#':\\r\\n continue\\r\\n\\r\\n # Controlled part\\r\\n elif WordList[0] == 'MakeGCMC:' and WordList[1] == 'open':\\r\\n MakeGCMC = True\\r\\n elif WordList[0] == 'UsePmap:' and WordList[1] == 'yes':\\r\\n UsePmap = True\\r\\n elif WordList[0] == 'UseEmap:' and WordList[1] == 'yes':\\r\\n UseEmap = True\\r\\n elif WordList[0] == 'UsePost:' and WordList[1] == 'yes':\\r\\n UsePost = True\\r\\n elif WordList[0] == 'MakePmap:' and WordList[1] == 'open':\\r\\n MakePmap = True\\r\\n elif WordList[0] == 'MakeEmap:' and WordList[1] == 'open':\\r\\n MakeEmap = True\\r\\n elif WordList[0] == 'MakeTorque:' and WordList[1] == 'open':\\r\\n MakeTorque = True\\r\\n elif WordList[0] == 'UseChargesFromPDBFile:' and WordList[1] == 'yes':\\r\\n PDBCharges = True\\r\\n\\r\\n # Basic part\\r\\n elif WordList[0]=='InputPath:':\\r\\n InputPath=WordList[1]\\r\\n elif WordList[0]=='MaterialInputFormat:':\\r\\n MaterialInputFormat=WordList[1]\\r\\n elif WordList[0]=='OutputPath:':\\r\\n OutputPath=WordList[1]\\r\\n elif WordList[0]=='AtomParameterPath:':\\r\\n AtomParameterPath=WordList[1]\\r\\n elif WordList[0] == 'GasType:':\\r\\n GasType = list(WordList[1:])\\r\\n elif WordList[0] == 'GasAtomTypeNum:':\\r\\n\\r\\n for i in WordList[1:]:\\r\\n GasAtomTypeNum.append(int(i))\\r\\n\\r\\n elif WordList[0] == 'GasAtomType:':\\r\\n GasAtomType = list(WordList[1:])\\r\\n elif WordList[0] == 'Multiple:':\\r\\n Multiple = int(WordList[1])\\r\\n elif WordList[0] == 'CutOff:':\\r\\n CutOff = float(WordList[1])\\r\\n\\r\\n # GCMC part\\r\\n\\r\\n elif WordList[0] == 'GasPartialPressure:':\\r\\n\\r\\n for j in WordList[1:]:\\r\\n GasPartialPressure.append(str(j))\\r\\n\\r\\n elif WordList[0] == 'TemperatureList(K):':\\r\\n\\r\\n for l in WordList[1:]:\\r\\n TemperatureList.append(float(l))\\r\\n\\r\\n elif WordList[0] == 'PressureList(kPa):':\\r\\n\\r\\n for k in WordList[1:]:\\r\\n PressureList.append(float(k))\\r\\n\\r\\n elif WordList[0] == 'EquilibriumStep:':\\r\\n EquilibriumStep = int(WordList[1])\\r\\n elif WordList[0] == 'ProductionStep:':\\r\\n ProductionStep = int(WordList[1])\\r\\n\\r\\n # Pmap part\\r\\n elif WordList[0] == 'GridSpacingP(Ang):':\\r\\n GridSpacingP = float(WordList[1])\\r\\n elif WordList[0] == 'HighEndPotentialCutoffP(kJ/mol):':\\r\\n HEPCP = int(WordList[1])\\r\\n\\r\\n # Emap part\\r\\n elif WordList[0] == 'GridSpacingE(Ang):':\\r\\n GridSpacingE = float(WordList[1])\\r\\n elif WordList[0] == 'HighEndPotentialCutoffE(kJ/mol):':\\r\\n HEPCE = int(WordList[1])\\r\\n\\r\\n # Torque part\\r\\n elif WordList[0] == 'Nodes:':\\r\\n Nodes = WordList[1:]\\r\\n elif WordList[0] == 'TaskSuffix:':\\r\\n TaskSuffix = WordList[1]\\r\\n elif WordList[0] == 'TorqueSetting:':\\r\\n KeyOne = True\\r\\n elif WordList[0] == 'MuSiCSetting:':\\r\\n KeyOne = False\\r\\n KeyTwo = True\\r\\n elif WordList[0] == 'END':\\r\\n KeyTwo = False\\r\\n elif KeyOne == True:\\r\\n TorqueSetting.append(Line)\\r\\n elif KeyTwo == True:\\r\\n MuSiCSetting.append(Line)\\r\\n\\r\\n return (InputPath,OutputPath,AtomParameterPath,MakeTorque,GasType,\\r\\n GasAtomTypeNum,GasAtomType,GasPartialPressure,TemperatureList,PressureList,CutOff,MakeGCMC,UsePmap,\\r\\n UseEmap,UsePost,MakePmap,MakeEmap,EquilibriumStep,ProductionStep,GridSpacingP,HEPCP,GridSpacingE,HEPCE,\\r\\n Multiple,TorqueSetting,MuSiCSetting,Nodes,TaskSuffix,PDBCharges,MaterialInputFormat)\",\n \"def testSimParamsStored(self):\\n params = self.tree.get_simulation_parameters()\\n actual_sim_parameters = dict(\\n seed=2,\\n task=5,\\n output_dir=\\\"output\\\",\\n speciation_rate=0.1,\\n sigma=4.0,\\n tau=4.0,\\n deme=1,\\n sample_size=1.0,\\n max_time=2.0,\\n dispersal_relative_cost=1.0,\\n min_num_species=1,\\n habitat_change_rate=0.0,\\n gen_since_historical=0.0,\\n time_config_file=\\\"null\\\",\\n coarse_map_file=\\\"null\\\",\\n coarse_map_x=20,\\n coarse_map_y=20,\\n coarse_map_x_offset=0,\\n coarse_map_y_offset=0,\\n coarse_map_scale=1.0,\\n fine_map_file=\\\"null\\\",\\n fine_map_x=10,\\n fine_map_y=10,\\n fine_map_x_offset=0,\\n fine_map_y_offset=0,\\n sample_file=\\\"null\\\",\\n grid_x=10,\\n grid_y=10,\\n sample_x=10,\\n sample_y=10,\\n sample_x_offset=0,\\n sample_y_offset=0,\\n historical_coarse_map=\\\"none\\\",\\n historical_fine_map=\\\"none\\\",\\n sim_complete=1,\\n dispersal_method=\\\"normal\\\",\\n m_probability=0.0,\\n cutoff=0.0,\\n landscape_type=\\\"closed\\\",\\n protracted=0,\\n min_speciation_gen=0.0,\\n max_speciation_gen=0.0,\\n dispersal_map=\\\"none\\\",\\n )\\n for key in params.keys():\\n self.assertEqual(params[key], actual_sim_parameters[key])\\n # self.assertDictEqual(params, actual_sim_parameters)\\n self.assertEqual(self.tree.get_job()[0], 2)\\n self.assertEqual(self.tree.get_job()[1], 5)\",\n \"def fixture_coord():\\n\\tEXAMPLE_FILE_FOLDER = str(MODULE_DIR) + \\\"/data/nail1/\\\"\\n\\tcoord_x, coord_y, coord = read.load_coord(EXAMPLE_FILE_FOLDER)\\n\\treturn coord\",\n \"def general_simulation_data(self):\\n iterations = {}\\n nstates = {}\\n natoms = {}\\n for phase in self.phases:\\n positions = self.ncfiles[phase].variables['positions']\\n iterations[phase], nstates[phase], natoms[phase], spatial = positions.shape\\n\\n leniter = max(len('Iterations'), *[len(str(i)) for i in iterations.values()]) + 2\\n lenstates = max(len('States'), *[len(str(i)) for i in nstates.values()]) + 2\\n lennatoms = max(len('Num Atoms'), *[len(str(i)) for i in natoms.values()]) + 2\\n lenleftcol = max(len('Phase'), *[len(phase) for phase in self.phases]) + 2\\n\\n lines = []\\n headstring = ''\\n headstring += ('{:^' + '{}'.format(lenleftcol) + '}').format('Phase') + '|'\\n headstring += ('{:^' + '{}'.format(leniter) + '}').format('Iterations') + '|'\\n headstring += ('{:^' + '{}'.format(lenstates) + '}').format('States') + '|'\\n headstring += ('{:^' + '{}'.format(lennatoms) + '}').format('Num Atoms')\\n lines.append(headstring)\\n lenline = len(headstring)\\n topdiv = '=' * lenline\\n lines.append(topdiv)\\n for phase in self.phases:\\n phasestring = ''\\n phasestring += ('{:^' + '{}'.format(lenleftcol) + '}').format(phase) + '|'\\n phasestring += ('{:^' + '{}'.format(leniter) + '}').format(iterations[phase]) + '|'\\n phasestring += ('{:^' + '{}'.format(lenstates) + '}').format(nstates[phase]) + '|'\\n phasestring += ('{:^' + '{}'.format(lennatoms) + '}').format(natoms[phase])\\n lines.append(phasestring)\\n lines.append('-' * lenline)\\n\\n for line in lines:\\n print(line)\\n self.iterations = iterations\\n self._general_run = True\",\n \"def read_from(self, filename):\\n\\n lon, lat, field, weight = [], [], [], []\\n\\n if os.path.exists(filename):\\n logger.info(\\\"Reading data from file {0}\\\".format(filename))\\n with open(filename, 'r') as f:\\n line = f.readline()\\n ncols = len(line.split())\\n while ncols >= 3:\\n lon.append(float(line.split()[0]))\\n lat.append(float(line.split()[1]))\\n field.append(float(line.split()[2]))\\n if ncols >= 4:\\n weight.append(float(line.split()[3]))\\n else:\\n weight.append(1.)\\n line = f.readline()\\n ncols = len(line.split())\\n\\n self.x = np.array(lon)\\n self.y = np.array(lat)\\n self.field = np.array(field)\\n self.weight = np.array(weight)\\n return self\\n else:\\n logger.error(\\\"File {0} does not exist\\\".format(filename))\\n raise FileNotFoundError('File does not exist')\",\n \"def read_sim_info(folder, filen):\\n \\n ### file path\\n \\n fpath = folder + filen + '.h5'\\n assert os.path.exists(fpath), \\\"The out.h5 file does NOT exist for \\\" + fpath\\n fl = h5py.File(fpath, 'r') \\n \\n ### simulation information\\n \\n lx = fl['/info/box/x'][...]\\n ly = fl['/info/box/y'][...]\\n dt = fl['/info/dt'][...]\\n nsteps = fl['/info/nsteps'][...]\\n nfils = fl['/info/nfils'][...]\\n nbeads = fl['/info/nbeads'][...]\\n nsamp = fl['/info/nsamp'][...]\\n nbpf = fl['/info/nbpf'][...]\\n \\n ### simulation parameters\\n \\n density = fl['/param/density'][...]\\n kappa = fl['/param/kappa'][...]\\n km = fl['/param/km'][...]\\n pa = fl['/param/pa'][...]\\n pp = fl['/param/pp'][...]\\n bl = fl['/param/bl'][...]\\n sigma = fl['/param/sigma'][...]\\n \\n fl.close()\\n \\n ### generate classes to submerge data\\n \\n sim = misc_tools.Simulation(lx, ly, dt, nsteps, nfils, nbeads, nsamp, nbpf, \\\\\\n density, kappa, km, pa, pp, bl, sigma)\\n \\n return sim\",\n \"def get_params(path = 'INPUT/conv_params'):\\n\\n # cd to Input, read the conv_params file in and pass each line to file reader\\n list = file_reader(path)\\n\\n Ecuts = list[0] # first element returned from filereader is the energies\\n start = int(Ecuts[0][0]) # the first element of this is the lower energy to start from. convert to integer for maths\\n multiplier = int(Ecuts[1][0]) # middle element is the step size\\n end = int(Ecuts[2][0]) # last element is upper bound on energy\\n E_range = (end - start)//multiplier +1 # the number of energies you will create\\n Es = [i*multiplier for i in range(E_range)] # take steps in the E_range of step size multiplier\\n Ecuts = [[str(i+start)] for i in Es] # add the start energy to all these steps to shift them to correct energies\\n # convert the numbers to strings for ease of file writing later\\n\\n kpts = list[1] # kpoints list is first element returned\\n def_E = list[2] # default energy\\n def_k = list[3] # default kpoints\\n params = Settings(Ecuts, kpts, def_E, def_k) # create the settings object\\n\\n return params # return the object\",\n \"def __read_job_params_file__(self):\\n # | - __read_job_params_file__\\n job_params = {}\\n\\n # file_path = self.full_path + \\\"/\\\" + \\\"job_parameters.json\\\"\\n\\n file_exists = False\\n\\n file_path = os.path.join(\\n self.full_path,\\n \\\"job_parameters.json\\\")\\n if os.path.exists(file_path):\\n file_exists = True\\n with open(file_path, \\\"r\\\") as fle:\\n job_params = json.load(fle)\\n\\n\\n ind_i = self.full_path.rfind(self.full_path.split(\\\"/\\\")[-1])\\n path_i_rt = self.full_path[:ind_i - 1]\\n\\n file_path = os.path.join(\\n # self.full_path[0:-2],\\n path_i_rt,\\n \\\"job_parameters.json\\\",\\n )\\n if os.path.exists(file_path):\\n file_exists = True\\n with open(file_path, \\\"r\\\") as fle:\\n job_params = json.load(fle)\\n\\n\\n file_path = os.path.join(\\n # self.full_path[0:-2],\\n path_i_rt,\\n \\\"job_params.json\\\",\\n )\\n if os.path.exists(file_path):\\n file_exists = True\\n with open(file_path, \\\"r\\\") as fle:\\n job_params = json.load(fle)\\n\\n if not file_exists:\\n print(\\\"No job_params file found for following job:\\\")\\n print(self.full_path)\\n\\n return(job_params)\\n # __|\",\n \"def Data_init(**kwargs):\\n if 'file' in kwargs:\\n print \\\"Reading the file\\\"\\n else:\\n print \\\"Randomizing the initial data\\\"\\n XV = np.random.rand(kwargs['particles'],kwargs['dimensions']*2) * 2 - 1\\n M = np.random.rand(kwargs['particles'])\\n\\n t_f,num = kwargs['time']\\n t = np.linspace(0,t_f,num)\\n\\n return XV,M,t\",\n \"def load_params():\\r\\n return pickle.load(open('params.p', mode='rb'))\",\n \"def vars_ifile(ifile):\\n\\n site = None\\n year = None\\n actual = None\\n doy = None\\n Ndays = None\\n params = None\\n Nsteps = None\\n models = None\\n resolution = None\\n fopt = None\\n window = None\\n tag = None\\n photo = None\\n plot = None\\n project = None\\n\\n with open(ifile, 'r') as f:\\n\\n for line in f:\\n\\n ll = line.strip()\\n\\n if not ll.startswith(\\\"#\\\"):\\n ll = ll.rstrip()\\n\\n if site is None:\\n site = read_var('site', ll)\\n\\n if year is None:\\n year = read_var('year', ll)\\n\\n if actual is None:\\n actual = read_var('actual', ll)\\n\\n if doy is None:\\n doy = read_var('doy', ll)\\n\\n if Ndays is None:\\n Ndays = read_var('Ndays', ll)\\n\\n if params is None:\\n params = read_var('params', ll)\\n\\n if Nsteps is None:\\n Nsteps = read_var('Nsteps', ll)\\n\\n if models is None:\\n models = read_var('models', ll)\\n\\n if resolution is None:\\n resolution = read_var('resolution', ll)\\n\\n if fopt is None:\\n fopt = read_var('fopt', ll)\\n\\n if window is None:\\n window = read_var('window', ll)\\n\\n if tag is None:\\n tag = read_var('tag', ll)\\n\\n if photo is None:\\n photo = read_var('photo', ll)\\n\\n if plot is None:\\n plot = read_var('plot', ll)\\n\\n if project is None:\\n project = read_var('project', ll)\\n\\n if actual is None: # make sure the spinup only runs for the Control\\n models = 'Control'\\n\\n return (site, year, actual, doy, Ndays, params, Nsteps, models, resolution,\\n fopt, window, tag, photo, plot, project)\",\n \"def read_params(self):\\n detector_params = namedtuple('params', ['image_path', 'circle_region',\\n 'vis_circle_det',\\n 'template_path', 'score_thres',\\n 'vis_det'])\\n with open(self.yaml_path, 'r') as stream:\\n try:\\n parameters = yaml.load(stream)\\n except:\\n raise FileNotFoundError\\n\\n detector_params.image_path = parameters.get('image_path', None)\\n if detector_params.image_path is None:\\n raise ValueError('Please provide path to image.')\\n\\n detector_params.circle_region = read_circle_region_params(parameters)\\n detector_params.vis_circle_det = read_vis_circle_det(parameters)\\n\\n detector_params.template_path = parameters.get('template_path', None)\\n if detector_params.template_path is None:\\n raise ValueError('Please provide path to template image.')\\n\\n detector_params.vis_det = parameters.get('vis_det', True)\\n detector_params.score_thres = parameters.get('score_thres', 0.3)\\n\\n return detector_params\",\n \"def readTestFile(self, filename):\\n size = 0\\n agentNum = 0\\n block = {}\\n agentList = []\\n f = open(filename, 'r')\\n for line in f:\\n if line[0] != '#':\\n c = line.split(' ')\\n if c[0] == 'grid':\\n size = int(line[5:7])\\n elif c[0] =='block':\\n block[(int(c[2]), int(c[1]))] = (int(c[3]) - int(c[1]) + 1, int(c[4]) - int(c[2]) + 1)\\n elif c[0] == 'nets':\\n agentNum = int(c[1])\\n elif c[0] == 'net' or c[0] == 'xet':\\n print(c)\\n agentList.append([int(c[1]), (int(c[3]), int(c[2])), (int(c[6]), int(c[5]))])\\n f.close()\\n print(size)\\n print(block)\\n print(agentNum)\\n print(agentList)\\n return size, block, agentNum, agentList\",\n \"def read_genesis(self, file_name):\\n \\n # genesis coordinates are as follows:\\n # x -- horizontal coordinate, m\\n # px -- horizontal momentum, beta_x gamma\\n # y -- vertical coordinate, m\\n # py -- vertical momentum, beta_y gamma\\n # th -- theta, the ponderomotive phase at fixed z\\n # t -- time of arrival at fixed z, sec\\n # gamma -- particle gamma\\n\\n return 0\",\n \"def readParameters(paramFile):\\n try:\\n with open(paramFile,\\\"r\\\") as infile:\\n contents = infile.read()\\n jsonfile = json.loads(contents)\\n print(\\\"Local parameter file found, returning saved parameters\\\")\\n paramWindDirection = jsonfile[\\\"parameters\\\"][\\\"windDirection\\\"]\\n paramWindSpeed = jsonfile[\\\"parameters\\\"][\\\"windSpeed\\\"]\\n paramWaterHeight = jsonfile[\\\"parameters\\\"][\\\"waterHeight\\\"]\\n paramRainFall = jsonfile[\\\"parameters\\\"][\\\"rainFall\\\"]\\n print(paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall)\\n except IOError:\\n print(\\\"Local parameter file could not be found, returning default parameters.\\\")\\n paramWindDirection = \\\"270\\\"\\n paramWindSpeed = \\\"20\\\"\\n paramWaterHeight = \\\"50\\\"\\n paramRainFall = \\\"150\\\"\\n print(paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall)\\n return paramWindDirection,paramWindSpeed,paramWaterHeight,paramRainFall\",\n \"def readDriverFile(self, input_file):\\n\\n\\n fid = open(self.basePath + input_file,'r')\\n\\n # Line 1\\n line = fid.readline()\\n l_input = line.split('!')\\n mshfile = l_input[0].rstrip()\\n\\n # Line 2\\n line = fid.readline()\\n l_input = line.split('!')\\n obsfile = l_input[0].rstrip()\\n\\n # Line 3\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input=='null':\\n topofile = []\\n\\n else:\\n topofile = l_input[0].rstrip()\\n\\n\\n # Line 4\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n mstart = float(l_input[1])\\n\\n else:\\n mstart = l_input[0].rstrip()\\n\\n # Line 5\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n mref = float(l_input[1])\\n\\n else:\\n mref = l_input[0].rstrip()\\n\\n # Line 6\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n staticInput = float(l_input[1])\\n\\n elif l_input[0]=='DEFAULT':\\n staticInput = None\\n\\n else:\\n staticInput = l_input[0].rstrip()\\n\\n\\n # Line 7\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input=='DEFAULT':\\n magfile = []\\n\\n else:\\n magfile = l_input[0].rstrip()\\n\\n # Line 8\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input=='DEFAULT':\\n wgtfile = []\\n\\n else:\\n wgtfile = l_input[0].rstrip()\\n\\n # Line 9\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n chi = float(l_input[0])\\n\\n # Line 10\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n val = np.array(l_input[0:4])\\n alphas = val.astype(np.float)\\n\\n # Line 11\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n val = np.array(l_input[1:3])\\n bounds = val.astype(np.float)\\n\\n else:\\n bounds = l_input[0].rstrip()\\n\\n # Line 12\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n val = np.array(l_input[1:6])\\n lpnorms = val.astype(np.float)\\n\\n else:\\n lpnorms = l_input[0].rstrip()\\n\\n # Line 13\\n line = fid.readline()\\n l_input = re.split('[!\\\\s]',line)\\n if l_input[0]=='VALUE':\\n val = np.array(l_input[1:3])\\n eps = val.astype(np.float)\\n\\n else:\\n eps = [None,None]\\n\\n self.mshfile = mshfile\\n self.obsfile = obsfile\\n self.topofile = topofile\\n self.mstart = mstart\\n self._mrefInput = mref\\n self._staticInput = staticInput\\n self.magfile = magfile\\n self.wgtfile = wgtfile\\n self.chi = chi\\n self.alphas = alphas\\n self.bounds = bounds\\n self.lpnorms = lpnorms\\n self.eps = eps\",\n \"def read_plot_config(config_file_name,input_filename, d,\\\\\\n call_time, call_lon, call_lat,\\\\\\n call_storm_name,\\\\\\n call_add_lon = 4., call_add_lat = 4,\\\\\\n call_var = None,\\\\\\n var_name = None,\\\\\\n call_units = '',\\\\\\n call_storm_num = None,\\\\\\n call_storm_basin = None,\\\\\\n lon0 = None, lat0 = None,\\\\\\n plt_type = 'barbs',\\\\\\n barbs_subplot_type = 'scatter',\\\\\\n plot_out_dir = '.',\\\\\\n call_var2 = None,\\\\\\n call_var3 = None):\\n\\n # --- lenght in km of 1 degree lat\\n LATKM = 111.\\n\\n try:\\n config_file = open(config_file_name,'r')\\n except IOError:\\n error_msg = 'Cannot open file '+ config_file_name\\n LOGGER.exception(error_msg)\\n sys.exit(error_codes.EX_IOERR)\\n\\n try:\\n data_block = False\\n for read_line in iter(config_file):\\n strip_line = read_line.strip()\\n if len(strip_line) > 1:\\n # --- read non-empty line\\n curr_line = strip_line.split(';')\\n\\n # --- parse non-empty line\\n if data_block is False and re.match('^ *#',curr_line[0]):\\n # --- skip comments\\n continue\\n\\n elif data_block is False and curr_line[0] == 'data':\\n var_name = curr_line[1].strip()\\n num_id = curr_line[2].strip()\\n read_press = curr_line[3].strip()\\n press = [int(x) for x in read_press.split(\\\",\\\")]\\n data_block = True\\n elif data_block:\\n if num_id == '1': #plot_data_lonlat \\n \\n call_time = d.var_dict[curr_line[0].strip()] \\n for ipress in press: \\n \\n call_var = d.var_dict[curr_line[1].strip()] \\n if ipress == 'none':\\n #MUST be 'none' for 2d variables\\n pass\\n else: \\n #3d variables\\n call_var = d.get_pressure_slice(call_var,ipress,var_name)\\n\\n call_lon = d.var_dict[curr_line[2].strip()]\\n call_lat = d.var_dict[curr_line[3].strip()]\\n call_storm_num = d.var_dict[curr_line[4].strip()]\\n call_storm_basin = d.var_dict[curr_line[5].strip()]\\n\\n\\n for ikw in curr_line[6:len(curr_line)]:\\n if re.match(' *add_lon', ikw): call_add_lon = float(ikw.split('=')[-1])\\n if re.match(' *add_lat', ikw): call_add_lat = float(ikw.split('=')[-1])\\n if re.match(' *storm_name', ikw): \\n call_storm_name = d.var_dict[ikw.split('=')[-1].strip()]\\n if re.match(' *units', ikw): call_units = ikw.split('=')[-1].strip()\\n if re.match(' *pos', ikw): call_pos = ikw.split('=')[-1].strip()\\n if re.match(' *rmax', ikw): call_rmax = ikw.split('=')[-1].strip()\\n if re.match(' *plot_var2', ikw): \\n plot_var2 = d.var_dict[ikw.split('=')[-1].strip()]\\n call_var2= d.get_pressure_slice(plot_var2,ipress,'var2')\\n if re.match(' *plot_var3', ikw): \\n plot_var3 = d.var_dict[ikw.split('=')[-1].strip()]\\n call_var3= d.get_pressure_slice(plot_var3,ipress,'var3')\\n if re.match(' *plt_type', ikw): \\n plt_type = ikw.split('=')[-1].strip()\\n if re.match(' *barbs_subplot_type', ikw): \\n barbs_subplot_type = ikw.split('=')[-1].strip()\\n \\n if ipress != 'none':\\n call_p_lev = ipress\\n else:\\n call_p_lev = 'none'\\n\\n if re.match(' *savefig', ikw): \\n savefig_str = ikw.split('=')[-1] \\n if savefig_str == 'True': call_savefig = True\\n else: call_savefig = False\\n if re.match(' *showfig', ikw): \\n show_str = ikw.split('=')[-1] \\n if show_str == 'True': call_show = True\\n else: call_show = False\\n if re.match(' *plot_out_dir', ikw): plot_out_dir = ikw.split('=')[-1].strip()\\n \\n LOGGER.info( \\\"plotting variable \\\"+var_name.strip()+', pressure_level = %d mb' % call_p_lev)\\n try: \\n plot_data_lonlat(call_time,call_var,call_lon,call_lat,\\\\\\n call_storm_num, call_storm_basin,\\\\\\n lon0 = lon0, lat0 = lat0,\\\\\\n add_lon = call_add_lon, add_lat = call_add_lat,\\\\\\n storm_name = call_storm_name,\\\\\\n p_lev = call_p_lev,var_name = var_name,\\\\\\n units = call_units,\\\\\\n filename_var = var_name,\\\\\\n plot_var2 = call_var2,\\\\\\n plot_var3 = call_var3,\\\\\\n plt_type = plt_type,\\\\\\n plot_out_dir = plot_out_dir,\\\\\\n input_filename = input_filename,\\\\\\n barbs_subplot_type = barbs_subplot_type,\\\\\\n savefig = True,showfig =False)\\n except:\\n error_msg = 'unable to make plot using values from config file'\\n raise ValueError(error_msg)\\n data_block = False\\n\\n #-----------------------------------------------------------------------------------\\n else: \\n data_block = False\\n else: \\n # ---error in config file\\n raise ValueError('Incorrect data format in config file '+config_file_name)\\n\\n else:\\n # --- skip empty lines\\n continue\\n except:\\n error_msg = 'Error encountered while reading config file '+config_file_name\\n LOGGER.exception(error_msg)\\n sys.exit(error_codes.EX_CONFIG) \\n \\n config_file.close()\",\n \"def read_from_ascii(self, filename):\\n self.ascii_filename = filename\\n # read file content into a string\\n f=open(filename,'r')\\n file_str=f.read()\\n f.close()\\n # make dictionary with file content\\n reg_exp_data_groups=re.compile(r'^#>>(\\\\w+):.*\\\\n',re.M)\\n file_dict=self.make_data_dict_from_str(reg_exp_data_groups,file_str)\\n # read arrays ------------------------------\\n self.x=np.loadtxt(StringIO.StringIO(file_dict['x']))\\n self.p=np.loadtxt(StringIO.StringIO(file_dict['p']))\\n self.fmci_XP=np.loadtxt(StringIO.StringIO(file_dict['XP']))\\n # regular expression for extracting parameter=value\\n reg_exp_param_val=re.compile(r'\\\\n*(\\\\w+)=',re.M)\\n # read params_physics -----------------------\\n params_physics_dict=self.make_data_dict_from_str(reg_exp_param_val,file_dict['params_physics'])\\n self.name=self.__get_particle_name(params_physics_dict['particle'])\\n self.time=float(params_physics_dict['time'])\\n # read params_TDC ---------------------------\\n params_TDC_dict=self.make_data_dict_from_str(reg_exp_param_val,file_dict['params_TDC'])\\n self.calc_id=params_TDC_dict['calc_id']\\n self.i_ts=int(params_TDC_dict['i_ts'])\",\n \"def read_settings():\\n # open file for reading\\n ifile = open(infilename, 'r')\\n # skip comment line\\n ifile.readline()\\n # char-file name\\n line = ifile.readline()\\n line = line.split()\\n charfile = line[-1]\\n # header-file name\\n line = ifile.readline()\\n line = line.split()\\n headerfile = line[-1]\\n # output folder\\n line = ifile.readline()\\n line = line.split()\\n ofname = line[-1]\\n # length of the filaments\\n line = ifile.readline()\\n line = line.split()\\n nfil = int(line[-1])\\n # number of snapshots to skip\\n line = ifile.readline()\\n line = line.split()\\n nskip = int(line[-1])\\n # number of bins\\n line = ifile.readline()\\n line = line.split()\\n nbin = int(line[-1])\\n # maximum cutoff\\n line = ifile.readline()\\n line = line.split()\\n rmax = float(line[-1])\\n # overall number of snapshots to use in the analysis\\n line = ifile.readline()\\n line = line.split()\\n ntotal = int(line[-1])\\n # close file\\n ifile.close()\\n # return input values\\n return charfile, headerfile, ofname, nfil, nskip, nbin, rmax, ntotal\",\n \"def load_params_from_file(path):\\n save_dict = mx.nd.load(path)\\n arg_params = {}\\n aux_params = {}\\n for k, v in save_dict.items():\\n tp, name = k.split(':', 1)\\n if tp == 'arg':\\n arg_params[name] = v\\n if tp == 'aux':\\n aux_params[name] = v\\n return arg_params, aux_params\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6841979","0.6729605","0.66394055","0.66348255","0.64284354","0.6424802","0.64047414","0.6300033","0.62991303","0.6293398","0.624105","0.62298125","0.6183919","0.6102133","0.609614","0.60784197","0.6073304","0.6040738","0.5993862","0.59910494","0.59779483","0.5953688","0.5950151","0.59373474","0.5919408","0.59147537","0.5891352","0.5877133","0.58770007","0.583785","0.5819981","0.58002585","0.579654","0.57949597","0.5790822","0.57891184","0.57843626","0.5781912","0.5769227","0.5768712","0.5767634","0.5765372","0.57587945","0.57553387","0.5752936","0.5752292","0.57404006","0.5739116","0.5735791","0.57198584","0.5716437","0.5706669","0.5704985","0.57008874","0.56991756","0.56935716","0.5685824","0.5683463","0.5668549","0.5667266","0.56567425","0.5654484","0.56541824","0.56516594","0.5642127","0.56417376","0.5638874","0.5630846","0.56304973","0.5619024","0.56187326","0.56138855","0.56114054","0.5608674","0.55922997","0.55878526","0.5587758","0.55856353","0.5583615","0.557973","0.5570053","0.55662143","0.55660146","0.5563614","0.5558518","0.55563766","0.5556073","0.55559593","0.5549846","0.5543248","0.55426997","0.5540286","0.5536256","0.5534764","0.5528861","0.552886","0.5524196","0.551742","0.551544","0.5511877"],"string":"[\n \"0.6841979\",\n \"0.6729605\",\n \"0.66394055\",\n \"0.66348255\",\n \"0.64284354\",\n \"0.6424802\",\n \"0.64047414\",\n \"0.6300033\",\n \"0.62991303\",\n \"0.6293398\",\n \"0.624105\",\n \"0.62298125\",\n \"0.6183919\",\n \"0.6102133\",\n \"0.609614\",\n \"0.60784197\",\n \"0.6073304\",\n \"0.6040738\",\n \"0.5993862\",\n \"0.59910494\",\n \"0.59779483\",\n \"0.5953688\",\n \"0.5950151\",\n \"0.59373474\",\n \"0.5919408\",\n \"0.59147537\",\n \"0.5891352\",\n \"0.5877133\",\n \"0.58770007\",\n \"0.583785\",\n \"0.5819981\",\n \"0.58002585\",\n \"0.579654\",\n \"0.57949597\",\n \"0.5790822\",\n \"0.57891184\",\n \"0.57843626\",\n \"0.5781912\",\n \"0.5769227\",\n \"0.5768712\",\n \"0.5767634\",\n \"0.5765372\",\n \"0.57587945\",\n \"0.57553387\",\n \"0.5752936\",\n \"0.5752292\",\n \"0.57404006\",\n \"0.5739116\",\n \"0.5735791\",\n \"0.57198584\",\n \"0.5716437\",\n \"0.5706669\",\n \"0.5704985\",\n \"0.57008874\",\n \"0.56991756\",\n \"0.56935716\",\n \"0.5685824\",\n \"0.5683463\",\n \"0.5668549\",\n \"0.5667266\",\n \"0.56567425\",\n \"0.5654484\",\n \"0.56541824\",\n \"0.56516594\",\n \"0.5642127\",\n \"0.56417376\",\n \"0.5638874\",\n \"0.5630846\",\n \"0.56304973\",\n \"0.5619024\",\n \"0.56187326\",\n \"0.56138855\",\n \"0.56114054\",\n \"0.5608674\",\n \"0.55922997\",\n \"0.55878526\",\n \"0.5587758\",\n \"0.55856353\",\n \"0.5583615\",\n \"0.557973\",\n \"0.5570053\",\n \"0.55662143\",\n \"0.55660146\",\n \"0.5563614\",\n \"0.5558518\",\n \"0.55563766\",\n \"0.5556073\",\n \"0.55559593\",\n \"0.5549846\",\n \"0.5543248\",\n \"0.55426997\",\n \"0.5540286\",\n \"0.5536256\",\n \"0.5534764\",\n \"0.5528861\",\n \"0.552886\",\n \"0.5524196\",\n \"0.551742\",\n \"0.551544\",\n \"0.5511877\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5666166"},"document_rank":{"kind":"string","value":"60"}}},{"rowIdx":88391,"cells":{"query":{"kind":"string","value":"Read visualise setup file"},"document":{"kind":"string","value":"def read_input_file(self):\n\n # Check if input file exists in current directory, if not kill process\n if not os.path.isfile('./visualise.inpt'):\n print('Cannot find input file \"visualise.inpt\" in current directory')\n sys.exit()\n\n # Read input file and analysis options and parameters\n print('Reading input file')\n with open('visualise.inpt','r') as f:\n f.readline()\n self.prefix = f.readline().split()[0]\n f.readline()\n f.readline()\n self.frame = int(f.readline().split()[0])\n f.readline()\n f.readline()\n self.vis_particles = int(f.readline().split()[0])\n self.vis_vortype = int(f.readline().split()[0])\n self.vis_cellcolour = int(f.readline().split()[0])\n self.vis_save = int(f.readline().split()[0])"},"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 read_setup(inifile):\n # inifile = os.path.join(spathy_path, inifile)\n print(inifile)\n cfg = configparser.ConfigParser()\n cfg.read(inifile)\n\n pp = {}\n for s in cfg.sections():\n section = s.encode('ascii', 'ignore')\n pp[section] = {}\n for k, v in cfg.items(section):\n key = k.encode('ascii', 'ignore')\n val = v.encode('ascii', 'ignore')\n if section == 'General': # 'general' section\n pp[section][key] = val\n else:\n pp[section][key] = float(val)\n pp['General']['dt'] = float(pp['General']['dt'])\n\n pgen = pp['General']\n pcpy = pp['CanopyGrid']\n pbu = pp['BucketGrid']\n ptop = pp['Topmodel']\n\n return pgen, pcpy, pbu, ptop","def readInConfigFileDlg( self ):\n pass","def read_config(self, config_filename):","def setup():\n setFormat()\n setFilename()\n setScreenMode()","def readInConfigFile( self, fileName ):\n self.console.info( \"Read input file\" )","def readConfigFileDlg( self ):\n fileName = QtGui.QFileDialog.getOpenFileName( self, \"Read application config file\", self.rsrc.lastFolder, \"Config files (*.cfg)\" )\n if ( fileName ):\n self.readConfigFile( fileName )\n path, fName = os.path.split( str( fileName ) )\n self.rsrc.lastFolder = path","def get_setup(setup_file):\n # load raw file\n setup = tab.read_namelist(setup_file, convert_to_number=True)\n\n with open(setup_file, 'r') as fid:\n setup['_original_setup_file'] = fid.readlines()\n\n # process\n process_setup(setup)\n\n return setup","def __read_config(self):\n with open(self.config_file, 'r') as data_file:\n dict = json.load(data_file)\n self.ibooks_doc_root = dict[\"ibooks_doc_root\"]\n self.library_folder = dict[\"library_folder\"]\n self.annotation_folder = dict[\"annotation_folder\"]\n self.tmp_dir = dict[\"tmp_dir\"]","def readSettingsFile():\n\tglobal logfile\n\tglobal backupCount\n\tglobal maxBytes\n\tglobal debug\n\t\n\tif SettingsFile.getOptionString(INI_Section,\"logfile\"):\n\t\tlogfile = SettingsFile.getOptionString(INI_Section,\"logfile\")\n\tif SettingsFile.getOptionInt(INI_Section,\"maxBytes\"):\n\t\tmaxBytes = SettingsFile.getOptionInt(INI_Section,\"maxBytes\")\n\tif SettingsFile.getOptionInt(INI_Section,\"backupCount\"):\n\t\tbackupCount = SettingsFile.getOptionInt(INI_Section,\"backupCount\")\n\tif SettingsFile.getOptionBoolean(INI_Section,\"debug\"):\n\t\tdebug = SettingsFile.getOptionBoolean(INI_Section,\"debug\")\n\t#endif","def readConfigFile( self, fileName ):\n try:\n self.analysisBox.readConfig( fileName )\n path, name = os.path.split( fileName )\n self.rsrc.lastFolder = path\n self.console.info( 'Read full config file %s\\n' % fileName )\n except IOError, ValueError:\n self.console.error( 'Error reading full config file %s\\n' % fileName )","def read_setup(fname):\n with codecs.open(fname, 'r') as fin:\n n_row, n_col, L, H = list(map(int, fin.readline().split()))\n\n pizza = []\n for _ in range(n_row):\n line = fin.readline().strip()\n pizza.append(line)\n\n return pizza, n_row, n_col, L, H","def cli(ctx, root):\n try:\n ctx.obj = create_initial_context(root)\n except SettingsBroken as e:\n click.echo(\n 'Failed to read the settings file: %s' % str(e),\n err=True\n )\n exit(1)","def config():","def config():","def read_readme(setup_file, name=\"README.rst\"):\n import os\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\n if not os.path.exists(TOP_DIR):\n raise FileNotFoundError(\n f\"Unable to find folder {TOP_DIR!r}.\")\n readme = os.path.join(TOP_DIR, name)\n if not os.path.exists(readme):\n raise FileNotFoundError(\n f\"Unable to find file {TOP_DIR!r}.\")\n with open(readme, \"r\", encoding=\"utf-8\") as f:\n content = f.read()\n return _clean_readme(content)","def read(self, run):\n # read the file\n self['run'] = run[0:run.rfind('.xml')]\n f = open(run)\n for line in f:\n \n if line.find('SDSU Exec') >= 0:\n n1 = line.index('name=') + 6\n n2 = line.index('\"', n1)\n self['application'] = line[n1:n2]\n\n elif line.find('<detector_status') >= 0:\n n1 = line.index('name=') + 6\n n2 = line.index('\"', n1)\n if line[n1:n2] != 'Ultraspec':\n raise Exception, 'Run ' + run + ' is not an Ultraspec file.'\n \n elif line.find('SPEED') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['speed'] = line[n1:n2]\n \n elif line.find('X_BIN') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['x_bin'] = line[n1:n2]\n \n elif line.find('Y_BIN') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['y_bin'] = line[n1:n2]\n \n # first window \n \n elif line.find('X1_START') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['x1_start'] = line[n1:n2]\n \n elif line.find('X1_SIZE') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['x1_size'] = line[n1:n2]\n \n elif line.find('Y1_START') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['y1_start'] = line[n1:n2]\n \n elif line.find('Y1_SIZE') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['y1_size'] = line[n1:n2]\n \n # second window\n \n elif line.find('X2_START') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['x2_start'] = line[n1:n2]\n \n elif line.find('X2_SIZE') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['x2_size'] = line[n1:n2]\n \n elif line.find('Y2_START') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['y2_start'] = line[n1:n2]\n \n elif line.find('Y2_SIZE') >= 0:\n n1 = line.index('value=') + 7\n n2 = line.index('\"', n1)\n self['y2_size'] = line[n1:n2]\n \n elif line.find('<target>') >= 0:\n n1 = line.index('target') + 7\n n2 = line.index('<', n1)\n self['target'] = line[n1:n2]\n\n elif line.find('<grating>') >= 0:\n n1 = line.index('grating') + 8\n n2 = line.index('<', n1)\n self['grating'] = line[n1:n2]\n\n elif line.find('<slit_width>') >= 0:\n n1 = line.index('slit_width') + 11\n n2 = line.index('<', n1)\n self['slit_width'] = line[n1:n2]\n\n elif line.find('<slit_angle>') >= 0:\n n1 = line.index('slit_angle') + 11\n n2 = line.index('<', n1)\n self['slit_angle'] = line[n1:n2]\n \n elif line.find('<filters>') >= 0:\n n1 = line.index('filters') + 8\n n2 = line.index('<', n1)\n self['filters'] = line[n1:n2]\n\n elif line.find('<ID>') >= 0:\n n1 = line.index('ID') + 3\n n2 = line.index('<', n1)\n self['ID'] = line[n1:n2]\n\n elif line.find('<PI>') >= 0:\n n1 = line.index('PI') + 3\n n2 = line.index('<', n1)\n self['PI'] = line[n1:n2]\n\n elif line.find('<comment>') >= 0:\n n1 = line.index('comment') + 8\n n2 = line.index('<', n1)\n self['comment'] = line[n1:n2]\n \n\n # check that we have found what we expected to find\n if 'application' not in self:\n raise Exception, 'Failed to find application name in ' + run\n\n if self.is_not_power_onoff():\n\n if 'x_bin' not in self:\n raise Exception, 'Failed to find X_BIN in ' + run\n\n if 'y_bin' not in self:\n raise Exception, 'Failed to find Y_BIN in ' + run\n\n if 'x1_start' not in self:\n raise Exception, 'Failed to find X2_START in ' + run\n \n if 'x1_size' not in self:\n raise Exception, 'Failed to find X2_SIZE in ' + run\n \n if 'y1_start' not in self:\n raise Exception, 'Failed to find Y2_START in ' + run\n \n if 'y1_size' not in self:\n raise Exception, 'Failed to find Y2_SIZE in ' + run\n \n if 'x2_start' not in self:\n raise Exception, 'Failed to find X2_START in ' + run\n \n if 'x2_size' not in self:\n raise Exception, 'Failed to find X2_SIZE in ' + run\n \n if 'y2_start' not in self:\n raise Exception, 'Failed to find Y2_START in ' + run\n \n if 'y2_size' not in self:\n raise Exception, 'Failed to find Y2_SIZE in ' + run\n \n if 'target' not in self:\n self['target'] = 'UNKNOWN'\n\n if 'filters' not in self:\n self['filters'] = '---'\n\n if 'grating' not in self:\n self['grating'] = '---'\n\n if 'slit_width' not in self:\n self['slit_width'] = '---'\n\n if 'slit_angle' not in self:\n self['slit_angle'] = '---'\n\n if 'ID' not in self:\n self['ID'] = 'UNKNOWN'\n\n if 'PI' not in self:\n self['PI'] = 'UNKNOWN'","def read_config(name):\n import yaml\n fname=get_config_file(name)\n #print(\"reading:\",fname)\n with open(fname) as fobj:\n data=yaml.load(fobj)\n return data","def parse_design(self, detailed_design_file):","def read_config(self,confile):\n\n\n print(\"reading:\",confile)\n with open(confile) as parf:\n data=yaml.load(parf)\n\n\n return data","def get_setup_file():\n repo_fs()\n return SETUP_FILES","def read_setup_py(path):\n with open('%s/setup.py' % path, 'r') as setup:\n return ''.join(setup.readlines())","def readSettingsFile(self):\n with open(self.settingsFilePath, 'r') as settingsFile:\n self.settings = json.loads(settingsFile.read())","def read_file(self, currentIndex):\n handle = open(\"Program Files\\\\TvInfo\\\\\" + str(currentIndex) + \".tvInfo\", \"r\")\n data = handle.read() #reading description\n handle.close()\n return data","def main(filename: str) -> None:\n # Template from HtDAP, based on composition \n return scatterplot(read(filename))","def read_file(self, currentIndex):\n handle = open(\"Program Files\\\\\" + str(currentIndex) + \".tvInfo\", \"r\")\n data = handle.read() #reading description\n handle.close()\n return data","def do_stuff_with_data_file():\n import os\n script_path = os.path.dirname(os.path.abspath(__file__))\n file_path = os.path.join(script_path, \"data/exampledata.txt\")\n print(\"reading the data file that was added to the installation:\")\n with open(file_path, \"r\") as f:\n print(f.read())","def read_graph_ui(self):\n filename = input('enter filename: ')\n try:\n self._graph = read_graph(filename)\n except FileNotFoundError:\n print('invalid filename! ')","def read_utilities(self):\n self.progs = self.lnp.read_utilities()\n self.update_autorun_list()","def setup(self):\n print(\"Looking for \", self.filename)\n if os.path.exists(self.filename):\n n, ext = os.path.splitext(self.filename)[:2]\n if ext == \".h5\" or ext == \".hdf5\":\n with h5py.File(self.filename, \"r\") as file:\n keys = list(file.keys())\n self.data = file[keys[0]].value\n print(\"Behavior Data length is \", self.data.shape[2])\n\n else:\n raise FileNotFoundError","def load(filename=None):\n filename = add_directory(filename or 'configure.json')\n try:\n with open(filename, \"r\") as f:\n return quickdot(json.load(f))\n except IOError:\n pass\n return quickdot()","def test_yaml_tech_file(self) -> None:\n tech_yaml = \"\"\"\nname: My Technology Library\ninstalls:\n - path: test\n base var: \"\" # means relative to tech dir\nlibraries: []\n \"\"\"\n tech_dir, tech_dir_base = HammerToolTestHelpers.create_tech_dir(\"dummy28\")\n\n tech_yaml_filename = os.path.join(tech_dir, \"dummy28.tech.yml\")\n with open(tech_yaml_filename, \"w\") as f: # pylint: disable=invalid-name\n f.write(tech_yaml)\n sys.path.append(tech_dir_base)\n tech_opt = hammer_tech.HammerTechnology.load_from_dir(\"dummy28\", tech_dir)\n self.assertFalse(tech_opt is None, \"Unable to load technology\")\n\n # Cleanup\n shutil.rmtree(tech_dir_base)","def getRecipies(self, show, sequence, beat, setup=\"*\", version=\"*\"):\n\n mode = Mode(show, sequence)\n pathArgs = mode.getMatches(Recipe.COMP_FOLDER, {\"beat\":beat, \"setup\":setup, \"version\":version})\n\n while pathArgs:\n if not pathArgs:\n break\n foundPath = pathArgs.pop(0)\n xmlPath = mode.get(Recipe.XML_FILE, foundPath)\n if self.fileService.exists(xmlPath):\n content = self.fileService.loadTextFile(xmlPath)\n self.addFeedback('loadSetupInLibrary', content)\n return","def settings():\r\n\r\n config = cp.ConfigParser()\r\n config.read('settings.ini')\r\n \r\n files = config['files']\r\n model = config['model']\r\n plot = config['plot']\r\n \r\n file_format = files['format']\r\n species_file = r'data/' + files['species file']\r\n reactions_file = r'data/' + files['reactions file']\r\n output_file = 'output/' + files['output file']\r\n model_type = model['model type']\r\n density = model.getfloat('density')\r\n temperature = model.getfloat('temperature')\r\n start_time = model.getfloat('start time')\r\n end_time = model.getfloat('end time')\r\n outfile = plot['outfile for plotting']\r\n\r\n return file_format, species_file, reactions_file, output_file, model_type, density, temperature, start_time, end_time, outfile","def read_config():\n with open('.vrocli.yml', 'r') as conffile:\n try:\n config = yaml.load(conffile)['vrocli']\n logger = logging.getLogger()\n logger.setLevel(config['log_level'])\n return config\n except yaml.YAMLError as e:\n logger.error(e)\n exit(-1)","def _read_project(self, filename):\n parser = configparser.ConfigParser()\n parser.read(filename, \"utf8\")\n return parser","def read_configuration (self):\n\t\tself.config.read(self._configfile)","def settings_show(ctx):\n path = ctx.obj['load_path']\n if not path:\n _raise_settings_not_found()\n with open(path) as handle:\n click.echo(json.dumps(json.load(handle), indent=2, sort_keys=True))","def load_experiment(self):\n load_dir = select_dir(os.getcwd())\n if load_dir is not None:\n if os.path.isfile(os.path.join(load_dir, 'conf', 'config')):\n self.load_main(load_dir)\n else:\n msg_window('missing conf/config file, not experiment directory')\n return\n\n if self.t is None:\n self.t = Tabs(self)\n self.vbox.addWidget(self.t)\n self.t.clear_configs()\n self.t.load_conf(load_dir)\n\n self.set_experiment(True)\n else:\n msg_window('please select valid conf directory')","def read_manifest(self): # -> None:\n ...","def showconfig():\n print(yaml.dump(CONFIG))","def viewer_setup(self):\n pass","def viewer_setup(self):\n pass","def init():\n args = []\n with open(\"settings.txt\", \"r\") as reader:\n for line in reader:\n args.append(line)\n return args","def test_visualisations_get_visualisation(self):\n pass","def input_data(self):\n return read_yaml(self.file_path)","def ReadEntries(self):\n entries = []\n config = wx.Config.Get()\n config.SetPath(DEPS_CONFIG)\n step = config.GetFirstEntry()\n while (step[0]):\n entries.append(config.Read(step[1]))\n step = config.GetNextEntry(step[2])\n config.SetPath('..')\n return entries","def read_collated(run):\n fname=get_collated_file(run)\n print(\"reading:\",fname)\n return fitsio.read(fname)","def read_config_file():\n # Read in the config file to get sensative (non-git) email info\n with open('assets/config.yaml', 'r') as f:\n dikt = yaml.safe_load(f)['email_config']\n\n # Allows to access this dict as if it were an object\n # TODO do we need this? Is there a better way?\n class ObjectView():\n def __init__(self, d):\n self.__dict__ = d\n return ObjectView(dikt)","def main(input_file, visualize):\n logging.info('Reading lines...')\n\n with open(input_file) as f:\n content = f.read()\n\n clauses, thesis = content.split('---\\n')\n\n logging.info('Parsing clauses...')\n parser = ClauseParser()\n parsed_clauses = parser.parse_cnf_list(clauses.splitlines())\n parsed_thesis = parser.parse_cnf_list(thesis.splitlines())\n\n result, tree = resolution(parsed_clauses, parsed_thesis)\n\n if visualize:\n display_resolution_tree(tree)\n\n logging.info(f'The thesis is {result}')","def readConfig(quickLogger,basename):\n\n commonDictionary = {}\n analysisDictionary = {}\n likelihoodDictionary = {}\n plotDictionary = {}\n curveDictionary = {}\n\n try:\n checkForFiles(quickLogger,[basename+\".cfg\"])\n quickLogger.info('Reading from config file ('+basename+'.cfg)') \n config = ConfigParser.RawConfigParser()\n config.read(basename+'.cfg')\n \n if(config.has_section('common')):\n quickLogger.info('Reading common variables...')\n commonDictionary = dict(config.items('common'))\n if( commonDictionary['binned'] in ['True', 'true', '1', 'yes']):\n commonDictionary['binned'] = True\n else:\n commonDictionary['binned'] = False\n \n if(config.has_section('quickAnalysis')):\n quickLogger.info('Reading quickAnalysis variables...')\n analysisDictionary = dict(config.items('quickAnalysis'))\n\n if(config.has_section('quickLike')):\n quickLogger.info('Reading quickLike variables...')\n likelihoodDictionary = dict(config.items('quickLike'))\n\n if(config.has_section('quickPlot')):\n quickLogger.info('Reading quickPlot variables...')\n plotDictionary = dict(config.items('quickPlot'))\n\n if(config.has_section('quickCurve')):\n quickLogger.info('Reading quickCurve variables...')\n curveDictionary = dict(config.items('quickCurve'))\n\n return commonDictionary,analysisDictionary,likelihoodDictionary,plotDictionary,curveDictionary\n\n except(FileNotFound):\n raise FileNotFound\n return","def testRead(self):\n test_reader = dependencies.DependencyDefinitionReader()\n\n file_object = io.StringIO(self._TEST_CONFIGURATION_DATA)\n definitions = list(test_reader.Read(file_object))\n\n self.assertEqual(len(definitions), 1)","def setup(self):","def setup(self):","def setup(self):","def setup(self):","def run():\n\n if lm.scene_object().type == 'env':\n read_layout(outFile=lm.scene_object().copy(ext='json').path_root)\n\n else:\n read_layout()","def main(path):\r\n whdload_slave = WHDLoadSlaveFile.from_path(path)\r\n whdload_slave.read()\r\n display = WHDLoadDisplay(whdload_slave)\r\n\r\n click.echo(click.style('WHDLoad Slave Reader v0.1.0', fg='green'))\r\n click.echo('')\r\n for key, value in display.display_properties():\r\n click.echo(click.style(key, fg='yellow'), nl=False)\r\n click.echo(\": {}\".format(value))","def readSettingsFile():\n settingsPath = os.environ['OCT_FIRE_SETTINGS'] if 'OCT_FIRE_SETTINGS' in os.environ else None\n if not settingsPath:\n settingsPath = findSettingsFile()\n logging.warning('Using settings from %s', settingsPath)\n settingsStr = goog_helper.readFile(settingsPath)\n settingsDict = json.loads(settingsStr)\n # logging.warning('settings %s', settingsDict)\n return settingsDict","def read_project(filename):\n sep ='='\n \n tags = {\n 'description': ['BEGIN DESCRIPTION:', 'END DESCRIPTION:']\n }\n\n fixed = {\n 'units': ['SI Units' 'English Units']\n }\n\n keys = {\n 'Proj Title': '',\n 'Default Exp/Contr': '=0.3,0.1',\n 'Current Plan': '=p03',\n 'Geom File': '=g01',\n 'Flow File': '=f01',\n 'Plan File': '=p01',\n 'Y Axis Title=Elevation': '',\n 'X Axis Title(PF)': '=Main Channel Distance',\n 'X Axis Title(XS)': '=Station',\n 'DSS Start Date': '=',\n 'DSS Start Time': '=',\n 'DSS End Date': '=',\n 'DSS End Time': '=',\n 'DSS Export Filename': '=',\n 'DSS Export Rating Curves': '= 0',\n 'DSS Export Rating Curve Sorted': '= 0',\n 'DSS Export Volume Flow Curves': '= 0',\n 'DXF Filename': '=',\n 'DXF OffsetX': '= 0',\n 'DXF OffsetY': '= 0',\n 'DXF ScaleX': '= 1',\n 'DXF ScaleY': '= 10',\n 'GIS Export Profiles': '= 0'\n }","def visualize(self, filename, options = {'showHead'}):\n\t\tVisualizer.useGraphViz(self, filename, options)","def configure(config_file):\n config = ConfigParser.ConfigParser()\n config.read(config_file)\n return config.get('repository', 'toplevel_processing_plots_path'), \\\n config.get('project', 'project_id')","def main():\n\n\tfilename = sys.argv[1]\n\tarrayabsurdit = ArrayAbsurdit(filename)\n\tarrayabsurdit.read_file()","def load_measurement_settings_file():\n\n # First update the settings that the state machine is up to date\n self.variables.ui_plugins[\"Settings_window\"].load_new_settings()\n\n fileDialog = QFileDialog()\n file = fileDialog.getOpenFileName()\n\n if file[0]:\n file = open(str(file[0]), \"r\")\n dict = yaml.load(file)\n file.close()\n\n # l.info(\"Loaded new measurement settings file: \" + str(file[0]))\n self.variables.default_values_dict[\"settings\"].update(\n dict\n ) # Updates the values of the dict, it either updates the values or adds them if not incluced\n self.variables.ui_plugins[\"Settings_window\"].configure_settings()","def read_settings():\n \n settings = OrdDic()\n settings.update(json.load(open(\"resources/files/settings.txt\", \"r\")))\n\n ## OLD WAY BELOW\n\n #r = open(\"resources/files/settings.txt\", \"r\", newline=\"\\n\")\n # for option in r.read().split('\\n'):\n # try:\n # #option = option.split('\\\\')\n # #settings.update({option[0]: option[1]})\n # # settings.update(json.loads(option))\n # except IndexError:\n # pass\n return settings","def setup():\n pass","def describe_preset(self, filename):\r\n\r\n raise NotImplementedError","def preview():\n local('pelican -o {} -s publishconf.py'.format(env.deploy_path))","def _get_setup(self, dataset_name):\n for potential_setup in self.setup:\n for dataset in potential_setup[\"datasets\"]:\n if dataset_name in dataset:\n test_setup = potential_setup\n self.io_args.color = os.path.join(self.io_args.input_root, dataset)\n return test_setup","def read_test_file(path):\n #TODO Handle multiple test sets in a given doc\n teststruct = yaml.safe_load(os.path.expandvars(read_file(path)))\n return teststruct","def setup(self):\n print(\"Looking for \", self.filename)\n if os.path.exists(self.filename):\n file = scio.loadmat(self.filename)\n self.data = np.squeeze(file[\"data\"])\n print(\"Motion Data length is \", len(self.data))\n\n else:\n raise FileNotFoundError","def setup(self):\n ...","def test_readfile(self):\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\n HEN_FILE_EXTENSION\n command = \"{0}\".format(fname)\n\n hen.io.main(command.split())","def load_data_conf(self):\n data_file = select_file(os.getcwd())\n if data_file is not None:\n self.load_tab(data_file)\n else:\n msg_window('please select valid data config file')","def setup():\n if not os.path.isfile(etymology_file):\n page = re.compile(r'index.php\\?l=\\w+&p=\\d+&allowed_in_frame=0.html')\n pages = list(find_files(directory=site, pattern=page, recursive=False))\n etymology = etymologies(pages)\n dump(etymology, etymology_file)\n for affix, dictionary in affixes(etymology):\n affix_file = os.path.join('resources', '{}.json'.format(affix))\n if not os.path.isfile(affix_file):\n dump(dictionary, affix_file)","def minimal_config():\n return yaml.round_trip_load(\n textwrap.dedent(\n r\"\"\"\n static_data_config:\n reference:\n path: /path/to/ref.fa\n\n step_config:\n ngs_mapping:\n tools:\n rna: ['star']\n star:\n path_index: /path/to/star/index\n\n data_sets:\n first_batch:\n file: sheet.tsv\n search_patterns:\n - {'left': '*/*/*_R1.fastq.gz', 'right': '*/*/*_R2.fastq.gz'}\n search_paths: ['/path']\n type: matched_cancer\n naming_scheme: only_secondary_id\n \"\"\"\n ).lstrip()\n )","def list_config():\n console = Console()\n _config = loadConfig()\n json_data = richJSON.from_data({**asdict(_config)})\n console.print(Panel(json_data, title=\"SubmarineCliConfig\"))","def reads(self, data):\n\n self.parser = configparser.ConfigParser()\n ds = io.StringIO(data)\n ds.name = os.path.expanduser(os.path.join('~', RC_FILE))\n self.parser.readfp(ds)","def importConfigFile(self, evt):\n dlg = wx.FileDialog(self.view, \"Open Configuration File\", wildcard = \"*.ini\" ,\n style=wx.FD_DEFAULT_STYLE | wx.FD_CHANGE_DIR)\n if dlg.ShowModal() == wx.ID_OK:\n fileName=dlg.GetPath()\n self.config.importConfig(fileName=fileName,e=None)\n print(''.join([\"WREnS runner path: \", self.config.wrensRunnerPath]))\n print(''.join([\"Linear path: \", self.config.wrensLinearPath]))\n print(''.join([\"Exponent path: \", self.config.wrensExponentPath]))\n print(''.join([\"Boltzmann path: \", self.config.wrensBoltzmannPath]))\n print(''.join([\"List path: \", self.config.wrensUserDefinedPath]))\n print(''.join([\"Reset path: \", self.config.wrensResetPath]))","def _read_uconf(self):\n fname = self.gen_conf.conf_file_name\n fdir = self.gen_conf.conf_file_path\n fpath = os.path.join(fdir, fname)\n \n from pathlib import Path\n cfile = Path(fpath) \n \n if cfile.exists() & cfile.is_file():\n\n self._load_uconf(fpath)\n \n else:\n if cfile.exists():\n raise Exception(\"Configuration file \"+fpath+\" seems to exist\"+\n \" but it is not a file\")\n else:\n print(\"Warning: Configuration file \"+fpath+\" does not exit\")\n print(\"Warning: Placing a default configuration are using it\")\n \n import pkg_resources\n\n resource_package = \"quantarhei\" # Could be any module/package name\n resource_path = '/'.join(('core', 'conf', 'qrhei.py')) \n content = pkg_resources.resource_string(resource_package,\n resource_path)\n\n with open(fpath, \"w\") as f:\n f.write(content.decode(\"utf-8\"))\n \n self._load_uconf(fpath)\n \n #printlog(\"Configuration file: \", fpath, \"loaded\", loglevel=9) ","def ReadConfig(bDisplay = False):\n tree = ET.parse(SE_CONFIG_PATH)\n root = tree.getroot()\n _config_dict = {}\n for child in root:\n# print child.tag,child.text\n if(\"fieldFile\" == child.tag or \"stopwordsFile\" == child.tag):\n temp = os.path.realpath(SE_CONFIG_PATH)\n child.text = os.path.normpath(os.path.join(os.path.dirname(temp),child.text))\n else:\n pass\n _config_dict[child.tag] = child.text\n if(bDisplay is not True):\n return _config_dict\n else:\n File_RW.DictPrint(_config_dict)\n return _config_dict","def _read_config(path):\n with open(path) as f:\n data = f.read()\n data = os.path.expandvars(data)\n data = yaml.safe_load(data)\n return data","def LoadProject(filename, toolchains):\n\n print 'Processing %s...' % filename\n # Default src directory is the directory the description was found in\n desc = open(filename, 'r').read()\n desc = eval(desc, {}, {})\n\n # Verify the format of this file\n if not ValidateFormat(desc, DSC_FORMAT):\n ErrorExit('Failed to validate: ' + filename)\n\n # Check if we are actually interested in this example\n match = False\n for toolchain in toolchains:\n if toolchain in desc['TOOLS']:\n match = True\n break\n if not match:\n return None\n\n desc['FILENAME'] = filename\n return desc","def read_config(self):\n return json.load(open(self.config_dir + \"/\" + self.graph_type.lower() + \"_config.json\"))","def tenv(request):\n with open(SETUP_FILE, \"r\") as f:\n tsetup = json.load(f)\n\n return tsetup[\"paths\"]","def infocalypse_setupfms(ui_, **opts):\n # REQUIRES config file.\n execute_setupfms(ui_, opts)","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def setup(self):\n pass","def show(self):\n # Used for testing because there is obviously no way back\n # from VISU_Gen.SetCurrentStudy\n if not self.display:\n return\n\n # Desactivation : Load the med file in the PARAVIS component\n #import smeca_utils.visu_utils as VU\n #log.info(\"Loading Paravis module...\")\n #msg = VU.load_med_file(self.read_fname())\n #log.info(msg)","def info(file, extended, vlrs, points):\n try:\n with pylas.open(openbin_file(file)) as fp:\n echo_header(fp.header, extended)\n\n if vlrs:\n click.echo(20 * \"-\")\n echo_vlrs(fp)\n\n if points:\n click.echo(20 * \"-\")\n echo_points(fp)\n except fs.errors.ResourceNotFound as e:\n click.echo(click.style(\"Error: {}\".format(e), fg=\"red\"))","def main():\n\n if os.path.exists(sys.argv[1]):\n # first argument is the JSON plot definition setup file\n with open(sys.argv[1]) as plotsetup:\n plotdefs = json.load(plotsetup)\n else:\n raise ValueError('No plot definition file entered')\n\n plots = []\n # second argument is the projections documentation directory\n outdir = sys.argv[2]\n\n for i, plotdef in enumerate(plotdefs):\n if plots != [] and plotdef['name'] not in plots:\n continue\n\n print(i, plotdef['projstring'])\n if 'skip' in plotdef.keys():\n print('skipping')\n continue\n\n update_caption(plotdef['name'],\n plotdef['projstring'],\n outdir)"],"string":"[\n \"def read_setup(inifile):\\n # inifile = os.path.join(spathy_path, inifile)\\n print(inifile)\\n cfg = configparser.ConfigParser()\\n cfg.read(inifile)\\n\\n pp = {}\\n for s in cfg.sections():\\n section = s.encode('ascii', 'ignore')\\n pp[section] = {}\\n for k, v in cfg.items(section):\\n key = k.encode('ascii', 'ignore')\\n val = v.encode('ascii', 'ignore')\\n if section == 'General': # 'general' section\\n pp[section][key] = val\\n else:\\n pp[section][key] = float(val)\\n pp['General']['dt'] = float(pp['General']['dt'])\\n\\n pgen = pp['General']\\n pcpy = pp['CanopyGrid']\\n pbu = pp['BucketGrid']\\n ptop = pp['Topmodel']\\n\\n return pgen, pcpy, pbu, ptop\",\n \"def readInConfigFileDlg( self ):\\n pass\",\n \"def read_config(self, config_filename):\",\n \"def setup():\\n setFormat()\\n setFilename()\\n setScreenMode()\",\n \"def readInConfigFile( self, fileName ):\\n self.console.info( \\\"Read input file\\\" )\",\n \"def readConfigFileDlg( self ):\\n fileName = QtGui.QFileDialog.getOpenFileName( self, \\\"Read application config file\\\", self.rsrc.lastFolder, \\\"Config files (*.cfg)\\\" )\\n if ( fileName ):\\n self.readConfigFile( fileName )\\n path, fName = os.path.split( str( fileName ) )\\n self.rsrc.lastFolder = path\",\n \"def get_setup(setup_file):\\n # load raw file\\n setup = tab.read_namelist(setup_file, convert_to_number=True)\\n\\n with open(setup_file, 'r') as fid:\\n setup['_original_setup_file'] = fid.readlines()\\n\\n # process\\n process_setup(setup)\\n\\n return setup\",\n \"def __read_config(self):\\n with open(self.config_file, 'r') as data_file:\\n dict = json.load(data_file)\\n self.ibooks_doc_root = dict[\\\"ibooks_doc_root\\\"]\\n self.library_folder = dict[\\\"library_folder\\\"]\\n self.annotation_folder = dict[\\\"annotation_folder\\\"]\\n self.tmp_dir = dict[\\\"tmp_dir\\\"]\",\n \"def readSettingsFile():\\n\\tglobal logfile\\n\\tglobal backupCount\\n\\tglobal maxBytes\\n\\tglobal debug\\n\\t\\n\\tif SettingsFile.getOptionString(INI_Section,\\\"logfile\\\"):\\n\\t\\tlogfile = SettingsFile.getOptionString(INI_Section,\\\"logfile\\\")\\n\\tif SettingsFile.getOptionInt(INI_Section,\\\"maxBytes\\\"):\\n\\t\\tmaxBytes = SettingsFile.getOptionInt(INI_Section,\\\"maxBytes\\\")\\n\\tif SettingsFile.getOptionInt(INI_Section,\\\"backupCount\\\"):\\n\\t\\tbackupCount = SettingsFile.getOptionInt(INI_Section,\\\"backupCount\\\")\\n\\tif SettingsFile.getOptionBoolean(INI_Section,\\\"debug\\\"):\\n\\t\\tdebug = SettingsFile.getOptionBoolean(INI_Section,\\\"debug\\\")\\n\\t#endif\",\n \"def readConfigFile( self, fileName ):\\n try:\\n self.analysisBox.readConfig( fileName )\\n path, name = os.path.split( fileName )\\n self.rsrc.lastFolder = path\\n self.console.info( 'Read full config file %s\\\\n' % fileName )\\n except IOError, ValueError:\\n self.console.error( 'Error reading full config file %s\\\\n' % fileName )\",\n \"def read_setup(fname):\\n with codecs.open(fname, 'r') as fin:\\n n_row, n_col, L, H = list(map(int, fin.readline().split()))\\n\\n pizza = []\\n for _ in range(n_row):\\n line = fin.readline().strip()\\n pizza.append(line)\\n\\n return pizza, n_row, n_col, L, H\",\n \"def cli(ctx, root):\\n try:\\n ctx.obj = create_initial_context(root)\\n except SettingsBroken as e:\\n click.echo(\\n 'Failed to read the settings file: %s' % str(e),\\n err=True\\n )\\n exit(1)\",\n \"def config():\",\n \"def config():\",\n \"def read_readme(setup_file, name=\\\"README.rst\\\"):\\n import os\\n TOP_DIR = os.path.abspath(os.path.dirname(setup_file))\\n if not os.path.exists(TOP_DIR):\\n raise FileNotFoundError(\\n f\\\"Unable to find folder {TOP_DIR!r}.\\\")\\n readme = os.path.join(TOP_DIR, name)\\n if not os.path.exists(readme):\\n raise FileNotFoundError(\\n f\\\"Unable to find file {TOP_DIR!r}.\\\")\\n with open(readme, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n content = f.read()\\n return _clean_readme(content)\",\n \"def read(self, run):\\n # read the file\\n self['run'] = run[0:run.rfind('.xml')]\\n f = open(run)\\n for line in f:\\n \\n if line.find('SDSU Exec') >= 0:\\n n1 = line.index('name=') + 6\\n n2 = line.index('\\\"', n1)\\n self['application'] = line[n1:n2]\\n\\n elif line.find('<detector_status') >= 0:\\n n1 = line.index('name=') + 6\\n n2 = line.index('\\\"', n1)\\n if line[n1:n2] != 'Ultraspec':\\n raise Exception, 'Run ' + run + ' is not an Ultraspec file.'\\n \\n elif line.find('SPEED') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['speed'] = line[n1:n2]\\n \\n elif line.find('X_BIN') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['x_bin'] = line[n1:n2]\\n \\n elif line.find('Y_BIN') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['y_bin'] = line[n1:n2]\\n \\n # first window \\n \\n elif line.find('X1_START') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['x1_start'] = line[n1:n2]\\n \\n elif line.find('X1_SIZE') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['x1_size'] = line[n1:n2]\\n \\n elif line.find('Y1_START') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['y1_start'] = line[n1:n2]\\n \\n elif line.find('Y1_SIZE') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['y1_size'] = line[n1:n2]\\n \\n # second window\\n \\n elif line.find('X2_START') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['x2_start'] = line[n1:n2]\\n \\n elif line.find('X2_SIZE') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['x2_size'] = line[n1:n2]\\n \\n elif line.find('Y2_START') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['y2_start'] = line[n1:n2]\\n \\n elif line.find('Y2_SIZE') >= 0:\\n n1 = line.index('value=') + 7\\n n2 = line.index('\\\"', n1)\\n self['y2_size'] = line[n1:n2]\\n \\n elif line.find('<target>') >= 0:\\n n1 = line.index('target') + 7\\n n2 = line.index('<', n1)\\n self['target'] = line[n1:n2]\\n\\n elif line.find('<grating>') >= 0:\\n n1 = line.index('grating') + 8\\n n2 = line.index('<', n1)\\n self['grating'] = line[n1:n2]\\n\\n elif line.find('<slit_width>') >= 0:\\n n1 = line.index('slit_width') + 11\\n n2 = line.index('<', n1)\\n self['slit_width'] = line[n1:n2]\\n\\n elif line.find('<slit_angle>') >= 0:\\n n1 = line.index('slit_angle') + 11\\n n2 = line.index('<', n1)\\n self['slit_angle'] = line[n1:n2]\\n \\n elif line.find('<filters>') >= 0:\\n n1 = line.index('filters') + 8\\n n2 = line.index('<', n1)\\n self['filters'] = line[n1:n2]\\n\\n elif line.find('<ID>') >= 0:\\n n1 = line.index('ID') + 3\\n n2 = line.index('<', n1)\\n self['ID'] = line[n1:n2]\\n\\n elif line.find('<PI>') >= 0:\\n n1 = line.index('PI') + 3\\n n2 = line.index('<', n1)\\n self['PI'] = line[n1:n2]\\n\\n elif line.find('<comment>') >= 0:\\n n1 = line.index('comment') + 8\\n n2 = line.index('<', n1)\\n self['comment'] = line[n1:n2]\\n \\n\\n # check that we have found what we expected to find\\n if 'application' not in self:\\n raise Exception, 'Failed to find application name in ' + run\\n\\n if self.is_not_power_onoff():\\n\\n if 'x_bin' not in self:\\n raise Exception, 'Failed to find X_BIN in ' + run\\n\\n if 'y_bin' not in self:\\n raise Exception, 'Failed to find Y_BIN in ' + run\\n\\n if 'x1_start' not in self:\\n raise Exception, 'Failed to find X2_START in ' + run\\n \\n if 'x1_size' not in self:\\n raise Exception, 'Failed to find X2_SIZE in ' + run\\n \\n if 'y1_start' not in self:\\n raise Exception, 'Failed to find Y2_START in ' + run\\n \\n if 'y1_size' not in self:\\n raise Exception, 'Failed to find Y2_SIZE in ' + run\\n \\n if 'x2_start' not in self:\\n raise Exception, 'Failed to find X2_START in ' + run\\n \\n if 'x2_size' not in self:\\n raise Exception, 'Failed to find X2_SIZE in ' + run\\n \\n if 'y2_start' not in self:\\n raise Exception, 'Failed to find Y2_START in ' + run\\n \\n if 'y2_size' not in self:\\n raise Exception, 'Failed to find Y2_SIZE in ' + run\\n \\n if 'target' not in self:\\n self['target'] = 'UNKNOWN'\\n\\n if 'filters' not in self:\\n self['filters'] = '---'\\n\\n if 'grating' not in self:\\n self['grating'] = '---'\\n\\n if 'slit_width' not in self:\\n self['slit_width'] = '---'\\n\\n if 'slit_angle' not in self:\\n self['slit_angle'] = '---'\\n\\n if 'ID' not in self:\\n self['ID'] = 'UNKNOWN'\\n\\n if 'PI' not in self:\\n self['PI'] = 'UNKNOWN'\",\n \"def read_config(name):\\n import yaml\\n fname=get_config_file(name)\\n #print(\\\"reading:\\\",fname)\\n with open(fname) as fobj:\\n data=yaml.load(fobj)\\n return data\",\n \"def parse_design(self, detailed_design_file):\",\n \"def read_config(self,confile):\\n\\n\\n print(\\\"reading:\\\",confile)\\n with open(confile) as parf:\\n data=yaml.load(parf)\\n\\n\\n return data\",\n \"def get_setup_file():\\n repo_fs()\\n return SETUP_FILES\",\n \"def read_setup_py(path):\\n with open('%s/setup.py' % path, 'r') as setup:\\n return ''.join(setup.readlines())\",\n \"def readSettingsFile(self):\\n with open(self.settingsFilePath, 'r') as settingsFile:\\n self.settings = json.loads(settingsFile.read())\",\n \"def read_file(self, currentIndex):\\n handle = open(\\\"Program Files\\\\\\\\TvInfo\\\\\\\\\\\" + str(currentIndex) + \\\".tvInfo\\\", \\\"r\\\")\\n data = handle.read() #reading description\\n handle.close()\\n return data\",\n \"def main(filename: str) -> None:\\n # Template from HtDAP, based on composition \\n return scatterplot(read(filename))\",\n \"def read_file(self, currentIndex):\\n handle = open(\\\"Program Files\\\\\\\\\\\" + str(currentIndex) + \\\".tvInfo\\\", \\\"r\\\")\\n data = handle.read() #reading description\\n handle.close()\\n return data\",\n \"def do_stuff_with_data_file():\\n import os\\n script_path = os.path.dirname(os.path.abspath(__file__))\\n file_path = os.path.join(script_path, \\\"data/exampledata.txt\\\")\\n print(\\\"reading the data file that was added to the installation:\\\")\\n with open(file_path, \\\"r\\\") as f:\\n print(f.read())\",\n \"def read_graph_ui(self):\\n filename = input('enter filename: ')\\n try:\\n self._graph = read_graph(filename)\\n except FileNotFoundError:\\n print('invalid filename! ')\",\n \"def read_utilities(self):\\n self.progs = self.lnp.read_utilities()\\n self.update_autorun_list()\",\n \"def setup(self):\\n print(\\\"Looking for \\\", self.filename)\\n if os.path.exists(self.filename):\\n n, ext = os.path.splitext(self.filename)[:2]\\n if ext == \\\".h5\\\" or ext == \\\".hdf5\\\":\\n with h5py.File(self.filename, \\\"r\\\") as file:\\n keys = list(file.keys())\\n self.data = file[keys[0]].value\\n print(\\\"Behavior Data length is \\\", self.data.shape[2])\\n\\n else:\\n raise FileNotFoundError\",\n \"def load(filename=None):\\n filename = add_directory(filename or 'configure.json')\\n try:\\n with open(filename, \\\"r\\\") as f:\\n return quickdot(json.load(f))\\n except IOError:\\n pass\\n return quickdot()\",\n \"def test_yaml_tech_file(self) -> None:\\n tech_yaml = \\\"\\\"\\\"\\nname: My Technology Library\\ninstalls:\\n - path: test\\n base var: \\\"\\\" # means relative to tech dir\\nlibraries: []\\n \\\"\\\"\\\"\\n tech_dir, tech_dir_base = HammerToolTestHelpers.create_tech_dir(\\\"dummy28\\\")\\n\\n tech_yaml_filename = os.path.join(tech_dir, \\\"dummy28.tech.yml\\\")\\n with open(tech_yaml_filename, \\\"w\\\") as f: # pylint: disable=invalid-name\\n f.write(tech_yaml)\\n sys.path.append(tech_dir_base)\\n tech_opt = hammer_tech.HammerTechnology.load_from_dir(\\\"dummy28\\\", tech_dir)\\n self.assertFalse(tech_opt is None, \\\"Unable to load technology\\\")\\n\\n # Cleanup\\n shutil.rmtree(tech_dir_base)\",\n \"def getRecipies(self, show, sequence, beat, setup=\\\"*\\\", version=\\\"*\\\"):\\n\\n mode = Mode(show, sequence)\\n pathArgs = mode.getMatches(Recipe.COMP_FOLDER, {\\\"beat\\\":beat, \\\"setup\\\":setup, \\\"version\\\":version})\\n\\n while pathArgs:\\n if not pathArgs:\\n break\\n foundPath = pathArgs.pop(0)\\n xmlPath = mode.get(Recipe.XML_FILE, foundPath)\\n if self.fileService.exists(xmlPath):\\n content = self.fileService.loadTextFile(xmlPath)\\n self.addFeedback('loadSetupInLibrary', content)\\n return\",\n \"def settings():\\r\\n\\r\\n config = cp.ConfigParser()\\r\\n config.read('settings.ini')\\r\\n \\r\\n files = config['files']\\r\\n model = config['model']\\r\\n plot = config['plot']\\r\\n \\r\\n file_format = files['format']\\r\\n species_file = r'data/' + files['species file']\\r\\n reactions_file = r'data/' + files['reactions file']\\r\\n output_file = 'output/' + files['output file']\\r\\n model_type = model['model type']\\r\\n density = model.getfloat('density')\\r\\n temperature = model.getfloat('temperature')\\r\\n start_time = model.getfloat('start time')\\r\\n end_time = model.getfloat('end time')\\r\\n outfile = plot['outfile for plotting']\\r\\n\\r\\n return file_format, species_file, reactions_file, output_file, model_type, density, temperature, start_time, end_time, outfile\",\n \"def read_config():\\n with open('.vrocli.yml', 'r') as conffile:\\n try:\\n config = yaml.load(conffile)['vrocli']\\n logger = logging.getLogger()\\n logger.setLevel(config['log_level'])\\n return config\\n except yaml.YAMLError as e:\\n logger.error(e)\\n exit(-1)\",\n \"def _read_project(self, filename):\\n parser = configparser.ConfigParser()\\n parser.read(filename, \\\"utf8\\\")\\n return parser\",\n \"def read_configuration (self):\\n\\t\\tself.config.read(self._configfile)\",\n \"def settings_show(ctx):\\n path = ctx.obj['load_path']\\n if not path:\\n _raise_settings_not_found()\\n with open(path) as handle:\\n click.echo(json.dumps(json.load(handle), indent=2, sort_keys=True))\",\n \"def load_experiment(self):\\n load_dir = select_dir(os.getcwd())\\n if load_dir is not None:\\n if os.path.isfile(os.path.join(load_dir, 'conf', 'config')):\\n self.load_main(load_dir)\\n else:\\n msg_window('missing conf/config file, not experiment directory')\\n return\\n\\n if self.t is None:\\n self.t = Tabs(self)\\n self.vbox.addWidget(self.t)\\n self.t.clear_configs()\\n self.t.load_conf(load_dir)\\n\\n self.set_experiment(True)\\n else:\\n msg_window('please select valid conf directory')\",\n \"def read_manifest(self): # -> None:\\n ...\",\n \"def showconfig():\\n print(yaml.dump(CONFIG))\",\n \"def viewer_setup(self):\\n pass\",\n \"def viewer_setup(self):\\n pass\",\n \"def init():\\n args = []\\n with open(\\\"settings.txt\\\", \\\"r\\\") as reader:\\n for line in reader:\\n args.append(line)\\n return args\",\n \"def test_visualisations_get_visualisation(self):\\n pass\",\n \"def input_data(self):\\n return read_yaml(self.file_path)\",\n \"def ReadEntries(self):\\n entries = []\\n config = wx.Config.Get()\\n config.SetPath(DEPS_CONFIG)\\n step = config.GetFirstEntry()\\n while (step[0]):\\n entries.append(config.Read(step[1]))\\n step = config.GetNextEntry(step[2])\\n config.SetPath('..')\\n return entries\",\n \"def read_collated(run):\\n fname=get_collated_file(run)\\n print(\\\"reading:\\\",fname)\\n return fitsio.read(fname)\",\n \"def read_config_file():\\n # Read in the config file to get sensative (non-git) email info\\n with open('assets/config.yaml', 'r') as f:\\n dikt = yaml.safe_load(f)['email_config']\\n\\n # Allows to access this dict as if it were an object\\n # TODO do we need this? Is there a better way?\\n class ObjectView():\\n def __init__(self, d):\\n self.__dict__ = d\\n return ObjectView(dikt)\",\n \"def main(input_file, visualize):\\n logging.info('Reading lines...')\\n\\n with open(input_file) as f:\\n content = f.read()\\n\\n clauses, thesis = content.split('---\\\\n')\\n\\n logging.info('Parsing clauses...')\\n parser = ClauseParser()\\n parsed_clauses = parser.parse_cnf_list(clauses.splitlines())\\n parsed_thesis = parser.parse_cnf_list(thesis.splitlines())\\n\\n result, tree = resolution(parsed_clauses, parsed_thesis)\\n\\n if visualize:\\n display_resolution_tree(tree)\\n\\n logging.info(f'The thesis is {result}')\",\n \"def readConfig(quickLogger,basename):\\n\\n commonDictionary = {}\\n analysisDictionary = {}\\n likelihoodDictionary = {}\\n plotDictionary = {}\\n curveDictionary = {}\\n\\n try:\\n checkForFiles(quickLogger,[basename+\\\".cfg\\\"])\\n quickLogger.info('Reading from config file ('+basename+'.cfg)') \\n config = ConfigParser.RawConfigParser()\\n config.read(basename+'.cfg')\\n \\n if(config.has_section('common')):\\n quickLogger.info('Reading common variables...')\\n commonDictionary = dict(config.items('common'))\\n if( commonDictionary['binned'] in ['True', 'true', '1', 'yes']):\\n commonDictionary['binned'] = True\\n else:\\n commonDictionary['binned'] = False\\n \\n if(config.has_section('quickAnalysis')):\\n quickLogger.info('Reading quickAnalysis variables...')\\n analysisDictionary = dict(config.items('quickAnalysis'))\\n\\n if(config.has_section('quickLike')):\\n quickLogger.info('Reading quickLike variables...')\\n likelihoodDictionary = dict(config.items('quickLike'))\\n\\n if(config.has_section('quickPlot')):\\n quickLogger.info('Reading quickPlot variables...')\\n plotDictionary = dict(config.items('quickPlot'))\\n\\n if(config.has_section('quickCurve')):\\n quickLogger.info('Reading quickCurve variables...')\\n curveDictionary = dict(config.items('quickCurve'))\\n\\n return commonDictionary,analysisDictionary,likelihoodDictionary,plotDictionary,curveDictionary\\n\\n except(FileNotFound):\\n raise FileNotFound\\n return\",\n \"def testRead(self):\\n test_reader = dependencies.DependencyDefinitionReader()\\n\\n file_object = io.StringIO(self._TEST_CONFIGURATION_DATA)\\n definitions = list(test_reader.Read(file_object))\\n\\n self.assertEqual(len(definitions), 1)\",\n \"def setup(self):\",\n \"def setup(self):\",\n \"def setup(self):\",\n \"def setup(self):\",\n \"def run():\\n\\n if lm.scene_object().type == 'env':\\n read_layout(outFile=lm.scene_object().copy(ext='json').path_root)\\n\\n else:\\n read_layout()\",\n \"def main(path):\\r\\n whdload_slave = WHDLoadSlaveFile.from_path(path)\\r\\n whdload_slave.read()\\r\\n display = WHDLoadDisplay(whdload_slave)\\r\\n\\r\\n click.echo(click.style('WHDLoad Slave Reader v0.1.0', fg='green'))\\r\\n click.echo('')\\r\\n for key, value in display.display_properties():\\r\\n click.echo(click.style(key, fg='yellow'), nl=False)\\r\\n click.echo(\\\": {}\\\".format(value))\",\n \"def readSettingsFile():\\n settingsPath = os.environ['OCT_FIRE_SETTINGS'] if 'OCT_FIRE_SETTINGS' in os.environ else None\\n if not settingsPath:\\n settingsPath = findSettingsFile()\\n logging.warning('Using settings from %s', settingsPath)\\n settingsStr = goog_helper.readFile(settingsPath)\\n settingsDict = json.loads(settingsStr)\\n # logging.warning('settings %s', settingsDict)\\n return settingsDict\",\n \"def read_project(filename):\\n sep ='='\\n \\n tags = {\\n 'description': ['BEGIN DESCRIPTION:', 'END DESCRIPTION:']\\n }\\n\\n fixed = {\\n 'units': ['SI Units' 'English Units']\\n }\\n\\n keys = {\\n 'Proj Title': '',\\n 'Default Exp/Contr': '=0.3,0.1',\\n 'Current Plan': '=p03',\\n 'Geom File': '=g01',\\n 'Flow File': '=f01',\\n 'Plan File': '=p01',\\n 'Y Axis Title=Elevation': '',\\n 'X Axis Title(PF)': '=Main Channel Distance',\\n 'X Axis Title(XS)': '=Station',\\n 'DSS Start Date': '=',\\n 'DSS Start Time': '=',\\n 'DSS End Date': '=',\\n 'DSS End Time': '=',\\n 'DSS Export Filename': '=',\\n 'DSS Export Rating Curves': '= 0',\\n 'DSS Export Rating Curve Sorted': '= 0',\\n 'DSS Export Volume Flow Curves': '= 0',\\n 'DXF Filename': '=',\\n 'DXF OffsetX': '= 0',\\n 'DXF OffsetY': '= 0',\\n 'DXF ScaleX': '= 1',\\n 'DXF ScaleY': '= 10',\\n 'GIS Export Profiles': '= 0'\\n }\",\n \"def visualize(self, filename, options = {'showHead'}):\\n\\t\\tVisualizer.useGraphViz(self, filename, options)\",\n \"def configure(config_file):\\n config = ConfigParser.ConfigParser()\\n config.read(config_file)\\n return config.get('repository', 'toplevel_processing_plots_path'), \\\\\\n config.get('project', 'project_id')\",\n \"def main():\\n\\n\\tfilename = sys.argv[1]\\n\\tarrayabsurdit = ArrayAbsurdit(filename)\\n\\tarrayabsurdit.read_file()\",\n \"def load_measurement_settings_file():\\n\\n # First update the settings that the state machine is up to date\\n self.variables.ui_plugins[\\\"Settings_window\\\"].load_new_settings()\\n\\n fileDialog = QFileDialog()\\n file = fileDialog.getOpenFileName()\\n\\n if file[0]:\\n file = open(str(file[0]), \\\"r\\\")\\n dict = yaml.load(file)\\n file.close()\\n\\n # l.info(\\\"Loaded new measurement settings file: \\\" + str(file[0]))\\n self.variables.default_values_dict[\\\"settings\\\"].update(\\n dict\\n ) # Updates the values of the dict, it either updates the values or adds them if not incluced\\n self.variables.ui_plugins[\\\"Settings_window\\\"].configure_settings()\",\n \"def read_settings():\\n \\n settings = OrdDic()\\n settings.update(json.load(open(\\\"resources/files/settings.txt\\\", \\\"r\\\")))\\n\\n ## OLD WAY BELOW\\n\\n #r = open(\\\"resources/files/settings.txt\\\", \\\"r\\\", newline=\\\"\\\\n\\\")\\n # for option in r.read().split('\\\\n'):\\n # try:\\n # #option = option.split('\\\\\\\\')\\n # #settings.update({option[0]: option[1]})\\n # # settings.update(json.loads(option))\\n # except IndexError:\\n # pass\\n return settings\",\n \"def setup():\\n pass\",\n \"def describe_preset(self, filename):\\r\\n\\r\\n raise NotImplementedError\",\n \"def preview():\\n local('pelican -o {} -s publishconf.py'.format(env.deploy_path))\",\n \"def _get_setup(self, dataset_name):\\n for potential_setup in self.setup:\\n for dataset in potential_setup[\\\"datasets\\\"]:\\n if dataset_name in dataset:\\n test_setup = potential_setup\\n self.io_args.color = os.path.join(self.io_args.input_root, dataset)\\n return test_setup\",\n \"def read_test_file(path):\\n #TODO Handle multiple test sets in a given doc\\n teststruct = yaml.safe_load(os.path.expandvars(read_file(path)))\\n return teststruct\",\n \"def setup(self):\\n print(\\\"Looking for \\\", self.filename)\\n if os.path.exists(self.filename):\\n file = scio.loadmat(self.filename)\\n self.data = np.squeeze(file[\\\"data\\\"])\\n print(\\\"Motion Data length is \\\", len(self.data))\\n\\n else:\\n raise FileNotFoundError\",\n \"def setup(self):\\n ...\",\n \"def test_readfile(self):\\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\\\\n HEN_FILE_EXTENSION\\n command = \\\"{0}\\\".format(fname)\\n\\n hen.io.main(command.split())\",\n \"def load_data_conf(self):\\n data_file = select_file(os.getcwd())\\n if data_file is not None:\\n self.load_tab(data_file)\\n else:\\n msg_window('please select valid data config file')\",\n \"def setup():\\n if not os.path.isfile(etymology_file):\\n page = re.compile(r'index.php\\\\?l=\\\\w+&p=\\\\d+&allowed_in_frame=0.html')\\n pages = list(find_files(directory=site, pattern=page, recursive=False))\\n etymology = etymologies(pages)\\n dump(etymology, etymology_file)\\n for affix, dictionary in affixes(etymology):\\n affix_file = os.path.join('resources', '{}.json'.format(affix))\\n if not os.path.isfile(affix_file):\\n dump(dictionary, affix_file)\",\n \"def minimal_config():\\n return yaml.round_trip_load(\\n textwrap.dedent(\\n r\\\"\\\"\\\"\\n static_data_config:\\n reference:\\n path: /path/to/ref.fa\\n\\n step_config:\\n ngs_mapping:\\n tools:\\n rna: ['star']\\n star:\\n path_index: /path/to/star/index\\n\\n data_sets:\\n first_batch:\\n file: sheet.tsv\\n search_patterns:\\n - {'left': '*/*/*_R1.fastq.gz', 'right': '*/*/*_R2.fastq.gz'}\\n search_paths: ['/path']\\n type: matched_cancer\\n naming_scheme: only_secondary_id\\n \\\"\\\"\\\"\\n ).lstrip()\\n )\",\n \"def list_config():\\n console = Console()\\n _config = loadConfig()\\n json_data = richJSON.from_data({**asdict(_config)})\\n console.print(Panel(json_data, title=\\\"SubmarineCliConfig\\\"))\",\n \"def reads(self, data):\\n\\n self.parser = configparser.ConfigParser()\\n ds = io.StringIO(data)\\n ds.name = os.path.expanduser(os.path.join('~', RC_FILE))\\n self.parser.readfp(ds)\",\n \"def importConfigFile(self, evt):\\n dlg = wx.FileDialog(self.view, \\\"Open Configuration File\\\", wildcard = \\\"*.ini\\\" ,\\n style=wx.FD_DEFAULT_STYLE | wx.FD_CHANGE_DIR)\\n if dlg.ShowModal() == wx.ID_OK:\\n fileName=dlg.GetPath()\\n self.config.importConfig(fileName=fileName,e=None)\\n print(''.join([\\\"WREnS runner path: \\\", self.config.wrensRunnerPath]))\\n print(''.join([\\\"Linear path: \\\", self.config.wrensLinearPath]))\\n print(''.join([\\\"Exponent path: \\\", self.config.wrensExponentPath]))\\n print(''.join([\\\"Boltzmann path: \\\", self.config.wrensBoltzmannPath]))\\n print(''.join([\\\"List path: \\\", self.config.wrensUserDefinedPath]))\\n print(''.join([\\\"Reset path: \\\", self.config.wrensResetPath]))\",\n \"def _read_uconf(self):\\n fname = self.gen_conf.conf_file_name\\n fdir = self.gen_conf.conf_file_path\\n fpath = os.path.join(fdir, fname)\\n \\n from pathlib import Path\\n cfile = Path(fpath) \\n \\n if cfile.exists() & cfile.is_file():\\n\\n self._load_uconf(fpath)\\n \\n else:\\n if cfile.exists():\\n raise Exception(\\\"Configuration file \\\"+fpath+\\\" seems to exist\\\"+\\n \\\" but it is not a file\\\")\\n else:\\n print(\\\"Warning: Configuration file \\\"+fpath+\\\" does not exit\\\")\\n print(\\\"Warning: Placing a default configuration are using it\\\")\\n \\n import pkg_resources\\n\\n resource_package = \\\"quantarhei\\\" # Could be any module/package name\\n resource_path = '/'.join(('core', 'conf', 'qrhei.py')) \\n content = pkg_resources.resource_string(resource_package,\\n resource_path)\\n\\n with open(fpath, \\\"w\\\") as f:\\n f.write(content.decode(\\\"utf-8\\\"))\\n \\n self._load_uconf(fpath)\\n \\n #printlog(\\\"Configuration file: \\\", fpath, \\\"loaded\\\", loglevel=9) \",\n \"def ReadConfig(bDisplay = False):\\n tree = ET.parse(SE_CONFIG_PATH)\\n root = tree.getroot()\\n _config_dict = {}\\n for child in root:\\n# print child.tag,child.text\\n if(\\\"fieldFile\\\" == child.tag or \\\"stopwordsFile\\\" == child.tag):\\n temp = os.path.realpath(SE_CONFIG_PATH)\\n child.text = os.path.normpath(os.path.join(os.path.dirname(temp),child.text))\\n else:\\n pass\\n _config_dict[child.tag] = child.text\\n if(bDisplay is not True):\\n return _config_dict\\n else:\\n File_RW.DictPrint(_config_dict)\\n return _config_dict\",\n \"def _read_config(path):\\n with open(path) as f:\\n data = f.read()\\n data = os.path.expandvars(data)\\n data = yaml.safe_load(data)\\n return data\",\n \"def LoadProject(filename, toolchains):\\n\\n print 'Processing %s...' % filename\\n # Default src directory is the directory the description was found in\\n desc = open(filename, 'r').read()\\n desc = eval(desc, {}, {})\\n\\n # Verify the format of this file\\n if not ValidateFormat(desc, DSC_FORMAT):\\n ErrorExit('Failed to validate: ' + filename)\\n\\n # Check if we are actually interested in this example\\n match = False\\n for toolchain in toolchains:\\n if toolchain in desc['TOOLS']:\\n match = True\\n break\\n if not match:\\n return None\\n\\n desc['FILENAME'] = filename\\n return desc\",\n \"def read_config(self):\\n return json.load(open(self.config_dir + \\\"/\\\" + self.graph_type.lower() + \\\"_config.json\\\"))\",\n \"def tenv(request):\\n with open(SETUP_FILE, \\\"r\\\") as f:\\n tsetup = json.load(f)\\n\\n return tsetup[\\\"paths\\\"]\",\n \"def infocalypse_setupfms(ui_, **opts):\\n # REQUIRES config file.\\n execute_setupfms(ui_, opts)\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def setup(self):\\n pass\",\n \"def show(self):\\n # Used for testing because there is obviously no way back\\n # from VISU_Gen.SetCurrentStudy\\n if not self.display:\\n return\\n\\n # Desactivation : Load the med file in the PARAVIS component\\n #import smeca_utils.visu_utils as VU\\n #log.info(\\\"Loading Paravis module...\\\")\\n #msg = VU.load_med_file(self.read_fname())\\n #log.info(msg)\",\n \"def info(file, extended, vlrs, points):\\n try:\\n with pylas.open(openbin_file(file)) as fp:\\n echo_header(fp.header, extended)\\n\\n if vlrs:\\n click.echo(20 * \\\"-\\\")\\n echo_vlrs(fp)\\n\\n if points:\\n click.echo(20 * \\\"-\\\")\\n echo_points(fp)\\n except fs.errors.ResourceNotFound as e:\\n click.echo(click.style(\\\"Error: {}\\\".format(e), fg=\\\"red\\\"))\",\n \"def main():\\n\\n if os.path.exists(sys.argv[1]):\\n # first argument is the JSON plot definition setup file\\n with open(sys.argv[1]) as plotsetup:\\n plotdefs = json.load(plotsetup)\\n else:\\n raise ValueError('No plot definition file entered')\\n\\n plots = []\\n # second argument is the projections documentation directory\\n outdir = sys.argv[2]\\n\\n for i, plotdef in enumerate(plotdefs):\\n if plots != [] and plotdef['name'] not in plots:\\n continue\\n\\n print(i, plotdef['projstring'])\\n if 'skip' in plotdef.keys():\\n print('skipping')\\n continue\\n\\n update_caption(plotdef['name'],\\n plotdef['projstring'],\\n outdir)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6377754","0.60416627","0.5966378","0.5848778","0.57741296","0.57032096","0.564497","0.5521531","0.54921776","0.5488427","0.544995","0.5425102","0.5385421","0.5385421","0.53816396","0.5381369","0.5374962","0.5364246","0.5362655","0.53585416","0.535645","0.5345261","0.53066134","0.5294272","0.5285377","0.52789056","0.52536094","0.5247393","0.5231192","0.5228923","0.5222806","0.5218058","0.5208254","0.5197452","0.5187061","0.51690763","0.5161213","0.5141333","0.51311547","0.51234293","0.5104412","0.5104412","0.5089737","0.5089172","0.50817496","0.5066754","0.50617945","0.50589675","0.50547045","0.5050675","0.5048288","0.50471884","0.50471884","0.50471884","0.50471884","0.5046678","0.5045642","0.5043625","0.5043381","0.50412583","0.50408345","0.5034106","0.50339687","0.50305456","0.50280213","0.5020888","0.5020722","0.50162274","0.50156265","0.50152844","0.5015182","0.5014625","0.50135285","0.5010495","0.5010447","0.50090295","0.50034374","0.5002029","0.49974424","0.49961117","0.49957517","0.4993769","0.4987418","0.49815536","0.49805152","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.4978005","0.49766564","0.49765489","0.49757513"],"string":"[\n \"0.6377754\",\n \"0.60416627\",\n \"0.5966378\",\n \"0.5848778\",\n \"0.57741296\",\n \"0.57032096\",\n \"0.564497\",\n \"0.5521531\",\n \"0.54921776\",\n \"0.5488427\",\n \"0.544995\",\n \"0.5425102\",\n \"0.5385421\",\n \"0.5385421\",\n \"0.53816396\",\n \"0.5381369\",\n \"0.5374962\",\n \"0.5364246\",\n \"0.5362655\",\n \"0.53585416\",\n \"0.535645\",\n \"0.5345261\",\n \"0.53066134\",\n \"0.5294272\",\n \"0.5285377\",\n \"0.52789056\",\n \"0.52536094\",\n \"0.5247393\",\n \"0.5231192\",\n \"0.5228923\",\n \"0.5222806\",\n \"0.5218058\",\n \"0.5208254\",\n \"0.5197452\",\n \"0.5187061\",\n \"0.51690763\",\n \"0.5161213\",\n \"0.5141333\",\n \"0.51311547\",\n \"0.51234293\",\n \"0.5104412\",\n \"0.5104412\",\n \"0.5089737\",\n \"0.5089172\",\n \"0.50817496\",\n \"0.5066754\",\n \"0.50617945\",\n \"0.50589675\",\n \"0.50547045\",\n \"0.5050675\",\n \"0.5048288\",\n \"0.50471884\",\n \"0.50471884\",\n \"0.50471884\",\n \"0.50471884\",\n \"0.5046678\",\n \"0.5045642\",\n \"0.5043625\",\n \"0.5043381\",\n \"0.50412583\",\n \"0.50408345\",\n \"0.5034106\",\n \"0.50339687\",\n \"0.50305456\",\n \"0.50280213\",\n \"0.5020888\",\n \"0.5020722\",\n \"0.50162274\",\n \"0.50156265\",\n \"0.50152844\",\n \"0.5015182\",\n \"0.5014625\",\n \"0.50135285\",\n \"0.5010495\",\n \"0.5010447\",\n \"0.50090295\",\n \"0.50034374\",\n \"0.5002029\",\n \"0.49974424\",\n \"0.49961117\",\n \"0.49957517\",\n \"0.4993769\",\n \"0.4987418\",\n \"0.49815536\",\n \"0.49805152\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.4978005\",\n \"0.49766564\",\n \"0.49765489\",\n \"0.49757513\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.59166896"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":88392,"cells":{"query":{"kind":"string","value":"Read XYZ and visualisation files from simulation"},"document":{"kind":"string","value":"def read_simulation_files(self):\n\n # Check if simulation files exist in current directory, if not kill process\n if not os.path.isfile('{}.xyz'.format(self.prefix)):\n print('Cannot find simulation file \"{}.xyz\"'.format(self.prefix))\n sys.exit()\n if not os.path.isfile('{}_vis2d.dat'.format(self.prefix)):\n print('Cannot find simulation file \"{}_vis2d.dat\"'.format(self.prefix))\n sys.exit()\n if not os.path.isfile('{}_dia.dat'.format(self.prefix)):\n print('Cannot find simulation file \"{}_dia.dat\"'.format(self.prefix))\n sys.exit()\n\n # Read coordinate file\n print('Reading simulation xyz file')\n with open('{}.xyz'.format(self.prefix),'r') as f:\n self.n = int(f.readline().split()[0])\n self.crds = np.zeros((self.n,2))\n f.seek(0,0)\n for i in range(self.frame):\n for j in range(2+self.n):\n f.readline()\n f.readline()\n f.readline()\n for j in range(self.n):\n self.crds[j,:] = np.array([float(c) for c in f.readline().split()[1:3]])\n\n # Read rings file\n print('Reading simulation ring file')\n with open('{}_vis2d.dat'.format(self.prefix),'r') as f:\n self.rings = []\n if self.vis_vortype != 0:\n while True:\n frame = int(f.readline().split()[0])\n vor_type = int(f.readline().split()[0])\n self.param = float(f.readline().split()[0])\n self.m = int(f.readline().split()[0])\n if frame==self.frame and vor_type==self.vis_vortype:\n for i in range(self.m):\n ring = np.array([float(c) for c in f.readline().split()])\n self.rings.append(ring.reshape(ring.shape[0]//2,2))\n break\n else:\n for i in range(self.m):\n f.readline()\n\n # Read diameter file\n print('Reading simulation radii and weights file')\n data = np.genfromtxt('{}_dia.dat'.format(self.prefix)).astype(float)\n self.radii = data[:self.n]/2\n self.weights = data[self.n:]"},"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 read_simulation_results(self,\n fname_sims, \n fname_pareto = None, \n fname_cull = None):\n\n \n self.fname_sims = fname_sims\n self.__read_file(fname_sims, 'sim_results')\n \n if fname_pareto is not None:\n self.fname_pareto = fname_pareto\n self.__read_file(fname_in, 'pareto')\n \n if fname_cull is not None:\n self.fname_cull = fname_cull\n self.__read_file(fname_in, 'cull')","def get_data(self,path):\n\t\twith open(path,'r') as file:\n\t\t\tdata = file.readlines()\n\t\t\tself.objects = int(data[0].split()[1])#getting num of object\n\t\t\tdata = data[2:]#Cutting header lines from data file\n\t\t\tself.positions = [[] for i in range(self.objects)]#creating array, each row represents all positions for agiven planet\n\t\t\tself.steps = int((len(data))/self.objects)#Cal steps\n\t\t\tself.center = [[] for i in range(self.objects)]\n\t\t\tprint \"steps = \", self.steps\n\t\t\tprint \"objects = \",self.objects \n\t\t\tprint(self.steps)\n\t\t\tfor el in range(self.objects):#iterator = all planets\n\t\t\t\tself.times =[]\n\t\t\t\tfor step in range(self.steps):#iterator = all simulation frames\n\t\t\t\t\ttemp_data = data[step*self.objects+el].split()#Separating t x y z from data lines\n\t\t\t\t\ttemp_data2 = [float(i) for i in temp_data[1:4]]#converting to float without t parameter\n\t\t\t\t\ttemp_center = [float(i) for i in temp_data[4:]]\n\t\t\t\t\tself.times.append(float(temp_data[0])) \n\t\t\t\t\tself.positions[el].append(temp_data2)#adding to self.positions list\n\t\t\t\t\tself.center[el].append(temp_center)\n\t\t\t\t\n\t\t\t\tself.add_planet(self.positions[el][0][0], self.positions[el][0][1], self.positions[el][0][2])#Inicialization planet with intial positions\n\t\t\tself.p = vis.points(pos=tuple(self.center[0][0]), size=3,color=color.black)#mass center \n\t\t\tself.p2 = vis.points(pos=(0,0,0),size=3,color=color.red)#sun center\n\t\t\tself.sun = vis.sphere(radius=0.2, pos = (0,0,0), opacity = 0.8, material=materials.emissive)\n\t\t\tself.dt= int(self.times[self.objects+1])","def simul_and_export(file, config, i):\n\n simulate_UVSPEC(file, config)\n\n load_skymap(config)\n\n sim = files_sim(config)[i]\n export_sim_rad(sim, config)","def readpil3d(self):\r\n\r\n # Read the data in as an array.\r\n res = np.loadtxt(self.name, delimiter=' ')\r\n\r\n # Split into useful chunks\r\n self.pos = res[:, 0:3] # Grid point locations\r\n self.Pn = res[:, 3:4] # Normal pressure [Pa]\r\n self.flux = res[:, -1] # Flux\r","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 rd_xyz(self):\n nmol = self.__rd_xyz_nmol()\n fpin = open(self.config['xyzfile'], \"r\")\n tmol = self.template['molspec']['atoms']\n ntatom = self.template['molspec']['n_atoms']\n mol = []\n for i in range(nmol):\n # number of atom,\n line = fpin.readline().strip()\n natom = int(line)\n line = fpin.readline()\n\n jobname = \"%s\" % line[:-1]\n atom = []\n\n if ntatom != natom:\n print \"geometry data in template file is not consistant with xyz file. check the template.\"\n for j in range(natom):\n line = fpin.readline()\n rec = line.split()\n if len(rec) == 5:\n atomname, x, y, z, imove = rec\n elif len(rec) == 4:\n atomname, x, y, z = rec\n else:\n print \"nothing to do...\"\n exit(1)\n frg = tmol[j]['frg']\n record = {'name': atomname, 'coord': [float(x),float(y),float(z)], 'frg':frg}\n atom.append(record)\n onemol = {'natom': natom, 'jobname': jobname, 'info': '', 'atom':atom}\n mol.append(onemol)\n self.model['mol'] = mol\n fpin.close()\n return","def plotfile(self):\r\n filename = self.locatefile()\r\n if filename == \"\":\r\n print \"\\nNo file was chosen, exiting ...\\n\"\r\n return\r\n else:\r\n print \"\\nXYZ Data file:\\n\" + filename\r\n \r\n print \"\\nReading XYZ data file....\"\r\n xyz = XYZImporter(filename)\r\n geodata = xyz.genericdata\r\n print \"FINISHED reading XYZ data file\"\r\n\r\n # Note PNG is only 8 bit, and so PDF has greater colour\r\n # depth \r\n print \"\\nAbout to render plot ...\"\r\n gp = GridPlotterCustom()\r\n gp.shownulls = False\r\n title = \"Plot of XYZ data file: \" + filename\r\n outfname = (filename.replace('.', '_') +\r\n '_PLOT_custom.pdf')\r\n gp.plotgeodata(geodata, title, outfname)\r\n print \"FINISHED rendering plot to:\\n\" + outfname\r\n print \"\\n\\n\"","def _read_input_file(self):\n file_type = 'np.array'\n with open(self._file_properties['file_name'], 'r') as in_file:\n for line in in_file.readlines():\n if line[0:5] == '$$SOE':\n file_type = 'Horizons'\n break\n\n if not isfile(self._file_properties['file_name']):\n msg = 'Horizons files {:} does not exists.'\n message = msg.format(self._file_properties['file_name'])\n raise FileExistsError(message)\n if file_type == 'Horizons':\n self._read_horizons_file()\n else:\n (time, x, y, z) = np.loadtxt(\n self._file_properties['file_name'],\n usecols=(0, 1, 2, 3), unpack=True)\n self._time = time\n if int(astropy_version[0]) >= 4:\n self._xyz = SkyCoord(x=x, y=y, z=z,\n representation_type='cartesian')\n else:\n self._xyz = SkyCoord(x=x, y=y, z=z,\n representation='cartesian')","def setup(self):\n print(\"Looking for \", self.filename)\n if os.path.exists(self.filename):\n file = scio.loadmat(self.filename)\n self.data = np.squeeze(file[\"data\"])\n print(\"Motion Data length is \", len(self.data))\n\n else:\n raise FileNotFoundError","def readin():\r\n nodes = np.loadtxt('Vnodes.txt', ndmin=2)\r\n mats = np.loadtxt('Vmater.txt', ndmin=2)\r\n elements = np.loadtxt('Veles.txt', ndmin=2)\r\n loads = np.loadtxt('Vloads.txt', ndmin=2)\r\n return nodes, mats, elements, loads","def read_xyz(self, filename):\n # first line contains number of atoms\n self.numatom = int(filename.readline().split()[0])\n # second line contains a comment\n self.comment = filename.readline()[:-3]\n # rest of the lines contain coordinates structured Element X Y Z\n string = \"Element X Y Z \\n\" + filename.read()\n self.contents = pd.read_table(StringIO(string), sep=r'\\s+')","def load_xyz(filename):\n periodic = load_periodic()\n #read molecule\n with open(filename) as f:\n size = int(next(f))\n title = next(f).strip()\n molecule = Molecule(title,size)\n for _ in range(size):\n row = next(f).split()\n tag = row[0]\n element = periodic[tag]\n coordinate = []\n for j in range(3):\n coordinate.append(float(row[j+1]))\n atom = Atom(element,coordinate)\n\n molecule.append(atom)\n f.close()\n \n return molecule","def run_analysis(self):\n ### skip some snapshots for testing purposes\n nskip = 199\n read_char.skip_snapshots(self.hfile, self.ifile, nskip)\n ### read in the first two steps (required for velocity related computations\n xs_old, ys_old, lx_old, ly_old, tstep_old, natoms_old = read_char.read_snapshot(self.hfile, self.ifile)\n x_old = xs_old*lx_old\n y_old = ys_old*ly_old\n xs,ys,lx,ly,tstep,natoms = read_char.read_snapshot(self.hfile, self.ifile)\n x = xs*lx\n y = ys*ly\n ### loop over all steps of the input file\n for step in range(nskip+1,self.nsteps-1):\n print step\n ### read in coordinates (as required)\n xs_new,ys_new,lx_new,ly_new,tstep_new,natoms_new = read_char.read_snapshot(self.hfile, self.ifile)\n x_new = xs_new*lx_new\n y_new = ys_new*ly_new\n ### compute further current per/atom quantities\n phi = misc_tools.compute_orientation(x,y,lx,ly,self.npol)\n vx,vy = misc_tools.compute_velocity(x_old,y_old, x_new, y_new, lx, ly, tstep_old, tstep_new, natoms)\n ### start desired analysis methods\n # density\n if self.density_flag:\n self.density.compute(step,x,y,lx,ly,natoms, plot = 'False')\n # number fluctuations\n if self.nf_flag:\n self.numberfluctuation.compute(step,xs,ys, plot = 'False')\n # voronoi density\n if self.voronoi_flag:\n self.voronoidensity.compute(step,x,y,lx,ly,natoms, plot = 'False')\n # velocity / worticity\n if self.velocity_flag:\n self.velocityworticity.compute(step,x,y,vx,vy,natoms,lx,ly, plot = 'False')\n # orientation / velocity\n if self.orientvel_flag:\n self.orientvel.compute(step,x,y,vx,vy,phi,natoms, plot = 'False')\n # defect points\n if self.pointdefects_flag:\n self.pointdefects.compute(step,x,y,phi,lx,ly,natoms)\n ### move coordinate arrays\n xs_old = np.copy(xs)\n ys_old = np.copy(ys)\n x_old = np.copy(x)\n y_old = np.copy(y)\n tstep_old = tstep\n xs = np.copy(xs_new)\n ys = np.copy(ys_new)\n x = np.copy(x_new)\n y = np.copy(y_new)\n tstep = tstep_new\n return","def __init__(self):\n\n self.read_input_file()\n self.read_simulation_files()","def test_readfile_fits(self):\n fitsname = os.path.join(self.datadir, 'monol_testA.evt')\n command = \"{0}\".format(fitsname)\n\n hen.io.main(command.split())","def test_read(self):\n for line in TESTIMAGES.split('\\n'):\n vals = line.strip().split()\n name = vals[0]\n logger.debug(\"Testing file %s\" % name)\n dim1, dim2 = [int(x) for x in vals[1:3]]\n mini, maxi, mean, stddev = [float(x) for x in vals[3:]]\n obj = raxisimage()\n obj.read(os.path.join(os.path.dirname(self.mar), name))\n\n self.assertAlmostEqual(mini, obj.getmin(), 2, \"getmin [%s,%s]\" % (mini, obj.getmin()))\n self.assertAlmostEqual(maxi, obj.getmax(), 2, \"getmax [%s,%s]\" % (maxi, obj.getmax()))\n self.assertAlmostEqual(mean, obj.getmean(), 2, \"getmean [%s,%s]\" % (mean, obj.getmean()))\n self.assertAlmostEqual(stddev, obj.getstddev(), 2, \"getstddev [%s,%s]\" % (stddev, obj.getstddev()))\n self.assertEqual(dim1, obj.dim1, \"dim1\")\n self.assertEqual(dim2, obj.dim2, \"dim2\")\n self.assertNotEqual(obj.dim1, obj.dim2, \"dim2!=dim1\")","def import_data():\n from project_parameters import perm,dataPointsPerAxis,numElectrodes,debug,scale\n from project_parameters import baseDataName,simulationDirectory,savePath,name\n from project_parameters import position,zMin,zMax,zStep,name,charge,mass,r0\n import pickle\n # renaming for convenience\n na, ne = dataPointsPerAxis, numElectrodes \n\n #works with import_data_HOA -smouradi 04/19\n print('Loading trap data from Sandia...')\n fname = (simulationDirectory+baseDataName+'.pkl')\n print fname\n try:\n f = open(fname,'rb')\n except IOError:\n return ('No pickle file foudn.')\n trap = pickle.load(f)\n\n Xi = trap['X'] #sandia defined coordinates\n Yi = trap['Y']\n Zi = trap['Z']\n #get everything into expected coordinates (described in project_paramters)\n coords = [Xi,Yi,Zi]\n X = coords[perm[0]]/scale\n Y = coords[perm[1]]/scale\n Z = coords[perm[2]]/scale\n if debug.import_data:\n print ('size of X,Y, and Z:')\n print X.shape\n print Y.shape\n print Z.shape\n\n sim=TreeDict()\n el = 0\n for key in trap['electrodes']:\n Vs = trap['electrodes'][key]['V']\n Vs = Vs.reshape(na[0],na[1],na[2])\n Vs = np.transpose(Vs,perm)\n electrode = TreeDict()\n electrode.potential = Vs\n electrode.name = trap['electrodes'][key]['name']\n electrode.position = trap['electrodes'][key]['position']\n if electrode.name == 'RF':\n sim['EL_RF'.format(el)] = electrode.copy()\n sim['EL_DC_{}'.format(el)] = electrode.copy()\n el=el+1\n\n del trap\n #4) Build the simulation data structure\n sim.X,sim.Y,sim.Z=X,Y,Z # set grid vectors\n sim.simulationDirectory = simulationDirectory\n sim.baseDataName = baseDataName\n sim.dataPointsPerAxis = na\n sim.numElectrodes = ne\n sim.savePath = savePath\n sim.perm = perm\n\n sim.configuration.position = position\n sim.configuration.charge = charge\n sim.configuration.mass = mass\n sim.configuration.r0 = r0\n\n if debug.import_data: # Plot each electrode\n print(plot_potential(sim.EL_RF.potential,X,Y,Z,'1D plots','RF electrode'))\n for el in range(0,ne): \n electrode = sim['EL_DC_{}'.format(el)] \n print(plot_potential(electrode.potential,X,Y,Z,\\\n '1D plots','Electrode {},{} Position:{}'.format(el,electrode.name,electrode.position)))\n\n #5) save the particular simulation as a pickle data structure\n nameOut=savePath+name+'.pkl'\n print ('Saving '+nameOut+' as a data structure...')\n output = open(nameOut,'wb')\n pickle.dump(sim,output)\n output.close()\n return 'Import complete.'","def read(self, simtype):\n\n if simtype == 'original':\n if self.filename.endswith(\".pkl\"):\n logging.debug(\"Loading pickle file %s\", self.filename)\n data = pd.read_pickle(self.filename)\n\n elif self.filename.endswith(\".hdf5\"):\n logging.debug(\"Loading HDF5 file %s\", self.filename)\n with h5py.File(self.filename, \"r\") as data_file:\n #print('treeIndex', data_file[\"treeIndex\"].keys())\n #print('haloTrees', data_file[\"haloTrees\"].keys())\n \n # Find dimensionality of keys\n columns_1dim = [] \n columns_2dim = [] \n for column in self.columns:\n if len(data_file[\"/haloTrees/%s\" % column].shape) == 1:\n columns_1dim.append(column)\n else:\n columns_2dim.append(column)\n \n # 1D keys\n data = pd.DataFrame(\n {\n column: data_file[\"/haloTrees/%s\" % column].value\n for column in columns_1dim\n },\n columns=columns_1dim\n ).set_index(\"nodeIndex\")\n del columns_1dim\n\n # 2D keys\n for column in columns_2dim:\n if column == 'position':\n pos = data_file[\"/haloTrees/%s\" % column].value\n data['X'] = pd.Series(pos[:, 0], index=data.index)\n data['Y'] = pd.Series(pos[:, 1], index=data.index)\n data['Z'] = pd.Series(pos[:, 2], index=data.index)\n del columns_2dim\n\n data.rename(index=str,\n columns={\"snapshotNumber\": \"snapnum\"})\n ## eliminate fake elements with isIntegrated=1\n #data = data[data.isInterpolated != 1]\n\n else:\n raise TypeError(\"Unknown filetype %s\" % self.filename)\n if simtype == 'EAGLE':\n if self.filename.endswith(\".pkl\"):\n logging.debug(\"Loading pickle file %s\", self.filename)\n data = pd.read_pickle(self.filename)\n\n elif self.filename.endswith(\".hdf5\"):\n logging.debug(\"Loading HDF5 file %s\", self.filename)\n data_file = h5py.File(self.filename, 'r')\n column_mt = []\n column_sh = []\n for column in self.columns:\n if column in data_file['MergerTree']:\n column_mt.append(column)\n else:\n column_sh.append(column)\n\n data = pd.DataFrame(\n {\n column: data_file[\"/MergerTree/%s\" % column].value\n for column in column_mt\n },\n columns=column_mt\n ).set_index(\"HaloID\")\n #.set_index(data_file[\"/Merger/HaloID\"].value)\n\n for column in column_sh:\n data[column] = pd.Series(data_file[\"/Subhalo/%s\" % column].value,\n index=data.index)\n data = data.rename(index=str,\n columns={\"SnapNum\": \"snapnum\", #\"HaloID\": \"nodeIndex\",\n \"DescendantID\" : \"descendantIndex\"})\n else:\n raise TypeError(\"Unknown filetype %s\" % self.filename)\n\n return data","def read(f):\n \n if isinstance(f, basestring):\n # If the input is a string, treat as file name\n with open(f) as fh: # Ensure file is closed\n return read(fh) # Call again with file object\n \n # First line contains the date\n date = f.readline()\n if not date:\n raise IOError(\"Cannot read from input file \"+str(filename))\n \n # Second is description\n desc = f.readline()\n \n token = file_numbers(f)\n \n # Third contains number of mesh points\n try:\n npsi = int(token.next())\n ntheta = int(token.next())\n isym = int(token.next())\n except StopIteration:\n raise IOError(\"Unexpected end of file while reading grid size\")\n except ValueError:\n raise IOError(\"Third line should contain npsi, ntheta and isym\")\n \n # Check values\n if (isym < 0) or (isym > 1):\n raise IOError(\"isym must be either 0 or 1\")\n if (npsi < 1) or (ntheta < 1):\n raise IOError(\"Invalid npsi=\"+str(npsi)+\" or ntheta=\" + str(ntheta))\n \n # Read normalisation factors\n\n try:\n rcnt = float(token.next())\n xma = float(token.next())\n zma = float(token.next())\n btor = float(token.next())\n curtot = float(token.next())\n eaxe = float(token.next())\n dnorm = float(token.next())\n except:\n raise IOError(\"Couldn't read normalisation factors\")\n \n def read_array(n, name=\"Unknown\"):\n data = np.zeros([n])\n try:\n for i in np.arange(n):\n data[i] = float(token.next())\n except:\n raise IOError(\"Failed reading array '\"+name+\"' of size \", n)\n return data\n\n def read_2d(nx, ny, name=\"Unknown\"):\n data = np.zeros([nx, ny])\n for i in np.arange(nx):\n data[i,:] = read_array(ny, name+\"[\"+str(i)+\"]\")\n return data\n\n # Read 1D arrays\n psiflux = read_array(npsi, \"psiflux\")\n fnorm = read_array(npsi, \"fnorm\")\n ffpnorm = read_array(npsi, \"ffpnorm\")\n ponly = read_array(npsi, \"ponly\")\n pponly = read_array(npsi, \"pponly\")\n qsf = read_array(npsi, \"qsf\")\n d = read_array(npsi, \"d\")\n \n dpdz = read_array(ntheta, \"dpdz\")\n dpdr = read_array(ntheta, \"dpdr\")\n \n # 2D arrays\n \n xnorm = read_2d(ntheta, npsi, \"xnorm\")\n znorm = read_2d(ntheta, npsi, \"znorm\")\n \n # Try to read Br and Bz (may be present)\n try:\n Br = read_2d(ntheta, npsi, \"Br\")\n Bz = read_2d(ntheta, npsi, \"Bz\")\n except:\n Br = Bz = None\n \n ny = ntheta\n\n if isym == 1:\n # Fill in values for up-down symmetric case\n print(\"Grid is up-down symmetric. Reflecting grid about midplane\")\n ny = tsize = 2*(ntheta - 1) + 1\n \n def reflect(data, mapfunc = lambda x:x):\n \"\"\" Reflect a variable about midplane\n Optionally supply a mapping function\"\"\"\n data2 = np.zeros([tsize, npsi])\n # Copy the original data\n for i in np.arange(ntheta):\n data2[i,:] = data[i,:]\n # Now fill in the remainder\n for i in np.arange(ntheta, tsize):\n t0 = tsize - 1 - i\n data2[i,:] = mapfunc(data[t0,:])\n return data2\n \n xnorm = reflect(xnorm)\n znorm = reflect(znorm, lambda x: 2.*zma - x) # Reflect about zma\n if Br != None:\n Br = reflect(Br, lambda x:-x) # Br reverses\n if Bz != None:\n Bz = reflect(Bz) # Bz remains the same\n theta = tsize\n\n # Make sure we have Br, Bz and Bpol\n\n if (Br == None) or (Bz == None):\n # Calculate Bpol from psi then Br and Bz from Bpol\n # Use dpsi = R*Bp dx (for now)\n Bpol = np.zeros([ny, npsi])\n \n def deriv(f):\n n = np.size(f)\n dfdi = np.zeros(n)\n dfdi[1:-1] = (f[2:n] - f[0:-2])/2. # Central difference in the middle\n dfdi[0] = f[1] - f[0]\n dfdi[-1] = f[-1] - f[-2]\n return dfdi\n \n for i in np.arange(ntheta):\n drdi = deriv(xnorm[i, :])\n dzdi = deriv(znorm[i, :])\n dldi = sqrt(drdi**2 + dzdi**2) # Arc length\n dpsidi = deriv(psiflux)\n \n Bpol[i, :] = dpsidi / (dldi * xnorm[i,:])\n else:\n Bpol = np.sqrt(Br**2 + Bz**2)\n \n # Calculate toroidal field\n Btor = fnorm / xnorm\n \n #########################################\n # Create a dictionary of values to return\n # \n # Need to transpose 2D arrays to [psi, theta] \n # to be consistent with elite inputs\n \n var = {\"npsi\":npsi, \"npol\":ny, # Sizes\n \n \"psi\":psiflux,\n \"f(psi)\":fnorm,\n \"p\":ponly,\n \n \"R\": np.transpose(xnorm),\n \"Z\": np.transpose(znorm),\n\n \"Bp\":np.transpose(Bpol),\n \"Bt\":np.transpose(Btor),\n\n \"q\":qsf,\n\n \"ffprime\":ffpnorm,\n \"pprime\":pponly}\n\n if Br != None:\n var['Br'] = np.transpose(Br)\n if Bz != None:\n var['Bz'] = np.transpose(Bz)\n \n return var","def import_xyz(self, fname):\n self.ftype = 'xyz'\n with open(fname) as f:\n lines = f.readlines()\n self.n_atom = int(lines[0].split()[0])\n\n # reading lines to build up class data\n self.sym = []\n self.at_num = []\n self.xyz = np.zeros((self.n_atom, 3))\n for i, line in enumerate(lines[2:]):\n tmp = line.split()\n self.sym.append(tmp[0])\n self.at_num.append(self.sym2num(tmp[0]))\n self.xyz[i, 0] = float(tmp[1])\n self.xyz[i, 1] = float(tmp[2])\n self.xyz[i, 2] = float(tmp[3])\n self.connectivity_matrix()","def read_xyz(filename):\n #print('Reading geom from:'),filename\n atoms = []\n coordinates = []\n\t\n xyz = open(filename)\n n_atoms = int(xyz.readline())\n title = xyz.readline()\n for line in xyz:\n\tif len(line.strip()) == 0:\n\t\tpass\n\t\tbreak\t\n\tatom,x,y,z = line.split()\n\tatoms.append(atom)\n\tcoordinates.append([float(x), float(y), float(z)])\n xyz.close()\n coordinates = [[w * angtobh for w in ww] for ww in coordinates] #ang to bh\n\n if n_atoms != len(coordinates):\n \tprint('Number of atoms in xyz file doesnt equal to the number of lines.')\n\tsys.exit(1)\n \n return atoms, coordinates","def test_read(self):\n for root, dirs, files in os.walk(os.path.join(self.test_dir, 'files')):\n for filename in files:\n if filename.endswith('.bin'):\n d = Dataset(os.path.join(root, filename))\n data = d.as_dict()\n for freq_dict in data['frequencies']:\n x = freq_dict['easting']\n y = freq_dict['northing']\n image = freq_dict['intensity']\n self.assertIsInstance(x, np.ndarray)\n self.assertIsInstance(y, np.ndarray)\n self.assertIsInstance(image, np.ndarray)","def test_file_io(self):\n temp_directory = tempfile.mkdtemp()\n filename = os.path.join(temp_directory, \"test.h5\")\n\n points = np.array([\n [0.1, 0.1, 0.1],\n [1.1, 2.1, 3.1],\n [1.3, 2.2, 3.4]])\n voxel_size = 0.5\n min_corner = Vector3f(-1, -2, -3)\n vg = VoxelGrid(voxel_size, min_corner=min_corner, points=points)\n\n # test writing\n vg.save(filename)\n self.assertTrue(os.path.isfile(filename))\n\n # test reading\n vg2 = VoxelGrid.from_file(filename)\n self.assertAlmostEquals(voxel_size, vg2.voxel_size)\n np.testing.assert_array_almost_equal(vg.min_corner, vg2.min_corner)\n shutil.rmtree(temp_directory)","def main():\n tmp_dir = xm.constants['dir_tmp']\n exr_f = join(tmp_dir, 'test.exr')\n exr = EXR(exr_f)\n exr.extract_normal(join(tmp_dir, 'test.png'), vis=True)","def extract_data( file_name):\n\n main_file = fits.open( file_name)\n\n ssp = main_file[1].data\n flux_elines = main_file[3].data\n org_hdr = main_file[0].header\n\n main_file.close()\n\n ###########################################################################\n # NOTE: The visual band fluxes are multiplied by 10^-16 as stated in the\n # units of the MaNGA Data Model.\n #\n # <https://data.sdss.org/datamodel/files/MANGA_PIPE3D/MANGADRP_VER\n # /PIPE3D_VER/PLATE/manga.Pipe3D.cube.html#hdu1>\n ###########################################################################\n v_band = ssp[0] # in units of erg / s / cm^2\n v_band_err = ssp[4] # in units of erg / s / cm^2\n sMass_density = ssp[19] * u.dex( u.M_sun) # in units of log10( Msun / spaxel**2)\n\n Ha_vel = flux_elines[102] # in units of km/s\n Ha_vel_err = flux_elines[330] # in units of km/s\n\n gal_ra = org_hdr['OBJRA']\n gal_dec = org_hdr['OBJDEC']\n\n target_galaxy = True\n MaNGA_galaxy_target = org_hdr['MNGTARG1']\n if MaNGA_galaxy_target == 0:\n target_galaxy = False\n\n data_quality = True\n DRP_3D_quality = org_hdr['DRP3QUAL']\n if DRP_3D_quality > 10000:\n data_quality = False\n\n return target_galaxy, data_quality, Ha_vel, Ha_vel_err, v_band, v_band_err, \\\n sMass_density, gal_ra, gal_dec","def read_results():\r\n with open(\"packing.nfo\", \"r\") as fin:\r\n fin.readline()\r\n fin.readline()\r\n por_theory = float(fin.readline().split()[2])\r\n por_final = float(fin.readline().split()[2])\r\n print('Theoretical porosity:', por_theory)\r\n print('Final porosity:', por_final)\r\n with open(\"packing.xyzd\", \"rb\") as fin:\r\n btxt = fin.read()\r\n txt = list(struct.unpack(\"<\" + \"d\" * (len(btxt) // 8), btxt))\r\n data = array(zip(*[iter(txt)] * 4))\r\n data[:, 3] = data[:, 3] * \\\r\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\r\n return data","def analyzeViSDEMData(dict):\n \n if 'path_in' in dict:\n path_in = dict['path_in']\n else:\n print(\"Caution: No path for input folder containing the data has been defined. Please define path to folder by dict['path_in']=path_in\") \n return\n \n path_out_default = '../colordeficiency-data/' \n if 'path_out' in dict:\n path_out = dict['path_out']\n else:\n print(\"Caution: No path for output folder where the data should be stored has been defined. Using default output path instead: \"+str(path_out_default))\n path_out = path_out_default\n \n if 'round' in dict:\n round = dict['round']\n else:\n print(\"Error: You have to chose a round first.\")\n \n path = os.path.join(os.path.dirname(os.path.abspath(os.path.join(__file__,os.pardir))),'colordeficiency-data')\n \n # 0. Step: Get all the relevant information, i.e. motive_ids, obs_col_defs etc.\n if round == 1:\n visualsearch_ids = os.path.join(path,\"visualsearch_ids.csv\")\n elif round == 2:\n visualsearch_ids = os.path.join(path,\"visualsearch_ids_2.csv\")\n \n vs_ids_sheet = pandas.read_csv(visualsearch_ids,sep=\";\")\n \n # Get all the relevant information about the observers, i.e. obs_col_defs etc.\n observer_ids = os.path.join(path,\"observer_ids.csv\")\n obs_ids_sheet = pandas.read_csv(observer_ids,sep=\";\")\n \n # 1. Step: Read all the XLSX data in the path\n ext = 'xlsx'; xlsx_files = getAllXXXinPath(path_in,ext)\n dataArray = pandas.DataFrame()\n i=1\n for xlsx_file in xlsx_files:\n sys.stdout.write(xlsx_file)\n dataArray_tmp, testArray, extraDataDict = extractExperimentData(os.path.join(path_in,xlsx_file))\n \n newDataArray = dataArray_tmp[['dalt_id','coldef_type','resp.corr_raw','resp.rt_raw','stimFile']]\n \n if \"2. Session\" in extraDataDict:\n sessionID = int(extraDataDict['2. Session'])\n newDataArray['session_id'] = sessionID\n \n if 'group' in extraDataDict:\n obsGroup = str(extraDataDict['group'])\n newDataArray['obsGroup'] = obsGroup\n \n if '0. Participant ID' in extraDataDict:\n obsID = int(extraDataDict['0. Participant ID'])\n \n newDataArray['observer_id'] = obsID\n obs_coldef_type = obs_ids_sheet.loc[obs_ids_sheet['observer_id']==obsID,['observer_coldef_type']]\n newDataArray['observer_coldef_type'] = int(obs_coldef_type['observer_coldef_type'])\n \n dataArray = pandas.concat([dataArray, newDataArray])\n sys.stdout.write(' . ')\n if (i%5)==0: sys.stdout.write('\\n')\n i+=1\n sys.stdout.write('\\n')\n \n # 2. Step: Adapt values to programstandards\n for item in settings.colDefLong2ID:\n dataArray.loc[dataArray['coldef_type'] == item, ['coldef_type']] = settings.colDefLong2ID[item]\n \n for item in settings.dalt2ID:\n dataArray.loc[dataArray['dalt_id'] == item, ['dalt_id']] = settings.dalt2ID[item]\n \n dataArray.loc[dataArray['dalt_id'] == 'none', ['dalt_id']] = 0\n \n \n dataArray = dataArray.rename(columns={'dalt_id': 'dalt_id',\n 'coldef_type': 'coldef_type',\n 'resp.corr_raw': 'is_correct',\n 'resp.rt_raw': 'resp_time',\n 'stimFile': 'filepath'})\n dataArray = dataArray.reset_index()\n \n # Adding set_id, motive_id and variant_id to each file\n for index, row in dataArray.iterrows():\n path_tmp = row['filepath']\n filename = os.path.basename(path_tmp).split('.')[0]\n dict_tmp = getStatsFromFilename(filename)\n imgID_tmp = int(dict_tmp['img_id'])\n \n tempVSDataArray = vs_ids_sheet.loc[vs_ids_sheet['image_id']==imgID_tmp,['set_id','motive_id','variant_id']]\n \n dataArray.at[index,'image_id'] = imgID_tmp\n dataArray.ix[index,'set_id'] = int(tempVSDataArray['set_id'])\n dataArray.ix[index,'motive_id'] = int(tempVSDataArray['motive_id'])\n dataArray.ix[index,'variant_id'] = int(tempVSDataArray['variant_id'])\n\n dataArray.image_id = dataArray.image_id.astype(int)\n dataArray.set_id = dataArray.set_id.astype(int)\n dataArray.motive_id = dataArray.motive_id.astype(int)\n dataArray.variant_id = dataArray.variant_id.astype(int)\n dataArray.is_correct = dataArray.is_correct.astype(bool)\n \n dataArray = dataArray[['image_id','set_id','motive_id','variant_id','dalt_id','coldef_type','is_correct','resp_time','observer_id','observer_coldef_type','session_id','filepath','obsGroup']]\n \n # 3. Saving data to file\n try:\n dataArray.to_csv(os.path.join(path_out, 'visdem-data.csv'),sep=\";\")\n sys.stdout.write(\"Success: ViSDEM data successfully saved in '\"+str(path_out)+\"'.\\n\")\n except Exception as e:\n print(e)","def analysis(file_name, sky_file_name):\n plt.rc('text', usetex=True)\n plt.rc('font', family='serif')\n plt.rcParams['text.latex.preamble'] = [r'\\boldmath']\n\n curr_file_name = file_name.split('.')\n curr_file_name = curr_file_name[0].split('/')\n stk_f_n = curr_file_name[-1]\n data_dir = 'cube_results/' + stk_f_n\n \n if not os.path.exists(data_dir):\n os.mkdir(data_dir)\n\n spectra_stacker(file_name)\n\n # one figure to rule them all\n main_fig = plt.figure(1)\n\n # calling data once will be enough\n im_coll_data = image_collapser(file_name)\n spectra_data = spectrum_creator(file_name)\n sr = wavelength_solution(file_name) \n gs_data = spectra_analysis(file_name, sky_file_name)\n \n def graph_indiv():\n cbd_x = np.linspace(sr['begin'], sr['end'], sr['steps'])\n cbs_y = gs_data['gd_shifted'] \n\n # plotting spectra to check\n fig, ax3 = plt.subplots()\n ax3.plot(cbd_x, cbs_y, linewidth=0.5, color=\"#000000\")\n ax3.tick_params(labelsize=20)\n ax3.set_xlabel(r'\\textbf{Wavelength (\\AA)}', fontsize=20)\n ax3.set_ylabel(r'\\textbf{Flux}', fontsize=20)\n fig.savefig(data_dir + \"/\" + stk_f_n + '_single_spectra.pdf', \n bbox_inches=\"tight\")\n\n # --- for collapsed images ---\n def graphs_collapsed(): \n f, (ax1, ax2) = plt.subplots(1, 2)\n \n ax1.imshow(im_coll_data['median'], cmap='gray_r') \n ax1.set_title(r'\\textbf{galaxy: median}', fontsize=13) \n ax1.set_xlabel(r'\\textbf{Pixels}', fontsize=13)\n ax1.set_ylabel(r'\\textbf{Pixels}', fontsize=13) \n\n ax2.imshow(im_coll_data['sum'], cmap='gray_r')\n ax2.set_title(r'\\textbf{galaxy: sum}', fontsize=13) \n ax2.set_xlabel(r'\\textbf{Pixels}', fontsize=13)\n ax2.set_ylabel(r'\\textbf{Pixels}', fontsize=13)\n \n f.subplots_adjust(wspace=0.4)\n f.savefig(data_dir + \"/\" + stk_f_n + '_collapsed_images.pdf')\n\n \n snw_data = sky_noise_weighting(file_name, sky_file_name)\n df_data = otwo_doublet_fitting(file_name, sky_file_name)\n\n # --- spectra ---\n def graphs_spectra():\n f, (ax1, ax2) = plt.subplots(2, 1) \n\n # --- redshifted data plotting\n cbd_x = np.linspace(sr['begin'], sr['end'], sr['steps'])\n \n ## plotting our cube data\n cbs_y = gs_data['gd_shifted'] \n ax1.plot(cbd_x, cbs_y, linewidth=0.5, color=\"#000000\")\n\n ## plotting our sky noise data\n snd_y = snw_data['sky_regions'][:,1]\n ax1.plot(cbd_x, snd_y, linewidth=0.5, color=\"#f44336\", alpha=0.5)\n\n # plotting spectra to check\n fig, ax3 = plt.subplots()\n ax3.plot(cbd_x, cbs_y, linewidth=0.5, color=\"#000000\")\n ax3.tick_params(labelsize=20)\n ax3.set_xlabel(r'\\textbf{Wavelength (\\AA)}', fontsize=20)\n ax3.set_ylabel(r'\\textbf{Flux}', fontsize=20)\n fig.savefig(data_dir + \"/\" + stk_f_n + '_single_spectra.pdf', \n bbox_inches=\"tight\")\n\n ## plotting our [OII] region\n ot_x = df_data['x_region']\n ot_y = df_data['y_region']\n ax1.plot(ot_x, ot_y, linewidth=0.5, color=\"#00c853\") \n\n ## plotting the standard deviation region in the [OII] section\n std_x = df_data['std_x']\n std_y = df_data['std_y']\n ax1.plot(std_x, std_y, linewidth=0.5, color=\"#00acc1\") \n \n ## plotting peak lines for scipy finder and peakutils finder\n #pk_lines = gs_data['gd_peaks']\n #for i in range(len(pk_lines)):\n #srb = sr['begin']\n #ax1.axvline(x=srb+pk_lines[i], linewidth=0.5, color=\"#8bc34a\", alpha=0.2)\n \n pu_lines = gs_data['pu_peaks']\n for i in range(len(pu_lines)):\n srb = sr['begin']\n ax1.axvline(x=(pu_lines[i]), linewidth=0.5, color=\"#ec407a\", alpha=0.2)\n\n ax1.set_title(r'\\textbf{spectra: cross-section redshifted}', fontsize=13) \n ax1.set_xlabel(r'\\textbf{Wavelength (\\AA)}', fontsize=13)\n ax1.set_ylabel(r'\\textbf{Flux}', fontsize=13)\n ax1.set_ylim([-1000,5000]) # setting manual limits for now\n \n # --- corrected redshift\n crs_x = np.linspace(sr['begin'], sr['end'], sr['steps'])\n rdst = gs_data['redshift']\n\n sp_lines = gs_data['spectra']\n\n ## corrected wavelengths\n corr_x = crs_x / (1+rdst)\n\n ## plotting our cube data\n cps_y = gs_data['gd_shifted']\n ax2.plot(corr_x, cps_y, linewidth=0.5, color=\"#000000\")\n\n ## plotting our sky noise data\n sn_y = gs_data['sky_noise']\n ax2.plot(corr_x, sn_y, linewidth=0.5, color=\"#e53935\")\n \n ## plotting spectra lines\n for e_key, e_val in sp_lines['emis'].items():\n spec_line = float(e_val)\n ax2.axvline(x=spec_line, linewidth=0.5, color=\"#00c853\")\n ax2.text(spec_line-10, 4800, e_key, rotation=-90)\n \n ax2.set_title(r'\\textbf{spectra: cross-section corrected}', fontsize=13) \n ax2.set_xlabel(r'\\textbf{Wavelength (\\AA)}', fontsize=13)\n ax2.set_ylabel(r'\\textbf{Flux}', fontsize=13)\n ax2.set_ylim([-500,5000]) # setting manual limits for now\n\n f.subplots_adjust(hspace=0.5)\n f.savefig(data_dir + \"/\" + stk_f_n + '_spectra.pdf')\n\n # saving our plotting into npy files so they can be used elsewhere\n np.save(data_dir + \"/\" + stk_f_n + \"_cbd_x\", cbd_x)\n np.save(data_dir + \"/\" + stk_f_n + \"_cbs_y\", cbs_y) \n\n np.save(data_dir + \"/\" + stk_f_n + \"_snd_y\", snd_y) \n \n np.save(data_dir + \"/\" + stk_f_n + \"_corr_x\", corr_x)\n np.save(data_dir + \"/\" + stk_f_n + \"_cps_y\", cps_y)\n \n def graphs_otwo_region():\n ot_fig = plt.figure(6)\n\n # plotting the data for the cutout [OII] region\n ot_x = df_data['x_region']\n ot_y = df_data['y_region']\n plt.plot(ot_x, ot_y, linewidth=1.5, color=\"#000000\")\n\n ## plotting the standard deviation region in the [OII] section\n std_x = df_data['std_x']\n std_y = df_data['std_y']\n #plt.plot(std_x, std_y, linewidth=1.5, color=\"#00acc1\") \n\n dblt_rng = df_data['doublet_range']\n ot_x_b, ot_x_e = dblt_rng[0], dblt_rng[-1]\n x_ax_vals = np.linspace(ot_x_b, ot_x_e, 1000)\n\n # lmfit \n lm_init = df_data['lm_init_fit']\n lm_best = df_data['lm_best_fit'] \n\n plt.plot(ot_x, lm_best, linewidth=1.5, color=\"#1e88e5\", \n label=r\"\\textbf{Best fit}\")\n plt.plot(ot_x, lm_init, linewidth=1.5, color=\"#43a047\", alpha=0.5,\n label=r\"\\textbf{Initial guess}\")\n \n lm_params = df_data['lm_best_param']\n lm_params = [prm_value for prm_key, prm_value in lm_params.items()]\n c, i_val1, i_val2, sig_g, rdsh, sig_i = lm_params\n\n dblt_mu = [3727.092, 3729.875] # the actual non-redshifted wavelengths for OII\n l1 = dblt_mu[0] * (1+rdsh)\n l2 = dblt_mu[1] * (1+rdsh)\n \n sig = np.sqrt(sig_g**2 + sig_i**2) \n norm = (sig*np.sqrt(2*np.pi))\n\n lm_y1 = c + ( i_val1 / norm ) * np.exp(-(ot_x-l1)**2/(2*sig**2))\n lm_y2 = c + ( i_val2 / norm ) * np.exp(-(ot_x-l2)**2/(2*sig**2))\n \n plt.plot(ot_x, lm_y1, linewidth=1.5, color=\"#e64a19\", alpha=0.7, \n label=r\"\\textbf{Gaussian 1}\") \n plt.plot(ot_x, lm_y2, linewidth=1.5, color=\"#1a237e\", alpha=0.7,\n label=r\"\\textbf{Gaussian 2}\")\n\n # plotting signal-to-noise straight line and gaussian to verify it works\n sn_line = df_data['sn_line']\n sn_gauss = df_data['sn_gauss']\n\n #plt.axhline(y=sn_line, linewidth=0.5, color=\"#5c6bc0\", alpha=0.7) \n #plt.plot(ot_x, sn_gauss, linewidth=0.5, color=\"#5c6bc0\", alpha=0.7)\n\n #plt.title(r'\\textbf{[OII] region}', fontsize=13)\n plt.legend(loc='upper left', prop={'size': 15})\n plt.tick_params(labelsize=20)\n plt.xlabel(r'\\textbf{Wavelength (\\AA)}', fontsize=20)\n plt.ylabel(r'\\textbf{Flux}', fontsize=20)\n plt.xlim([l1-100,np.max(ot_x)])\n plt.ylim([-100,np.max(ot_y)+100]) # setting manual limits for now\n plt.savefig(data_dir + \"/\" + stk_f_n + '_otwo_region.pdf',bbox_inches=\"tight\")\n\n graph_indiv()\n graphs_collapsed()\n graphs_spectra()\n graphs_otwo_region()\n\n plt.close(\"all\")\n\n return {'image_data': im_coll_data, 'spectra_data': spectra_data, 'sr': sr,\n 'df_data': df_data, 'gs_data': gs_data, 'snw_data': snw_data}","def read_xyz_file(filename, num_spatial_dimensions):\n print(\"Reading data from XYZ file.\")\n\n particle_positions = []\n frame_number = 0\n line_number = 0\n frame_particles = 0\n with open(filename, 'r') as input_file:\n for line in input_file:\n if line_number == 0:\n # Check for blank line at end of file\n if line != \"\":\n frame_particles = int(line)\n particle_positions.append(np.zeros((frame_particles, num_spatial_dimensions)))\n elif line_number == 1:\n pass\n else:\n for dimension in range(num_spatial_dimensions):\n particle_positions[frame_number][line_number-2][dimension] = line.split()[1:][dimension]\n line_number += 1\n # If we have reached the last particle in the frame, reset counter for next frame\n if line_number == (frame_particles + 2):\n line_number = 0\n frame_number += 1\n\n print(\"XYZ read complete.\")\n\n return particle_positions","def xrds_from_dir(path=None, fjord=None, metastr='_mdf', bitmask=False):\n warnings.warn(\"This function currently assumes a constant grid and EPSG for all input files\")\n assert fjord != None, \"You must specify the fjord code for these DEMs\"\n\n files = [f for f in os.listdir(path) if f.endswith('dem.tif')]\n\n # for DEMs nested in directories\n if len(files) == 0:\n try: \n os.remove(path+'.DS_Store')\n except FileNotFoundError:\n pass\n dirs = [dir for dir in os.listdir(path)]\n nestfiles=[]\n for dir in dirs:\n nestfiles.append([dir+'/'+f for f in os.listdir(path+dir) if f.endswith('dem.tif')])\n files = [items for nest in nestfiles for items in nest]\n\n i=0\n darrays = list(np.zeros(len(files)))\n dtimes = list(np.zeros(len(files)))\n for f in files:\n print(f)\n\n metaf = f.rpartition(\"_dem.tif\")[0] + metastr + \".txt\"\n try:\n meta = read_meta(path+metaf)\n # print(meta)\n dtimes[i] = get_DEM_img_times(meta)\n except FileNotFoundError:\n print(\"You must manually enter dtimes for these files within the code\")\n # dtimes[0] = dt.datetime(2012, 6, 29, hour=15, minute=26, second=30)\n # dtimes[1] = dt.datetime(2010, 8, 14, hour=15, minute=34)\n # except KeyError:\n # raise\n except AssertionError:\n print(\"These stereo image times are >30 min apart... skipped\")\n continue\n\n try:\n darrays[i] = read_DEM(path+f, fjord)\n # darrays[i] = read_DEM(path+f.rpartition(\"_dem.tif\")[0] + \"_dem_geoidcomp.tif\")\n except RasterioIOError:\n print(\"RasterioIOError on your input file\")\n break\n \n # read in and apply the bitmask\n if bitmask==True:\n bitmaskfn = path + f.rpartition(\"dem.tif\")[0] + \"bitmask.tif\"\n maskarr = read_mask(bitmaskfn, fjord)\n darrays[i] = darrays[i].where(maskarr==0, )\n \n i = i + 1\n\n if len(darrays)==1 and np.all(darrays[0]) == 0:\n warnings.warn(\"Your DEM will not be put into XArray\")\n return \"nodems\"\n\n elif len(darrays)>1 and np.all(darrays[darrays!=0]) == 0:\n warnings.simplefilter(\"always\")\n warnings.warn(\"None of your DEMs will be put into XArray\")\n return \"nodems\"\n\n else:\n # I just discovered xarray's mfdataset with the preprocess option to modify each dataset prior to opening. I'm guessing that'd be the way to go here\n # darr = xr.combine_nested(darrays, concat_dim=['dtime'])\n darr = xr.concat(darrays, \n dim=pd.Index(dtimes, name='dtime'), \n # coords=['x','y'], \n join='outer').chunk({'dtime': 1, 'x':3072, 'y':3072}) # figure out a better value for chunking this (it slows the JI one with 3 dems way down)\n # combine_attrs='no_conflicts' # only in newest version of xarray\n\n try:\n for arr in darrays:\n arr.close()\n except:\n pass\n del darrays\n \n # convert to dataset with elevation as a variable and add attributes\n attr = darr.attrs\n ds = darr.to_dataset()\n\n # coarsen the data to 4 m resolution to reduce memory crashes during processing\n # note that this may be important in later steps when resolution is used as an input\n coarse = 2\n if coarse > 1:\n print(\"Your input DEMs will be downsampled to enable processing\")\n ds = ds.coarsen(x=coarse, y=coarse, boundary='pad').mean()\n ds = ds.chunk({'dtime': 1, 'x':3072, 'y':3072})\n\n ds.attrs = attr\n ds.attrs['fjord'] = fjord\n ds.attrs['res'] = tuple(x * coarse for x in attr['res'])\n attr=None\n\n # newest version of xarray (0.16) has promote_attrs=True kwarg. Earlier versions don't...\n # ds = ds.to_dataset(name='elevation', promote_attrs=True).squeeze().drop('band')\n \n # using rioxarray means the transform is read in/created as part of the geospatial info, so it's unnecessary to manually create a transform\n # create affine transform for concatted dataset\n print('Please note the transform is computed assuming a coordinate reference system\\\n where x(min) is west and y(min) is south')\n # inputs: west, south, east, north, width, height\n # don't use len(x,y) for width and height in case they're not continuous\n width = abs((ds.x.max().item() - ds.x.min().item())/ds.attrs['res'][0])\n ht = abs((ds.y.max().item() - ds.y.min().item())/ds.attrs['res'][1])\n transform = rasterio.transform.from_bounds(ds.x.min().item()-0.5*ds.attrs['res'][0], ds.y.min().item()-0.5*ds.attrs['res'][1], \n ds.x.max().item()+0.5*ds.attrs['res'][0], ds.y.max().item()+0.5*ds.attrs['res'][1], \n width, ht)\n ds.attrs['transform'] = transform\n # set the transform and crs as attributes since that's how they're accessed later in the pipeline\n # ds.attrs['transform'] = (ds.spatial_ref.GeoTransform)\n # ds.attrs['crs'] = ds.spatial_ref.crs_wkt\n\n\n return ds","def extraction(userinputs):\n #Set up required variables\n target_dir = userinputs['OUTDIR']\n seximage = userinputs['IMAGE']\n logging.info('Running sextractor on {}'.format(userinputs['IMAGE']))\n\n print 'Executing SExtractor on user selected image : ', seximage\n\n # Verify that file exists\n if os.path.exists(userinputs['DATA'] + '/' + seximage) == False:\n print 'File ' + seximage + ' could not be found in ' + userinputs['DATA']\n logging.critical(' Could not find {}. Quitting'.format(seximage))\n logging.debug('Looking for {} but unable to locate'.format(userinputs['DATA'] + '/' + seximage))\n filemanagement.shutdown('Quitting now...',userinputs)\n\n # Run sextractor\n logging.info('Start sextractor')\n os.chdir(target_dir + '/s_extraction')\n logging.debug('Changed dir to {}'.format(os.getcwd()))\n command = 'sex ' + userinputs['DATA'] + '/' + seximage + '[1] -c R2_wl_aa.config'\n os.system(command)\n os.chdir(target_dir)\n logging.debug('Changed working directory back to {}'.format(target_dir))\n\n # Read in results and make regions file of objects sextracted\n logging.info('Read in Sextractor catalog')\n xx, yy = np.loadtxt(target_dir + '/s_extraction/R2_wl_dpop_detarea.cat', unpack=True,\n skiprows=5, usecols=(0,1))\n\n outputfile = target_dir + '/s_extraction/catalog_ds9_sextractor.reg'\n\n logging.info('Writing region file from source extractor data')\n logging.debug('Sextractor file: {}'.format(target_dir + '/s_extraction/R2_wl_dpop_detarea.cat'))\n with open(outputfile, 'w') as file:\n file.write('global color=blue width=5 font=\"helvetica 15 normal roman\" highlite=1 \\n')\n file.write('image\\n')\n\n for i in range(len(xx)):\n newline = 'circle(' + str(xx[i]) + ',' + str(yy[i]) + ',7) \\n'\n file.write(newline)\n print ''\n print 'Check catalog_ds9_sextractor.reg in the /s_extraction directory for'\n print 'the quality of source extraction.'\n print ''\n\n return target_dir + '/s_extraction/R2_wl_dpop_detarea.cat'","def test_run_experiment_from_xml_files():\n solvent_path = examples_paths()['toluene-solvent']\n vacuum_path = examples_paths()['toluene-vacuum']\n with mmtools.utils.temporary_directory() as tmp_dir:\n yaml_script = get_template_script(tmp_dir)\n del yaml_script['molecules'] # we shouldn't need any molecule\n yaml_script['systems'] = {'explicit-system':\n {'phase1_path': solvent_path, 'phase2_path': vacuum_path,\n 'solvent_dsl': 'not resname TOL'}}\n\n exp_builder = ExperimentBuilder(yaml_script)\n exp_builder._check_resume() # check_resume should not raise exceptions\n exp_builder.run_experiments()\n\n # The experiments folders are correctly named and positioned\n output_dir = exp_builder._get_experiment_dir('')\n assert os.path.isdir(output_dir)\n assert os.path.isfile(os.path.join(output_dir, 'complex.nc'))\n assert os.path.isfile(os.path.join(output_dir, 'solvent.nc'))\n assert os.path.isfile(os.path.join(output_dir, 'experiments.yaml'))\n assert os.path.isfile(os.path.join(output_dir, 'experiments.log'))\n\n # Analysis script is correct\n analysis_script_path = os.path.join(output_dir, 'analysis.yaml')\n with open(analysis_script_path, 'r') as f:\n assert yaml.load(f, Loader=yaml.FullLoader) == [['complex', 1], ['solvent', -1]]","def readWrite_gpt2_1w(xdir, station, site_lat, site_lon):\n# this should use the environment variable\n outfile = xdir + '/input/' + station + '_refr.txt'\n if os.path.isfile(outfile):\n print('refraction file for this station already exists')\n else:\n print('refraction output file will be written to ', outfile)\n\n# change to radians\n dlat = site_lat*np.pi/180 \n dlon = site_lon*np.pi/180 \n\n# read VMF gridfile in pickle format \n pname = xdir + '/input/' + 'gpt_1wA.pickle'\n print('large refraction file is stored here:', pname)\n try:\n f = open(pname, 'rb')\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\n f.close()\n except:\n print('I did not find the large refraction file where it is supposed to be, but I will try looking in your home directory')\n try:\n pname = 'gpt_1wA.pickle'\n f = open(pname, 'rb')\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\n f.close()\n except:\n print('hmm, failed again. Go into gnssIR_lomb.py, set RefractionCorrection to false, and rerun the code.... ')\n sys.exit()\n\n# print(np.shape(All_pgrid))\n# really should e zero to four, but whatever\n indx = np.zeros(4,dtype=int)\n indx_lat = np.zeros(4,dtype=int)\n indx_lon = np.zeros(4,dtype=int)\n\n\n#figure out grid index\n# % only positive longitude in degrees\n if (dlon < 0):\n plon = (dlon + 2*np.pi)*180/np.pi;\n else:\n plon = dlon*180/np.pi \n#\n# transform to polar distance in degrees\n ppod = (-dlat + np.pi/2)*180/np.pi \n\n#% find the index (line in the grid file) of the nearest point\n# % changed for the 1 degree grid (GP)\n ipod = np.floor(ppod+1) \n ilon = np.floor(plon+1) \n \n# % normalized (to one) differences, can be positive or negative\n# % changed for the 1 degree grid (GP)\n diffpod = (ppod - (ipod - 0.5)) \n difflon = (plon - (ilon - 0.5)) \n# % added by HCY\n# % changed for the 1 degree grid (GP)\n if (ipod == 181):\n ipod = 180 \n if (ilon == 361):\n ilon = 1 \n if (ilon == 0):\n ilon = 360\n\n# get the number of the corresponding line\n#\t changed for the 1 degree grid (GP)\n indx[0] = (ipod - 1)*360 + ilon \n# save the lat lon of the grid points\n indx_lat[0] = 90-ipod+1 \n indx_lon[0] = ilon-1 \n# % near the poles: nearest neighbour interpolation, otherwise: bilinear\n# % with the 1 degree grid the limits are lower and upper (GP)\n\n bilinear = 0 \n max_ind = 1 \n if (ppod > 0.5) and (ppod < 179.5):\n bilinear = 1 \n if (bilinear == 1):\n max_ind =4 \n\n# % bilinear interpolation\n# % get the other indexes \n \n ipod1 = ipod + np.sign(diffpod) \n ilon1 = ilon + np.sign(difflon) \n# % changed for the 1 degree grid (GP)\n if (ilon1 == 361):\n ilon1 = 1 \n if (ilon1 == 0):\n ilon1 = 360 \n# get the number of the line\n# changed for the 1 degree grid (GP)\n# four indices ???\n indx[1] = (ipod1 - 1)*360 + ilon; # % along same longitude\n indx[2] = (ipod - 1)*360 + ilon1;# % along same polar distance\n indx[3] = (ipod1 - 1)*360 + ilon1;# % diagonal\n#\n# save the lat lon of the grid points lat between [-90 ;90] lon [0 360] \n indx_lat[1] = 90 - ipod1+np.sign(diffpod) \n indx_lon[1] = ilon-1 \n indx_lat[2] = 90-ipod +1\n indx_lon[2] = ilon1 - np.sign(difflon) \n indx_lat[3] = 90 -ipod1+np.sign(diffpod) \n indx_lon[3] = ilon1- np.sign(difflon);\n\n# extract the new grid\n# will need to do 0-4 instead of 1-5 because stored that way in python\n# which values to use in the bigger array\n# assign the correct values\n indx = indx - 1\n indx_list = indx.tolist()\n# print(indx_list)\n# print(indx)\n#print(np.shape(indx_lat))\n#print(np.shape(indx_lon))\n w = 0\n# need to write values for a given station to a plain text file\n#\n fout = open(outfile, 'w+')\n for a in indx_list:\n for k in [0,1,2,3,4]:\n fout.write(\" {0:4.0f} {1:5.0f} {2:13.4f} {3:10.4f} {4:10.6f} {5:10.4f} {6:12.5f} {7:12.5f} {8:10.6f} {9:10.6f} {10:10.6f} {11:10.4f} \\n\".format( indx_lat[w], indx_lon[w],All_pgrid[a,k],All_Tgrid[a,k],All_Qgrid[a,k]*1000,All_dTgrid[a,k]*1000,All_U[a,0],All_Hs[a,0], All_ahgrid[a,k]*1000, All_awgrid[a,k]*1000, All_lagrid[a,k], All_Tmgrid[a,k] ))\n\n w+=1\n fout.close()\n print('file written')","def _OpenOutputFiles(self):\n self.gfile = open(self.geomout, \"w\")\n self.efile = open(self.energyout, \"w\")\n self.PrintEnergyHeader()","def _make_files(self):\n if not self.path.is_dir():\n raise FileNotFoundError(f\"Path {self.path} does not exist.\")\n\n # Make the filepaths\n self.file_points = self.path / \"point.dat\"\n self.file_lines = self.path / \"line.dat\"\n self.file_cadastre = self.path / \"cadastre.dat\"\n self.file_portals = self.path / \"portals.dat\"\n\n with open(self.file_points, \"w\") as f:\n # 2 lines ignored\n header = datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n f.write(header)\n self.points_dfs = []\n with open(self.file_lines, \"w\") as f:\n # 5 lines ignored\n header = (\n datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n + 3 * \"Generated: \\n\"\n + \"Name,Section,source_group,x1,y1,z1,x2,y2,z2,width,vert. ext.,-,-,\"\n \"emission_rate[kg/h/km],-,-,-,-\\n\"\n )\n f.write(header)\n with open(self.file_cadastre, \"w\") as f:\n # 1 line ignored\n header = \"x,y,z,dx,dy,dz,emission_rate[kg/h],-,-,-,source_group\\n\"\n f.write(header)\n with open(self.file_portals, \"w\") as f:\n # 2 lines ignored\n header = (\n datetime.datetime.now().strftime(\"Generated: %d/%m/%Y %H:%M\\n\")\n + \"x1,y1,x2,y2,z0,z1,emission_rate[kg/h],-,-,-,source_group\\n\"\n )\n f.write(header)\n\n\n # File to save the source groups values\n self.file_source_groups = self.path / \"source_groups.json\"\n with open(self.file_source_groups, \"w\") as f:\n # reverse the dict (items become keys and vice versa)\n reversed_source_groups = {v: k for k, v in self.source_groups.items()}\n json.dump(reversed_source_groups, f, indent=2)","def read_from_ses3d_block(directory):\n\n # Initialise arrays of Cartesian coordinates.\n\n x=[]\n y=[]\n z=[]\n\n # Read yaml file containing information on the ses3d submodel.\n with io.open(os.path.join(directory,'modelinfo.yml'), 'rt') as fh:\n model_info = yaml.load(fh)\n\n rot_vec = np.array([model_info['geometry']['rot_x'], model_info['geometry']['rot_y'], model_info['geometry']['rot_z']])\n rot_angle = model_info['geometry']['rot_angle']\n\n # Read block files.\n\n fid_x = open(os.path.join(directory,'block_x'), 'r')\n fid_y = open(os.path.join(directory,'block_y'), 'r')\n fid_z = open(os.path.join(directory,'block_z'), 'r')\n\n dx = np.array(fid_x.read().strip().split('\\n'), dtype=float)\n dy = np.array(fid_y.read().strip().split('\\n'), dtype=float)\n dz = np.array(fid_z.read().strip().split('\\n'), dtype=float)\n\n fid_x.close()\n fid_y.close()\n fid_z.close()\n\n # Setup of coordinate lines.\n\n nsubvol = int(dx[0])\n\n idx = np.ones(nsubvol, dtype=int)\n idy = np.ones(nsubvol, dtype=int)\n idz = np.ones(nsubvol, dtype=int)\n\n for k in np.arange(1, nsubvol, dtype=int):\n idx[k] = int(dx[idx[k - 1]]) + idx[k - 1] + 1\n idy[k] = int(dy[idy[k - 1]]) + idy[k - 1] + 1\n idz[k] = int(dz[idz[k - 1]]) + idz[k - 1] + 1\n\n for k in np.arange(nsubvol, dtype=int):\n\n # Coordinates of the box corners.\n colat = dx[(idx[k] + 1):(idx[k] + 1 + int(dx[idx[k]]))]\n lon = dy[(idy[k] + 1):(idy[k] + 1 + int(dy[idy[k]]))]\n rad = dz[(idz[k] + 1):(idz[k] + 1 + int(dz[idz[k]]))]\n \n # Coordinates of the box centroids.\n colat_c = (np.array(colat[0:-1])+np.array(colat[1:]))/2.0\n lon_c = (np.array(lon[0:-1]) + np.array(lon[1:]))/2.0\n rad_c = (np.array(rad[0:-1]) + np.array(rad[1:]))/2.0\n \n # Compute Cartesian coordinates for all grid points.\n for c in colat_c:\n for l in lon_c:\n xx=np.cos(l*np.pi/180.0)*np.sin(c*np.pi/180.0)\n yy=np.sin(l*np.pi/180.0)*np.sin(c*np.pi/180.0)\n zz=np.cos(c*np.pi/180.0)\n for r in rad_c:\n x.append(r*xx)\n y.append(r*yy)\n z.append(r*zz)\n \n\n # Rotate, if needed.\n\n if (rot_angle!=0.0):\n rot_mat = get_rot_matrix(rot_angle*np.pi/180.0, *rot_vec)\n x, y, z = rotate(x, y, z, rot_mat)\n\n # Return.\n\n return x, y, z","def read_positions():\n return np.genfromtxt(\"POSITIONS.OUT\").transpose()","def test_to_single_xyz(self):\n\n # load a molecule with a single conformation\n toluene = Molecule.from_file(get_data_file_path(\"molecules/toluene.sdf\"), \"sdf\")\n # make sure it has one conformer\n assert toluene.n_conformers == 1\n\n with NamedTemporaryFile(suffix=\".xyz\") as iofile:\n # try and write out the xyz file\n toluene.to_file(iofile.name, \"xyz\")\n\n # now lets check the file contents\n with open(iofile.name) as xyz_data:\n data = xyz_data.readlines()\n # make sure we have the correct amount of lines writen\n assert len(data) == 17\n # make sure all headers and frame data was writen\n assert data.count(\"15\\n\") == 1\n assert data.count(\"C7H8\\n\") == 1\n # now check that we can find the first and last coords\n coords = [\n \"C 0.0000000000 0.0000000000 0.0000000000\\n\",\n \"H -0.0000000000 3.7604000568 0.0000000000\\n\",\n ]\n for coord in coords:\n assert coord in data","def main():\n data_visualisation()\n write_hyper_params()\n write_result_tables()\n write_box_plots()","def _read_xyz(ds,datafile,long_format=False):\n\n from cheml.io.xyz import get_molecules\n\n ds.list_of_mol = get_molecules(datafile,ds.nmol,long_format)\n ds.nmol = len(ds.list_of_mol)","def _check_xyz_output(self, cwd):\n\n for ii, refname in enumerate(self.files):\n if self.forms[ii] == \"xyz\":\n ref_structs = []\n try:\n with open(Path(cwd) / refname) as ref:\n ref_natoms = int(ref.readline())\n for s, ll in enumerate(ref.readlines()):\n if (s + 1) % (ref_natoms + 2) != 0 and (s + 1) % (\n ref_natoms + 2\n ) != 1:\n ref_structs.append(ll.split()[1:])\n reff = [[float(v) for v in r] for r in ref_structs]\n ref_xyz = np.array(reff)\n except IOError:\n raise IOError(\n \"Please provide a reference file named {} in {}\".format(\n refname, str((self.parent / cwd).absolute())\n )\n )\n\n except ValueError:\n raise ValueError(\n \"Please check the values for the file named {} in {}\".format(\n refname, str((self.parent / cwd).absolute())\n )\n )\n\n fname = refname[4:]\n structs = []\n with open(self.tmp_dir / fname) as f:\n natoms = int(f.readline())\n for s, ll in enumerate(f.readlines()):\n if (s + 1) % (natoms + 2) != 0 and (s + 1) % (natoms + 2) != 1:\n structs.append(ll.split()[1:])\n testt = [[float(v) for v in r] for r in structs]\n test_xyz = np.array(testt)\n\n try:\n np.testing.assert_allclose(\n test_xyz, ref_xyz, rtol=1.0e-7, atol=1.0e-8\n )\n # print(\"No anomaly during the regtest for {}\".format(refname))\n except AssertionError:\n raise AssertionError(\n \"ANOMALY: {} in {}\".format(\n fname,\n str((self.parent / cwd).absolute()).split(\"ipi_tests/\", 1)[\n 1\n ],\n )\n )","def readViewerOutputFile(lines, debug=False):\n x = []; y = []\n pixel = ''\n xunits = 'unknown'\n intensityUnits = 'unknown'\n for line in lines:\n if (line[0] == '#'): \n if (line.find('pixel') > 0):\n pixel = line.split('[[')[1].split(']]')[0]\n elif (line.find('xLabel') > 0):\n xunits = line.split()[-1]\n if (debug):\n print \"Read xunits = \", xunits\n elif (line.find('yLabel') > 0):\n tokens = line.split()\n if (len(tokens) == 2):\n intensityUnits = tokens[1]\n else:\n intensityUnits = tokens[1] + ' (' + tokens[2] + ')'\n continue\n tokens = line.split()\n if (len(tokens) < 2): \n continue\n x.append(float(tokens[0]))\n y.append(float(tokens[1]))\n return(np.array(x), np.array(y), xunits, intensityUnits)","def loadNodes(self, fname):\r\n with open(fname, \"r\") as fp:\r\n\r\n # Read in the header\r\n for line in fp:\r\n item = line.split()\r\n if len(item) > 0:\r\n if item[0] == \"SPECGRID\":\r\n self.SPECGRID = np.array(fp.readline().split()[0:3], dtype=int)\r\n if item[0] == \"COORDSYS\":\r\n self.COORDSYS = fp.readline().split()\r\n if item[0] == \"COORD\":\r\n break\r\n\r\n # Read in the coordinates\r\n self.coords = []\r\n for line in fp:\r\n if line.split()[-1] != \"/\":\r\n item = line.split()\r\n for c in item:\r\n if '*' in c:\r\n cc = c.split('*')\r\n for i in range(int(cc[0])):\r\n self.coords.append(cc[-1])\r\n else:\r\n self.coords.append(c)\r\n else:\r\n if len(line.split()) > 1:\r\n item = line.split()\r\n for i in range(len(item) - 1):\r\n cc = item[i]\r\n if '*' in cc:\r\n ccc = cc.split('*')\r\n for j in range(int(ccc[0])):\r\n self.coords.append(ccc[-1])\r\n else:\r\n self.coords.append(c)\r\n break\r\n else:\r\n break\r\n\r\n # Read in ZCORN\r\n self.zcorn = []\r\n i = 0\r\n for line in fp:\r\n item = line.split()\r\n if len(item) > 0:\r\n if item[0] == \"ZCORN\":\r\n for line in fp:\r\n if line.split():\r\n if line.split()[-1] != \"/\":\r\n self.zcorn += line.split()\r\n else:\r\n self.zcorn += line.split()[0:-1]\r\n break\r\n if len(self.zcorn) > 0:\r\n break\r\n\r\n # Read in (in)active cells\r\n self.active = []\r\n for line in fp:\r\n item = line.split()\r\n if len(item) > 0:\r\n if item[0] == \"ACTNUM\":\r\n for line in fp:\r\n if line.split():\r\n if line.split()[-1] != \"/\":\r\n c = line.split()\r\n if '*' in c:\r\n cc = c.split('*')\r\n for i in range(float(cc[0])):\r\n self.active += cc[-1]\r\n else:\r\n self.active += c\r\n else:\r\n self.active += line.split()[0:-1]\r\n break\r\n\r\n self.coords = np.array(self.coords, dtype=float)\r\n print(self.coords)\r\n\r\n # In Petrel...\r\n self.ne = self.SPECGRID[0] # x i\r\n self.nn = self.SPECGRID[1] # y j\r\n self.nz = self.SPECGRID[2] # z k\r\n\r\n # build grid\r\n self.buildGrid(plot=False)\r\n self.buildActiveCells(plot=False)\r\n self.buildZGrid(plot=False)\r\n # self.calculateVolumes(plot=False)\r\n #\r\n # Convert to VTK\r\n self.GridType = \"vtkStructuredGrid\"\r\n self.Grid = vtk.vtkStructuredGrid()\r\n self.Grid.SetDimensions(self.ne+1, self.nn+1, self.nz+1)\r\n vtk_points = vtk.vtkPoints()\r\n ve = 1.\r\n\r\n for iz in range(self.nz):\r\n if iz == 0:\r\n for iy in range(self.nn+1):\r\n for ix in range(self.ne+1):\r\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\r\n self.Y0[ix,iy], \\\r\n ve * self.ZZT[iz][ix,iy] )\r\n for iy in range(self.nn+1):\r\n for ix in range(self.ne+1):\r\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\r\n self.Y0[ix,iy], \\\r\n ve * self.ZZB[iz][ix,iy] )\r\n self.Grid.SetPoints(vtk_points)\r\n\r\n # Add in active cells\r\n ac = vtk.vtkIntArray()\r\n ac.SetName( \"ActiveCells\" )\r\n for iac in self.ActiveCells.flatten( order='F' ):\r\n ac.InsertNextTuple1( iac )\r\n self.Grid.GetCellData().AddArray(ac)","def plot_skeleton(project_dir, part):\n scene_fpath = os.path.join(project_dir, 'scene_sba.json')\n print(scene_fpath)\n K_arr, D_arr, R_arr, t_arr, _ = utils.load_scene(scene_fpath)\n D_arr = D_arr.reshape((-1,4))\n\n print(f\"\\n\\n\\nLoading data\")\n df_paths = sorted(glob.glob(os.path.join(project_dir, '*.h5')))\n #print(df_paths)\n\n points_2d_df = utils.create_dlc_points_2d_file(df_paths)\n triangulate_func = calib.triangulate_points_fisheye\n points_2d_filtered_df = points_2d_df[points_2d_df['likelihood']>0.5]\n points_3d_df = calib.get_pairwise_3d_points_from_df(points_2d_filtered_df, K_arr, D_arr, R_arr, t_arr, triangulate_func)\n\n # estimate initial points\n nose_pts = points_3d_df[points_3d_df[\"marker\"]==part][[\"x\", \"y\", \"z\", \"frame\"]].values\n x_slope, x_intercept, *_ = stats.linregress(nose_pts[:,3], nose_pts[:,0])\n y_slope, y_intercept, *_ = stats.linregress(nose_pts[:,3], nose_pts[:,1])\n z_slope, z_intercept, *_ = stats.linregress(nose_pts[:,3], nose_pts[:,2])\n frame_est = np.arange(100)\n x_est = frame_est*x_slope + x_intercept\n y_est = frame_est*y_slope + y_intercept\n z_est = frame_est*z_slope + z_intercept\n psi_est = np.arctan2(y_slope, x_slope)\n \n #print(points_2d_df)\n #print(points_2d_df[points_2d_df['frame']==160])\n #return([nose_pts[:,0], nose_pts[:,1], nose_pts[:,2]])\n return(x_est, y_est, z_est)","def run_plots(self):\n # load the files\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\n\n # plots\n self.plot_jump_flags_image()\n self.plot_groupdq_flags(pixel=[884, 550])\n self.plot_ramps_pre_post_correction(pixel=[884, 550])","def __init__(self, fname):\n f = zopen(fname, \"rt\")\n\n # skip header lines\n for i in range(2):\n f.readline()\n\n # number of atoms included in the file followed by the position of the origin of the volumetric data\n line = f.readline().split()\n self.natoms = int(line[0])\n self.origin = np.array(np.array(list(map(float, line[1:]))))\n\n # The next three lines give the number of voxels along each axis (x, y, z) followed by the axis vector.\n line = f.readline().split()\n self.NX = int(line[0])\n self.X = np.array([bohr_to_angstrom * float(l) for l in line[1:]])\n\n line = f.readline().split()\n self.NY = int(line[0])\n self.Y = np.array([bohr_to_angstrom * float(l) for l in line[1:]])\n\n line = f.readline().split()\n self.NZ = int(line[0])\n self.Z = np.array([bohr_to_angstrom * float(l) for l in line[1:]])\n\n self.voxelVolume = abs(np.dot(np.cross(self.X, self.Y), self.Z))\n self.volume = abs(np.dot(np.cross(self.X.dot(self.NZ), self.Y.dot(self.NY)), self.Z.dot(self.NZ)))\n\n # The last section in the header is one line for each atom consisting of 5 numbers,\n # the first is the atom number, second is charge, the last three are the x,y,z coordinates of the atom center.\n self.sites = []\n for i in range(self.natoms):\n line = f.readline().split()\n self.sites.append(Site(line[0], np.multiply(bohr_to_angstrom, list(map(float, line[2:])))))\n\n self.structure = Structure(\n lattice=[self.X * self.NX, self.Y * self.NY, self.Z * self.NZ],\n species=[s.specie for s in self.sites],\n coords=[s.coords for s in self.sites],\n coords_are_cartesian=True,\n )\n\n # Volumetric data\n self.data = np.zeros((self.NX, self.NY, self.NZ))\n i = 0\n for s in f:\n for v in s.split():\n self.data[\n int(i / (self.NY * self.NZ)),\n int((i / self.NZ) % self.NY),\n int(i % self.NZ),\n ] = float(v)\n i += 1","def read_data(infiles, variable, time_constraint):\n\n cube = iris.load(infiles, gio.check_iris_var(variable), callback=save_history)\n equalise_attributes(cube)\n iris.util.unify_time_units(cube)\n cube = cube.concatenate_cube()\n cube = gio.check_time_units(cube)\n\n cube = cube.extract(time_constraint)\n\n if not 'J' in str(cube.units):\n cube = convert_to_joules(cube) \n\n if variable == 'surface_downward_heat_flux_in_sea_water':\n agg_method = 'sum'\n elif variable == 'ocean_heat_content':\n agg_method = 'mean'\n cube = timeseries.convert_to_annual(cube, aggregation=agg_method) \n \n coord_names = [coord.name() for coord in cube.dim_coords]\n aux_coord_names = [coord.name() for coord in cube.aux_coords]\n assert 'time' in coord_names\n assert len(coord_names) == 3\n grid_type = 'curvilinear' if aux_coord_names == ['latitude', 'longitude'] else 'latlon'\n\n return cube, coord_names, aux_coord_names, grid_type","def read_mesa(self, filename=None):\n\n if filename is None:\n filename = self.model_file\n\n with open(filename, 'r') as f:\n # count number of lines\n npts_file = sum([1 for line in f])\n\n # go back to start and read first line in file to get number of parameters\n f.seek(0)\n l = f.readline()\n nparams_file = int(l.split(' ')[-1])\n\n # skip lines 2-4\n for i in range(3):\n f.readline()\n\n # the fifth line will give us the number of variables\n l = f.readline()\n nvars_file = int(l.split(' ')[-1])\n\n # subtract header rows\n npts_file -= 6\n\n print(f'{nvars_file} variables found in the initial model file')\n print(f'{npts_file} points found in the initial model file')\n\n var_idx_map = {}\n logR_idx = -1\n\n # read in the names of the variables\n for i in range(nvars_file):\n var_name_file = f.readline().strip()\n if var_name_file.lower() == 'n':\n var_name_file = 'neut'\n elif var_name_file == 'p':\n var_name_file = 'prot'\n\n if var_name_file == 'logR':\n logR_idx = i\n continue\n\n # create map of file indices to model indices\n try:\n var_idx_map[self.idx[var_name_file]] = i\n except KeyError:\n var_idx_map[self.idx['spec'] - 1 + network_module.network_species_index(var_name_file.lower())] = i\n\n base_r = np.zeros(npts_file)\n base_state = np.zeros((npts_file, self.nvar))\n\n # read in model data\n for i, line in enumerate(f):\n variables = [float(v) for v in line.split(' ')]\n\n # need to reverse the inputs file here\n\n n = npts_file - i - 1\n\n base_r[n] = R_solar * 10**variables[logR_idx]\n\n for j in range(self.nvar):\n if j in var_idx_map:\n base_state[n, j] = variables[var_idx_map[j]]\n\n return npts_file, base_r, base_state","def beforeLoop(self):\n\t\tself.loadInputFiles()\n\t\tself.loadOutputFile()\n\t\tself.addHistogram1D(\"True_Enu\", \"True Neutrino Energy [GeV]\", 100, 0.0, 10.0)#Histogram of neutrino energy\n\t\tself.addHistogram1D(\"True_Enu_Delta\", \"True Neutrino Energy from Delta producing events [GeV]\", 100, 0.0, 10.0)#Histogram of neutrino energy from Delta producing events\n\t\tself.addHistogram1D(\"Interaction_Mode_Delta\", \"NEUT interaction codes of Delta producing events\", 53, 0, 53)#Histogram of interaction modes of Delta producing events\n\t\tself.addHistogram2D(\"Vertex_Location_XY\", \"Location of interaction vertices in the X-Y plane of the detector\",100,-3000,3000,100,-3000,3000)#Histogram of vertex location in XY plane\n\t\tself.addHistogram2D(\"Vertex_Location_YZ\", \"Location of interaction vertices in the Y-Z plane of the detector\",100,-3000,3000,100,-3000,3000)#Histogram of vertex location in YZ plane\n\t\tself.addHistogram1D(\"True_Enu_Delta_inFGD\", \"Neutrino energies of FGD Delta producing events (GeV)\",100,0,10)#Histogram of neutrino energy of Deltas produced in the FGD\n\t\tself.addHistogram1D(\"Delta_Momentum\", \"Momentum of Delta baryons (GeV/c)\",100,0,5)#Histogram of neutrino energy of Deltas produced in the FGD\n\t\tself.addHistogram1D(\"Proton_Momentum\", \"Momentum of Protons from Delta decays (GeV/c)\",100,0,4)#Histogram of proton momentum from Delta decays\n\t\tself.addHistogram1D(\"Pion_Momentum\", \"Momentum of Pions from Delta decays (GeV/c)\",100,0,4)#Histogram of pion momentum from Delta decays","def test_fake_file_xmm(self):\n fits_file = os.path.join(self.datadir, 'monol_test_fake_lc_xmm.evt')\n hen.fake.main(['--deadtime', '1e-4', '-m', 'XMM', '-i', 'epn',\n '--ctrate', '2000',\n '-o', fits_file])\n hdu_list = fits.open(fits_file)\n hdunames = [hdu.name for hdu in hdu_list]\n assert 'STDGTI01' in hdunames\n assert 'STDGTI02' in hdunames\n assert 'STDGTI07' in hdunames","def read_DEM(fn=None, fjord=None):\n # intake.open_rasterio accepts a list of input files and may effectively do what this function does!\n # try using cropped versions of the input files. Doesn't seem to make a difference r.e. crashing\n '''\n cropped_fn = fn.rpartition(\".tif\")[0] + \"_cropped.tif\"\n print(cropped_fn)\n if os._exists(cropped_fn):\n fn = cropped_fn\n elif fjord != None:\n bbox = fjord_props.get_fjord_bounds(fjord)\n ds = rioxarray.open_rasterio(fn)\n trimmed_ds = ds.rio.slice_xy(*bbox)\n trimmed_ds.rio.to_raster(fn.rpartition(\".tif\")[0] + \"_cropped.tif\")\n del ds\n del trimmed_ds\n fn = cropped_fn \n '''\n\n # try bringing in the rasters as virtual rasters (i.e. lazily loading)\n with rasterio.open(fn) as src:\n # print('Source CRS:' +str(src.crs))\n # print(src.is_tiled)\n # print(src.block_shapes)\n with WarpedVRT(src,src_crs=src.crs,crs=src.crs) as vrt:\n # warp_mem_limit=12000,warp_extras={'NUM_THREADS':2}) as vrt:\n # print('Destination CRS:' +str(vrt.crs))\n darr = xr.open_rasterio(vrt)\n # ds = rioxarray.open_rasterio(vrt).chunk({'x':1500,'y':1500,'band':1}).to_dataset(name='HLS_Red')\n\n\n # Rasterio automatically checks that the file exists\n # ultimately switch to using rioxarray, but it causes issues down the pipeline so it will need to be debugged through\n # with rioxarray.open_rasterio(fn) as src:\n # with xr.open_rasterio(fn) as darr:\n # darr = src\n\n # open_rasterio automatically brings the geotiff in as a DataArray with 'band' as a dimensional coordinate\n # we rename it and remove the band as a coordinate, since our DEM only has one dimension\n # squeeze removes dimensions of length 0 or 1, in this case our 'band'\n # Then, drop('band') actually removes the 'band' dimension from the Dataset\n darr = darr.rename('elevation').squeeze().drop_vars('band')\n # darr = darr.rename({'band':'dtime'})\n \n # if we wanted to instead convert it to a dataset\n # attr = darr.attrs\n # darr = darr.to_dataset(name='elevation').squeeze().drop('band')\n # darr.attrs = attr\n # attr=None\n # newest version of xarray (0.16) has promote_attrs=True kwarg. Earlier versions don't...\n # darr = darr.to_dataset(name='elevation', promote_attrs=True).squeeze().drop('band')\n\n # mask out the nodata values, since the nodatavals attribute is wrong\n darr = darr.where(darr != -9999.)\n\n # the gdalwarp geoid files have this extra attribute in the geoTiff, which when brought in\n # ultimately causes a \"__module__\" related error when trying to plot with hvplot\n try:\n del darr.attrs[\"units\"] \n except KeyError:\n pass\n\n if fjord != None:\n # USE RIOXARRAY - specifically, slicexy() which can be fed the bounding box\n # darr = darr.rio.slice_xy(fjord_props.get_fjord_bounds(fjord))\n bbox = fjord_props.get_fjord_bounds(fjord)\n if pd.Series(darr.y).is_monotonic_increasing:\n darr = darr.sel(x=slice(bbox[0], bbox[2]), y=slice(bbox[1], bbox[3]))\n else:\n darr = darr.sel(x=slice(bbox[0], bbox[2]), y=slice(bbox[3], bbox[1]))\n \n return darr","def t12_loadSMFile(self):\n print \"spectrumFile\"\n filename = tkFileDialog.askopenfilename()\n filename = \"data/\" + self.filenameparser(filename)\n orgin_file = self.filenameparser(filename)\n self.t12_smfilename = filename\n self.t12_orginfilename = orgin_file","def sim12_r_simulation(datafiles, simulation_mag_zeropoint, simulation_exposure):\n return stuff.Simulation(datafiles / 'sim12' / 'sim12_r.list', simulation_mag_zeropoint, simulation_exposure)","def main(filename: str) -> None:\n # Template from HtDAP, based on composition \n return scatterplot(read(filename))","def read_sim_info(folder, filen):\n \n ### file path\n \n fpath = folder + filen + '.h5'\n assert os.path.exists(fpath), \"The out.h5 file does NOT exist for \" + fpath\n fl = h5py.File(fpath, 'r') \n \n ### simulation information\n \n lx = fl['/info/box/x'][...]\n ly = fl['/info/box/y'][...]\n dt = fl['/info/dt'][...]\n nsteps = fl['/info/nsteps'][...]\n nfils = fl['/info/nfils'][...]\n nbeads = fl['/info/nbeads'][...]\n nsamp = fl['/info/nsamp'][...]\n nbpf = fl['/info/nbpf'][...]\n \n ### simulation parameters\n \n density = fl['/param/density'][...]\n kappa = fl['/param/kappa'][...]\n km = fl['/param/km'][...]\n pa = fl['/param/pa'][...]\n pp = fl['/param/pp'][...]\n bl = fl['/param/bl'][...]\n sigma = fl['/param/sigma'][...]\n \n fl.close()\n \n ### generate classes to submerge data\n \n sim = misc_tools.Simulation(lx, ly, dt, nsteps, nfils, nbeads, nsamp, nbpf, \\\n density, kappa, km, pa, pp, bl, sigma)\n \n return sim","def read_sim_info_arvind_format(folder, filen):\n \n ### file path\n \n fpath = folder + filen + '.h5'\n assert os.path.exists(fpath), \"The out.h5 file does NOT exist for \" + fpath\n fl = h5py.File(fpath, 'r') \n \n ### simulation information\n \n lx = fl['/info/box/x'][...]\n ly = fl['/info/box/y'][...]\n dt = fl['/info/dt'][...]\n nsteps = fl['/info/nsteps'][...]\n nfils = fl['/info/nfils'][...]\n nbeads = fl['/info/nbeads'][...]\n nsamp = fl['/info/nsamp'][...]\n nbpf = fl['/info/nbpf'][...]\n \n ### simulation parameters\n \n density = fl['/param/density'][...]\n kappa = fl['/param/kappa'][...]\n km = fl['/param/km'][...]\n pa = fl['/param/pa'][...]\n pp = fl['/param/pp'][...]\n bl = fl['/param/bl'][...]\n sigma = fl['/param/sigma'][...]\n \n fl.close()\n \n ### generate classes to submerge data\n \n sim = misc_tools.Simulation(lx, ly, dt, nsteps, nfils, nbeads, nsamp, nbpf, \\\n density, kappa, km, pa, pp, bl, sigma)\n \n return sim","def readOutputfile(filename, verbose=False):\n\n # -----------------------------------------------------------------------------\n # Defining the classes for data structure\n T_Simulation = namedtuple('Simulation', ['step'])\n T_Step = namedtuple('Step', ['element', 'node'])\n\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\n\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\n T_GP = namedtuple('GP', ['stress', 'strain'])\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\n # -----------------------------------------------------------------------------\n\n nSteps = 0 # Simulation step counter\n\n SimData = T_Simulation(list())\n\n with open(filename) as f:\n line = f.readline() # Read in the first line of the input file\n while True: # Loop over all lines of the input file\n # Read the nodes displacements\n #line = f.readline()\n #print(line)\n if line == 'DofManager output:\\n': # String starts a list of nodes displacement information\n nSteps += 1 # The above string starts a new simulation step\n line = f.readline() # Cancel ---------- seperator\n line = f.readline()\n Nodes = list() # Initialize/clear list of nodes\n\n while line != '\\n' and line != 'Element output:\\n': # Strings that finish the list\n #\t\t\t\tnNode = int(line.strip().split()[1]) # Node id\n line = f.readline()\n dim1 = float(line.strip().split()[3]) # Displacement dim1\n line = f.readline()\n dim2 = float(line.strip().split()[3]) # Displacement dim2\n Nodes.append(\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\n line = f.readline()\n\n\n if verbose:\n print('Step {}: Dofs completed.\\n'.format(nSteps))\n print('---------------------------------\\n')\n\n # Read the stresses an strains at Gauss points\n elif line == 'Element output:\\n': # String starts a list elements, GPs, strains and stresses\n line = f.readline() # Cancel ---------- seperator\n line = f.readline()\n Elements = list() # Initialize/clear list of elements\n\n while line != '\\n' and line != '\\tR E A C T I O N S O U T P U T:\\n': # Strings that finish the list\n #\t\t\t\t\tnElement = line.strip().split()[2] # Element id\n line = f.readline()\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\n\n while line != '\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\n #\t\t\t\t\t\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\n line = f.readline()\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\n GPs.gp.append(\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\n line = f.readline()\n\n\n Elements.append(GPs) # Append GP list of the current element to the element list\n\n if verbose:\n print('Step {}: GPs completed.\\n'.format(nSteps))\n print('---------------------------------\\n')\n\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\n #print('the file input ends')\n #print(nSteps)\n # only needed with a while loop\n # Jump over the lines until we reach the next time step (Caught by if-clause)\n try:\n line = f.readline() # Will generate an error if files end is reached\n if line == \"\":\n raise EOFError\n except:\n if verbose: print(\"End of file reached.\\n\")\n break # Break the 'while True' loop\n\n # -----------------------------------------------------------------------------\n\n\n print('averaging the stress')\n # Averaging of strains and stress of GPs of each element\n for istep in range(len(SimData.step)):\n\n for ielement in range(len(SimData.step[istep].element)):\n print(len)\n # Initialization before each element\n stresses = np.array([0., 0., 0., 0., 0., 0.])\n strains = np.array([0., 0., 0., 0., 0., 0.])\n\n for igp in range(len(SimData.step[istep].element[ielement])):\n print(igp)\n # Add up all data of all GPs\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\n\n # Divide GP sum by number of GPs\n stresses /= len(SimData.step[istep].element[ielement])\n strains /= len(SimData.step[istep].element[ielement])\n # Replace the field (initialized with 0) with new information\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\n print('Analysis finished')\n return SimData","def read_input():\n \n argv = sys.argv\n\n # Read file names from sd input\n f_dy = argv[1] # matdyn.modes\n f_pat = argv[2] # path.out (should be in crystal coords)\n f_ph = argv[3] # ph.x output (Gamma point)\n\n # Read input card\n f_inp = open(\"input.dat\",'r')\n l1 = f_inp.readline()\n l2 = f_inp.readline()\n l3 = f_inp.readline().split()\n f_inp.close()\n\n # Open files\n\n f = open(f_dy,'r') # matdyn.modes \n f_dyn = f.readlines()\n f.close()\n\n f = open(f_pat,'r') # path.out\n f_path = f.readlines()\n f.close()\n\n f = open(f_ph,'r') # ph.x output\n f_zs = f.readlines()\n f.close()\n\n # Assign values to a0, nat, M, nqp\n a0, vol = float(l1.split()[0]), float(l1.split()[1])\n nat = int(l2) \n mass = np.zeros(nat)\n for iat in range(nat):\n mass[iat] = float(l3[iat])\n\n # Assign values to G (reciprocal lattice vec)\n ig = 0 ; i = 0\n for line in f_zs:\n if \"reciprocal axes:\" in line:\n ig = i + 1 \n break\n i += 1 \n\n rG = np.zeros((3,3))\n for ic in range(3):\n rGtext = f_zs[ig+ic][23:48].split()\n rG[ic,:] = np.array([float(rGtext[0]), float(rGtext[1]), float(rGtext[2])])\n\n # Read Z* tensor from f_zs\n i = 0\n iz = 0\n zstart = []\n for line in f_zs:\n if \"(d P / du)\" in line:\n iz = i + 3\n if \"Px\" in line:\n zstart.append(i)\n\n i += 1\n\n # Read the dielectric tensor from f_zs\n i = 0\n ie = 0\n for line in f_zs:\n if \"Dielectric constant in cartesian axis\" in line:\n ie = i + 2\n break\n\n i += 1\n\n # Assign Z* values\n zs = np.zeros((nat,3,3)) # initialize Z*\n\n for iat in range(nat):\n for ic in range(3):\n ztext = f_zs[zstart[iat]+ic][19:56].split()\n for jc in range(3):\n zs[iat][ic][jc] = float(ztext[jc])\n\n # Assing the dielectric tensor\n eps = np.zeros((3,3))\n\n for ic in range(3):\n epstext = f_zs[ie+ic][16:66].split()\n for jc in range(3):\n eps[ic][jc] = float(epstext[jc])\n\n # Number of modes and q-points\n nmodes = 3 * nat\n nqpt = int(f_path[0].split()[0])\n\n # Read the q-points\n q = np.zeros((nqpt,4)) # 4th dimension is lenght for q-points on a line, weights for q-points on a grid \n for iq in range(1,nqpt+1):\n q[iq-1,] = np.array([float(f_path[iq].split()[0]),float(f_path[iq].split()[1]), \\\n float(f_path[iq].split()[2]),float(f_path[iq].split()[3])])\n\n # Read the eigenvalues(om) and eigenvectors(eig) \n # Initiate first\n om = np.zeros((nmodes,nqpt))\n eig = np.zeros((nmodes,nqpt,nat,3), dtype=complex) \n\n # Get the starting lines for each q-pt\n i = 0\n i_q = []\n for line in f_dyn:\n if \"q =\" in line:\n i_q.append(i+2)\n i += 1\n\n #Assign values to om and eig\n for iq in range(nqpt):\n for imod in range(nmodes):\n omtext = f_dyn[i_q[iq]+imod*(nat+1)][43:55]\n om[imod][iq] = float(omtext)\n for iat in range(nat):\n etext = f_dyn[i_q[iq]+imod*(nat+1)+iat+1][2:72].split()\n for ic in range(3):\n eig.real[imod][iq][iat][ic]=float(etext[2*ic])*np.sqrt(mass[iat])\n eig.imag[imod][iq][iat][ic]=float(etext[2*ic+1])*np.sqrt(mass[iat])\n\n #Normalize the eigenvectors\n t1 = eig[imod,iq,:,:]\n t_nu = np.sum(np.sum(np.conjugate(t1)*t1,axis=0))\n eig[imod,iq,:,:] = eig[imod,iq,:,:]/np.sqrt(np.abs(t_nu))\n\n # Check normalization\n delta = np.zeros((nmodes,nmodes), dtype=complex)\n for iat in range(nat):\n for ic in range(3):\n t2 = eig[:,iq,iat,ic]\n delta += np.outer(np.conjugate(t2),t2)\n\n unit = np.diag(np.diag(np.ones((nmodes,nmodes)))) # Unit vector\n test = np.abs( (delta-unit) )\n if ( np.max(test) > 1e-3):\n print \"Non-orthonormal eigenvector at iq=\", q[iq,:]\n\n return om, eig, q, zs, eps, mass, a0, vol, rG, nmodes, nqpt, nat","def t9_loadSMFile(self):\n print \"spectrumFile\"\n filename = tkFileDialog.askopenfilename()\n filename = \"data/\" + self.filenameparser(filename)\n orgin_file = self.filenameparser(filename).split('.')[0]\n self.t9_smfilename = filename\n self.t9_orginfilename = orgin_file","def print_geometries(self, name) -> None:\n\n open(f\"{name}.xyz\", \"w\").close() # Empty the file\n\n for i, image in enumerate(self):\n energy = image.energy if image.energy is not None else \"none\"\n\n title_line = (\n f\"autodE path point {i}. E = {energy} \"\n f\"charge = {image.charge} \"\n f\"mult = {image.mult} \"\n )\n\n if image.solvent is not None:\n title_line += f\"solvent = {image.solvent.name} \"\n\n atoms_to_xyz_file(\n image.atoms,\n f\"{name}.xyz\",\n title_line=title_line,\n append=True,\n )\n return None","def read_data(self):\n data = np.genfromtxt(self.__file) # Planck SED\n self.__nu = 10.0**data[:,0]\n self.__nuF = 10.0**data[:,2]\n self.__err = 10.0**data[:,3]\n #self.__W = 10.0**data[:,4]\n self.__yerr = [ self.__nuF - self.__nuF / self.__err, \\\n self.__nuF * self.__err - self.__nuF ]\n self.__maxY = max( self.__nuF )\n self.__minY = min( self.__nuF )","def load(self):\n from time import time\n from subprocess import Popen\n logger_name = thisfile + '->EXR:load()'\n assert self.exr_f is not None, \"Set the exr_f first\"\n npz_f = '/tmp/%s_t%s.npz' % \\\n (basename(self.exr_f).replace('.exr', ''), time())\n # Convert to .npz\n # cv2.imread() can't load more than three channels from .exr even with IMREAD_UNCHANGED\n # Has to go through IO. Maybe there's a better way?\n cwd = join(dirname(abspath(__file__)), '..', '..', 'cli')\n bash_cmd = 'python2 exr2npz.py %s %s' % (self.exr_f, npz_f)\n process = Popen(bash_cmd.split(), cwd=cwd)\n _, _ = process.communicate()\n # Load this .npz\n data = np.load(npz_f)\n logger.name = logger_name\n logger.info(\"Loaded %s\", self.exr_f)\n return data","def run():\n\n if lm.scene_object().type == 'env':\n read_layout(outFile=lm.scene_object().copy(ext='json').path_root)\n\n else:\n read_layout()","def create_e3d_file(self,path='./'):\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt needs to satify the courant condition\n t=int(self.model_parameters['duration']/dt)\n \n # Check path exists, if not create one\n if not os.path.exists(path):\n os.makedirs(path)\n \n # Create e3d parameter file\n f=open('%s%s_e3dmodel.txt'%(path,self.model_name),'w')\n f.write(\"grid x=%s z=%s dh=%s b=2 q=1\\ntime dt=%0.5f t=%s\\n\"%(self.model_parameters['xmax'],self.model_parameters['zmax'],self.model_parameters['dh'],dt,t))\n f.write(\"block p=%s s=%s r=%s Q=20 Qf=50\\n\"%(self.velocity_model['vp'][0],self.velocity_model['vs'][0],self.velocity_model['rho'][0]))\n \n for i in range(1,len(self.velocity_model['vp'])-1):\n f.write(\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\n\"%(self.velocity_model['vp'][i],self.velocity_model['vs'][i],self.velocity_model['rho'][i],\n self.velocity_model['depth'][i],self.velocity_model['depth'][i+1]))\n \n f.write(\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\n\\n\"%(self.velocity_model['vp'][i+1],self.velocity_model['vs'][i+1],self.velocity_model['rho'][i+1],\n self.velocity_model['depth'][i+1],self.model_parameters['zmax'])) # extend to the based of the model \n \n f.write(\"visual movie=5\\n\\n\")\n\n if self.source['src_type']!=4:\n f.write(\"source type=%s x=%s z=%s freq=%s amp=%s\\n\\n\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'])) \n else:\n f.write(\"source type=%s x=%s z=%s freq=%s amp=%s Mxx=%s Myy=%s Mzz=%s Mxy=%s Mxz=%s Myz=%s\\n\\n\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'],self.source['mt'][0],self.source['mt'][1],self.source['mt'][2],self.source['mt'][3],self.source['mt'][4],self.source['mt'][5])) \n\n for r in range(len(self.receivers['recxs'])):\n f.write('sac x=%0.3f z=%0.3f file=%s\\n'%(self.receivers['recxs'][r],self.receivers['reczs'][r],self.model_name))\n\n f.write(\"visual sample=0.1 movie=1 scale=10000000000/n\")\n f.close()\n \n print('File created: %s%s_e3dmodel.txt'%(path,self.model_name))","def read_all_poses(world):\n dataset_root='./jsonfile'\n path = os.path.join(dataset_root, world, 'image_structs.mat')\n data = sio.loadmat(path)\n\n xyz = data['image_structs']['world_pos']\n image_names = data['image_structs']['image_name'][0]\n\n dire=data['image_structs']['direction']\n #rot = data['image_structs']['R'][0]\n #scale = data['scale'][0][0]\n\n n = xyz.shape[1]\n x = [xyz[0][i][0][0] for i in range(n)]\n y = [0 for i in range(n)]\n z = [xyz[0][i][2][0] for i in range(n)]\n px= [dire[0][i][0][0] for i in range(n)]\n py= [0 for i in range(n)]\n pz= [dire[0][i][2][0] for i in range(n)]\n#============================================================\n names = [name[0][:-4] for name in image_names]\n if len(names) != len(x):\n raise ValueError('number of image names are not equal to the number of '\n 'poses {} != {}'.format(len(names), len(x)))\n output = {}\n for i in range(n):\n output[names[i]] = [x[i], z[i], px[i], pz[i]]\n return output","def main(dataset, n, ms=False, out=sys.stdout):\n # build lists of paths previews files, tif, rpc and dzi files\n prv_paths = ' '.join([os.path.join(dataset, 'prv_%02d.jpg' % (i+1)) for i in xrange(n)])\n tif_paths = ' '.join([os.path.join(dataset, 'im_panchro_%02d.tif' % (i+1)) for i in xrange(n)])\n rpc_paths = ' '.join([os.path.join(dataset, 'rpc_%02d.xml' % (i+1)) for i in xrange(n)])\n dzi8_paths, dzi16_paths = None, None\n if ms:\n ms_paths = ' '.join([os.path.join(dataset, 'im_ms_%02d.tif' % (i+1)) for i in xrange(n)])\n if os.path.isfile(os.path.abspath(os.path.join(dataset,\n 'im_panchro_8BITS_01.dzi'))):\n dzi8_paths = ' '.join([os.path.join('input', dataset,\n 'im_panchro_8BITS_%02d.dzi' %\n (i+1)) for i in xrange(n)])\n if os.path.isfile(os.path.abspath(os.path.join(dataset,\n 'im_panchro_16BITS_01.dzi'))):\n dzi16_paths = ' '.join([os.path.join('input', dataset,\n 'im_panchro_16BITS_%02d.dzi' %\n (i+1)) for i in xrange(n)])\n\n # read infos in DIM*.XML file\n dim_xml_file = os.path.join(dataset, 'dim_01.xml')\n tif_file = os.path.join(dataset, 'im_panchro_01.tif')\n if os.path.isfile(dim_xml_file): # check if the link points to an existing file\n date = grep_xml(dim_xml_file, \"IMAGING_DATE\")\n satellite = grep_xml(dim_xml_file, \"INSTRUMENT_INDEX\")\n elif os.path.isfile(tif_file):\n date = extract_date_from_pleiades_filename(os.readlink(tif_file))\n satellite = extract_satellite_from_pleiades_filename(os.readlink(tif_file))\n else:\n date = 'DD-MM-YYYY'\n satellite = 'Pleiades 1X'\n\n # print to stdout\n if dzi8_paths or dzi16_paths:\n print('[%s]' % dataset, file=out)\n print('files = ', prv_paths, file=out)\n print('tif = ', tif_paths, file=out)\n print('rpc = ', rpc_paths, file=out)\n if ms:\n print('clr = ', ms_paths, file=out)\n if dzi8_paths:\n print('dzi8 = ', dzi8_paths, file=out)\n if dzi16_paths:\n print('dzi16 = ', dzi16_paths, file=out)\n s = dataset.split(os.path.sep)\n if len(s) == 3: # ie the path is of the kind 'pleiades/reunion/dataset_1'\n print('title = %s (%s)' % (s[1].capitalize(), s[2][-1]), file=out) # ie 'Reunion (1)'\n elif len(s) == 2: # ie the path is of the kind 'pleiades/reunion'\n print('title = %s' % s[1].capitalize(), file=out) # ie 'Reunion'\n else:\n print('path %s not expected by the author of the script: ' % dataset, s, file=sys.stderr)\n print('date = %s' % date, file=out)\n print('satellite = Pleiades %s' % satellite, file=out)\n print('nb_img = %d' % n, file=out)\n if ms:\n print('color = panchro_xs', file=out)\n else:\n print('color = panchro', file=out)","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 read_input_file(self):\n\n # Check if input file exists in current directory, if not kill process\n if not os.path.isfile('./visualise.inpt'):\n print('Cannot find input file \"visualise.inpt\" in current directory')\n sys.exit()\n\n # Read input file and analysis options and parameters\n print('Reading input file')\n with open('visualise.inpt','r') as f:\n f.readline()\n self.prefix = f.readline().split()[0]\n f.readline()\n f.readline()\n self.frame = int(f.readline().split()[0])\n f.readline()\n f.readline()\n self.vis_particles = int(f.readline().split()[0])\n self.vis_vortype = int(f.readline().split()[0])\n self.vis_cellcolour = int(f.readline().split()[0])\n self.vis_save = int(f.readline().split()[0])","def load_vo_txt(*, fname, sampling='1M', sv_spacing):\n # Load GVO MF and sigmas from txt file\n df_mf = load_vo_txt_raw(fname=fname, sampling=sampling)\n df_sigma = pd.DataFrame({'sigma_r': df_mf['sigma_r'],\n 'sigma_theta': df_mf['sigma_theta'],\n 'sigma_phi': df_mf['sigma_phi'],\n 'N_data': df_mf['N_data']})\n\n # Rearrange to dataframe of timeseries at each GVO location\n dates = df_mf[\"date\"].unique() # timeseries for all GVO\n # dates_mjd2000 = df_mf[\"mjd2000\"].unique()\n\n # Array of GVO positions [t, p, r]\n positions = df_mf.drop_duplicates(subset=[\"theta\", \"phi\"])\n positions = positions[[\"theta\", \"phi\"]].to_numpy()\n positions = np.column_stack((positions,\n np.repeat(df_mf[\"r\"].dropna().unique(),\n len(positions)))) # txt file\n\n df_mf_pos = pd.DataFrame({\"date\": dates})\n for pos in range(len(positions)):\n df_mf_pos[\"X\"] = df_mf[\"X\"].loc[(df_mf[\"theta\"] == positions[pos, 0])\n & (df_mf[\"phi\"]\n == positions[pos, 1])].values\n df_mf_pos[\"Y\"] = df_mf[\"Y\"].loc[(df_mf[\"theta\"] == positions[pos, 0])\n & (df_mf[\"phi\"]\n == positions[pos, 1])].values\n df_mf_pos[\"Z\"] = df_mf[\"Z\"].loc[(df_mf[\"theta\"] == positions[pos, 0])\n & (df_mf[\"phi\"]\n == positions[pos, 1])].values\n\n # Get SV, then rename SV columns\n if sampling == '1M':\n df_sv = calculate_sv(df_mf_pos, mean_spacing=sv_spacing)\n elif sampling == '4M':\n # Calculate SV as annual differences of four-monthly GVO MF and set\n # the SV date to be between the two MF dates\n df_sv = pd.DataFrame()\n df_sv['date'] = df_mf_pos['date'] - \\\n pd.tseries.offsets.DateOffset(months=6)\n df_sv['dx'] = df_mf_pos['X'].diff(periods=3)\n df_sv['dy'] = df_mf_pos['Y'].diff(periods=3)\n df_sv['dz'] = df_mf_pos['Z'].diff(periods=3)\n df_sv.drop(df_sv.head(3).index, inplace=True)\n df_sv.reset_index(drop=True, inplace=True)\n if pos == 0: # keep date and data columns in first instance\n df_sv_pos = df_sv\n df_sv_pos.rename(columns={\"dx\": \"dx_\"+str(pos).zfill(3),\n \"dy\": \"dy_\"+str(pos).zfill(3),\n \"dz\": \"dz_\"+str(pos).zfill(3)},\n inplace=True)\n else: # only keep data columns otherwise\n df_sv_pos[[\"dx_\"+str(pos).zfill(3),\n \"dy_\"+str(pos).zfill(3),\n \"dz_\"+str(pos).zfill(3)]] = df_sv[[\"dx\", \"dy\", \"dz\"]]\n\n # Rename MF columns starting from GVO 000\n df_mf_pos.rename(columns={\"X\": \"X_\"+str(pos).zfill(3),\n \"Y\": \"Y_\"+str(pos).zfill(3),\n \"Z\": \"Z_\"+str(pos).zfill(3)}, inplace=True)\n\n return df_mf_pos, df_sv_pos, positions, dates, df_sigma","def test_to_multiframe_xyz(self):\n\n # load in an SDF of butane with multiple conformers in it\n molecules = Molecule.from_file(\n get_data_file_path(\"molecules/butane_multi.sdf\"), \"sdf\"\n )\n # now we want to combine the conformers to one molecule\n butane = molecules[0]\n for mol in molecules[1:]:\n butane.add_conformer(mol._conformers[0])\n\n # make sure we have the 7 conformers\n assert butane.n_conformers == 7\n with NamedTemporaryFile(suffix=\".xyz\") as iofile:\n # try and write out the xyz file\n butane.to_file(iofile.name, \"xyz\")\n\n # now lets check whats in the file\n with open(iofile.name) as xyz_data:\n data = xyz_data.readlines()\n # make sure we have the correct amount of lines writen\n assert len(data) == 112\n # make sure all headers and frame data was writen\n assert data.count(\"14\\n\") == 7\n for i in range(1, 8):\n assert f\"C4H10 Frame {i}\\n\" in data\n\n # now make sure the first line of the coordinates are correct in every frame\n coords = [\n \"C 1.8902000189 0.0425999984 0.2431000024\\n\",\n \"C 1.8976000547 -0.0232999995 0.2845999897\\n\",\n \"C -1.8794000149 -0.1792999953 -0.2565000057\\n\",\n \"C -1.5205999613 -0.0164999999 0.2786999941\\n\",\n \"C -1.4889999628 -0.2619000077 0.4871000051\\n\",\n \"C -1.4940999746 -0.2249000072 -0.0957999974\\n\",\n \"C -1.8826999664 -0.0372000001 0.1937000006\\n\",\n ]\n for coord in coords:\n assert coord in data","def __init__(self, filepath='multidrcl', suffix='DRCL', extension='.IMG', lblext='.LBL', force_read=True, unit='s', feature='sh', eye='L', do_print=True, initdatadir=None, initdata=None, readintuple=None):\n\n Dataset.__init__(self, None, \"mastcam\")\n\n if readintuple != None:\n (self.data, self.fullimages, self.segmentation, self.labels, self.xlabel, self.ylabel, self.xvals, self.rgbdict, self.lblext) = readintuple[0:9]\n if initdata != None:\n self.initdata = initdata\n if self.initfilename != None:\n self.initfilename = initarchive\n else:\n self.initfilename = 'param'\n return\n \n if do_print: print(filepath)\n \n if filepath == '388':\n filepath = '/proj/imbue/data/msl-mastcam/sol388/'\n \n if filepath == 'multidrcl':\n filepath = '/proj/imbue/data/msl-mastcam/multispectral_drcl/'\n \n self.filepath = filepath\n self.xlabel = 'TBD'\n self.ylabel = 'TBD'\n \n #dirname = filepath[:-1]\n #subsetname = dirname.split('/')[-1]\n subsetname = os.path.basename(filepath)\n self.name += \"-\" + subsetname\n if len(suffix) > 0:\n self.name += \"-\" + eye + '-' + suffix + '-' + unit + '-' + feature\n if do_print: print(\"Dataset name: \" + self.name)\n \n self.data = []\n self.cadence = []\n \n self.unit = unit\n self.feature = feature\n self.eye = eye\n\n self.rgbdict = {}\n self.extension = extension\n self.lblext = lblext\n self.suffix = suffix\n \n self.archive = os.path.join(filepath,\n subsetname + eye + \"_\" + suffix + '_' + unit + '_' + feature + \".pkl\")\n\n if initdata != None:\n self.initdata = initdata\n if self.initfilename != None:\n self.initfilename = initarchive\n else:\n self.initfilename = 'param'\n elif initdatadir != None:\n print(\"Reading in initialization data...\")\n #initsubsetname = initdatadir[:-1].split('/')[-1]\n initsubsetname = os.path.basename(initdatadir)\n initarchive = os.path.join(initdatadir,\n initsubsetname + eye + \"_\" + suffix + '_' + unit + '_' + feature + \".pkl\")\n if os.path.exists(initarchive):\n with open(initarchive, 'r') as f:\n self.initdata = pickle.load(f)[0]\n self.initfilename = initarchive\n print(\"...done!\")\n print(\"initdata.shape:\", self.initdata.shape)\n else:\n print(\"...initialization data does not exist!\")\n print(\"Desired pickle was: %s\" % initarchive)\n \n # Determine if we need to preprocess the data\n if (not os.path.exists(self.archive)) or force_read:\n self.read_mastcam_dir(filepath, suffix, unit, feature, extension, lblext, eye)\n else:\n if do_print: print(\"Found pickle at \" + self.archive)\n \n self.readin()","def plotsources(self): \n mainDir = Inverse.mainDir\n folder_name = self.folder_name\n os.chdir(mainDir)\n \n folder = os.listdir(u'.')\n subfolders = [f for f in folder if f[0] == 'S']\n\n for subject in subfolders:\n # go to the directory\n curdir = os.path.join(mainDir, subject)\n os.chdir(curdir)\n # locate source files\n stcfiles = glob.glob('*-rh.stc')\n\n for ii, fname in enumerate(stcfiles):\n # read the source files\n print(fname)\n stc = mne.read_source_estimate(os.path.join(curdir, fname))\n plottitle = fname.split('_c')[0]\n\n try:# plot the surface\n # Get labels for FreeSurfer 'aparc' cortical parcellation with 34 labels/hemi\n labels_parc = mne.read_labels_from_annot(subject, parc='aparc', subjects_dir = mainDir)\n\n # plot the sources\n brain = stc.plot(subject=subject, surface='pial', hemi='both', colormap='auto',\n time_label='auto', smoothing_steps=10, transparent=True, alpha=0.8,\n time_viewer=False, subjects_dir=None, figure=None, views='dor',\n colorbar=True, clim='auto', cortex='classic', size=800, background='black',\n foreground='white',\n initial_time = self.initial_time, time_unit='s', backend='auto', spacing='oct5')\n\n vertno_max, time_max = stc.get_peak(hemi='lh')\n brain.add_foci(vertno_max, coords_as_verts=True, hemi='lh', color='red')\n\n vertno_max_rh, time_max_rh = stc.get_peak(hemi='rh')\n brain.add_foci(vertno_max_rh, coords_as_verts=True, hemi='rh', color='blue')\n\n brain.add_text(0.1, 0.9, plottitle, 'title', font_size=36)\n\n except Exception as errMessage:\n print('Something went wrong with subject >>>', fname)\n print(errMessage)\n pass\n \"\"\"\n views : str | list\n View to use. See surfer.Brain(). Supported views: ['lat', 'med', 'fos',\n 'cau', 'dor' 'ven', 'fro', 'par']. Using multiple views is not\n supported for mpl backend.\n \"\"\"\n labelo = []\n try:\n #brain.add_annotation\n labelo.append([label for label in labels_parc if label.name == 'postcentral-lh'][0])\n labelo.append([label for label in labels_parc if label.name == 'postcentral-rh'][0])\n labelo.append([label for label in labels_parc if label.name == 'precentral-lh'][0] )\n labelo.append([label for label in labels_parc if label.name == 'precentral-rh'][0] )\n# labelo.append([label for label in labels_parc if label.name == 'inferiorparietal-lh'][0])\n# labelo.append([label for label in labels_parc if label.name == 'inferiorparietal-rh'][0])\n# labelo.append([label for label in labels_parc if label.name == 'superiorfrontal-rh'][0])\n# labelo.append([label for label in labels_parc if label.name == 'superiorfrontal-lh'][0])\n\n for label in labelo:\n brain.add_label(label, borders=1)\n\n except Exception as errMessage:\n print(errMessage)\n pass\n\n try: # make a directory called 'results'\n os.mkdir(os.path.join(curdir, folder_name))\n except Exception as errMessage:\n print(errMessage)\n\n finally:\n os.chdir(os.path.join(curdir, folder_name))\n brain.save_image(fname.split('_c')[0])\n brain.close()\n\n os.chdir(mainDir)","def sim12_g_simulation(datafiles, simulation_mag_zeropoint, simulation_exposure):\n return stuff.Simulation(datafiles / 'sim12' / 'sim12_g.list', simulation_mag_zeropoint, simulation_exposure)","def load_data(self):\n x_vector = pickle.load(open(self.file_stem + \"x.pickle\", \"rb\"))\n ode_sols = pickle.load(open(self.file_stem + \"sols.pickle\", \"rb\"))\n forcings = pickle.load(open(self.file_stem + \"fs.pickle\", \"rb\"))\n sl_coeffs = pickle.load(open(self.file_stem + \"coeffs.pickle\", \"rb\"))\n\n return x_vector, ode_sols, forcings, sl_coeffs","def import_file(self):\n\n t0 = datetime.now()\n\n print(\"\\n\" + \"Importing {}...\".format(self.filepath))\n\n file = pyedflib.EdfReader(self.filepath)\n\n self.sample_rate = file.getSampleFrequencies()[0]\n self.accel_sample_rate = file.getSampleFrequencies()[1]\n\n # READS IN ECG DATA ===========================================================================================\n if self.end_offset == 0:\n print(\"Importing file from index {} to the end...\".format(self.start_offset))\n self.raw = file.readSignal(chn=0, start=self.start_offset)\n\n if self.load_accel:\n self.x = file.readSignal(chn=1, start=int(self.start_offset *\n self.accel_sample_rate / self.sample_rate))\n self.y = file.readSignal(chn=2, start=int(self.start_offset *\n self.accel_sample_rate / self.sample_rate))\n self.z = file.readSignal(chn=3, start=int(self.start_offset *\n self.accel_sample_rate / self.sample_rate))\n\n if self.end_offset != 0:\n print(\"Importing file from index {} to {}...\".format(self.start_offset,\n self.start_offset + self.end_offset))\n self.raw = file.readSignal(chn=0, start=self.start_offset, n=self.end_offset)\n\n if self.load_accel:\n self.x = file.readSignal(chn=1,\n start=int(self.start_offset * self.accel_sample_rate / self.sample_rate),\n n=int(self.end_offset * self.accel_sample_rate / self.sample_rate))\n\n self.y = file.readSignal(chn=2,\n start=int(self.start_offset * self.accel_sample_rate / self.sample_rate),\n n=int(self.end_offset * self.accel_sample_rate / self.sample_rate))\n\n self.z = file.readSignal(chn=3,\n start=int(self.start_offset * self.accel_sample_rate / self.sample_rate),\n n=int(self.end_offset * self.accel_sample_rate / self.sample_rate))\n\n # Calculates gravity-subtracted vector magnitude. Converts from mg to G\n # Negative values become zero\n if self.load_accel:\n self.vm = (np.sqrt(np.square(np.array([self.x, self.y, self.z])).sum(axis=0)) - 1000) / 1000\n self.vm[self.vm < 0] = 0\n\n print(\"ECG data import complete.\")\n\n self.starttime = file.getStartdatetime() + timedelta(seconds=self.start_offset/self.sample_rate)\n self.file_dur = round(file.getFileDuration() / 3600, 3)\n\n # Data filtering\n self.filtered = Filtering.filter_signal(data=self.raw, low_f=self.low_f, high_f=self.high_f,\n filter_type=self.f_type, sample_f=self.sample_rate, filter_order=3)\n\n # TIMESTAMP GENERATION ========================================================================================\n t0_stamp = datetime.now()\n\n print(\"\\n\" + \"Creating timestamps...\")\n\n # Timestamps\n end_time = self.starttime + timedelta(seconds=len(self.raw)/self.sample_rate)\n self.timestamps = np.asarray(pd.date_range(start=self.starttime, end=end_time, periods=len(self.raw)))\n self.epoch_timestamps = self.timestamps[::self.epoch_len * self.sample_rate]\n\n t1_stamp = datetime.now()\n stamp_time = (t1_stamp - t0_stamp).seconds\n print(\"Complete ({} seconds).\".format(round(stamp_time, 2)))\n\n t1 = datetime.now()\n proc_time = (t1 - t0).seconds\n print(\"\\n\" + \"Import complete ({} seconds).\".format(round(proc_time, 2)))","def main(name, line1, line2, orbital_filename):\n #name = \"TERRA\"\n #line1 = \"1 25994U 99068A 16048.43680378 .00000258 00000-0 67198-4 0 9999\"\n #line2 = \"2 25994 98.1982 124.4247 0001352 105.3907 254.7441 14.57126067859938\"\n satellite = ephem.readtle(name, line1, line2)\n \n\n # Landsat 8\n #name = \"Landsat8\"\n #line1=\"1 39084U 13008A 16051.82349873 .00000188 00000-0 51829-4 0 9999\"\n #line2=\"2 39084 98.1988 123.2603 0001265 89.4360 270.6984 14.57110027160810\"\n #LD8 = ephem.readtle(name, line1, line2)\n \n\n sun = ephem.Sun()\n fov = np.radians(68.6)\n\n \"\"\"\n Make pandas dataframe to store swath information\n \"\"\"\n import pandas as pd\n data = {\"DateTime\": [],\"DOY\":[],\"Month\": [],\n \"orbit_id\":[], \"ground_lat\": [], \n \"ground_lon\": [], \"swath_width\": []}\n swaths = pd.DataFrame(data)\n swaths.set_index(keys=\"DateTime\")\n # generate shapefile\n\n orbit_id = 0\n # need to do splitted by hemisphere unfortunately..\n for orbit in make_an_orbit(satellite):\n #import pdb; pdb.set_trace()\n if len(orbit) > 1:\n \"\"\"\n So worth doing processing on orbit...\n\n \"\"\"\n sun = ephem.Sun()\n\n print(orbit[0].datetime)\n\n for overpass in orbit:\n overpass.only_daytime_overpasses(sun)\n overpass.derive_swath_width(fov)\n \"\"\"\n Create a tempoary dataframe for this orbit\n \"\"\"\n epoch = datetime.datetime(1970, 1, 1)\n #import pdb; pdb.set_trace()\n tmp_d = {\"DateTime\": [(o.datetime - epoch).total_seconds() for o in orbit],\n \"DOY\":[int(o.datetime.strftime('%j')) for o in orbit],\n \"Month\": [o.datetime.month for o in orbit],\n \"orbit_id\": orbit_id * np.ones(len(orbit)),\n \"ground_lat\": [o.lat for o in orbit],\n \"ground_lon\": [o.long for o in orbit],\n \"swath_width\": [o.swath_width for o in orbit]}\n tmp = pd.DataFrame(tmp_d)\n tmp.set_index(keys=\"DateTime\")\n #import pdb; pdb.set_trace()\n orbit_id +=1 \n \"\"\"\n Append to main dataframe\n \"\"\"\n swaths = swaths.append(tmp)\n #swaths.set_index(keys=\"DateTime\")\n\n \"\"\"\n Save the DataFrame to a file\n \"\"\"\n swaths = swaths.set_index(keys=\"DateTime\")\n #swaths.set_index(keys=\"DateTime\")\n #import pdb; pdb.set_trace()\n swaths.to_csv(orbital_filename, header=True)","def extract_relevant_data( case_list = [], exceptions = [], y_delta_locs = [],\n x_2h_locs = [] , plot = False, output_root = '',\n overwrite = False, just_plot = False ):\n\n from os import listdir\n from os.path import join,split,isfile\n from pandas import DataFrame, HDFStore\n from boundary_layer_routines import return_bl_parameters\n from progressbar import ProgressBar,Percentage\n from progressbar import Bar,ETA,SimpleProgress\n from numpy import array, round, linspace, nan, sign\n from data_cleaning_routines import show_surface_from_df\n\n x_2h_locs = round( array( x_2h_locs ), 2 )\n y_delta_locs = round( array( y_delta_locs ), 2 )\n\n if not output_root:\n output_root = '/media/carlos/6E34D2CD34D29783/' +\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\n\n # Get the available HDF5 files #############################################\n hdf5_root = '/media/carlos/6E34D2CD34D29783/' +\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\n\n if not len(case_list):\n hdf5_files = [f for f in listdir( hdf5_root ) \\\n if f.endswith('.hdf5') \\\n and not f in exceptions ]\n else:\n hdf5_files = [f for f in listdir( hdf5_root ) \\\n if f.endswith('.hdf5') \\\n and f in case_list ]\n # ##########################################################################\n\n for hf in [join( hdf5_root, f ) for f in hdf5_files]:\n\n suffix = '_AirfoilNormal'\n\n mean_flow_rotated = False\n if hf.endswith(\"MeanFlowRotated.hdf5\"):\n mean_flow_rotated = True\n suffix = ('_MeanFlowRotated')\n\n f = split( hf )[1].replace(suffix,'')\\\n .replace('_Aligned.hdf5','').replace('.hdf5','')\n if mean_flow_rotated:\n f = f + '_mfr'\n\n # Get the normalization locations depending on the case ################\n if 'z00' in f and not 'STE' in f:\n x_bl_loc = 38\n elif 'z05' in f:\n x_bl_loc = 18\n elif 'z10' in f or 'STE' in f:\n x_bl_loc = -2\n\n #if mean_flow_rotated:\n # mean_flow_df = read_pickle( mean_flow_pickle )\n # mean_flow_angle = mean_flow_df.T.ix[ \n # f.replace('.hdf5','')\n # ].ix[0].values[0]\n\n # yshift = - x_bl_loc * sin( radians( mean_flow_angle ) )\n #else:\n # yshift = 0\n\n print \" Processing {0}\".format( f )\n if not overwrite and isfile( 'ReservedData/' + f + '.hdf5' ):\n print \" File exists; skipping\"\n continue\n\n\n hdf_t = HDFStore( hf, 'r' )\n\n # Get the available coordinates ########################################\n hf_coords = hdf_t.select('data', where = [ 't = 0' ], \n columns = [ 'x', 'y' , 'u' ] )\n # ######################################################################\n\n # Turn the non-dim requested locations into physical coords ############\n requested_locations = []\n requested_normalized_locations = []\n #for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\n # for y_d in y_delta_locs:\n # bl_params = return_bl_parameters( f , [x] )\n # d_99 = bl_params.delta_99.values[0]\n # #if \"STE\" in f:\n # # d_99 = 9.4\n # y = y_d * d_99\n # requested_locations.append( (x,y) )\n # requested_normalized_locations.append( ( x_norm, y_d ) )\n\n bl_params = return_bl_parameters( \n f.replace( '_mfr', '' ) , \n [x_bl_loc] )\n d_99 = bl_params.delta_99.values[0]\n\n for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\n for y_d in y_delta_locs:\n y = y_d * d_99\n requested_locations.append( (x,y) )\n requested_normalized_locations.append( ( x_norm, y_d ) )\n print \" Normalizing to a BL thickness of {0:.2f} mm\".\\\n format(d_99)\n # ######################################################################\n\n hf_coords = hf_coords.replace( 0, nan )\n hf_coords = hf_coords.dropna()\n\n min_x_real_loc = min( x_2h_locs ) * tooth_length\n max_x_real_loc = max( x_2h_locs ) * tooth_length\n\n # This is the max y location for a full square in the rotated FoV ######\n max_y_field_of_view = min(\n hf_coords[ \n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \n ].y.max(),\n\n hf_coords[ \n ( hf_coords.x < \\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\n ( hf_coords.x > \\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \n ].y.max()\n )\n # ######################################################################\n\n # This is the minimum (and x_loc aligned) y location for a full square\n # in the rotated FoV ###################################################\n min_y_field_of_view = max(\n hf_coords[ \n ( hf_coords.x < \\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\n ( hf_coords.x > \\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \n ].y.min(), \n hf_coords[ \n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \n ].y.min()\n )\n\n # ######################################################################\n\n if max( y_delta_locs ) * d_99 < max_y_field_of_view:\n max_y_loc = max( y_delta_locs ) * d_99\n else:\n max_y_loc = max_y_field_of_view\n\n if min( y_delta_locs ) * d_99 > min_y_field_of_view:\n min_y_loc = min( y_delta_locs ) * d_99\n else:\n min_y_loc = min_y_field_of_view\n\n available_xy_locs = hf_coords[\n ( hf_coords.x > min( x_2h_locs ) * 40. ) & \\\n ( hf_coords.x < max( x_2h_locs ) * 40. ) & \\\n ( hf_coords.y > min_y_loc ) & \\\n ( hf_coords.y < max_y_loc )\n ][ ['x','y'] ]\n\n if available_xy_locs.empty:\n return 0\n \n available_xy_locs = [ tuple(x) for x in available_xy_locs.values ]\n\n #if mean_flow_rotated:\n # y_correction = - x_bl_loc * sin( radians( mean_flow_angle ) )\n\n #if plot:\n\n # trailing_edge,phi,alpha,U,z = decript_case_name( f )\n\n # if trailing_edge == 'serrated': device = 'Sr20R21'\n # elif trailing_edge == 'straight': device = 'STE'\n # elif trailing_edge == 'slitted': device = 'Slit20R21'\n\n # case_name = \"{0}_phi{1}_alpha{2}_U{3}_loc{4}_tr.dat\".format(\n # device, phi, alpha, U, z\n # )\n\n # plot_name = ''\n # if mean_flow_rotated:\n # average_pickle_name = 'averaged_data/' + case_name + \\\n # '_mean_flow_rotated.p'\n # else:\n # average_pickle_name = 'averaged_data/' + case_name + '.p'\n # df_av = read_pickle( average_pickle_name )\n\n # if mean_flow_rotated:\n # df_av.y = df_av.y - yshift\n\n # plot_name = 'ReservedData/' + f + '.png'\n # show_surface_from_df( \n # df_av , \n # points = available_xy_locs ,\n # plot_name = plot_name,\n # point_correction = ( 0 , 0 )\n # )\n # if not plot_name:\n # continue\n\n # Don't try to get it all at once; split the vertical in 4 pieces\n vertical_split_blocks = 10\n\n y_ranges = linspace( \n min_y_loc,\n max_y_loc,\n vertical_split_blocks\n ) \n\n xmin = min(x_2h_locs) * tooth_length\n xmax = max(x_2h_locs) * tooth_length\n\n print \" Extracting data from {0}\".format(f)\n print \" at the streamwise locations:\",\n print \" {0:.2f} to {1:.2f}\".format( xmin, xmax )\n print \" at the wall-normal locations:\",\n print \" {0:.2f} to {1:.2f}\".format( min_y_loc, max_y_loc )\n\n if plot:\n query = \" x>={0} & x<{1} & y>={2} & y<{3} & t=0\".\\\n format( xmin, xmax, min_y_loc, max_y_loc )\n\n df0 = hdf_t.select(\n key = 'data',\n where = [ query ],\n )\n\n plot_name = 'ReservedData/' + f + '.png'\n if mean_flow_rotated:\n plot_name = plot_name.replace( '.png', '_mfr.png' )\n\n show_surface_from_df( \n df0,\n plot_name = plot_name,\n point_correction = ( 0 , 0 )\n )\n if just_plot:\n return 0\n\n query = ''\n cnt_all = 0\n\n cnt = 0\n time_series_hdf = HDFStore( 'ReservedData/' + f + '.hdf5', 'w' )\n\n progress = ProgressBar(\n widgets=[\n Bar(),' ',\n Percentage(),' ',\n ETA(), ' (query bunch ',\n SimpleProgress(),')'], \n maxval = vertical_split_blocks\n ).start()\n\n for ymin, ymax in zip( y_ranges[:-1], y_ranges[1:] ):\n\n query = \" x>={0} & x<{1} & y>={2} & y<{3} \".\\\n format( xmin, xmax, ymin, ymax )\n\n df_t = hdf_t.select(\n key = 'data',\n where = [ query ],\n )\n\n df_t['near_x_2h'] = round( df_t.x / 40., 4 )\n df_t['near_y_delta'] = round( df_t.y / d_99, 4 )\n\n # If it has been flow rotated, the zero y direction needs to be\n # brought back to the location of the wall at the reference x\n # location #########################################################\n #if mean_flow_rotated:\n # df_t.y = df_t.y - y_correction\n # ##################################################################\n # The translation now happens when pickling the raw data\n\n if not cnt:\n time_series_hdf.put( 'data', df_t , \n data_columns = [\n 'near_x_2h',\n 'near_y_delta',\n 't'\n ],\n format = 't')\n else:\n time_series_hdf.append( 'data', df_t , \n data_columns = [\n 'near_x_2h',\n 'near_y_delta',\n 't'\n ],\n format = 't')\n\n cnt_all += 1\n cnt += 1\n\n progress.update(cnt_all)\n\n df_t = DataFrame()\n\n\n progress.finish()\n hdf_t.close()\n time_series_hdf.close()","def hxb_data_experiment(directory):\n\n #######################################################################\n #LOADING DATA\n #######################################################################\n\n #Loading all files in the folder\n xyz_files = []\n blur_files = []\n\n #Spliting files in xyz coordinates and voxels data.\n files = os.listdir(directory)\n files.sort()\n for f in files:\n if os.path.isfile(os.path.join(directory, f)):\n if f.startswith('C'):\n xyz_files.append(f)\n if f.startswith('F'):\n blur_files.append(f)\n\n #Loading xyz data\n dict_xyz = {}\n for f in xyz_files:\n #The name of the subject is given by the four last letter.\n dict_xyz[f[1]] = np.genfromtxt(os.path.join(directory, f),\n dtype = float)\n print \"xyz_file for subject %s was loaded.\" %(f[1])\n\n #Loading voxels data and creating the intermediate representation objects\n inter_reps = []\n for f in blur_files:\n #Name of the subject is always in positions [7:11]\n s_name = f[1]\n #Class is in possition 5\n cls = str(f[3:-4])\n arr_voxels = np.genfromtxt(os.path.join(directory, f), dtype = float, delimiter = ' ')\n inter_reps.append(ir.IntermRep(arr_voxels, dict_xyz[s_name], s_name,\n cls))\n\n print \"Intermediate representation for subject %s and class %s created.\" %(s_name, cls)\n\n #######################################################################\n\n\n #######################################################################\n #Computing the Graph Encoding\n #######################################################################\n\n graphs = []\n classes = []\n subjects = []\n\n #Cluster based graph encoding with a fixed threshold\n #-----------------------------\n# fc = ge.GE_ClusterBased()\n# for i_rep in inter_reps:\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\n# n_clusters = -1, clust_ratio = 170,\n# similarity_measure=\"pearson\",\n# threshold=0.1, n_jobs = 1))\n# classes.append(i_rep.cls)\n# subjects.append(i_rep.subj_name)\n# print \"Graph built for subject %s and class %s.\" %(i_rep.subj_name, i_rep.cls)\n# print \"Number of nodes: %i, number of edges: %i\" %(graphs[-1].number_of_nodes(),\n# graphs[-1].number_of_edges())\n# print \"\"\n #---------------------------\n\n #Cluster based graph encoding with percentage of completeness\n #-----------------------------\n# fc = gpc.GE_ClustBased_PercCompleteness()\n# for i_rep in inter_reps:\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\n# n_clusters = -1, clust_ratio = 110,\n# similarity_measure=\"pearson\",\n# completeness=0.3, n_jobs = 1))\n# classes.append(i_rep.cls)\n# subjects.append(i_rep.subj_name)\n# print \"Graph built for subject %s and class %s.\" %(i_rep.subj_name, i_rep.cls)\n# print \"Number of nodes: %i, number of edges: %i\" %(graphs[-1].number_of_nodes(),\n# graphs[-1].number_of_edges())\n# print \"\"\n #---------------------------\n\n #Cluster based graph encoding with categories for node degree\n #-----------------------------\n# fc = gnd.GE_ClustBased_DiscNodeDegree()\n# for i_rep in inter_reps:\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\n# n_clusters = -1, clust_ratio = 170,\n# similarity_measure=\"pearson\",\n# threshold=0.1, n_categ=10, n_jobs = 1))\n# classes.append(i_rep.cls)\n# subjects.append(i_rep.subj_name)\n# print \"Graph built for subject %s and class %s.\" %(i_rep.subj_name, i_rep.cls)\n# print \"Number of nodes: %i, number of edges: %i\" %(graphs[-1].number_of_nodes(),\n# graphs[-1].number_of_edges())\n# print \"\"\n #---------------------------\n\n\n #Weighted version of graph encoding with a fixed threshold\n #-----------------------------\n# fc = gwe.GE_FuncConn_WeightedEncoding()\n# for i_rep in inter_reps:\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\n# n_clusters = -1, clust_ratio = 200,\n# similarity_measure=\"pearson\",\n# threshold=0.5, n_jobs = 1))\n# classes.append(i_rep.cls)\n# subjects.append(i_rep.subj_name)\n# print \"Graph built for subject %s and class %s.\" %(i_rep.subj_name, i_rep.cls)\n# print \"Number of nodes: %i, number of edges: %i\" %(graphs[-1].number_of_nodes(),\n# graphs[-1].number_of_edges())\n# print \"\"\n #---------------------------\n\n # Graph encoding based on Neirghboring connections and hierarchical clustering algorithm.\n #-----------------------------\n fc = gnc.GE_NeighConst_HCA()\n for i_rep in inter_reps:\n graphs.append(fc.encode(i_rep, clust_ratio=8, encoding='geometrical', threshold=0.2))\n classes.append(i_rep.cls)\n subjects.append(i_rep.subj_name)\n print \"Graph built for subject %s and class %s.\" %(i_rep.subj_name, i_rep.cls)\n print \"Number of nodes: %i, number of edges: %i\" %(graphs[-1].number_of_nodes(),\n graphs[-1].number_of_edges())\n print \"\"\n #---------------------------\n\n #######################################################################\n\n\n #######################################################################\n #Reordering data for the leave-one-subject-out cross-validation\n #######################################################################\n\n #Permutting elements for a further leave-two-out cv (leaving out\n #two samples corresponding to the same subject avoiding problems with\n #unbalanced data).\n# nm_graphs = [None] * len(graphs)\n# nm_classes = [None] * len(classes)\n# nm_subjects = [None] * len(subjects)\n#\n# for i in range(len(graphs) / 2):\n# nm_graphs[i*2] = graphs[i]\n# nm_graphs[i*2 + 1] = graphs[(len(graphs) / 2) + i]\n# nm_classes[i*2] = classes[i]\n# nm_classes[i*2 + 1] = classes[(len(classes) / 2) + i]\n# nm_subjects[i*2] = subjects[i]\n# nm_subjects[i*2 + 1] = subjects[(len(subjects) / 2) + i]\n#\n print subjects\n print classes\n\n\n# #Testing if I get chance level when I permutted the class label...\n# np.random.shuffle(nm_classes)\n# np.random.shuffle(nm_classes)\n# print nm_classes\n\n\n #######################################################################\n\n\n #######################################################################\n #Computing the Graph Kernel\n #######################################################################\n\n #Computing the kernel matrix by using WL graph kernel.\n gk_wl = gk.GK_WL()\n k_matrix = gk_wl.compare_list_normalized(graphs, h = 1, nl = True)\n\n #Computing the kernel matrix with the normalized vectors graph kernel\n# gk_wl = gknv.GK_WL_NV()\n# k_norm_mat = gk_wl.compare_list_normalized(nm_graphs, h = 2, nl = False)\n\n #Computing the kernel matrix by using the weighted version of WL.\n# gk_wl = gkw.GK_WL_Weights()\n# k_matrix = gk_wl.compare_list_normalized(nm_graphs, h = 0, nl = False)\n\n #######################################################################\n\n\n #######################################################################\n #Ploting the similarity matrix\n #######################################################################\n\n #Ploting the similarity matrix, the matrix is permuted to have all\n #samples belonging to the first class at the beggining.\n# perm_matrix = ut.PermuteMatrix(k_matrix, nm_classes)\n# vs.PlotMatrix(perm_matrix)\n\n #Making a list with number of nodes and edges of all graphs. They will be\n #used in the plotting.\n n_nodes = []\n n_edges = []\n for g in graphs:\n n_nodes.append(g.number_of_nodes())\n n_edges.append(g.number_of_edges())\n\n #Plotting the vectorial representation of each graph. In the picture we\n #include number_of_nodes and number_of_edges, original_vectors and\n #normalized_vectors.\n #vs.PlotFeatureVectors(n_nodes, n_edges, gk_wl.vectors, gk_wl_nv.vectors, nm_classes)\n vs.PlotFeatureVectors(n_nodes, n_edges, gk_wl.vectors, gk_wl.vectors, classes)\n\n #######################################################################\n\n\n #######################################################################\n #Leave-one-subject-out cross-validation\n #######################################################################\n\n preds, scores = cl.subject_fold_cv(k_matrix, np.array(classes),\n n_subjects = 6)\n print \"\"\n print \"Predictions: \"\n print preds\n print \"\"\n print \"Scores:\"\n print scores\n\n #######################################################################\n\n\n return scores","def open_files(self):\n if not self.unbalanced:\n if not self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest.nc')\n return datas\n if self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_valid.nc')\n return datas\n if self.unbalanced:\n if not self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced.nc')\n return datas\n if self.validation:\n datas={}\n for var in self.variables:\n datas[var]=xr.open_dataset(\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced_valid.nc')\n return datas","def main(folder, quiet=0):\n\n if quiet:\n output_stream = StringIO()\n else:\n output_stream = sys.stdout\n\n\n\n color1 = \"I4\" #filter system for first color of CMD\n color2 = \"M1\" #filter system for second color of CMD\n zeromagc1 = zero.zero_mag[color1]\n zeromagc2 = zero.zero_mag[color2]\n min_mag = 8. #minimal observation limit\n max_mag = 0. #maximal observation limit\n\n#getting file list\n files = sorted(os.listdir('%s/%s' % (os.getcwdu(), folder))) \n out = []\n\n for fil in files:\n#only using files created by the automated simulation\n if fil.startswith('sim_') and not 'settings' in fil.encode(\"ascii\"):\n print(\"%s/%s\" % (folder,fil.encode(\"ascii\")), file=output_stream)\n \n\n # Read in\n hdulist = fits.open('%s/%s' %(folder,fil))\n data = hdulist[1].data\n\n #calculating magnitudes from fluxes and converting to CMD-data\n x = -2.5*(np.log10(data['c%s' % color1]/zeromagc1) - np.log10(data['c%s' % color2]/zeromagc2))\n y = -2.5*(np.log10(data['c%s' % color2]/zeromagc2))\n\n \n sel = np.logical_and( (y > -10./3. * (x-1.) + 10.), np.logical_and(max_mag < y, y < min_mag))\n sel = np.logical_and(sel, y < -x + 12.)\n n = sum(sel)\n t = Table(hdulist[1].data)\n if 'sel' in t.columns:\n t.remove_column('sel')\n t.add_column(Column(name='sel', data=sel.astype('int')))\n \n hdulist[1].data = np.array(t)\n tmp, av, apera, age = fil.split('_')\n fits.update('%s/%s' %(folder,fil), np.array(t), ext = 1, clobber=True)\n out.append([av, apera, age, n])\n\n #writing obtained data to \"folder/__expected_number\"\n head = ['#', 'AV', 'Aperature_size', 'Age', 'Expected_number']\n f = open('%s/__expected_number' % folder, 'w')\n f.write(','.join(head)+'\\n' )\n np.savetxt(f, np.asarray(out).astype(int))\n f.close()\n \n print (\"Analysed %s files and saved output to %s\" % (len(out),'%s/__expected_number' % folder), file=output_stream)","def open_file(self):\n file = open(self.file_name_dat, \"r\")\n rows = []\n hashlinecount = 0 # looking at commented lines in order to extract fermi energy\n for line in file:\n rows.append(line)\n\n # Getting information from the comments section\n xdatatemp = []\n ydatatemp = []\n for row in rows:\n if \"#\" in row: # Getting information from the comments\n hashlinecount += 1\n if hashlinecount == 7: # Getting the E_f value\n temp = row.split()\n if len(temp) == 4:\n self.E_f = temp[3]\n elif len(temp) == 7:\n self.E_f = temp[6]\n self.Efshift = True\n continue\n elif hashlinecount == 9: # Getting the min and max band energies\n temp = row.split()\n self.E_min = float(temp[4])\n self.E_max = float(temp[5])\n continue\n elif hashlinecount == 11: # Gettiing the minimum and maximum band numbers to plot\n temp = row.split()\n self.band_number_min = int(temp[5])\n self.band_number_max = int(temp[6])\n continue\n\n elif row.strip() == \"\": # saving individual bands the first save will be a null band\n self.band_data_x.append(xdatatemp) # Saving in a 2d list.\n self.band_data_y.append(ydatatemp)\n xdatatemp = []\n ydatatemp = []\n else:\n t = row.split()\n xdatatemp.append(float(t[0]))\n ydatatemp.append(float(t[1]))\n\n # Getting rid of empty lists\n self.band_data_x = [x for x in self.band_data_x if x]\n self.band_data_y = [x for x in self.band_data_y if x]\n\n # opening the bands file to get the kpath\n bands_file = open(self.file_name_bands, \"r\")\n bands_file_rows = []\n hashlinecount = 0 # looking at commented lines in order to extract fermi energy\n for bands_file_line in bands_file:\n bands_file_rows.append(bands_file_line)\n\n length_bands_file_rows = len(bands_file_rows)\n for i in range(length_bands_file_rows-1, 0, -1):\n temperary = bands_file_rows[i].split()\n if len(temperary) == 2:\n self.kpath_k.append(float(temperary[0].strip()))\n self.kpath_symbol.append(str(temperary[1].strip(\"'\")))\n elif len(temperary) is not 2:\n break\n self.kpath_symbol = latexify(self.kpath_symbol)","def main():\n parser = argparse.ArgumentParser(description=\n ('Plot and save data from DS9 projections. If only labels are '\n 'given, it will just plot existing dat files.'\n 'Other regions/objects in file are ignored.'))\n\n parser.add_argument('infile', help='Input DS9 region file (fk5 coords)')\n parser.add_argument('datroot', help='Stem for output profile data')\n\n parser.add_argument('-p', '--pltroot', help='Stem for output plots')\n parser.add_argument('-f', '--files', help=('Files (.fits) to be processed,'\n ' one for each energy band'),\n nargs='*')\n\n parser.add_argument('-l', '--labels', help='Band labels for plots/files',\n nargs='+')\n parser.add_argument('-v', '--verbose', action='store_true',\n help='verbose mode')\n parser.add_argument('-s', '--subplot', action='store_true',\n help='Generate subplot plots')\n\n # Parse arguments\n args = parser.parse_args()\n regions_file = args.infile\n pltroot, datroot = args.pltroot, args.datroot\n bands, labels = args.files, args.labels # NOTE bands = args.files...\n verbose, subplot = args.verbose, args.subplot\n\n # Check arguments for sanity\n # If -p is supplied, output plots\n # If -b is supplied, output data\n if bands is None:\n if not pltroot:\n parser.error('Nothing to be done! Need bands or pltroot.')\n else:\n print 'No bands supplied, generating plots only'\n else:\n if len(bands) != len(labels):\n raise ValueError(('Non-zero number of bands '\n 'does not match number of labels!'))\n elif not pltroot:\n print 'No pltroot supplied, generating data only'\n\n # Parse projections\n rspecs = get_projection_params(regions_file)\n if verbose:\n print 'Projections parsed from region file'\n\n # Generate data files, if desired\n if bands is not None:\n regparse.check_dir(datroot, verbose) # only create if saving data\n generate_dat_files(rspecs, datroot, bands, labels)\n\n # Generate plots, if desired\n if pltroot:\n regparse.check_dir(pltroot, verbose)\n generate_plots(rspecs, datroot, pltroot, labels, verbose, subplot)\n\n if verbose:\n print 'Done!'","def read_fluxes(self, time_step,\n periodic_directions=[],\n directory=None,\n **kwargs):\n print('[time-step {}] reading fluxes from files ...'.format(time_step)),\n dim3 = (len(self.grid) == 3)\n # directory with numerical solution\n if not directory:\n directory = os.path.join(self.directory, '{:0>7}'.format(time_step))\n # read grid-stations and fluxes\n x, y = self.grid[:2]\n nx, ny = x.size - 1, y.size - 1\n qx_file_path = os.path.join(directory, 'qx.dat')\n qx = PetscBinaryIO.PetscBinaryIO().readBinaryFile(qx_file_path)[0]\n qy_file_path = os.path.join(directory, 'qy.dat')\n qy = PetscBinaryIO.PetscBinaryIO().readBinaryFile(qy_file_path)[0]\n if dim3:\n z = self.grid[2]\n nz = z.size - 1\n qz_file_path = os.path.join(directory, 'qz.dat')\n qz = PetscBinaryIO.PetscBinaryIO().readBinaryFile(qz_file_path)[0]\n # create flux Field objects in staggered arrangement\n # reshape fluxes in multi-dimensional arrays\n if dim3:\n qx = qx.reshape((nz, ny, (nx if 'x' in periodic_directions else nx - 1)))\n qx = qx[:, :, :(-1 if 'x' in periodic_directions else None)]\n qx = Field(label='x-flux',\n time_step=time_step,\n x=x[1:-1],\n y=0.5 * (y[:-1] + y[1:]),\n z=0.5 * (z[:-1] + z[1:]),\n values=qx)\n qy = qy.reshape((nz, (ny if 'y' in periodic_directions else ny - 1), nx))\n qy = qy[:, :(-1 if 'y' in periodic_directions else None), :]\n qy = Field(label='y-flux',\n time_step=time_step,\n x=0.5 * (x[:-1] + x[1:]),\n y=y[1:-1],\n z=0.5 * (z[:-1] + z[1:]),\n values=qy)\n qz = qz.reshape(((nz if 'z' in periodic_directions else nz - 1), ny, nx))\n qz = qz[:(-1 if 'z' in periodic_directions else None), :, :]\n qz = Field(label='z-flux',\n time_step=time_step,\n x=0.5 * (x[:-1] + x[1:]),\n y=0.5 * (y[:-1] + y[1:]),\n z=z[1:-1],\n values=qz)\n print('done')\n return qx, qy, qz\n else:\n qx = qx.reshape((ny, (nx if 'x' in periodic_directions else nx - 1)))\n qx = qx[:, :(-1 if 'x' in periodic_directions else None)]\n qx = Field(label='x-flux',\n time_step=time_step,\n x=x[1:-1],\n y=0.5 * (y[:-1] + y[1:]),\n values=qx)\n qy = qy.reshape(((ny if 'y' in periodic_directions else ny - 1), nx))\n qy = qy[:(-1 if 'y' in periodic_directions else None), :]\n qy = Field(label='y-flux',\n time_step=time_step,\n x=0.5 * (x[:-1] + x[1:]),\n y=y[1:-1],\n values=qy)\n print('done')\n return qx, qy","def run_script(input_dir, output_dir):\n\n \"\"\"+++++++++++++++++++++++++++++++++++\"\"\"\n \"\"\"Step 1. load dataset \"\"\"\n print(\"loading data ......\")\n print(\"+++++++Read the surface shape data+++++++\")\n shape_file_name = input_dir + \"aligned_shapes.mat\"\n mat = loadmat(shape_file_name)\n y_design = mat['aligned_shape']\n n, l, m = y_design.shape\n print(\"The dimension of shape matrix is \" + str(y_design.shape))\n print(\"+++++++Read the sphere coordinate data+++++++\")\n template_file_name = input_dir + \"template.mat\"\n mat = loadmat(template_file_name)\n coord_mat = mat['template']\n # d = coord_mat.shape[1]\n print(\"+++++++Read the design matrix+++++++\")\n design_data_file_name = input_dir + \"design_data.txt\"\n design_data = np.loadtxt(design_data_file_name)\n # read the covariate type\n var_type_file_name = input_dir + \"var_type.txt\"\n var_type = np.loadtxt(var_type_file_name)\n print(\"+++++++Construct the design matrix: normalization+++++++\")\n x_design = read_x(design_data, var_type)\n p = x_design.shape[1]\n print(\"The dimension of design matrix is \" + str(x_design.shape))\n\n \"\"\"+++++++++++++++++++++++++++++++++++\"\"\"\n \"\"\"Step 2. Statistical analysis: including (1) smoothing and (2) hypothesis testing\"\"\"\n gpvals, lpvals_fdr, clu_pvals, efit_beta, efity_design, efit_eta = mfsda.run_stats(y_design, coord_mat, design_data, var_type)\n\n \"\"\"+++++++++++++++++++++++++++++++++++\"\"\"\n \"\"\"Step3. Save all the results\"\"\"\n gpvals_file_name = output_dir + \"global_pvalue.txt\"\n np.savetxt(gpvals_file_name, gpvals)\n lpvals_fdr_file_name = output_dir + \"local_pvalue_fdr.txt\"\n np.savetxt(lpvals_fdr_file_name, lpvals_fdr)\n clu_pvals_file_name = output_dir + \"cluster_pvalue.txt\"\n np.savetxt(clu_pvals_file_name, clu_pvals)","def read(self, **kwargs):\n\n if not os.path.isfile(self.file_name):\n self.build()\n elif 'clobber' in self.kwargs.keys():\n if self.kwargs['clobber']: \n self.build()\n\n # read dLOS file from parent class\n super(DlosPhotoz, self).read()\n\n self.dlos, self.dlos_photoz = np.loadtxt(\n self.file_name, \n skiprows=1, \n unpack=True, \n usecols=[0, 1]\n )\n return None","def test_to_single_xyz_rdkit(self):\n from openff.toolkit.utils import RDKitToolkitWrapper\n\n tkw = RDKitToolkitWrapper()\n\n # load a molecule with a single conformation\n toluene = Molecule.from_file(\n get_data_file_path(\"molecules/toluene.sdf\"), \"sdf\", toolkit_registry=tkw\n )\n # make sure it has one conformer\n assert toluene.n_conformers == 1\n\n with NamedTemporaryFile(suffix=\".xyz\") as iofile:\n # try and write out the xyz file\n toluene.to_file(iofile.name, \"xyz\", toolkit_registry=tkw)\n\n # now lets check the file contents\n with open(iofile.name) as xyz_data:\n data = xyz_data.readlines()\n # make sure we have the correct amount of lines writen\n assert len(data) == 17\n # make sure all headers and frame data was writen\n assert data.count(\"15\\n\") == 1\n assert data.count(\"C7H8\\n\") == 1\n # now check that we can find the first and last coords\n coords = [\n \"C 22.3700000000 21.6800000000 29.7700000000\\n\",\n \"H 26.7900000000 23.1900000000 28.7200000000\\n\",\n ]\n for coord in coords:\n assert coord in data","def Test(self):\n\t\tself.filename = \"NC-Xy_norm_bgsub.txt\"\n\t\tself.dirname = \"data\"\n\t\tself.FileText.SetLabel(\"File: \"+self.filename)\n\t\t#self.raw_file = self.LoadData(os.path.join(self.dirname, self.filename))\n\t\tself.AddBackgroundCheckBox.SetValue(True)\n\t\tself.combine_data()\n\t\tself.PP_AlgorithmRadio.SetValue(True)\n\t\tself.plot_data()","def Plot_RCWA_Ssim(Path) :\n #/Users/simonvassant/Documents/20090707_TestsPython/Result_Champ/SSim_O21Pr_2000H_res1000F1.res\n x,y=[],[]\n fs = open(Path, 'r') \n#index_array = 0\n while 1: \n txt = fs.readline()\n if txt =='': \n break\n x.append(float(txt[0:12]))\n y.append(float(txt[13:-1]))\n #x[index_array],y[index_array] = float(txt[0:9]),float(txt[10:17])\n #index_array = index_array+1\n \n fs.close()\n plt.figure(1)\n plt.plot(x,y)\n plt.xlabel(r\"Longueur d'onde $(\\mu m)$\")\n plt.ylabel('R')","def run(self):\r\n # Close any open models\r\n self.cleanUp()\r\n # Dynamically select file to preview\r\n self.selectTrial() \r\n # Add adjusted COM (RRA/CMC) model\r\n self.loadAdjustedModel()\r\n # Hide the markers from view\r\n self.hideModelMarkers()\r\n # Load CMC motion to model\r\n self.loadCMCMotion()","def load(fnames, tag='', inst_id=''):\n\n # Save each file to the output DataFrame\n data = load_csv_data(fnames, read_csv_kwargs={'index_col': 0,\n 'parse_dates': True})\n\n # Assign the meta data\n meta, status_desc = mm_ace.common_metadata()\n flux_desc = '5-min averaged Differential '\n\n meta['status_e'] = {meta.labels.units: '',\n meta.labels.name: 'Diff e- Flux Status',\n meta.labels.notes: '',\n meta.labels.desc: status_desc,\n meta.labels.fill_val: np.nan,\n meta.labels.min_val: 0,\n meta.labels.max_val: 9}\n meta['status_p'] = {meta.labels.units: '',\n meta.labels.name: 'Diff Proton Flux Status',\n meta.labels.notes: '',\n meta.labels.desc: status_desc,\n meta.labels.fill_val: np.nan,\n meta.labels.min_val: 0,\n meta.labels.max_val: 9}\n meta['anis_ind'] = {meta.labels.units: '',\n meta.labels.name: 'Anisotropy Index',\n meta.labels.notes: '',\n meta.labels.desc: 'Range: 0.0 - 2.0',\n meta.labels.fill_val: -1.0,\n meta.labels.min_val: 0.0,\n meta.labels.max_val: 2.0}\n meta['eflux_38-53'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff e- Flux 38-53 eV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Electron Flux between 35-53 eV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['eflux_175-315'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff e- Flux 175-315 eV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Electron Flux between 175-315 eV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_47-68'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 47-68 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 47-68 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_115-195'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 115-195 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 115-195 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_310-580'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 310-580 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 310-580 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_795-1193'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name: 'Diff Proton Flux 795-1193 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 795-1193 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n meta['pflux_1060-1900'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\n meta.labels.name:\n 'Diff Proton Flux 1060-1900 keV',\n meta.labels.notes: '',\n meta.labels.desc:\n ''.join([flux_desc,\n 'Proton Flux between 1060-1900 keV']),\n meta.labels.fill_val: -1.0e5,\n meta.labels.min_val: -np.inf,\n meta.labels.max_val: np.inf}\n return data, meta","def txt2hdf5_mudis(config, init_file=0, final_file=100, step=1, expo='100'):\n # --------SKYMAP--------------\n # Create the directory to save the results\n os.makedirs(os.path.dirname(cwd + '/config_files/'), exist_ok=True)\n\n alignment = add_align()\n\n # Extract skymap from alignment file\n skymap = np.zeros((len(alignment), 2))\n\n for i in np.arange(len(skymap)):\n skymap[i] = alignment['Azimuth'][i], alignment['Zenith'][i]\n\n # Save Skymap information\n with h5py.File(cwd + '/config_files/skymap_radiance.h5', 'w') as sky:\n\n if not list(sky.items()):\n sky.create_dataset('/skymap', data=skymap)\n else:\n del sky['skymap']\n\n sky.create_dataset('/skymap', data=skymap, dtype='f4')\n sky['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\n sky['skymap'].dims[0].label = 'channel'\n sky['skymap'].dims[1].label = 'Azimuth, Zenith'\n\n config['skymap'] = skymap\n\n # Save MUDIS file information\n\n # Import the radiance data from sensor\n files = sorted(\n glob.glob(config['raw_dir'] + '/radiance/{}/data/data_*.txt'.format(config['date'])))\n\n print('Total files in the directory: ' + str(len(files)) + ' files')\n\n ans = input('convert all files? (y/n): ')\n\n if ans == 'n':\n print('configure initial and final file index in the function options')\n else:\n init_file = 0\n final_file = len(files)\n\n for fil in np.arange(init_file, final_file):\n # Import the data from the file\n file = np.genfromtxt(files[fil], delimiter='', skip_header=11)\n\n # ------------RADIANCE DATA RAW---------------\n # create the radiance matrix\n data = np.zeros([113, 992])\n\n for i in np.arange(113):\n if str(alignment.iloc[i][3]) == 'nan':\n data[i] = np.nan\n else:\n try:\n data[i] = file[:, int(alignment.iloc[i][3] + config['channel_pixel_adj'])] #\n except:\n pass #\n # read the pixels index\n # in the alignment file and copy the\n # data in the radiance matrix']))\n\n # Correct time for the file UTC\n name = os.path.split(files[fil])\n\n # Read name of the file (correct time)\n time = name[1][6:25]\n # convert time to datetime format\n time = datetime.datetime.strptime(time, '%d.%m.%Y_%H_%M_%S')\n # print(time)\n new_name = datetime.datetime.strftime(time, '%Y%m%d_%H%M%S')\n\n with open(files[fil], 'r') as file:\n dat = file.readlines()\n\n # Extract information from .dat file\n exposure = int(dat[4][12:-1])\n NumAve = int(dat[7][17:-1])\n CCDTemp = int(dat[8][15:-1])\n NumSingMes = int(dat[10][27:-1])\n ElectrTemp = int(dat[9][23:-1])\n\n # Create the directory to save the results\n os.makedirs(os.path.dirname(config['str_dir'] + '/radiance/{}/data/').format(config['date']),\n exist_ok=True)\n\n if exposure == expo:\n # Create a file in the disk\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(config['date'], new_name),\n 'w') as datos:\n\n if not list(datos.items()):\n # Create two datasets(use only one time)\n datos.create_dataset('/data', data=data, dtype='f4')\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\n else:\n del datos['data']\n del datos['skymap']\n print('data deleted and corrected')\n datos.create_dataset('/data', data=data, dtype='f4')\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\n\n # Add attributes to datasets\n datos['data'].attrs['time'] = str(time)\n datos['data'].attrs['Exposure'] = exposure\n datos['data'].attrs['NumAver'] = NumAve\n datos['data'].attrs['CCDTemp'] = CCDTemp\n datos['data'].attrs['NumSingMes'] = NumSingMes\n datos['data'].attrs['ElectrTemp'] = ElectrTemp\n datos['data'].attrs['Latitude'] = '52.39N'\n datos['data'].attrs['Longitude'] = '9.7E'\n datos['data'].attrs['Altitude'] = '65 AMSL'\n datos['data'].dims[0].label = 'channel'\n datos['data'].dims[1].label = 'wavelength'\n\n datos['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\n\n datos.close()\n\n print('File ' + str(fil + init_file + 1) + ' of ' +\n str((final_file - init_file)) + ' saved')\n else:\n print('Exposure are not same', expo, exposure)\n break\n\n print('Completed')","def test_run_experiment_from_gromacs_files():\n complex_path = examples_paths()['pxylene-complex']\n solvent_path = examples_paths()['pxylene-solvent']\n include_path = examples_paths()['pxylene-gro-include']\n with mmtools.utils.temporary_directory() as tmp_dir:\n yaml_script = get_template_script(tmp_dir)\n yaml_script['options']['anisotropic_dispersion_cutoff'] = None\n del yaml_script['molecules'] # we shouldn't need any molecule\n yaml_script['systems'] = {'explicit-system':\n {'phase1_path': complex_path, 'phase2_path': solvent_path,\n 'ligand_dsl': 'resname \"p-xylene\"', 'solvent': 'PME',\n 'gromacs_include_dir': include_path}}\n yaml_script['experiments']['system'] = 'explicit-system'\n\n exp_builder = ExperimentBuilder(yaml_script)\n exp_builder._check_resume() # check_resume should not raise exceptions\n exp_builder.run_experiments()\n\n # The experiments folders are correctly named and positioned\n output_dir = exp_builder._get_experiment_dir('')\n assert os.path.isdir(output_dir)\n assert os.path.isfile(os.path.join(output_dir, 'complex.nc'))\n assert os.path.isfile(os.path.join(output_dir, 'solvent.nc'))\n assert os.path.isfile(os.path.join(output_dir, 'experiments.yaml'))\n assert os.path.isfile(os.path.join(output_dir, 'experiments.log'))\n\n # Analysis script is correct\n analysis_script_path = os.path.join(output_dir, 'analysis.yaml')\n with open(analysis_script_path, 'r') as f:\n assert yaml.load(f, Loader=yaml.FullLoader) == [['complex', 1], ['solvent', -1]]","def load_raw_data(self, input_files):\n\n log.debug(f\"Loading dataset {input_files}\") \n print(f\"Loading dataset\")\n\n # Load stroke information from XML files\n for file in input_files:\n new_strokeset = strokeset.StrokeSet(file)\n self.strokesets.append(new_strokeset)\n self.stroke_matrix.append(new_strokeset.as_delta_array())\n self.stroke_ascii.append(new_strokeset.get_text())\n\n done_msg = \"Finished parsing dataset. Imported {} lines\".format(len(self.get_strokesets()))\n print (done_msg)\n log.info(done_msg)","def useZstat(zstat, file_path_name_save, file_path_conte, file_path_name_resting_atlas):\n\n import matplotlib.pyplot as plt\n import os\n from glob import glob\n import numpy as np\n import nibabel as nb\n import nibabel.gifti as gifti\n\n # Crucial: xvfb must be imported and started before importing mayavi\n from xvfbwrapper import Xvfb\n print('XVb pre')\n vdisplay = Xvfb()\n vdisplay.start()\n\n print('pre maya')\n # Crashes on this line if run with plain python (not xvfb-run ... python) and if xvfbwrapper is after it.\n from mayavi import mlab\n print('post maya')\n from tvtk.api import tvtk\n print('post tvtk')\n import math\n\n print('display')\n mlab.options.offscreen = True #offscreen window for rendering\n\n img = nb.load(file_path_name_resting_atlas)\n #img = nb.load('/Users/MathiasMacbook/Desktop/rfMRI_REST1_LR_Atlas.dtseries.nii')\n mim = img.header.matrix.mims[1]\n #for idx, bm in enumerate(mim.brainModels):\n # print((idx, bm.indexOffset, bm.brainStructure))\n bm1 = mim.brainModels[0]\n lidx = bm1.vertexIndices.indices\n bm2 = mim.brainModels[1]\n ridx = bm1.surfaceNumberOfVertices + bm2.vertexIndices.indices\n bidx = np.concatenate((lidx, ridx))\n\n axis = [0, 0, 1]\n theta = np.pi\n\n inflated = True\n split_brain = True\n\n surf = gifti.read(file_path_conte + '/Conte69.L.midthickness.32k_fs_LR.surf.gii') \n verts_L_data = surf.darrays[0].data\n faces_L_data = surf.darrays[1].data\n\n surf = gifti.read(file_path_conte + '/Conte69.R.midthickness.32k_fs_LR.surf.gii') \n verts_R_data = surf.darrays[0].data\n faces_R_data = surf.darrays[1].data\n\n if inflated:\n surf = gifti.read(file_path_conte + '/Conte69.L.inflated.32k_fs_LR.surf.gii')\n verts_L_display = surf.darrays[0].data\n faces_L_display = surf.darrays[1].data\n surf = gifti.read(file_path_conte + '/Conte69.R.inflated.32k_fs_LR.surf.gii')\n verts_R_display = surf.darrays[0].data\n faces_R_display = surf.darrays[1].data\n else:\n verts_L_display = verts_L_data.copy()\n verts_R_display = verts_R_data.copy()\n faces_L_display = faces_L_data.copy()\n faces_R_display = faces_R_data.copy()\n\n verts_L_display[:, 0] -= max(verts_L_display[:, 0])\n verts_R_display[:, 0] -= min(verts_R_display[:, 0])\n verts_L_display[:, 1] -= (max(verts_L_display[:, 1]) + 1)\n verts_R_display[:, 1] -= (max(verts_R_display[:, 1]) + 1)\n\n faces = np.vstack((faces_L_display, verts_L_display.shape[0] + faces_R_display))\n\n if split_brain:\n verts2 = rotation_matrix(axis, theta).dot(verts_R_display.T).T\n else:\n verts_L_display[:, 1] -= np.mean(verts_L_display[:, 1])\n verts_R_display[:, 1] -= np.mean(verts_R_display[:, 1])\n verts2 = verts_R_display\n\n verts_rot = np.vstack((verts_L_display, verts2))\n verts = np.vstack((verts_L_data, verts_R_data))\n #print verts.shape\n #print faces.shape\n\n if not os.path.exists(os.path.split(file_path_name_save)[0]):\n os.makedirs(os.path.split(file_path_name_save)[0]) \n\n print('use zstat')\n img = nb.load(zstat)\n print('loaded img')\n \n threshold = 2.3 # 1000, lower limit\n display_threshold = 6 #8000, upper limit\n\n data = img.get_data()\n aff = img.affine\n indices = np.round((np.linalg.pinv(aff).dot(np.hstack((verts, \n np.ones((verts.shape[0], 1)))).T))[:3, :].T).astype(int)\n scalars2 = data[indices[:, 0], indices[:, 1], indices[:, 2]]\n scalars2[np.abs(scalars2) < threshold] = 0.\n scalars = np.zeros(verts.shape[0])\n scalars[bidx] = scalars2[bidx]\n\n negative = positive = False\n if np.any(scalars < 0):\n negative = True\n if np.any(scalars > 0):\n positive = True\n\n nlabels = 2\n vmin = 0\n vmax = 0\n if negative and positive:\n maxval = max(-scalars.min(), scalars.max())\n if maxval > display_threshold:\n maxval = display_threshold\n vmin = -maxval\n vmax = maxval\n nlabels = 3\n vmin = -display_threshold ######\n vmax = display_threshold ######\n elif negative:\n vmin = scalars.min()\n if vmin < -display_threshold:\n vmin = -display_threshold\n vmax = 0\n vmin = -display_threshold ######\n elif positive:\n vmax = scalars.max()\n if vmax > display_threshold:\n vmax = display_threshold\n vmin = 0\n vmax = display_threshold ######\n #print zstat\n \n dual_split = True\n\n fig1 = mlab.figure(1, bgcolor=(0, 0, 0))\n mlab.clf()\n mesh = tvtk.PolyData(points=verts_rot, polys=faces)\n mesh.point_data.scalars = scalars\n mesh.point_data.scalars.name = 'scalars'\n surf = mlab.pipeline.surface(mesh, colormap='autumn', vmin=vmin, vmax=vmax)\n if dual_split:\n verts_rot_shifted = verts_rot.copy()\n verts_rot_shifted = rotation_matrix(axis, theta).dot(verts_rot_shifted.T).T\n verts_rot_shifted[:, 2] -= (np.max(verts_rot_shifted[:, 2]) - np.min(verts_rot_shifted[:, 2]))\n verts_rot_shifted[:, 0] -= np.max(verts_rot_shifted[:, 0])\n mesh2 = tvtk.PolyData(points=verts_rot_shifted, polys=faces)\n mesh2.point_data.scalars = scalars\n mesh2.point_data.scalars.name = 'scalars'\n surf2 = mlab.pipeline.surface(mesh2, colormap='autumn', vmin=vmin, vmax=vmax)\n colorbar = mlab.colorbar(surf, nb_labels=nlabels) #, orientation='vertical')\n lut = surf.module_manager.scalar_lut_manager.lut.table.to_array()\n\n if negative and positive:\n half_index = lut.shape[0] / 2\n index = int(half_index * threshold / vmax)\n lut[(half_index - index + 1):(half_index + index), :] = 192\n lut[(half_index + index):, :] = 255 * plt.cm.autumn(np.linspace(0, 255, half_index - index).astype(int))\n lut[:(half_index - index), :] = 255 * plt.cm.cool(np.linspace(0, 255, half_index - index).astype(int))\n elif negative:\n index = int(lut.shape[0] * threshold / abs(vmin))\n lut[(lut.shape[0] - index):, :] = 192\n lut[:(lut.shape[0] - index), :] = 255 * plt.cm.cool(np.linspace(0, 255, lut.shape[0] - index).astype(int))\n elif positive:\n index = int(lut.shape[0] * threshold / vmax)\n lut[:index, :] = 192\n lut[index:, :] = 255 * plt.cm.autumn(np.linspace(0, 255, lut.shape[0] - index).astype(int))\n lut[:, -1] = 255\n\n surf.module_manager.scalar_lut_manager.lut.table = lut\n if dual_split:\n surf2.module_manager.scalar_lut_manager.lut.table = lut\n surf.module_manager.scalar_lut_manager.show_scalar_bar = False\n surf.module_manager.scalar_lut_manager.show_legend = False\n surf.module_manager.scalar_lut_manager.label_text_property.font_size = 10\n surf.module_manager.scalar_lut_manager.show_scalar_bar = True\n surf.module_manager.scalar_lut_manager.show_legend = True\n mlab.draw()\n\n translate = [0, 0, 0]\n if inflated:\n zoom = -700\n else:\n zoom = -600\n if dual_split:\n if inflated:\n translate = [0, 0, -104.01467148]\n else:\n translate = [0, 0, -54.76305802] \n if inflated:\n zoom = -750\n else:\n zoom = -570\n \n #mlab.view(0, 90.0, zoom, translate)\n mlab.view(9, 90.0)\n\n print(file_path_name_save)\n \n mlab.savefig(file_path_name_save, figure=fig1, magnification=5)\n\n vdisplay.stop()","def main(args):\n args = parse_args(args)\n setup_logging(args.loglevel)\n _logger.debug(\"Generating NUFEB simulation files\")\n\n # create nutrients\n light = Nutrient(1e-1, None, None, \"g\", \"nn\")\n co2 = Nutrient(float(args.co2), 1.9e-09, 44.01, \"l\", \"nn\")\n o2 = Nutrient(0.28125, 2.30e-9, 32, \"l\", \"nn\")\n sucrose = Nutrient(float(args.sucrose), 5.2e-10, 342.3, \"l\", \"nn\")\n gco2 = Nutrient(0, None, 44.01, \"g\", \"nn\")\n TEMPLATES_DIR = (Path(__file__).parent) / \"templates\"\n\n captureRate = round(1000 / args.timestep)\n # define dump parameters\n dump_list = {\n \"vtk_dump\": f\"dump atom_vtk all vtk {captureRate} dump*.vtu id type diameter vx vy vz fx fy fz \\n dump grid_vtk all grid/vtk {captureRate} dump_%_*.vti con\",\n \"image_dump\": f\"dump du_image all image {captureRate} image.*.jpg type diameter zoom 2 bacillus type size 1280 720 view 45 60 \\n dump_modify du_image acolor 1 green acolor 2 red\",\n \"movie_dump\": f\"dump du_mov all movie {captureRate} movie.avi type diameter zoom 1.5 bacillus type size 1280 720 view 0 0 \\n dump_modify du_mov acolor 1 green acolor 2 red\",\n \"hdf_dump\": f\"dump du_h5 all nufeb/hdf5 {captureRate} dump.h5 id type x y z vx vy vz fx fy fz radius conc reac\",\n }\n\n dumps = defaultdict(list)\n for i in range(4):\n tmp = [\"vtk_dump\", \"image_dump\", \"movie_dump\", \"hdf_dump\"]\n dumps[tmp[i]]\n\n for dump, dump_var in zip(\n [args.vtk, args.img, args.movie, args.hdf],\n [\"vtk_dump\", \"image_dump\", \"movie_dump\", \"hdf_dump\"],\n ):\n if dump is True or dump == \"True\":\n dumps[dump_var] = dump_list[dump_var]\n else:\n dumps[dump_var] = \"\"\n\n ## Species-specific parameters\n\n # check for runs folder\n if not os.path.isdir(\"runs\"):\n os.mkdir(\"runs\")\n x = float(args.dims.split(\",\")[0])\n y = float(args.dims.split(\",\")[1])\n z = float(args.dims.split(\",\")[2])\n for n in range(1, int(args.num) + 1):\n culture = Culture(args)\n atoms_list = []\n bacilli_list = []\n # Create list of atoms and bacilli for atom definition file\n for cell in culture.cells:\n atoms_list.append(cell.Atom())\n bacilli_list.append(cell.Bacillus())\n # make atom definition file\n for r in range(1, int(args.reps) + 1):\n L = [\n \" NUFEB Simulation\\r\\n\\n\",\n f\" {args.cells_init} atoms \\n\",\n f\" {len(culture.cell_types)} atom types \\n\",\n f\" {args.cells_init} bacilli \\n\\n\",\n f\" 0.0e-4 {x :.2e} xlo xhi \\n\",\n f\" 0.0e-4 {y :.2e} ylo yhi \\n\",\n f\" 0.0e-4 {z :.2e} zlo zhi \\n\\n\",\n \" Atoms \\n\\n\",\n ]\n atoms = L + atoms_list\n atoms.append(\"\\n\")\n atoms.append(\" Bacilli \\n\\n\")\n atoms = atoms + bacilli_list\n # write atom definition file\n f = open(\n f\"runs/atom_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{r}.in\",\n \"w+\",\n )\n f.writelines(atoms)\n RUN_DIR = (\n Path(\"runs\")\n / f\"Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}\"\n )\n if not os.path.isdir(RUN_DIR):\n os.mkdir(RUN_DIR)\n # os.mkdir(f'runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}')\n # write initial conditions json file\n dumpfile = open(RUN_DIR / \"metadata.json\", \"w\")\n # dumpfile = open(f\"/runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}/metadata.json\",'w')\n json.dump(CellInfo, dumpfile, indent=6)\n dumpfile.close()\n ###\n\n # write Inputscript\n # open the file\n filein = open(TEMPLATES_DIR / \"bacillus.txt\")\n # filein = resources.read_text(\"nufeb_tools.templates\", \"Bacillus.txt\")\n # read it\n src = Template(filein.read())\n # do the substitution\n result = src.safe_substitute(\n {\n \"n\": args.cells_init,\n \"SucRatio\": culture.SucRatio,\n \"SucPct\": culture.SucPct,\n \"n_cyanos\": culture.n_cyanos,\n \"n_ecw\": culture.n_ecw,\n \"Replicates\": args.reps,\n \"Timesteps\": args.ntimesteps,\n \"ts\": args.timestep,\n \"CYANOGroup\": culture.cyGroup,\n \"ECWGroup\": culture.ecwGroup,\n \"Zheight\": float(args.dims.split(\",\")[2]),\n \"CYANODiv\": culture.cyDiv,\n \"ECWDiv\": culture.ecwDiv,\n \"light\": light.concentration,\n \"co2\": co2.concentration,\n \"o2\": o2.concentration,\n \"sucrose\": sucrose.concentration,\n \"gco2\": gco2.concentration,\n \"CYANOMonod\": culture.cyMonod,\n \"ECWMonod\": culture.ecwMonod,\n \"CYANOcount\": culture.cyanoCount,\n \"ECWcount\": culture.ecwCount,\n \"v_ncyano\": culture.vcyano,\n \"v_necw\": culture.vecw,\n \"vtk_dump\": dumps[\"vtk_dump\"],\n \"image_dump\": dumps[\"image_dump\"],\n \"movie_dump\": dumps[\"movie_dump\"],\n \"hdf_dump\": dumps[\"hdf_dump\"],\n }\n )\n f = open(\n f\"./runs/Inputscript_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.lmp\",\n \"w+\",\n )\n f.writelines(result)\n\n # write local run script\n # open the file\n filein = open(TEMPLATES_DIR / \"local.txt\")\n # filein = resources.read_text(\"nufeb_tools.templates\", \"local.txt\")\n # read it\n src = Template(filein.read())\n # do the substitution\n result = src.safe_substitute(\n {\n \"n\": n,\n \"SucRatio\": culture.SucRatio,\n \"SucPct\": culture.SucPct,\n \"n_cyanos\": culture.n_cyanos,\n \"n_ecw\": culture.n_ecw,\n \"Reps\": args.reps,\n }\n )\n f = open(\n f\"./runs/local_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.sh\", \"w+\"\n )\n f.writelines(result)\n # write slurm script\n # open the file\n filein = open(TEMPLATES_DIR / \"slurm_dev.txt\")\n # filein = resources.read_text(\"nufeb_tools.templates\", \"Slurm.txt\")\n # read it\n src = Template(filein.read())\n # do the substitution\n result = src.safe_substitute(\n {\n \"n\": args.cells_init,\n \"job\": f\"NUFEB_cyano{n}\",\n \"USER\": args.user,\n \"Replicates\": args.reps,\n \"SucPct\": culture.SucPct,\n \"n_cyanos\": culture.n_cyanos,\n \"n_ecw\": culture.n_ecw,\n }\n )\n _logger.info(\"Script ends here\")","def _read(self):\n # initializng data dictionary\n self.data={}\n\n f = FortranFile(self.filename)\n # Default omnivor binary header\n self.data['MK'] = f.readInts('i')\n self.data['itime'] = f.readInts('i')\n self.data['version'] = f.readString()\n self.data['file_id'] = f.readInts('i')\n self.data['sversion'] = f.readString()\n # Velocity field\n self.data['stype'] = f.readString()\n self.data['is_grid'] = f.readInts('i')\n nCPs = f.readInts('i')\n self.data['nCPs'] = nCPs\n if self.data['MK'] == 8:\n real_char='d'\n else:\n real_char='f'\n if self.data['is_grid']:\n #print('File is a velocity grid file')\n n1 = f.readInts('i')\n n2 = f.readInts('i')\n n3 = f.readInts('i')\n self.data['n1'] = n1\n self.data['n2'] = n2\n self.data['n3'] = n3\n self.data['is_straight'] = f.readInts('i')\n self.data['v1'] = f.readReals(real_char)\n self.data['v2'] = f.readReals(real_char)\n self.data['v3'] = f.readReals(real_char)\n\n CPs_raw = f.readReals(real_char)\n Utot_raw = f.readReals(real_char)\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\n\n acc=-1\n CPsTab = np.zeros((3, n1,n2,n3))\n UtotTab = np.zeros((3, n1,n2,n3))\n # Reshaping the nasty way (this is natural order). \n for i in range(0,n1):\n for j in range(0,n2):\n for k in range(0,n3):\n acc=acc+1\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\n\n self.data['CPs'] = CPs\n self.data['CPsTab'] = CPsTab\n self.data['Utot'] = Utot\n self.data['UtotTab'] = UtotTab","def test_readfile(self):\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\n HEN_FILE_EXTENSION\n command = \"{0}\".format(fname)\n\n hen.io.main(command.split())","def generate_data(path=resource_filename('locals', 'data/fake/'), mag_range=(11.13,18)):\n # Get some random spectra\n try:\n files = glob.glob('/user/jfilippazzo/Models/ACES/default/*.fits')[::50]\n except:\n files = glob.glob('/Users/jfilippazzo/Documents/Modules/_DEPRECATED/limb_dark_jeff/limb/specint/*.fits')[::20]\n \n # Make a fake source catalog (with only essential columns for now)\n catpath = os.path.join(path,'fake_source_catalog.ecsv')\n ids = list(range(len(files)))\n coords = SkyCoord([89.7455]*len(ids), [-29.05744]*len(ids), unit='deg', frame='icrs')\n cat = at.QTable([ids,coords], names=('id','icrs_centroid'))\n cat.write(catpath)\n \n # Open the x1d file\n header = fits.getheader(resource_filename('locals', 'data/template_x1d.fits'))\n \n # Make Spectrum objects from models at R=150\n wavelength = np.arange(0.05,2.6,0.0001)[::66]*q.um\n \n # Normalize the spectra to a random F200W magnitude\n spectra = []\n f200w = Bandpass('NIRISS.F200W')\n f200w.wave_units = q.um\n for file in files:\n \n # Create Spectrum\n flux = fits.getdata(file)[-1][::66]*q.erg/q.s/q.cm**2/q.AA\n unc = flux/50.\n spec = Spectrum(wavelength, flux, unc)\n \n # Normalize to F200W\n mag = np.random.uniform(*mag_range)\n norm_spec = spec.renormalize(mag, f200w)\n spectra.append(norm_spec)\n \n # Make a separate x1d file and photometry file for each bandpass\n # containing data for each source\n for band in NIRISS_bands:\n \n try:\n \n # Get the Bandpass object\n bp = Bandpass(band)\n bp.wave_units = q.um\n \n # Make x1d file for spectra\n x1d_file = os.path.join(path,'{}_x1d.fits'.format(band))\n x1d_hdu = fits.HDUList(fits.PrimaryHDU(header=header))\n \n # Make csv file for photometry\n phot_file = os.path.join(path,'{}_phot.csv'.format(band))\n phot_data = at.Table(names=('id','band','magnitude','magnitude_unc'), dtype=(int,'S20',float,float))\n \n # Iterate over spectra\n for id,(f,spec) in enumerate(zip(files,spectra)):\n \n # Trim spectrum to bandpass for x1d file\n spec = Spectrum(*spec.spectrum, trim=[(0*q.um,bp.WavelengthMin*1E-4*q.um),(bp.WavelengthMax*1E-4*q.um,10*q.um)])\n \n # Calculate magnitude and add to photometry table\n mag, mag_unc = spec.synthetic_magnitude(bp, force=True)\n phot_data.add_row([id, band, mag, mag_unc])\n \n # Add source spectrum params for verification\n params = f.split('/')[-1].split('-')\n header['TEFF'] = int(params[0].replace('lte',''))\n header['LOGG'] = float(params[1][:4])\n header['FEH'] = float(params[-6][:-8].split('+')[-1])\n header['FILEPATH'] = f\n header['PUPIL'] = band\n\n # Put spectrum in x1d fits file\n data = fits.BinTableHDU(data=np.rec.array(list(zip(*spec.data)),\n formats='float32,float32,float32',\n names='WAVELENGTH,FLUX,ERROR'),\n header=header)\n data.name = 'EXTRACT1D'\n \n x1d_hdu.append(data)\n \n # Write the photometry file\n phot_data.write(phot_file, format='ascii.csv')\n del phot_data\n \n # Write the x1d file\n x1d_hdu.writeto(x1d_file, overwrite=True)\n del x1d_hdu\n \n except IOError:\n pass","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 readExperi(directory,varid,experi,level):\n print('\\n>>> Using readExperi function! \\n')\n \n ### Import modules\n import numpy as np\n from netCDF4 import Dataset\n \n ### Call files\n totaldirectory = directory + experi + '/monthly/'\n filename = totaldirectory + varid + '_1900-2000.nc'\n \n if any([experi == 'FPOL',experi == 'FSUB']):\n directory = '/home/zlabe/green/simu/'\n totaldirectory = directory + experi + '/monthly/'\n filename = totaldirectory + varid + '_1900-2000.nc'\n \n ### Read in Data\n if level == 'surface': # 3d variables\n data = Dataset(filename,'r')\n varq = data.variables['%s' % varid][:,:,:,0]\n data.close()\n \n dataq = Dataset(totaldirectory + 'T2M_1900-2000.nc')\n time = dataq.variables['time'][:]\n lev = 'surface'\n lat = dataq.variables['latitude'][:]\n lon = dataq.variables['longitude'][:]\n dataq.close()\n elif level == 'profile': # 4d variables\n data = Dataset(filename,'r')\n varq = data.variables['%s' % varid][:,:,:,0]\n data.close()\n \n dataq = Dataset(totaldirectory + 'TEMP_1900-2000.nc')\n time = dataq.variables['time'][:]\n lev = dataq.variables['level'][:]\n lat = dataq.variables['latitude'][:]\n lon = dataq.variables['longitude'][:]\n dataq.close()\n else:\n print(ValueError('Selected wrong height - (surface or profile!)!')) \n print('Completed: Read data for *%s* : %s!' % (experi[:4],varid))\n \n ### Reshape to split years and months\n months = 12\n if level == 'surface': # 3d variables\n var = np.reshape(varq,(int(varq.shape[0]/12),months,\n int(lat.shape[0])))\n elif level == 'profile': # 4d variables\n var = np.reshape(varq,(int(varq.shape[0]/12),months,int(lev.shape[0]),\n int(lat.shape[0])))\n else:\n print(ValueError('Selected wrong height - (surface or profile!)!')) \n print('Completed: Reshaped %s array!' % (varid))\n \n ### Convert units\n if varid in ('TEMP','T2M'):\n var = var - 273.15 # Kelvin to degrees Celsius \n print('Completed: Changed units (K to C)!')\n\n print('\\n*Completed: Finished readExperi function!')\n return lat,lon,time,lev,var"],"string":"[\n \"def read_simulation_results(self,\\n fname_sims, \\n fname_pareto = None, \\n fname_cull = None):\\n\\n \\n self.fname_sims = fname_sims\\n self.__read_file(fname_sims, 'sim_results')\\n \\n if fname_pareto is not None:\\n self.fname_pareto = fname_pareto\\n self.__read_file(fname_in, 'pareto')\\n \\n if fname_cull is not None:\\n self.fname_cull = fname_cull\\n self.__read_file(fname_in, 'cull')\",\n \"def get_data(self,path):\\n\\t\\twith open(path,'r') as file:\\n\\t\\t\\tdata = file.readlines()\\n\\t\\t\\tself.objects = int(data[0].split()[1])#getting num of object\\n\\t\\t\\tdata = data[2:]#Cutting header lines from data file\\n\\t\\t\\tself.positions = [[] for i in range(self.objects)]#creating array, each row represents all positions for agiven planet\\n\\t\\t\\tself.steps = int((len(data))/self.objects)#Cal steps\\n\\t\\t\\tself.center = [[] for i in range(self.objects)]\\n\\t\\t\\tprint \\\"steps = \\\", self.steps\\n\\t\\t\\tprint \\\"objects = \\\",self.objects \\n\\t\\t\\tprint(self.steps)\\n\\t\\t\\tfor el in range(self.objects):#iterator = all planets\\n\\t\\t\\t\\tself.times =[]\\n\\t\\t\\t\\tfor step in range(self.steps):#iterator = all simulation frames\\n\\t\\t\\t\\t\\ttemp_data = data[step*self.objects+el].split()#Separating t x y z from data lines\\n\\t\\t\\t\\t\\ttemp_data2 = [float(i) for i in temp_data[1:4]]#converting to float without t parameter\\n\\t\\t\\t\\t\\ttemp_center = [float(i) for i in temp_data[4:]]\\n\\t\\t\\t\\t\\tself.times.append(float(temp_data[0])) \\n\\t\\t\\t\\t\\tself.positions[el].append(temp_data2)#adding to self.positions list\\n\\t\\t\\t\\t\\tself.center[el].append(temp_center)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\tself.add_planet(self.positions[el][0][0], self.positions[el][0][1], self.positions[el][0][2])#Inicialization planet with intial positions\\n\\t\\t\\tself.p = vis.points(pos=tuple(self.center[0][0]), size=3,color=color.black)#mass center \\n\\t\\t\\tself.p2 = vis.points(pos=(0,0,0),size=3,color=color.red)#sun center\\n\\t\\t\\tself.sun = vis.sphere(radius=0.2, pos = (0,0,0), opacity = 0.8, material=materials.emissive)\\n\\t\\t\\tself.dt= int(self.times[self.objects+1])\",\n \"def simul_and_export(file, config, i):\\n\\n simulate_UVSPEC(file, config)\\n\\n load_skymap(config)\\n\\n sim = files_sim(config)[i]\\n export_sim_rad(sim, config)\",\n \"def readpil3d(self):\\r\\n\\r\\n # Read the data in as an array.\\r\\n res = np.loadtxt(self.name, delimiter=' ')\\r\\n\\r\\n # Split into useful chunks\\r\\n self.pos = res[:, 0:3] # Grid point locations\\r\\n self.Pn = res[:, 3:4] # Normal pressure [Pa]\\r\\n self.flux = res[:, -1] # Flux\\r\",\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 rd_xyz(self):\\n nmol = self.__rd_xyz_nmol()\\n fpin = open(self.config['xyzfile'], \\\"r\\\")\\n tmol = self.template['molspec']['atoms']\\n ntatom = self.template['molspec']['n_atoms']\\n mol = []\\n for i in range(nmol):\\n # number of atom,\\n line = fpin.readline().strip()\\n natom = int(line)\\n line = fpin.readline()\\n\\n jobname = \\\"%s\\\" % line[:-1]\\n atom = []\\n\\n if ntatom != natom:\\n print \\\"geometry data in template file is not consistant with xyz file. check the template.\\\"\\n for j in range(natom):\\n line = fpin.readline()\\n rec = line.split()\\n if len(rec) == 5:\\n atomname, x, y, z, imove = rec\\n elif len(rec) == 4:\\n atomname, x, y, z = rec\\n else:\\n print \\\"nothing to do...\\\"\\n exit(1)\\n frg = tmol[j]['frg']\\n record = {'name': atomname, 'coord': [float(x),float(y),float(z)], 'frg':frg}\\n atom.append(record)\\n onemol = {'natom': natom, 'jobname': jobname, 'info': '', 'atom':atom}\\n mol.append(onemol)\\n self.model['mol'] = mol\\n fpin.close()\\n return\",\n \"def plotfile(self):\\r\\n filename = self.locatefile()\\r\\n if filename == \\\"\\\":\\r\\n print \\\"\\\\nNo file was chosen, exiting ...\\\\n\\\"\\r\\n return\\r\\n else:\\r\\n print \\\"\\\\nXYZ Data file:\\\\n\\\" + filename\\r\\n \\r\\n print \\\"\\\\nReading XYZ data file....\\\"\\r\\n xyz = XYZImporter(filename)\\r\\n geodata = xyz.genericdata\\r\\n print \\\"FINISHED reading XYZ data file\\\"\\r\\n\\r\\n # Note PNG is only 8 bit, and so PDF has greater colour\\r\\n # depth \\r\\n print \\\"\\\\nAbout to render plot ...\\\"\\r\\n gp = GridPlotterCustom()\\r\\n gp.shownulls = False\\r\\n title = \\\"Plot of XYZ data file: \\\" + filename\\r\\n outfname = (filename.replace('.', '_') +\\r\\n '_PLOT_custom.pdf')\\r\\n gp.plotgeodata(geodata, title, outfname)\\r\\n print \\\"FINISHED rendering plot to:\\\\n\\\" + outfname\\r\\n print \\\"\\\\n\\\\n\\\"\",\n \"def _read_input_file(self):\\n file_type = 'np.array'\\n with open(self._file_properties['file_name'], 'r') as in_file:\\n for line in in_file.readlines():\\n if line[0:5] == '$$SOE':\\n file_type = 'Horizons'\\n break\\n\\n if not isfile(self._file_properties['file_name']):\\n msg = 'Horizons files {:} does not exists.'\\n message = msg.format(self._file_properties['file_name'])\\n raise FileExistsError(message)\\n if file_type == 'Horizons':\\n self._read_horizons_file()\\n else:\\n (time, x, y, z) = np.loadtxt(\\n self._file_properties['file_name'],\\n usecols=(0, 1, 2, 3), unpack=True)\\n self._time = time\\n if int(astropy_version[0]) >= 4:\\n self._xyz = SkyCoord(x=x, y=y, z=z,\\n representation_type='cartesian')\\n else:\\n self._xyz = SkyCoord(x=x, y=y, z=z,\\n representation='cartesian')\",\n \"def setup(self):\\n print(\\\"Looking for \\\", self.filename)\\n if os.path.exists(self.filename):\\n file = scio.loadmat(self.filename)\\n self.data = np.squeeze(file[\\\"data\\\"])\\n print(\\\"Motion Data length is \\\", len(self.data))\\n\\n else:\\n raise FileNotFoundError\",\n \"def readin():\\r\\n nodes = np.loadtxt('Vnodes.txt', ndmin=2)\\r\\n mats = np.loadtxt('Vmater.txt', ndmin=2)\\r\\n elements = np.loadtxt('Veles.txt', ndmin=2)\\r\\n loads = np.loadtxt('Vloads.txt', ndmin=2)\\r\\n return nodes, mats, elements, loads\",\n \"def read_xyz(self, filename):\\n # first line contains number of atoms\\n self.numatom = int(filename.readline().split()[0])\\n # second line contains a comment\\n self.comment = filename.readline()[:-3]\\n # rest of the lines contain coordinates structured Element X Y Z\\n string = \\\"Element X Y Z \\\\n\\\" + filename.read()\\n self.contents = pd.read_table(StringIO(string), sep=r'\\\\s+')\",\n \"def load_xyz(filename):\\n periodic = load_periodic()\\n #read molecule\\n with open(filename) as f:\\n size = int(next(f))\\n title = next(f).strip()\\n molecule = Molecule(title,size)\\n for _ in range(size):\\n row = next(f).split()\\n tag = row[0]\\n element = periodic[tag]\\n coordinate = []\\n for j in range(3):\\n coordinate.append(float(row[j+1]))\\n atom = Atom(element,coordinate)\\n\\n molecule.append(atom)\\n f.close()\\n \\n return molecule\",\n \"def run_analysis(self):\\n ### skip some snapshots for testing purposes\\n nskip = 199\\n read_char.skip_snapshots(self.hfile, self.ifile, nskip)\\n ### read in the first two steps (required for velocity related computations\\n xs_old, ys_old, lx_old, ly_old, tstep_old, natoms_old = read_char.read_snapshot(self.hfile, self.ifile)\\n x_old = xs_old*lx_old\\n y_old = ys_old*ly_old\\n xs,ys,lx,ly,tstep,natoms = read_char.read_snapshot(self.hfile, self.ifile)\\n x = xs*lx\\n y = ys*ly\\n ### loop over all steps of the input file\\n for step in range(nskip+1,self.nsteps-1):\\n print step\\n ### read in coordinates (as required)\\n xs_new,ys_new,lx_new,ly_new,tstep_new,natoms_new = read_char.read_snapshot(self.hfile, self.ifile)\\n x_new = xs_new*lx_new\\n y_new = ys_new*ly_new\\n ### compute further current per/atom quantities\\n phi = misc_tools.compute_orientation(x,y,lx,ly,self.npol)\\n vx,vy = misc_tools.compute_velocity(x_old,y_old, x_new, y_new, lx, ly, tstep_old, tstep_new, natoms)\\n ### start desired analysis methods\\n # density\\n if self.density_flag:\\n self.density.compute(step,x,y,lx,ly,natoms, plot = 'False')\\n # number fluctuations\\n if self.nf_flag:\\n self.numberfluctuation.compute(step,xs,ys, plot = 'False')\\n # voronoi density\\n if self.voronoi_flag:\\n self.voronoidensity.compute(step,x,y,lx,ly,natoms, plot = 'False')\\n # velocity / worticity\\n if self.velocity_flag:\\n self.velocityworticity.compute(step,x,y,vx,vy,natoms,lx,ly, plot = 'False')\\n # orientation / velocity\\n if self.orientvel_flag:\\n self.orientvel.compute(step,x,y,vx,vy,phi,natoms, plot = 'False')\\n # defect points\\n if self.pointdefects_flag:\\n self.pointdefects.compute(step,x,y,phi,lx,ly,natoms)\\n ### move coordinate arrays\\n xs_old = np.copy(xs)\\n ys_old = np.copy(ys)\\n x_old = np.copy(x)\\n y_old = np.copy(y)\\n tstep_old = tstep\\n xs = np.copy(xs_new)\\n ys = np.copy(ys_new)\\n x = np.copy(x_new)\\n y = np.copy(y_new)\\n tstep = tstep_new\\n return\",\n \"def __init__(self):\\n\\n self.read_input_file()\\n self.read_simulation_files()\",\n \"def test_readfile_fits(self):\\n fitsname = os.path.join(self.datadir, 'monol_testA.evt')\\n command = \\\"{0}\\\".format(fitsname)\\n\\n hen.io.main(command.split())\",\n \"def test_read(self):\\n for line in TESTIMAGES.split('\\\\n'):\\n vals = line.strip().split()\\n name = vals[0]\\n logger.debug(\\\"Testing file %s\\\" % name)\\n dim1, dim2 = [int(x) for x in vals[1:3]]\\n mini, maxi, mean, stddev = [float(x) for x in vals[3:]]\\n obj = raxisimage()\\n obj.read(os.path.join(os.path.dirname(self.mar), name))\\n\\n self.assertAlmostEqual(mini, obj.getmin(), 2, \\\"getmin [%s,%s]\\\" % (mini, obj.getmin()))\\n self.assertAlmostEqual(maxi, obj.getmax(), 2, \\\"getmax [%s,%s]\\\" % (maxi, obj.getmax()))\\n self.assertAlmostEqual(mean, obj.getmean(), 2, \\\"getmean [%s,%s]\\\" % (mean, obj.getmean()))\\n self.assertAlmostEqual(stddev, obj.getstddev(), 2, \\\"getstddev [%s,%s]\\\" % (stddev, obj.getstddev()))\\n self.assertEqual(dim1, obj.dim1, \\\"dim1\\\")\\n self.assertEqual(dim2, obj.dim2, \\\"dim2\\\")\\n self.assertNotEqual(obj.dim1, obj.dim2, \\\"dim2!=dim1\\\")\",\n \"def import_data():\\n from project_parameters import perm,dataPointsPerAxis,numElectrodes,debug,scale\\n from project_parameters import baseDataName,simulationDirectory,savePath,name\\n from project_parameters import position,zMin,zMax,zStep,name,charge,mass,r0\\n import pickle\\n # renaming for convenience\\n na, ne = dataPointsPerAxis, numElectrodes \\n\\n #works with import_data_HOA -smouradi 04/19\\n print('Loading trap data from Sandia...')\\n fname = (simulationDirectory+baseDataName+'.pkl')\\n print fname\\n try:\\n f = open(fname,'rb')\\n except IOError:\\n return ('No pickle file foudn.')\\n trap = pickle.load(f)\\n\\n Xi = trap['X'] #sandia defined coordinates\\n Yi = trap['Y']\\n Zi = trap['Z']\\n #get everything into expected coordinates (described in project_paramters)\\n coords = [Xi,Yi,Zi]\\n X = coords[perm[0]]/scale\\n Y = coords[perm[1]]/scale\\n Z = coords[perm[2]]/scale\\n if debug.import_data:\\n print ('size of X,Y, and Z:')\\n print X.shape\\n print Y.shape\\n print Z.shape\\n\\n sim=TreeDict()\\n el = 0\\n for key in trap['electrodes']:\\n Vs = trap['electrodes'][key]['V']\\n Vs = Vs.reshape(na[0],na[1],na[2])\\n Vs = np.transpose(Vs,perm)\\n electrode = TreeDict()\\n electrode.potential = Vs\\n electrode.name = trap['electrodes'][key]['name']\\n electrode.position = trap['electrodes'][key]['position']\\n if electrode.name == 'RF':\\n sim['EL_RF'.format(el)] = electrode.copy()\\n sim['EL_DC_{}'.format(el)] = electrode.copy()\\n el=el+1\\n\\n del trap\\n #4) Build the simulation data structure\\n sim.X,sim.Y,sim.Z=X,Y,Z # set grid vectors\\n sim.simulationDirectory = simulationDirectory\\n sim.baseDataName = baseDataName\\n sim.dataPointsPerAxis = na\\n sim.numElectrodes = ne\\n sim.savePath = savePath\\n sim.perm = perm\\n\\n sim.configuration.position = position\\n sim.configuration.charge = charge\\n sim.configuration.mass = mass\\n sim.configuration.r0 = r0\\n\\n if debug.import_data: # Plot each electrode\\n print(plot_potential(sim.EL_RF.potential,X,Y,Z,'1D plots','RF electrode'))\\n for el in range(0,ne): \\n electrode = sim['EL_DC_{}'.format(el)] \\n print(plot_potential(electrode.potential,X,Y,Z,\\\\\\n '1D plots','Electrode {},{} Position:{}'.format(el,electrode.name,electrode.position)))\\n\\n #5) save the particular simulation as a pickle data structure\\n nameOut=savePath+name+'.pkl'\\n print ('Saving '+nameOut+' as a data structure...')\\n output = open(nameOut,'wb')\\n pickle.dump(sim,output)\\n output.close()\\n return 'Import complete.'\",\n \"def read(self, simtype):\\n\\n if simtype == 'original':\\n if self.filename.endswith(\\\".pkl\\\"):\\n logging.debug(\\\"Loading pickle file %s\\\", self.filename)\\n data = pd.read_pickle(self.filename)\\n\\n elif self.filename.endswith(\\\".hdf5\\\"):\\n logging.debug(\\\"Loading HDF5 file %s\\\", self.filename)\\n with h5py.File(self.filename, \\\"r\\\") as data_file:\\n #print('treeIndex', data_file[\\\"treeIndex\\\"].keys())\\n #print('haloTrees', data_file[\\\"haloTrees\\\"].keys())\\n \\n # Find dimensionality of keys\\n columns_1dim = [] \\n columns_2dim = [] \\n for column in self.columns:\\n if len(data_file[\\\"/haloTrees/%s\\\" % column].shape) == 1:\\n columns_1dim.append(column)\\n else:\\n columns_2dim.append(column)\\n \\n # 1D keys\\n data = pd.DataFrame(\\n {\\n column: data_file[\\\"/haloTrees/%s\\\" % column].value\\n for column in columns_1dim\\n },\\n columns=columns_1dim\\n ).set_index(\\\"nodeIndex\\\")\\n del columns_1dim\\n\\n # 2D keys\\n for column in columns_2dim:\\n if column == 'position':\\n pos = data_file[\\\"/haloTrees/%s\\\" % column].value\\n data['X'] = pd.Series(pos[:, 0], index=data.index)\\n data['Y'] = pd.Series(pos[:, 1], index=data.index)\\n data['Z'] = pd.Series(pos[:, 2], index=data.index)\\n del columns_2dim\\n\\n data.rename(index=str,\\n columns={\\\"snapshotNumber\\\": \\\"snapnum\\\"})\\n ## eliminate fake elements with isIntegrated=1\\n #data = data[data.isInterpolated != 1]\\n\\n else:\\n raise TypeError(\\\"Unknown filetype %s\\\" % self.filename)\\n if simtype == 'EAGLE':\\n if self.filename.endswith(\\\".pkl\\\"):\\n logging.debug(\\\"Loading pickle file %s\\\", self.filename)\\n data = pd.read_pickle(self.filename)\\n\\n elif self.filename.endswith(\\\".hdf5\\\"):\\n logging.debug(\\\"Loading HDF5 file %s\\\", self.filename)\\n data_file = h5py.File(self.filename, 'r')\\n column_mt = []\\n column_sh = []\\n for column in self.columns:\\n if column in data_file['MergerTree']:\\n column_mt.append(column)\\n else:\\n column_sh.append(column)\\n\\n data = pd.DataFrame(\\n {\\n column: data_file[\\\"/MergerTree/%s\\\" % column].value\\n for column in column_mt\\n },\\n columns=column_mt\\n ).set_index(\\\"HaloID\\\")\\n #.set_index(data_file[\\\"/Merger/HaloID\\\"].value)\\n\\n for column in column_sh:\\n data[column] = pd.Series(data_file[\\\"/Subhalo/%s\\\" % column].value,\\n index=data.index)\\n data = data.rename(index=str,\\n columns={\\\"SnapNum\\\": \\\"snapnum\\\", #\\\"HaloID\\\": \\\"nodeIndex\\\",\\n \\\"DescendantID\\\" : \\\"descendantIndex\\\"})\\n else:\\n raise TypeError(\\\"Unknown filetype %s\\\" % self.filename)\\n\\n return data\",\n \"def read(f):\\n \\n if isinstance(f, basestring):\\n # If the input is a string, treat as file name\\n with open(f) as fh: # Ensure file is closed\\n return read(fh) # Call again with file object\\n \\n # First line contains the date\\n date = f.readline()\\n if not date:\\n raise IOError(\\\"Cannot read from input file \\\"+str(filename))\\n \\n # Second is description\\n desc = f.readline()\\n \\n token = file_numbers(f)\\n \\n # Third contains number of mesh points\\n try:\\n npsi = int(token.next())\\n ntheta = int(token.next())\\n isym = int(token.next())\\n except StopIteration:\\n raise IOError(\\\"Unexpected end of file while reading grid size\\\")\\n except ValueError:\\n raise IOError(\\\"Third line should contain npsi, ntheta and isym\\\")\\n \\n # Check values\\n if (isym < 0) or (isym > 1):\\n raise IOError(\\\"isym must be either 0 or 1\\\")\\n if (npsi < 1) or (ntheta < 1):\\n raise IOError(\\\"Invalid npsi=\\\"+str(npsi)+\\\" or ntheta=\\\" + str(ntheta))\\n \\n # Read normalisation factors\\n\\n try:\\n rcnt = float(token.next())\\n xma = float(token.next())\\n zma = float(token.next())\\n btor = float(token.next())\\n curtot = float(token.next())\\n eaxe = float(token.next())\\n dnorm = float(token.next())\\n except:\\n raise IOError(\\\"Couldn't read normalisation factors\\\")\\n \\n def read_array(n, name=\\\"Unknown\\\"):\\n data = np.zeros([n])\\n try:\\n for i in np.arange(n):\\n data[i] = float(token.next())\\n except:\\n raise IOError(\\\"Failed reading array '\\\"+name+\\\"' of size \\\", n)\\n return data\\n\\n def read_2d(nx, ny, name=\\\"Unknown\\\"):\\n data = np.zeros([nx, ny])\\n for i in np.arange(nx):\\n data[i,:] = read_array(ny, name+\\\"[\\\"+str(i)+\\\"]\\\")\\n return data\\n\\n # Read 1D arrays\\n psiflux = read_array(npsi, \\\"psiflux\\\")\\n fnorm = read_array(npsi, \\\"fnorm\\\")\\n ffpnorm = read_array(npsi, \\\"ffpnorm\\\")\\n ponly = read_array(npsi, \\\"ponly\\\")\\n pponly = read_array(npsi, \\\"pponly\\\")\\n qsf = read_array(npsi, \\\"qsf\\\")\\n d = read_array(npsi, \\\"d\\\")\\n \\n dpdz = read_array(ntheta, \\\"dpdz\\\")\\n dpdr = read_array(ntheta, \\\"dpdr\\\")\\n \\n # 2D arrays\\n \\n xnorm = read_2d(ntheta, npsi, \\\"xnorm\\\")\\n znorm = read_2d(ntheta, npsi, \\\"znorm\\\")\\n \\n # Try to read Br and Bz (may be present)\\n try:\\n Br = read_2d(ntheta, npsi, \\\"Br\\\")\\n Bz = read_2d(ntheta, npsi, \\\"Bz\\\")\\n except:\\n Br = Bz = None\\n \\n ny = ntheta\\n\\n if isym == 1:\\n # Fill in values for up-down symmetric case\\n print(\\\"Grid is up-down symmetric. Reflecting grid about midplane\\\")\\n ny = tsize = 2*(ntheta - 1) + 1\\n \\n def reflect(data, mapfunc = lambda x:x):\\n \\\"\\\"\\\" Reflect a variable about midplane\\n Optionally supply a mapping function\\\"\\\"\\\"\\n data2 = np.zeros([tsize, npsi])\\n # Copy the original data\\n for i in np.arange(ntheta):\\n data2[i,:] = data[i,:]\\n # Now fill in the remainder\\n for i in np.arange(ntheta, tsize):\\n t0 = tsize - 1 - i\\n data2[i,:] = mapfunc(data[t0,:])\\n return data2\\n \\n xnorm = reflect(xnorm)\\n znorm = reflect(znorm, lambda x: 2.*zma - x) # Reflect about zma\\n if Br != None:\\n Br = reflect(Br, lambda x:-x) # Br reverses\\n if Bz != None:\\n Bz = reflect(Bz) # Bz remains the same\\n theta = tsize\\n\\n # Make sure we have Br, Bz and Bpol\\n\\n if (Br == None) or (Bz == None):\\n # Calculate Bpol from psi then Br and Bz from Bpol\\n # Use dpsi = R*Bp dx (for now)\\n Bpol = np.zeros([ny, npsi])\\n \\n def deriv(f):\\n n = np.size(f)\\n dfdi = np.zeros(n)\\n dfdi[1:-1] = (f[2:n] - f[0:-2])/2. # Central difference in the middle\\n dfdi[0] = f[1] - f[0]\\n dfdi[-1] = f[-1] - f[-2]\\n return dfdi\\n \\n for i in np.arange(ntheta):\\n drdi = deriv(xnorm[i, :])\\n dzdi = deriv(znorm[i, :])\\n dldi = sqrt(drdi**2 + dzdi**2) # Arc length\\n dpsidi = deriv(psiflux)\\n \\n Bpol[i, :] = dpsidi / (dldi * xnorm[i,:])\\n else:\\n Bpol = np.sqrt(Br**2 + Bz**2)\\n \\n # Calculate toroidal field\\n Btor = fnorm / xnorm\\n \\n #########################################\\n # Create a dictionary of values to return\\n # \\n # Need to transpose 2D arrays to [psi, theta] \\n # to be consistent with elite inputs\\n \\n var = {\\\"npsi\\\":npsi, \\\"npol\\\":ny, # Sizes\\n \\n \\\"psi\\\":psiflux,\\n \\\"f(psi)\\\":fnorm,\\n \\\"p\\\":ponly,\\n \\n \\\"R\\\": np.transpose(xnorm),\\n \\\"Z\\\": np.transpose(znorm),\\n\\n \\\"Bp\\\":np.transpose(Bpol),\\n \\\"Bt\\\":np.transpose(Btor),\\n\\n \\\"q\\\":qsf,\\n\\n \\\"ffprime\\\":ffpnorm,\\n \\\"pprime\\\":pponly}\\n\\n if Br != None:\\n var['Br'] = np.transpose(Br)\\n if Bz != None:\\n var['Bz'] = np.transpose(Bz)\\n \\n return var\",\n \"def import_xyz(self, fname):\\n self.ftype = 'xyz'\\n with open(fname) as f:\\n lines = f.readlines()\\n self.n_atom = int(lines[0].split()[0])\\n\\n # reading lines to build up class data\\n self.sym = []\\n self.at_num = []\\n self.xyz = np.zeros((self.n_atom, 3))\\n for i, line in enumerate(lines[2:]):\\n tmp = line.split()\\n self.sym.append(tmp[0])\\n self.at_num.append(self.sym2num(tmp[0]))\\n self.xyz[i, 0] = float(tmp[1])\\n self.xyz[i, 1] = float(tmp[2])\\n self.xyz[i, 2] = float(tmp[3])\\n self.connectivity_matrix()\",\n \"def read_xyz(filename):\\n #print('Reading geom from:'),filename\\n atoms = []\\n coordinates = []\\n\\t\\n xyz = open(filename)\\n n_atoms = int(xyz.readline())\\n title = xyz.readline()\\n for line in xyz:\\n\\tif len(line.strip()) == 0:\\n\\t\\tpass\\n\\t\\tbreak\\t\\n\\tatom,x,y,z = line.split()\\n\\tatoms.append(atom)\\n\\tcoordinates.append([float(x), float(y), float(z)])\\n xyz.close()\\n coordinates = [[w * angtobh for w in ww] for ww in coordinates] #ang to bh\\n\\n if n_atoms != len(coordinates):\\n \\tprint('Number of atoms in xyz file doesnt equal to the number of lines.')\\n\\tsys.exit(1)\\n \\n return atoms, coordinates\",\n \"def test_read(self):\\n for root, dirs, files in os.walk(os.path.join(self.test_dir, 'files')):\\n for filename in files:\\n if filename.endswith('.bin'):\\n d = Dataset(os.path.join(root, filename))\\n data = d.as_dict()\\n for freq_dict in data['frequencies']:\\n x = freq_dict['easting']\\n y = freq_dict['northing']\\n image = freq_dict['intensity']\\n self.assertIsInstance(x, np.ndarray)\\n self.assertIsInstance(y, np.ndarray)\\n self.assertIsInstance(image, np.ndarray)\",\n \"def test_file_io(self):\\n temp_directory = tempfile.mkdtemp()\\n filename = os.path.join(temp_directory, \\\"test.h5\\\")\\n\\n points = np.array([\\n [0.1, 0.1, 0.1],\\n [1.1, 2.1, 3.1],\\n [1.3, 2.2, 3.4]])\\n voxel_size = 0.5\\n min_corner = Vector3f(-1, -2, -3)\\n vg = VoxelGrid(voxel_size, min_corner=min_corner, points=points)\\n\\n # test writing\\n vg.save(filename)\\n self.assertTrue(os.path.isfile(filename))\\n\\n # test reading\\n vg2 = VoxelGrid.from_file(filename)\\n self.assertAlmostEquals(voxel_size, vg2.voxel_size)\\n np.testing.assert_array_almost_equal(vg.min_corner, vg2.min_corner)\\n shutil.rmtree(temp_directory)\",\n \"def main():\\n tmp_dir = xm.constants['dir_tmp']\\n exr_f = join(tmp_dir, 'test.exr')\\n exr = EXR(exr_f)\\n exr.extract_normal(join(tmp_dir, 'test.png'), vis=True)\",\n \"def extract_data( file_name):\\n\\n main_file = fits.open( file_name)\\n\\n ssp = main_file[1].data\\n flux_elines = main_file[3].data\\n org_hdr = main_file[0].header\\n\\n main_file.close()\\n\\n ###########################################################################\\n # NOTE: The visual band fluxes are multiplied by 10^-16 as stated in the\\n # units of the MaNGA Data Model.\\n #\\n # <https://data.sdss.org/datamodel/files/MANGA_PIPE3D/MANGADRP_VER\\n # /PIPE3D_VER/PLATE/manga.Pipe3D.cube.html#hdu1>\\n ###########################################################################\\n v_band = ssp[0] # in units of erg / s / cm^2\\n v_band_err = ssp[4] # in units of erg / s / cm^2\\n sMass_density = ssp[19] * u.dex( u.M_sun) # in units of log10( Msun / spaxel**2)\\n\\n Ha_vel = flux_elines[102] # in units of km/s\\n Ha_vel_err = flux_elines[330] # in units of km/s\\n\\n gal_ra = org_hdr['OBJRA']\\n gal_dec = org_hdr['OBJDEC']\\n\\n target_galaxy = True\\n MaNGA_galaxy_target = org_hdr['MNGTARG1']\\n if MaNGA_galaxy_target == 0:\\n target_galaxy = False\\n\\n data_quality = True\\n DRP_3D_quality = org_hdr['DRP3QUAL']\\n if DRP_3D_quality > 10000:\\n data_quality = False\\n\\n return target_galaxy, data_quality, Ha_vel, Ha_vel_err, v_band, v_band_err, \\\\\\n sMass_density, gal_ra, gal_dec\",\n \"def read_results():\\r\\n with open(\\\"packing.nfo\\\", \\\"r\\\") as fin:\\r\\n fin.readline()\\r\\n fin.readline()\\r\\n por_theory = float(fin.readline().split()[2])\\r\\n por_final = float(fin.readline().split()[2])\\r\\n print('Theoretical porosity:', por_theory)\\r\\n print('Final porosity:', por_final)\\r\\n with open(\\\"packing.xyzd\\\", \\\"rb\\\") as fin:\\r\\n btxt = fin.read()\\r\\n txt = list(struct.unpack(\\\"<\\\" + \\\"d\\\" * (len(btxt) // 8), btxt))\\r\\n data = array(zip(*[iter(txt)] * 4))\\r\\n data[:, 3] = data[:, 3] * \\\\\\r\\n ((1 - por_final) / (1 - por_theory))**(1 / 3)\\r\\n return data\",\n \"def analyzeViSDEMData(dict):\\n \\n if 'path_in' in dict:\\n path_in = dict['path_in']\\n else:\\n print(\\\"Caution: No path for input folder containing the data has been defined. Please define path to folder by dict['path_in']=path_in\\\") \\n return\\n \\n path_out_default = '../colordeficiency-data/' \\n if 'path_out' in dict:\\n path_out = dict['path_out']\\n else:\\n print(\\\"Caution: No path for output folder where the data should be stored has been defined. Using default output path instead: \\\"+str(path_out_default))\\n path_out = path_out_default\\n \\n if 'round' in dict:\\n round = dict['round']\\n else:\\n print(\\\"Error: You have to chose a round first.\\\")\\n \\n path = os.path.join(os.path.dirname(os.path.abspath(os.path.join(__file__,os.pardir))),'colordeficiency-data')\\n \\n # 0. Step: Get all the relevant information, i.e. motive_ids, obs_col_defs etc.\\n if round == 1:\\n visualsearch_ids = os.path.join(path,\\\"visualsearch_ids.csv\\\")\\n elif round == 2:\\n visualsearch_ids = os.path.join(path,\\\"visualsearch_ids_2.csv\\\")\\n \\n vs_ids_sheet = pandas.read_csv(visualsearch_ids,sep=\\\";\\\")\\n \\n # Get all the relevant information about the observers, i.e. obs_col_defs etc.\\n observer_ids = os.path.join(path,\\\"observer_ids.csv\\\")\\n obs_ids_sheet = pandas.read_csv(observer_ids,sep=\\\";\\\")\\n \\n # 1. Step: Read all the XLSX data in the path\\n ext = 'xlsx'; xlsx_files = getAllXXXinPath(path_in,ext)\\n dataArray = pandas.DataFrame()\\n i=1\\n for xlsx_file in xlsx_files:\\n sys.stdout.write(xlsx_file)\\n dataArray_tmp, testArray, extraDataDict = extractExperimentData(os.path.join(path_in,xlsx_file))\\n \\n newDataArray = dataArray_tmp[['dalt_id','coldef_type','resp.corr_raw','resp.rt_raw','stimFile']]\\n \\n if \\\"2. Session\\\" in extraDataDict:\\n sessionID = int(extraDataDict['2. Session'])\\n newDataArray['session_id'] = sessionID\\n \\n if 'group' in extraDataDict:\\n obsGroup = str(extraDataDict['group'])\\n newDataArray['obsGroup'] = obsGroup\\n \\n if '0. Participant ID' in extraDataDict:\\n obsID = int(extraDataDict['0. Participant ID'])\\n \\n newDataArray['observer_id'] = obsID\\n obs_coldef_type = obs_ids_sheet.loc[obs_ids_sheet['observer_id']==obsID,['observer_coldef_type']]\\n newDataArray['observer_coldef_type'] = int(obs_coldef_type['observer_coldef_type'])\\n \\n dataArray = pandas.concat([dataArray, newDataArray])\\n sys.stdout.write(' . ')\\n if (i%5)==0: sys.stdout.write('\\\\n')\\n i+=1\\n sys.stdout.write('\\\\n')\\n \\n # 2. Step: Adapt values to programstandards\\n for item in settings.colDefLong2ID:\\n dataArray.loc[dataArray['coldef_type'] == item, ['coldef_type']] = settings.colDefLong2ID[item]\\n \\n for item in settings.dalt2ID:\\n dataArray.loc[dataArray['dalt_id'] == item, ['dalt_id']] = settings.dalt2ID[item]\\n \\n dataArray.loc[dataArray['dalt_id'] == 'none', ['dalt_id']] = 0\\n \\n \\n dataArray = dataArray.rename(columns={'dalt_id': 'dalt_id',\\n 'coldef_type': 'coldef_type',\\n 'resp.corr_raw': 'is_correct',\\n 'resp.rt_raw': 'resp_time',\\n 'stimFile': 'filepath'})\\n dataArray = dataArray.reset_index()\\n \\n # Adding set_id, motive_id and variant_id to each file\\n for index, row in dataArray.iterrows():\\n path_tmp = row['filepath']\\n filename = os.path.basename(path_tmp).split('.')[0]\\n dict_tmp = getStatsFromFilename(filename)\\n imgID_tmp = int(dict_tmp['img_id'])\\n \\n tempVSDataArray = vs_ids_sheet.loc[vs_ids_sheet['image_id']==imgID_tmp,['set_id','motive_id','variant_id']]\\n \\n dataArray.at[index,'image_id'] = imgID_tmp\\n dataArray.ix[index,'set_id'] = int(tempVSDataArray['set_id'])\\n dataArray.ix[index,'motive_id'] = int(tempVSDataArray['motive_id'])\\n dataArray.ix[index,'variant_id'] = int(tempVSDataArray['variant_id'])\\n\\n dataArray.image_id = dataArray.image_id.astype(int)\\n dataArray.set_id = dataArray.set_id.astype(int)\\n dataArray.motive_id = dataArray.motive_id.astype(int)\\n dataArray.variant_id = dataArray.variant_id.astype(int)\\n dataArray.is_correct = dataArray.is_correct.astype(bool)\\n \\n dataArray = dataArray[['image_id','set_id','motive_id','variant_id','dalt_id','coldef_type','is_correct','resp_time','observer_id','observer_coldef_type','session_id','filepath','obsGroup']]\\n \\n # 3. Saving data to file\\n try:\\n dataArray.to_csv(os.path.join(path_out, 'visdem-data.csv'),sep=\\\";\\\")\\n sys.stdout.write(\\\"Success: ViSDEM data successfully saved in '\\\"+str(path_out)+\\\"'.\\\\n\\\")\\n except Exception as e:\\n print(e)\",\n \"def analysis(file_name, sky_file_name):\\n plt.rc('text', usetex=True)\\n plt.rc('font', family='serif')\\n plt.rcParams['text.latex.preamble'] = [r'\\\\boldmath']\\n\\n curr_file_name = file_name.split('.')\\n curr_file_name = curr_file_name[0].split('/')\\n stk_f_n = curr_file_name[-1]\\n data_dir = 'cube_results/' + stk_f_n\\n \\n if not os.path.exists(data_dir):\\n os.mkdir(data_dir)\\n\\n spectra_stacker(file_name)\\n\\n # one figure to rule them all\\n main_fig = plt.figure(1)\\n\\n # calling data once will be enough\\n im_coll_data = image_collapser(file_name)\\n spectra_data = spectrum_creator(file_name)\\n sr = wavelength_solution(file_name) \\n gs_data = spectra_analysis(file_name, sky_file_name)\\n \\n def graph_indiv():\\n cbd_x = np.linspace(sr['begin'], sr['end'], sr['steps'])\\n cbs_y = gs_data['gd_shifted'] \\n\\n # plotting spectra to check\\n fig, ax3 = plt.subplots()\\n ax3.plot(cbd_x, cbs_y, linewidth=0.5, color=\\\"#000000\\\")\\n ax3.tick_params(labelsize=20)\\n ax3.set_xlabel(r'\\\\textbf{Wavelength (\\\\AA)}', fontsize=20)\\n ax3.set_ylabel(r'\\\\textbf{Flux}', fontsize=20)\\n fig.savefig(data_dir + \\\"/\\\" + stk_f_n + '_single_spectra.pdf', \\n bbox_inches=\\\"tight\\\")\\n\\n # --- for collapsed images ---\\n def graphs_collapsed(): \\n f, (ax1, ax2) = plt.subplots(1, 2)\\n \\n ax1.imshow(im_coll_data['median'], cmap='gray_r') \\n ax1.set_title(r'\\\\textbf{galaxy: median}', fontsize=13) \\n ax1.set_xlabel(r'\\\\textbf{Pixels}', fontsize=13)\\n ax1.set_ylabel(r'\\\\textbf{Pixels}', fontsize=13) \\n\\n ax2.imshow(im_coll_data['sum'], cmap='gray_r')\\n ax2.set_title(r'\\\\textbf{galaxy: sum}', fontsize=13) \\n ax2.set_xlabel(r'\\\\textbf{Pixels}', fontsize=13)\\n ax2.set_ylabel(r'\\\\textbf{Pixels}', fontsize=13)\\n \\n f.subplots_adjust(wspace=0.4)\\n f.savefig(data_dir + \\\"/\\\" + stk_f_n + '_collapsed_images.pdf')\\n\\n \\n snw_data = sky_noise_weighting(file_name, sky_file_name)\\n df_data = otwo_doublet_fitting(file_name, sky_file_name)\\n\\n # --- spectra ---\\n def graphs_spectra():\\n f, (ax1, ax2) = plt.subplots(2, 1) \\n\\n # --- redshifted data plotting\\n cbd_x = np.linspace(sr['begin'], sr['end'], sr['steps'])\\n \\n ## plotting our cube data\\n cbs_y = gs_data['gd_shifted'] \\n ax1.plot(cbd_x, cbs_y, linewidth=0.5, color=\\\"#000000\\\")\\n\\n ## plotting our sky noise data\\n snd_y = snw_data['sky_regions'][:,1]\\n ax1.plot(cbd_x, snd_y, linewidth=0.5, color=\\\"#f44336\\\", alpha=0.5)\\n\\n # plotting spectra to check\\n fig, ax3 = plt.subplots()\\n ax3.plot(cbd_x, cbs_y, linewidth=0.5, color=\\\"#000000\\\")\\n ax3.tick_params(labelsize=20)\\n ax3.set_xlabel(r'\\\\textbf{Wavelength (\\\\AA)}', fontsize=20)\\n ax3.set_ylabel(r'\\\\textbf{Flux}', fontsize=20)\\n fig.savefig(data_dir + \\\"/\\\" + stk_f_n + '_single_spectra.pdf', \\n bbox_inches=\\\"tight\\\")\\n\\n ## plotting our [OII] region\\n ot_x = df_data['x_region']\\n ot_y = df_data['y_region']\\n ax1.plot(ot_x, ot_y, linewidth=0.5, color=\\\"#00c853\\\") \\n\\n ## plotting the standard deviation region in the [OII] section\\n std_x = df_data['std_x']\\n std_y = df_data['std_y']\\n ax1.plot(std_x, std_y, linewidth=0.5, color=\\\"#00acc1\\\") \\n \\n ## plotting peak lines for scipy finder and peakutils finder\\n #pk_lines = gs_data['gd_peaks']\\n #for i in range(len(pk_lines)):\\n #srb = sr['begin']\\n #ax1.axvline(x=srb+pk_lines[i], linewidth=0.5, color=\\\"#8bc34a\\\", alpha=0.2)\\n \\n pu_lines = gs_data['pu_peaks']\\n for i in range(len(pu_lines)):\\n srb = sr['begin']\\n ax1.axvline(x=(pu_lines[i]), linewidth=0.5, color=\\\"#ec407a\\\", alpha=0.2)\\n\\n ax1.set_title(r'\\\\textbf{spectra: cross-section redshifted}', fontsize=13) \\n ax1.set_xlabel(r'\\\\textbf{Wavelength (\\\\AA)}', fontsize=13)\\n ax1.set_ylabel(r'\\\\textbf{Flux}', fontsize=13)\\n ax1.set_ylim([-1000,5000]) # setting manual limits for now\\n \\n # --- corrected redshift\\n crs_x = np.linspace(sr['begin'], sr['end'], sr['steps'])\\n rdst = gs_data['redshift']\\n\\n sp_lines = gs_data['spectra']\\n\\n ## corrected wavelengths\\n corr_x = crs_x / (1+rdst)\\n\\n ## plotting our cube data\\n cps_y = gs_data['gd_shifted']\\n ax2.plot(corr_x, cps_y, linewidth=0.5, color=\\\"#000000\\\")\\n\\n ## plotting our sky noise data\\n sn_y = gs_data['sky_noise']\\n ax2.plot(corr_x, sn_y, linewidth=0.5, color=\\\"#e53935\\\")\\n \\n ## plotting spectra lines\\n for e_key, e_val in sp_lines['emis'].items():\\n spec_line = float(e_val)\\n ax2.axvline(x=spec_line, linewidth=0.5, color=\\\"#00c853\\\")\\n ax2.text(spec_line-10, 4800, e_key, rotation=-90)\\n \\n ax2.set_title(r'\\\\textbf{spectra: cross-section corrected}', fontsize=13) \\n ax2.set_xlabel(r'\\\\textbf{Wavelength (\\\\AA)}', fontsize=13)\\n ax2.set_ylabel(r'\\\\textbf{Flux}', fontsize=13)\\n ax2.set_ylim([-500,5000]) # setting manual limits for now\\n\\n f.subplots_adjust(hspace=0.5)\\n f.savefig(data_dir + \\\"/\\\" + stk_f_n + '_spectra.pdf')\\n\\n # saving our plotting into npy files so they can be used elsewhere\\n np.save(data_dir + \\\"/\\\" + stk_f_n + \\\"_cbd_x\\\", cbd_x)\\n np.save(data_dir + \\\"/\\\" + stk_f_n + \\\"_cbs_y\\\", cbs_y) \\n\\n np.save(data_dir + \\\"/\\\" + stk_f_n + \\\"_snd_y\\\", snd_y) \\n \\n np.save(data_dir + \\\"/\\\" + stk_f_n + \\\"_corr_x\\\", corr_x)\\n np.save(data_dir + \\\"/\\\" + stk_f_n + \\\"_cps_y\\\", cps_y)\\n \\n def graphs_otwo_region():\\n ot_fig = plt.figure(6)\\n\\n # plotting the data for the cutout [OII] region\\n ot_x = df_data['x_region']\\n ot_y = df_data['y_region']\\n plt.plot(ot_x, ot_y, linewidth=1.5, color=\\\"#000000\\\")\\n\\n ## plotting the standard deviation region in the [OII] section\\n std_x = df_data['std_x']\\n std_y = df_data['std_y']\\n #plt.plot(std_x, std_y, linewidth=1.5, color=\\\"#00acc1\\\") \\n\\n dblt_rng = df_data['doublet_range']\\n ot_x_b, ot_x_e = dblt_rng[0], dblt_rng[-1]\\n x_ax_vals = np.linspace(ot_x_b, ot_x_e, 1000)\\n\\n # lmfit \\n lm_init = df_data['lm_init_fit']\\n lm_best = df_data['lm_best_fit'] \\n\\n plt.plot(ot_x, lm_best, linewidth=1.5, color=\\\"#1e88e5\\\", \\n label=r\\\"\\\\textbf{Best fit}\\\")\\n plt.plot(ot_x, lm_init, linewidth=1.5, color=\\\"#43a047\\\", alpha=0.5,\\n label=r\\\"\\\\textbf{Initial guess}\\\")\\n \\n lm_params = df_data['lm_best_param']\\n lm_params = [prm_value for prm_key, prm_value in lm_params.items()]\\n c, i_val1, i_val2, sig_g, rdsh, sig_i = lm_params\\n\\n dblt_mu = [3727.092, 3729.875] # the actual non-redshifted wavelengths for OII\\n l1 = dblt_mu[0] * (1+rdsh)\\n l2 = dblt_mu[1] * (1+rdsh)\\n \\n sig = np.sqrt(sig_g**2 + sig_i**2) \\n norm = (sig*np.sqrt(2*np.pi))\\n\\n lm_y1 = c + ( i_val1 / norm ) * np.exp(-(ot_x-l1)**2/(2*sig**2))\\n lm_y2 = c + ( i_val2 / norm ) * np.exp(-(ot_x-l2)**2/(2*sig**2))\\n \\n plt.plot(ot_x, lm_y1, linewidth=1.5, color=\\\"#e64a19\\\", alpha=0.7, \\n label=r\\\"\\\\textbf{Gaussian 1}\\\") \\n plt.plot(ot_x, lm_y2, linewidth=1.5, color=\\\"#1a237e\\\", alpha=0.7,\\n label=r\\\"\\\\textbf{Gaussian 2}\\\")\\n\\n # plotting signal-to-noise straight line and gaussian to verify it works\\n sn_line = df_data['sn_line']\\n sn_gauss = df_data['sn_gauss']\\n\\n #plt.axhline(y=sn_line, linewidth=0.5, color=\\\"#5c6bc0\\\", alpha=0.7) \\n #plt.plot(ot_x, sn_gauss, linewidth=0.5, color=\\\"#5c6bc0\\\", alpha=0.7)\\n\\n #plt.title(r'\\\\textbf{[OII] region}', fontsize=13)\\n plt.legend(loc='upper left', prop={'size': 15})\\n plt.tick_params(labelsize=20)\\n plt.xlabel(r'\\\\textbf{Wavelength (\\\\AA)}', fontsize=20)\\n plt.ylabel(r'\\\\textbf{Flux}', fontsize=20)\\n plt.xlim([l1-100,np.max(ot_x)])\\n plt.ylim([-100,np.max(ot_y)+100]) # setting manual limits for now\\n plt.savefig(data_dir + \\\"/\\\" + stk_f_n + '_otwo_region.pdf',bbox_inches=\\\"tight\\\")\\n\\n graph_indiv()\\n graphs_collapsed()\\n graphs_spectra()\\n graphs_otwo_region()\\n\\n plt.close(\\\"all\\\")\\n\\n return {'image_data': im_coll_data, 'spectra_data': spectra_data, 'sr': sr,\\n 'df_data': df_data, 'gs_data': gs_data, 'snw_data': snw_data}\",\n \"def read_xyz_file(filename, num_spatial_dimensions):\\n print(\\\"Reading data from XYZ file.\\\")\\n\\n particle_positions = []\\n frame_number = 0\\n line_number = 0\\n frame_particles = 0\\n with open(filename, 'r') as input_file:\\n for line in input_file:\\n if line_number == 0:\\n # Check for blank line at end of file\\n if line != \\\"\\\":\\n frame_particles = int(line)\\n particle_positions.append(np.zeros((frame_particles, num_spatial_dimensions)))\\n elif line_number == 1:\\n pass\\n else:\\n for dimension in range(num_spatial_dimensions):\\n particle_positions[frame_number][line_number-2][dimension] = line.split()[1:][dimension]\\n line_number += 1\\n # If we have reached the last particle in the frame, reset counter for next frame\\n if line_number == (frame_particles + 2):\\n line_number = 0\\n frame_number += 1\\n\\n print(\\\"XYZ read complete.\\\")\\n\\n return particle_positions\",\n \"def xrds_from_dir(path=None, fjord=None, metastr='_mdf', bitmask=False):\\n warnings.warn(\\\"This function currently assumes a constant grid and EPSG for all input files\\\")\\n assert fjord != None, \\\"You must specify the fjord code for these DEMs\\\"\\n\\n files = [f for f in os.listdir(path) if f.endswith('dem.tif')]\\n\\n # for DEMs nested in directories\\n if len(files) == 0:\\n try: \\n os.remove(path+'.DS_Store')\\n except FileNotFoundError:\\n pass\\n dirs = [dir for dir in os.listdir(path)]\\n nestfiles=[]\\n for dir in dirs:\\n nestfiles.append([dir+'/'+f for f in os.listdir(path+dir) if f.endswith('dem.tif')])\\n files = [items for nest in nestfiles for items in nest]\\n\\n i=0\\n darrays = list(np.zeros(len(files)))\\n dtimes = list(np.zeros(len(files)))\\n for f in files:\\n print(f)\\n\\n metaf = f.rpartition(\\\"_dem.tif\\\")[0] + metastr + \\\".txt\\\"\\n try:\\n meta = read_meta(path+metaf)\\n # print(meta)\\n dtimes[i] = get_DEM_img_times(meta)\\n except FileNotFoundError:\\n print(\\\"You must manually enter dtimes for these files within the code\\\")\\n # dtimes[0] = dt.datetime(2012, 6, 29, hour=15, minute=26, second=30)\\n # dtimes[1] = dt.datetime(2010, 8, 14, hour=15, minute=34)\\n # except KeyError:\\n # raise\\n except AssertionError:\\n print(\\\"These stereo image times are >30 min apart... skipped\\\")\\n continue\\n\\n try:\\n darrays[i] = read_DEM(path+f, fjord)\\n # darrays[i] = read_DEM(path+f.rpartition(\\\"_dem.tif\\\")[0] + \\\"_dem_geoidcomp.tif\\\")\\n except RasterioIOError:\\n print(\\\"RasterioIOError on your input file\\\")\\n break\\n \\n # read in and apply the bitmask\\n if bitmask==True:\\n bitmaskfn = path + f.rpartition(\\\"dem.tif\\\")[0] + \\\"bitmask.tif\\\"\\n maskarr = read_mask(bitmaskfn, fjord)\\n darrays[i] = darrays[i].where(maskarr==0, )\\n \\n i = i + 1\\n\\n if len(darrays)==1 and np.all(darrays[0]) == 0:\\n warnings.warn(\\\"Your DEM will not be put into XArray\\\")\\n return \\\"nodems\\\"\\n\\n elif len(darrays)>1 and np.all(darrays[darrays!=0]) == 0:\\n warnings.simplefilter(\\\"always\\\")\\n warnings.warn(\\\"None of your DEMs will be put into XArray\\\")\\n return \\\"nodems\\\"\\n\\n else:\\n # I just discovered xarray's mfdataset with the preprocess option to modify each dataset prior to opening. I'm guessing that'd be the way to go here\\n # darr = xr.combine_nested(darrays, concat_dim=['dtime'])\\n darr = xr.concat(darrays, \\n dim=pd.Index(dtimes, name='dtime'), \\n # coords=['x','y'], \\n join='outer').chunk({'dtime': 1, 'x':3072, 'y':3072}) # figure out a better value for chunking this (it slows the JI one with 3 dems way down)\\n # combine_attrs='no_conflicts' # only in newest version of xarray\\n\\n try:\\n for arr in darrays:\\n arr.close()\\n except:\\n pass\\n del darrays\\n \\n # convert to dataset with elevation as a variable and add attributes\\n attr = darr.attrs\\n ds = darr.to_dataset()\\n\\n # coarsen the data to 4 m resolution to reduce memory crashes during processing\\n # note that this may be important in later steps when resolution is used as an input\\n coarse = 2\\n if coarse > 1:\\n print(\\\"Your input DEMs will be downsampled to enable processing\\\")\\n ds = ds.coarsen(x=coarse, y=coarse, boundary='pad').mean()\\n ds = ds.chunk({'dtime': 1, 'x':3072, 'y':3072})\\n\\n ds.attrs = attr\\n ds.attrs['fjord'] = fjord\\n ds.attrs['res'] = tuple(x * coarse for x in attr['res'])\\n attr=None\\n\\n # newest version of xarray (0.16) has promote_attrs=True kwarg. Earlier versions don't...\\n # ds = ds.to_dataset(name='elevation', promote_attrs=True).squeeze().drop('band')\\n \\n # using rioxarray means the transform is read in/created as part of the geospatial info, so it's unnecessary to manually create a transform\\n # create affine transform for concatted dataset\\n print('Please note the transform is computed assuming a coordinate reference system\\\\\\n where x(min) is west and y(min) is south')\\n # inputs: west, south, east, north, width, height\\n # don't use len(x,y) for width and height in case they're not continuous\\n width = abs((ds.x.max().item() - ds.x.min().item())/ds.attrs['res'][0])\\n ht = abs((ds.y.max().item() - ds.y.min().item())/ds.attrs['res'][1])\\n transform = rasterio.transform.from_bounds(ds.x.min().item()-0.5*ds.attrs['res'][0], ds.y.min().item()-0.5*ds.attrs['res'][1], \\n ds.x.max().item()+0.5*ds.attrs['res'][0], ds.y.max().item()+0.5*ds.attrs['res'][1], \\n width, ht)\\n ds.attrs['transform'] = transform\\n # set the transform and crs as attributes since that's how they're accessed later in the pipeline\\n # ds.attrs['transform'] = (ds.spatial_ref.GeoTransform)\\n # ds.attrs['crs'] = ds.spatial_ref.crs_wkt\\n\\n\\n return ds\",\n \"def extraction(userinputs):\\n #Set up required variables\\n target_dir = userinputs['OUTDIR']\\n seximage = userinputs['IMAGE']\\n logging.info('Running sextractor on {}'.format(userinputs['IMAGE']))\\n\\n print 'Executing SExtractor on user selected image : ', seximage\\n\\n # Verify that file exists\\n if os.path.exists(userinputs['DATA'] + '/' + seximage) == False:\\n print 'File ' + seximage + ' could not be found in ' + userinputs['DATA']\\n logging.critical(' Could not find {}. Quitting'.format(seximage))\\n logging.debug('Looking for {} but unable to locate'.format(userinputs['DATA'] + '/' + seximage))\\n filemanagement.shutdown('Quitting now...',userinputs)\\n\\n # Run sextractor\\n logging.info('Start sextractor')\\n os.chdir(target_dir + '/s_extraction')\\n logging.debug('Changed dir to {}'.format(os.getcwd()))\\n command = 'sex ' + userinputs['DATA'] + '/' + seximage + '[1] -c R2_wl_aa.config'\\n os.system(command)\\n os.chdir(target_dir)\\n logging.debug('Changed working directory back to {}'.format(target_dir))\\n\\n # Read in results and make regions file of objects sextracted\\n logging.info('Read in Sextractor catalog')\\n xx, yy = np.loadtxt(target_dir + '/s_extraction/R2_wl_dpop_detarea.cat', unpack=True,\\n skiprows=5, usecols=(0,1))\\n\\n outputfile = target_dir + '/s_extraction/catalog_ds9_sextractor.reg'\\n\\n logging.info('Writing region file from source extractor data')\\n logging.debug('Sextractor file: {}'.format(target_dir + '/s_extraction/R2_wl_dpop_detarea.cat'))\\n with open(outputfile, 'w') as file:\\n file.write('global color=blue width=5 font=\\\"helvetica 15 normal roman\\\" highlite=1 \\\\n')\\n file.write('image\\\\n')\\n\\n for i in range(len(xx)):\\n newline = 'circle(' + str(xx[i]) + ',' + str(yy[i]) + ',7) \\\\n'\\n file.write(newline)\\n print ''\\n print 'Check catalog_ds9_sextractor.reg in the /s_extraction directory for'\\n print 'the quality of source extraction.'\\n print ''\\n\\n return target_dir + '/s_extraction/R2_wl_dpop_detarea.cat'\",\n \"def test_run_experiment_from_xml_files():\\n solvent_path = examples_paths()['toluene-solvent']\\n vacuum_path = examples_paths()['toluene-vacuum']\\n with mmtools.utils.temporary_directory() as tmp_dir:\\n yaml_script = get_template_script(tmp_dir)\\n del yaml_script['molecules'] # we shouldn't need any molecule\\n yaml_script['systems'] = {'explicit-system':\\n {'phase1_path': solvent_path, 'phase2_path': vacuum_path,\\n 'solvent_dsl': 'not resname TOL'}}\\n\\n exp_builder = ExperimentBuilder(yaml_script)\\n exp_builder._check_resume() # check_resume should not raise exceptions\\n exp_builder.run_experiments()\\n\\n # The experiments folders are correctly named and positioned\\n output_dir = exp_builder._get_experiment_dir('')\\n assert os.path.isdir(output_dir)\\n assert os.path.isfile(os.path.join(output_dir, 'complex.nc'))\\n assert os.path.isfile(os.path.join(output_dir, 'solvent.nc'))\\n assert os.path.isfile(os.path.join(output_dir, 'experiments.yaml'))\\n assert os.path.isfile(os.path.join(output_dir, 'experiments.log'))\\n\\n # Analysis script is correct\\n analysis_script_path = os.path.join(output_dir, 'analysis.yaml')\\n with open(analysis_script_path, 'r') as f:\\n assert yaml.load(f, Loader=yaml.FullLoader) == [['complex', 1], ['solvent', -1]]\",\n \"def readWrite_gpt2_1w(xdir, station, site_lat, site_lon):\\n# this should use the environment variable\\n outfile = xdir + '/input/' + station + '_refr.txt'\\n if os.path.isfile(outfile):\\n print('refraction file for this station already exists')\\n else:\\n print('refraction output file will be written to ', outfile)\\n\\n# change to radians\\n dlat = site_lat*np.pi/180 \\n dlon = site_lon*np.pi/180 \\n\\n# read VMF gridfile in pickle format \\n pname = xdir + '/input/' + 'gpt_1wA.pickle'\\n print('large refraction file is stored here:', pname)\\n try:\\n f = open(pname, 'rb')\\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\\n f.close()\\n except:\\n print('I did not find the large refraction file where it is supposed to be, but I will try looking in your home directory')\\n try:\\n pname = 'gpt_1wA.pickle'\\n f = open(pname, 'rb')\\n [All_pgrid, All_Tgrid, All_Qgrid, All_dTgrid, All_U, All_Hs, All_ahgrid, All_awgrid, All_lagrid, All_Tmgrid] = pickle.load(f)\\n f.close()\\n except:\\n print('hmm, failed again. Go into gnssIR_lomb.py, set RefractionCorrection to false, and rerun the code.... ')\\n sys.exit()\\n\\n# print(np.shape(All_pgrid))\\n# really should e zero to four, but whatever\\n indx = np.zeros(4,dtype=int)\\n indx_lat = np.zeros(4,dtype=int)\\n indx_lon = np.zeros(4,dtype=int)\\n\\n\\n#figure out grid index\\n# % only positive longitude in degrees\\n if (dlon < 0):\\n plon = (dlon + 2*np.pi)*180/np.pi;\\n else:\\n plon = dlon*180/np.pi \\n#\\n# transform to polar distance in degrees\\n ppod = (-dlat + np.pi/2)*180/np.pi \\n\\n#% find the index (line in the grid file) of the nearest point\\n# % changed for the 1 degree grid (GP)\\n ipod = np.floor(ppod+1) \\n ilon = np.floor(plon+1) \\n \\n# % normalized (to one) differences, can be positive or negative\\n# % changed for the 1 degree grid (GP)\\n diffpod = (ppod - (ipod - 0.5)) \\n difflon = (plon - (ilon - 0.5)) \\n# % added by HCY\\n# % changed for the 1 degree grid (GP)\\n if (ipod == 181):\\n ipod = 180 \\n if (ilon == 361):\\n ilon = 1 \\n if (ilon == 0):\\n ilon = 360\\n\\n# get the number of the corresponding line\\n#\\t changed for the 1 degree grid (GP)\\n indx[0] = (ipod - 1)*360 + ilon \\n# save the lat lon of the grid points\\n indx_lat[0] = 90-ipod+1 \\n indx_lon[0] = ilon-1 \\n# % near the poles: nearest neighbour interpolation, otherwise: bilinear\\n# % with the 1 degree grid the limits are lower and upper (GP)\\n\\n bilinear = 0 \\n max_ind = 1 \\n if (ppod > 0.5) and (ppod < 179.5):\\n bilinear = 1 \\n if (bilinear == 1):\\n max_ind =4 \\n\\n# % bilinear interpolation\\n# % get the other indexes \\n \\n ipod1 = ipod + np.sign(diffpod) \\n ilon1 = ilon + np.sign(difflon) \\n# % changed for the 1 degree grid (GP)\\n if (ilon1 == 361):\\n ilon1 = 1 \\n if (ilon1 == 0):\\n ilon1 = 360 \\n# get the number of the line\\n# changed for the 1 degree grid (GP)\\n# four indices ???\\n indx[1] = (ipod1 - 1)*360 + ilon; # % along same longitude\\n indx[2] = (ipod - 1)*360 + ilon1;# % along same polar distance\\n indx[3] = (ipod1 - 1)*360 + ilon1;# % diagonal\\n#\\n# save the lat lon of the grid points lat between [-90 ;90] lon [0 360] \\n indx_lat[1] = 90 - ipod1+np.sign(diffpod) \\n indx_lon[1] = ilon-1 \\n indx_lat[2] = 90-ipod +1\\n indx_lon[2] = ilon1 - np.sign(difflon) \\n indx_lat[3] = 90 -ipod1+np.sign(diffpod) \\n indx_lon[3] = ilon1- np.sign(difflon);\\n\\n# extract the new grid\\n# will need to do 0-4 instead of 1-5 because stored that way in python\\n# which values to use in the bigger array\\n# assign the correct values\\n indx = indx - 1\\n indx_list = indx.tolist()\\n# print(indx_list)\\n# print(indx)\\n#print(np.shape(indx_lat))\\n#print(np.shape(indx_lon))\\n w = 0\\n# need to write values for a given station to a plain text file\\n#\\n fout = open(outfile, 'w+')\\n for a in indx_list:\\n for k in [0,1,2,3,4]:\\n fout.write(\\\" {0:4.0f} {1:5.0f} {2:13.4f} {3:10.4f} {4:10.6f} {5:10.4f} {6:12.5f} {7:12.5f} {8:10.6f} {9:10.6f} {10:10.6f} {11:10.4f} \\\\n\\\".format( indx_lat[w], indx_lon[w],All_pgrid[a,k],All_Tgrid[a,k],All_Qgrid[a,k]*1000,All_dTgrid[a,k]*1000,All_U[a,0],All_Hs[a,0], All_ahgrid[a,k]*1000, All_awgrid[a,k]*1000, All_lagrid[a,k], All_Tmgrid[a,k] ))\\n\\n w+=1\\n fout.close()\\n print('file written')\",\n \"def _OpenOutputFiles(self):\\n self.gfile = open(self.geomout, \\\"w\\\")\\n self.efile = open(self.energyout, \\\"w\\\")\\n self.PrintEnergyHeader()\",\n \"def _make_files(self):\\n if not self.path.is_dir():\\n raise FileNotFoundError(f\\\"Path {self.path} does not exist.\\\")\\n\\n # Make the filepaths\\n self.file_points = self.path / \\\"point.dat\\\"\\n self.file_lines = self.path / \\\"line.dat\\\"\\n self.file_cadastre = self.path / \\\"cadastre.dat\\\"\\n self.file_portals = self.path / \\\"portals.dat\\\"\\n\\n with open(self.file_points, \\\"w\\\") as f:\\n # 2 lines ignored\\n header = datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n f.write(header)\\n self.points_dfs = []\\n with open(self.file_lines, \\\"w\\\") as f:\\n # 5 lines ignored\\n header = (\\n datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n + 3 * \\\"Generated: \\\\n\\\"\\n + \\\"Name,Section,source_group,x1,y1,z1,x2,y2,z2,width,vert. ext.,-,-,\\\"\\n \\\"emission_rate[kg/h/km],-,-,-,-\\\\n\\\"\\n )\\n f.write(header)\\n with open(self.file_cadastre, \\\"w\\\") as f:\\n # 1 line ignored\\n header = \\\"x,y,z,dx,dy,dz,emission_rate[kg/h],-,-,-,source_group\\\\n\\\"\\n f.write(header)\\n with open(self.file_portals, \\\"w\\\") as f:\\n # 2 lines ignored\\n header = (\\n datetime.datetime.now().strftime(\\\"Generated: %d/%m/%Y %H:%M\\\\n\\\")\\n + \\\"x1,y1,x2,y2,z0,z1,emission_rate[kg/h],-,-,-,source_group\\\\n\\\"\\n )\\n f.write(header)\\n\\n\\n # File to save the source groups values\\n self.file_source_groups = self.path / \\\"source_groups.json\\\"\\n with open(self.file_source_groups, \\\"w\\\") as f:\\n # reverse the dict (items become keys and vice versa)\\n reversed_source_groups = {v: k for k, v in self.source_groups.items()}\\n json.dump(reversed_source_groups, f, indent=2)\",\n \"def read_from_ses3d_block(directory):\\n\\n # Initialise arrays of Cartesian coordinates.\\n\\n x=[]\\n y=[]\\n z=[]\\n\\n # Read yaml file containing information on the ses3d submodel.\\n with io.open(os.path.join(directory,'modelinfo.yml'), 'rt') as fh:\\n model_info = yaml.load(fh)\\n\\n rot_vec = np.array([model_info['geometry']['rot_x'], model_info['geometry']['rot_y'], model_info['geometry']['rot_z']])\\n rot_angle = model_info['geometry']['rot_angle']\\n\\n # Read block files.\\n\\n fid_x = open(os.path.join(directory,'block_x'), 'r')\\n fid_y = open(os.path.join(directory,'block_y'), 'r')\\n fid_z = open(os.path.join(directory,'block_z'), 'r')\\n\\n dx = np.array(fid_x.read().strip().split('\\\\n'), dtype=float)\\n dy = np.array(fid_y.read().strip().split('\\\\n'), dtype=float)\\n dz = np.array(fid_z.read().strip().split('\\\\n'), dtype=float)\\n\\n fid_x.close()\\n fid_y.close()\\n fid_z.close()\\n\\n # Setup of coordinate lines.\\n\\n nsubvol = int(dx[0])\\n\\n idx = np.ones(nsubvol, dtype=int)\\n idy = np.ones(nsubvol, dtype=int)\\n idz = np.ones(nsubvol, dtype=int)\\n\\n for k in np.arange(1, nsubvol, dtype=int):\\n idx[k] = int(dx[idx[k - 1]]) + idx[k - 1] + 1\\n idy[k] = int(dy[idy[k - 1]]) + idy[k - 1] + 1\\n idz[k] = int(dz[idz[k - 1]]) + idz[k - 1] + 1\\n\\n for k in np.arange(nsubvol, dtype=int):\\n\\n # Coordinates of the box corners.\\n colat = dx[(idx[k] + 1):(idx[k] + 1 + int(dx[idx[k]]))]\\n lon = dy[(idy[k] + 1):(idy[k] + 1 + int(dy[idy[k]]))]\\n rad = dz[(idz[k] + 1):(idz[k] + 1 + int(dz[idz[k]]))]\\n \\n # Coordinates of the box centroids.\\n colat_c = (np.array(colat[0:-1])+np.array(colat[1:]))/2.0\\n lon_c = (np.array(lon[0:-1]) + np.array(lon[1:]))/2.0\\n rad_c = (np.array(rad[0:-1]) + np.array(rad[1:]))/2.0\\n \\n # Compute Cartesian coordinates for all grid points.\\n for c in colat_c:\\n for l in lon_c:\\n xx=np.cos(l*np.pi/180.0)*np.sin(c*np.pi/180.0)\\n yy=np.sin(l*np.pi/180.0)*np.sin(c*np.pi/180.0)\\n zz=np.cos(c*np.pi/180.0)\\n for r in rad_c:\\n x.append(r*xx)\\n y.append(r*yy)\\n z.append(r*zz)\\n \\n\\n # Rotate, if needed.\\n\\n if (rot_angle!=0.0):\\n rot_mat = get_rot_matrix(rot_angle*np.pi/180.0, *rot_vec)\\n x, y, z = rotate(x, y, z, rot_mat)\\n\\n # Return.\\n\\n return x, y, z\",\n \"def read_positions():\\n return np.genfromtxt(\\\"POSITIONS.OUT\\\").transpose()\",\n \"def test_to_single_xyz(self):\\n\\n # load a molecule with a single conformation\\n toluene = Molecule.from_file(get_data_file_path(\\\"molecules/toluene.sdf\\\"), \\\"sdf\\\")\\n # make sure it has one conformer\\n assert toluene.n_conformers == 1\\n\\n with NamedTemporaryFile(suffix=\\\".xyz\\\") as iofile:\\n # try and write out the xyz file\\n toluene.to_file(iofile.name, \\\"xyz\\\")\\n\\n # now lets check the file contents\\n with open(iofile.name) as xyz_data:\\n data = xyz_data.readlines()\\n # make sure we have the correct amount of lines writen\\n assert len(data) == 17\\n # make sure all headers and frame data was writen\\n assert data.count(\\\"15\\\\n\\\") == 1\\n assert data.count(\\\"C7H8\\\\n\\\") == 1\\n # now check that we can find the first and last coords\\n coords = [\\n \\\"C 0.0000000000 0.0000000000 0.0000000000\\\\n\\\",\\n \\\"H -0.0000000000 3.7604000568 0.0000000000\\\\n\\\",\\n ]\\n for coord in coords:\\n assert coord in data\",\n \"def main():\\n data_visualisation()\\n write_hyper_params()\\n write_result_tables()\\n write_box_plots()\",\n \"def _read_xyz(ds,datafile,long_format=False):\\n\\n from cheml.io.xyz import get_molecules\\n\\n ds.list_of_mol = get_molecules(datafile,ds.nmol,long_format)\\n ds.nmol = len(ds.list_of_mol)\",\n \"def _check_xyz_output(self, cwd):\\n\\n for ii, refname in enumerate(self.files):\\n if self.forms[ii] == \\\"xyz\\\":\\n ref_structs = []\\n try:\\n with open(Path(cwd) / refname) as ref:\\n ref_natoms = int(ref.readline())\\n for s, ll in enumerate(ref.readlines()):\\n if (s + 1) % (ref_natoms + 2) != 0 and (s + 1) % (\\n ref_natoms + 2\\n ) != 1:\\n ref_structs.append(ll.split()[1:])\\n reff = [[float(v) for v in r] for r in ref_structs]\\n ref_xyz = np.array(reff)\\n except IOError:\\n raise IOError(\\n \\\"Please provide a reference file named {} in {}\\\".format(\\n refname, str((self.parent / cwd).absolute())\\n )\\n )\\n\\n except ValueError:\\n raise ValueError(\\n \\\"Please check the values for the file named {} in {}\\\".format(\\n refname, str((self.parent / cwd).absolute())\\n )\\n )\\n\\n fname = refname[4:]\\n structs = []\\n with open(self.tmp_dir / fname) as f:\\n natoms = int(f.readline())\\n for s, ll in enumerate(f.readlines()):\\n if (s + 1) % (natoms + 2) != 0 and (s + 1) % (natoms + 2) != 1:\\n structs.append(ll.split()[1:])\\n testt = [[float(v) for v in r] for r in structs]\\n test_xyz = np.array(testt)\\n\\n try:\\n np.testing.assert_allclose(\\n test_xyz, ref_xyz, rtol=1.0e-7, atol=1.0e-8\\n )\\n # print(\\\"No anomaly during the regtest for {}\\\".format(refname))\\n except AssertionError:\\n raise AssertionError(\\n \\\"ANOMALY: {} in {}\\\".format(\\n fname,\\n str((self.parent / cwd).absolute()).split(\\\"ipi_tests/\\\", 1)[\\n 1\\n ],\\n )\\n )\",\n \"def readViewerOutputFile(lines, debug=False):\\n x = []; y = []\\n pixel = ''\\n xunits = 'unknown'\\n intensityUnits = 'unknown'\\n for line in lines:\\n if (line[0] == '#'): \\n if (line.find('pixel') > 0):\\n pixel = line.split('[[')[1].split(']]')[0]\\n elif (line.find('xLabel') > 0):\\n xunits = line.split()[-1]\\n if (debug):\\n print \\\"Read xunits = \\\", xunits\\n elif (line.find('yLabel') > 0):\\n tokens = line.split()\\n if (len(tokens) == 2):\\n intensityUnits = tokens[1]\\n else:\\n intensityUnits = tokens[1] + ' (' + tokens[2] + ')'\\n continue\\n tokens = line.split()\\n if (len(tokens) < 2): \\n continue\\n x.append(float(tokens[0]))\\n y.append(float(tokens[1]))\\n return(np.array(x), np.array(y), xunits, intensityUnits)\",\n \"def loadNodes(self, fname):\\r\\n with open(fname, \\\"r\\\") as fp:\\r\\n\\r\\n # Read in the header\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"SPECGRID\\\":\\r\\n self.SPECGRID = np.array(fp.readline().split()[0:3], dtype=int)\\r\\n if item[0] == \\\"COORDSYS\\\":\\r\\n self.COORDSYS = fp.readline().split()\\r\\n if item[0] == \\\"COORD\\\":\\r\\n break\\r\\n\\r\\n # Read in the coordinates\\r\\n self.coords = []\\r\\n for line in fp:\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n item = line.split()\\r\\n for c in item:\\r\\n if '*' in c:\\r\\n cc = c.split('*')\\r\\n for i in range(int(cc[0])):\\r\\n self.coords.append(cc[-1])\\r\\n else:\\r\\n self.coords.append(c)\\r\\n else:\\r\\n if len(line.split()) > 1:\\r\\n item = line.split()\\r\\n for i in range(len(item) - 1):\\r\\n cc = item[i]\\r\\n if '*' in cc:\\r\\n ccc = cc.split('*')\\r\\n for j in range(int(ccc[0])):\\r\\n self.coords.append(ccc[-1])\\r\\n else:\\r\\n self.coords.append(c)\\r\\n break\\r\\n else:\\r\\n break\\r\\n\\r\\n # Read in ZCORN\\r\\n self.zcorn = []\\r\\n i = 0\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"ZCORN\\\":\\r\\n for line in fp:\\r\\n if line.split():\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n self.zcorn += line.split()\\r\\n else:\\r\\n self.zcorn += line.split()[0:-1]\\r\\n break\\r\\n if len(self.zcorn) > 0:\\r\\n break\\r\\n\\r\\n # Read in (in)active cells\\r\\n self.active = []\\r\\n for line in fp:\\r\\n item = line.split()\\r\\n if len(item) > 0:\\r\\n if item[0] == \\\"ACTNUM\\\":\\r\\n for line in fp:\\r\\n if line.split():\\r\\n if line.split()[-1] != \\\"/\\\":\\r\\n c = line.split()\\r\\n if '*' in c:\\r\\n cc = c.split('*')\\r\\n for i in range(float(cc[0])):\\r\\n self.active += cc[-1]\\r\\n else:\\r\\n self.active += c\\r\\n else:\\r\\n self.active += line.split()[0:-1]\\r\\n break\\r\\n\\r\\n self.coords = np.array(self.coords, dtype=float)\\r\\n print(self.coords)\\r\\n\\r\\n # In Petrel...\\r\\n self.ne = self.SPECGRID[0] # x i\\r\\n self.nn = self.SPECGRID[1] # y j\\r\\n self.nz = self.SPECGRID[2] # z k\\r\\n\\r\\n # build grid\\r\\n self.buildGrid(plot=False)\\r\\n self.buildActiveCells(plot=False)\\r\\n self.buildZGrid(plot=False)\\r\\n # self.calculateVolumes(plot=False)\\r\\n #\\r\\n # Convert to VTK\\r\\n self.GridType = \\\"vtkStructuredGrid\\\"\\r\\n self.Grid = vtk.vtkStructuredGrid()\\r\\n self.Grid.SetDimensions(self.ne+1, self.nn+1, self.nz+1)\\r\\n vtk_points = vtk.vtkPoints()\\r\\n ve = 1.\\r\\n\\r\\n for iz in range(self.nz):\\r\\n if iz == 0:\\r\\n for iy in range(self.nn+1):\\r\\n for ix in range(self.ne+1):\\r\\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\\\\r\\n self.Y0[ix,iy], \\\\\\r\\n ve * self.ZZT[iz][ix,iy] )\\r\\n for iy in range(self.nn+1):\\r\\n for ix in range(self.ne+1):\\r\\n vtk_points.InsertNextPoint( self.X0[ix,iy], \\\\\\r\\n self.Y0[ix,iy], \\\\\\r\\n ve * self.ZZB[iz][ix,iy] )\\r\\n self.Grid.SetPoints(vtk_points)\\r\\n\\r\\n # Add in active cells\\r\\n ac = vtk.vtkIntArray()\\r\\n ac.SetName( \\\"ActiveCells\\\" )\\r\\n for iac in self.ActiveCells.flatten( order='F' ):\\r\\n ac.InsertNextTuple1( iac )\\r\\n self.Grid.GetCellData().AddArray(ac)\",\n \"def plot_skeleton(project_dir, part):\\n scene_fpath = os.path.join(project_dir, 'scene_sba.json')\\n print(scene_fpath)\\n K_arr, D_arr, R_arr, t_arr, _ = utils.load_scene(scene_fpath)\\n D_arr = D_arr.reshape((-1,4))\\n\\n print(f\\\"\\\\n\\\\n\\\\nLoading data\\\")\\n df_paths = sorted(glob.glob(os.path.join(project_dir, '*.h5')))\\n #print(df_paths)\\n\\n points_2d_df = utils.create_dlc_points_2d_file(df_paths)\\n triangulate_func = calib.triangulate_points_fisheye\\n points_2d_filtered_df = points_2d_df[points_2d_df['likelihood']>0.5]\\n points_3d_df = calib.get_pairwise_3d_points_from_df(points_2d_filtered_df, K_arr, D_arr, R_arr, t_arr, triangulate_func)\\n\\n # estimate initial points\\n nose_pts = points_3d_df[points_3d_df[\\\"marker\\\"]==part][[\\\"x\\\", \\\"y\\\", \\\"z\\\", \\\"frame\\\"]].values\\n x_slope, x_intercept, *_ = stats.linregress(nose_pts[:,3], nose_pts[:,0])\\n y_slope, y_intercept, *_ = stats.linregress(nose_pts[:,3], nose_pts[:,1])\\n z_slope, z_intercept, *_ = stats.linregress(nose_pts[:,3], nose_pts[:,2])\\n frame_est = np.arange(100)\\n x_est = frame_est*x_slope + x_intercept\\n y_est = frame_est*y_slope + y_intercept\\n z_est = frame_est*z_slope + z_intercept\\n psi_est = np.arctan2(y_slope, x_slope)\\n \\n #print(points_2d_df)\\n #print(points_2d_df[points_2d_df['frame']==160])\\n #return([nose_pts[:,0], nose_pts[:,1], nose_pts[:,2]])\\n return(x_est, y_est, z_est)\",\n \"def run_plots(self):\\n # load the files\\n self.pre_dark_file = os.path.join(self.input_dir, 'step_lastframe.fits')\\n self.post_dark_file = os.path.join(self.input_dir, 'step_dark_current.fits')\\n self.jump_file = os.path.join(self.input_dir, 'step_jump.fits')\\n self.rate_file = os.path.join(self.input_dir, 'step_rate.fits')\\n self.ramp_file = glob.glob(os.path.join(self.input_dir, '*.fits'))[0]\\n\\n # plots\\n self.plot_jump_flags_image()\\n self.plot_groupdq_flags(pixel=[884, 550])\\n self.plot_ramps_pre_post_correction(pixel=[884, 550])\",\n \"def __init__(self, fname):\\n f = zopen(fname, \\\"rt\\\")\\n\\n # skip header lines\\n for i in range(2):\\n f.readline()\\n\\n # number of atoms included in the file followed by the position of the origin of the volumetric data\\n line = f.readline().split()\\n self.natoms = int(line[0])\\n self.origin = np.array(np.array(list(map(float, line[1:]))))\\n\\n # The next three lines give the number of voxels along each axis (x, y, z) followed by the axis vector.\\n line = f.readline().split()\\n self.NX = int(line[0])\\n self.X = np.array([bohr_to_angstrom * float(l) for l in line[1:]])\\n\\n line = f.readline().split()\\n self.NY = int(line[0])\\n self.Y = np.array([bohr_to_angstrom * float(l) for l in line[1:]])\\n\\n line = f.readline().split()\\n self.NZ = int(line[0])\\n self.Z = np.array([bohr_to_angstrom * float(l) for l in line[1:]])\\n\\n self.voxelVolume = abs(np.dot(np.cross(self.X, self.Y), self.Z))\\n self.volume = abs(np.dot(np.cross(self.X.dot(self.NZ), self.Y.dot(self.NY)), self.Z.dot(self.NZ)))\\n\\n # The last section in the header is one line for each atom consisting of 5 numbers,\\n # the first is the atom number, second is charge, the last three are the x,y,z coordinates of the atom center.\\n self.sites = []\\n for i in range(self.natoms):\\n line = f.readline().split()\\n self.sites.append(Site(line[0], np.multiply(bohr_to_angstrom, list(map(float, line[2:])))))\\n\\n self.structure = Structure(\\n lattice=[self.X * self.NX, self.Y * self.NY, self.Z * self.NZ],\\n species=[s.specie for s in self.sites],\\n coords=[s.coords for s in self.sites],\\n coords_are_cartesian=True,\\n )\\n\\n # Volumetric data\\n self.data = np.zeros((self.NX, self.NY, self.NZ))\\n i = 0\\n for s in f:\\n for v in s.split():\\n self.data[\\n int(i / (self.NY * self.NZ)),\\n int((i / self.NZ) % self.NY),\\n int(i % self.NZ),\\n ] = float(v)\\n i += 1\",\n \"def read_data(infiles, variable, time_constraint):\\n\\n cube = iris.load(infiles, gio.check_iris_var(variable), callback=save_history)\\n equalise_attributes(cube)\\n iris.util.unify_time_units(cube)\\n cube = cube.concatenate_cube()\\n cube = gio.check_time_units(cube)\\n\\n cube = cube.extract(time_constraint)\\n\\n if not 'J' in str(cube.units):\\n cube = convert_to_joules(cube) \\n\\n if variable == 'surface_downward_heat_flux_in_sea_water':\\n agg_method = 'sum'\\n elif variable == 'ocean_heat_content':\\n agg_method = 'mean'\\n cube = timeseries.convert_to_annual(cube, aggregation=agg_method) \\n \\n coord_names = [coord.name() for coord in cube.dim_coords]\\n aux_coord_names = [coord.name() for coord in cube.aux_coords]\\n assert 'time' in coord_names\\n assert len(coord_names) == 3\\n grid_type = 'curvilinear' if aux_coord_names == ['latitude', 'longitude'] else 'latlon'\\n\\n return cube, coord_names, aux_coord_names, grid_type\",\n \"def read_mesa(self, filename=None):\\n\\n if filename is None:\\n filename = self.model_file\\n\\n with open(filename, 'r') as f:\\n # count number of lines\\n npts_file = sum([1 for line in f])\\n\\n # go back to start and read first line in file to get number of parameters\\n f.seek(0)\\n l = f.readline()\\n nparams_file = int(l.split(' ')[-1])\\n\\n # skip lines 2-4\\n for i in range(3):\\n f.readline()\\n\\n # the fifth line will give us the number of variables\\n l = f.readline()\\n nvars_file = int(l.split(' ')[-1])\\n\\n # subtract header rows\\n npts_file -= 6\\n\\n print(f'{nvars_file} variables found in the initial model file')\\n print(f'{npts_file} points found in the initial model file')\\n\\n var_idx_map = {}\\n logR_idx = -1\\n\\n # read in the names of the variables\\n for i in range(nvars_file):\\n var_name_file = f.readline().strip()\\n if var_name_file.lower() == 'n':\\n var_name_file = 'neut'\\n elif var_name_file == 'p':\\n var_name_file = 'prot'\\n\\n if var_name_file == 'logR':\\n logR_idx = i\\n continue\\n\\n # create map of file indices to model indices\\n try:\\n var_idx_map[self.idx[var_name_file]] = i\\n except KeyError:\\n var_idx_map[self.idx['spec'] - 1 + network_module.network_species_index(var_name_file.lower())] = i\\n\\n base_r = np.zeros(npts_file)\\n base_state = np.zeros((npts_file, self.nvar))\\n\\n # read in model data\\n for i, line in enumerate(f):\\n variables = [float(v) for v in line.split(' ')]\\n\\n # need to reverse the inputs file here\\n\\n n = npts_file - i - 1\\n\\n base_r[n] = R_solar * 10**variables[logR_idx]\\n\\n for j in range(self.nvar):\\n if j in var_idx_map:\\n base_state[n, j] = variables[var_idx_map[j]]\\n\\n return npts_file, base_r, base_state\",\n \"def beforeLoop(self):\\n\\t\\tself.loadInputFiles()\\n\\t\\tself.loadOutputFile()\\n\\t\\tself.addHistogram1D(\\\"True_Enu\\\", \\\"True Neutrino Energy [GeV]\\\", 100, 0.0, 10.0)#Histogram of neutrino energy\\n\\t\\tself.addHistogram1D(\\\"True_Enu_Delta\\\", \\\"True Neutrino Energy from Delta producing events [GeV]\\\", 100, 0.0, 10.0)#Histogram of neutrino energy from Delta producing events\\n\\t\\tself.addHistogram1D(\\\"Interaction_Mode_Delta\\\", \\\"NEUT interaction codes of Delta producing events\\\", 53, 0, 53)#Histogram of interaction modes of Delta producing events\\n\\t\\tself.addHistogram2D(\\\"Vertex_Location_XY\\\", \\\"Location of interaction vertices in the X-Y plane of the detector\\\",100,-3000,3000,100,-3000,3000)#Histogram of vertex location in XY plane\\n\\t\\tself.addHistogram2D(\\\"Vertex_Location_YZ\\\", \\\"Location of interaction vertices in the Y-Z plane of the detector\\\",100,-3000,3000,100,-3000,3000)#Histogram of vertex location in YZ plane\\n\\t\\tself.addHistogram1D(\\\"True_Enu_Delta_inFGD\\\", \\\"Neutrino energies of FGD Delta producing events (GeV)\\\",100,0,10)#Histogram of neutrino energy of Deltas produced in the FGD\\n\\t\\tself.addHistogram1D(\\\"Delta_Momentum\\\", \\\"Momentum of Delta baryons (GeV/c)\\\",100,0,5)#Histogram of neutrino energy of Deltas produced in the FGD\\n\\t\\tself.addHistogram1D(\\\"Proton_Momentum\\\", \\\"Momentum of Protons from Delta decays (GeV/c)\\\",100,0,4)#Histogram of proton momentum from Delta decays\\n\\t\\tself.addHistogram1D(\\\"Pion_Momentum\\\", \\\"Momentum of Pions from Delta decays (GeV/c)\\\",100,0,4)#Histogram of pion momentum from Delta decays\",\n \"def test_fake_file_xmm(self):\\n fits_file = os.path.join(self.datadir, 'monol_test_fake_lc_xmm.evt')\\n hen.fake.main(['--deadtime', '1e-4', '-m', 'XMM', '-i', 'epn',\\n '--ctrate', '2000',\\n '-o', fits_file])\\n hdu_list = fits.open(fits_file)\\n hdunames = [hdu.name for hdu in hdu_list]\\n assert 'STDGTI01' in hdunames\\n assert 'STDGTI02' in hdunames\\n assert 'STDGTI07' in hdunames\",\n \"def read_DEM(fn=None, fjord=None):\\n # intake.open_rasterio accepts a list of input files and may effectively do what this function does!\\n # try using cropped versions of the input files. Doesn't seem to make a difference r.e. crashing\\n '''\\n cropped_fn = fn.rpartition(\\\".tif\\\")[0] + \\\"_cropped.tif\\\"\\n print(cropped_fn)\\n if os._exists(cropped_fn):\\n fn = cropped_fn\\n elif fjord != None:\\n bbox = fjord_props.get_fjord_bounds(fjord)\\n ds = rioxarray.open_rasterio(fn)\\n trimmed_ds = ds.rio.slice_xy(*bbox)\\n trimmed_ds.rio.to_raster(fn.rpartition(\\\".tif\\\")[0] + \\\"_cropped.tif\\\")\\n del ds\\n del trimmed_ds\\n fn = cropped_fn \\n '''\\n\\n # try bringing in the rasters as virtual rasters (i.e. lazily loading)\\n with rasterio.open(fn) as src:\\n # print('Source CRS:' +str(src.crs))\\n # print(src.is_tiled)\\n # print(src.block_shapes)\\n with WarpedVRT(src,src_crs=src.crs,crs=src.crs) as vrt:\\n # warp_mem_limit=12000,warp_extras={'NUM_THREADS':2}) as vrt:\\n # print('Destination CRS:' +str(vrt.crs))\\n darr = xr.open_rasterio(vrt)\\n # ds = rioxarray.open_rasterio(vrt).chunk({'x':1500,'y':1500,'band':1}).to_dataset(name='HLS_Red')\\n\\n\\n # Rasterio automatically checks that the file exists\\n # ultimately switch to using rioxarray, but it causes issues down the pipeline so it will need to be debugged through\\n # with rioxarray.open_rasterio(fn) as src:\\n # with xr.open_rasterio(fn) as darr:\\n # darr = src\\n\\n # open_rasterio automatically brings the geotiff in as a DataArray with 'band' as a dimensional coordinate\\n # we rename it and remove the band as a coordinate, since our DEM only has one dimension\\n # squeeze removes dimensions of length 0 or 1, in this case our 'band'\\n # Then, drop('band') actually removes the 'band' dimension from the Dataset\\n darr = darr.rename('elevation').squeeze().drop_vars('band')\\n # darr = darr.rename({'band':'dtime'})\\n \\n # if we wanted to instead convert it to a dataset\\n # attr = darr.attrs\\n # darr = darr.to_dataset(name='elevation').squeeze().drop('band')\\n # darr.attrs = attr\\n # attr=None\\n # newest version of xarray (0.16) has promote_attrs=True kwarg. Earlier versions don't...\\n # darr = darr.to_dataset(name='elevation', promote_attrs=True).squeeze().drop('band')\\n\\n # mask out the nodata values, since the nodatavals attribute is wrong\\n darr = darr.where(darr != -9999.)\\n\\n # the gdalwarp geoid files have this extra attribute in the geoTiff, which when brought in\\n # ultimately causes a \\\"__module__\\\" related error when trying to plot with hvplot\\n try:\\n del darr.attrs[\\\"units\\\"] \\n except KeyError:\\n pass\\n\\n if fjord != None:\\n # USE RIOXARRAY - specifically, slicexy() which can be fed the bounding box\\n # darr = darr.rio.slice_xy(fjord_props.get_fjord_bounds(fjord))\\n bbox = fjord_props.get_fjord_bounds(fjord)\\n if pd.Series(darr.y).is_monotonic_increasing:\\n darr = darr.sel(x=slice(bbox[0], bbox[2]), y=slice(bbox[1], bbox[3]))\\n else:\\n darr = darr.sel(x=slice(bbox[0], bbox[2]), y=slice(bbox[3], bbox[1]))\\n \\n return darr\",\n \"def t12_loadSMFile(self):\\n print \\\"spectrumFile\\\"\\n filename = tkFileDialog.askopenfilename()\\n filename = \\\"data/\\\" + self.filenameparser(filename)\\n orgin_file = self.filenameparser(filename)\\n self.t12_smfilename = filename\\n self.t12_orginfilename = orgin_file\",\n \"def sim12_r_simulation(datafiles, simulation_mag_zeropoint, simulation_exposure):\\n return stuff.Simulation(datafiles / 'sim12' / 'sim12_r.list', simulation_mag_zeropoint, simulation_exposure)\",\n \"def main(filename: str) -> None:\\n # Template from HtDAP, based on composition \\n return scatterplot(read(filename))\",\n \"def read_sim_info(folder, filen):\\n \\n ### file path\\n \\n fpath = folder + filen + '.h5'\\n assert os.path.exists(fpath), \\\"The out.h5 file does NOT exist for \\\" + fpath\\n fl = h5py.File(fpath, 'r') \\n \\n ### simulation information\\n \\n lx = fl['/info/box/x'][...]\\n ly = fl['/info/box/y'][...]\\n dt = fl['/info/dt'][...]\\n nsteps = fl['/info/nsteps'][...]\\n nfils = fl['/info/nfils'][...]\\n nbeads = fl['/info/nbeads'][...]\\n nsamp = fl['/info/nsamp'][...]\\n nbpf = fl['/info/nbpf'][...]\\n \\n ### simulation parameters\\n \\n density = fl['/param/density'][...]\\n kappa = fl['/param/kappa'][...]\\n km = fl['/param/km'][...]\\n pa = fl['/param/pa'][...]\\n pp = fl['/param/pp'][...]\\n bl = fl['/param/bl'][...]\\n sigma = fl['/param/sigma'][...]\\n \\n fl.close()\\n \\n ### generate classes to submerge data\\n \\n sim = misc_tools.Simulation(lx, ly, dt, nsteps, nfils, nbeads, nsamp, nbpf, \\\\\\n density, kappa, km, pa, pp, bl, sigma)\\n \\n return sim\",\n \"def read_sim_info_arvind_format(folder, filen):\\n \\n ### file path\\n \\n fpath = folder + filen + '.h5'\\n assert os.path.exists(fpath), \\\"The out.h5 file does NOT exist for \\\" + fpath\\n fl = h5py.File(fpath, 'r') \\n \\n ### simulation information\\n \\n lx = fl['/info/box/x'][...]\\n ly = fl['/info/box/y'][...]\\n dt = fl['/info/dt'][...]\\n nsteps = fl['/info/nsteps'][...]\\n nfils = fl['/info/nfils'][...]\\n nbeads = fl['/info/nbeads'][...]\\n nsamp = fl['/info/nsamp'][...]\\n nbpf = fl['/info/nbpf'][...]\\n \\n ### simulation parameters\\n \\n density = fl['/param/density'][...]\\n kappa = fl['/param/kappa'][...]\\n km = fl['/param/km'][...]\\n pa = fl['/param/pa'][...]\\n pp = fl['/param/pp'][...]\\n bl = fl['/param/bl'][...]\\n sigma = fl['/param/sigma'][...]\\n \\n fl.close()\\n \\n ### generate classes to submerge data\\n \\n sim = misc_tools.Simulation(lx, ly, dt, nsteps, nfils, nbeads, nsamp, nbpf, \\\\\\n density, kappa, km, pa, pp, bl, sigma)\\n \\n return sim\",\n \"def readOutputfile(filename, verbose=False):\\n\\n # -----------------------------------------------------------------------------\\n # Defining the classes for data structure\\n T_Simulation = namedtuple('Simulation', ['step'])\\n T_Step = namedtuple('Step', ['element', 'node'])\\n\\n T_Displacement = namedtuple('Displacement', ['ux', 'uy'])\\n\\n T_Element = namedtuple('Element', ['gp', 'avstrain', 'avstress', 'eqstrain'])\\n T_GP = namedtuple('GP', ['stress', 'strain'])\\n T_Stresses = namedtuple('Stresses', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n T_Strains = namedtuple('Strains', ['xx', 'yy', 'zz', 'yz', 'zx', 'xy'])\\n # -----------------------------------------------------------------------------\\n\\n nSteps = 0 # Simulation step counter\\n\\n SimData = T_Simulation(list())\\n\\n with open(filename) as f:\\n line = f.readline() # Read in the first line of the input file\\n while True: # Loop over all lines of the input file\\n # Read the nodes displacements\\n #line = f.readline()\\n #print(line)\\n if line == 'DofManager output:\\\\n': # String starts a list of nodes displacement information\\n nSteps += 1 # The above string starts a new simulation step\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Nodes = list() # Initialize/clear list of nodes\\n\\n while line != '\\\\n' and line != 'Element output:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\tnNode = int(line.strip().split()[1]) # Node id\\n line = f.readline()\\n dim1 = float(line.strip().split()[3]) # Displacement dim1\\n line = f.readline()\\n dim2 = float(line.strip().split()[3]) # Displacement dim2\\n Nodes.append(\\n T_Displacement(dim1, dim2)) # Append displacements of the current node to the node list\\n line = f.readline()\\n\\n\\n if verbose:\\n print('Step {}: Dofs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n # Read the stresses an strains at Gauss points\\n elif line == 'Element output:\\\\n': # String starts a list elements, GPs, strains and stresses\\n line = f.readline() # Cancel ---------- seperator\\n line = f.readline()\\n Elements = list() # Initialize/clear list of elements\\n\\n while line != '\\\\n' and line != '\\\\tR E A C T I O N S O U T P U T:\\\\n': # Strings that finish the list\\n #\\t\\t\\t\\t\\tnElement = line.strip().split()[2] # Element id\\n line = f.readline()\\n GPs = T_Element(list(), 0, 0, 0) # List of Gauss points\\n\\n while line != '\\\\n' and line.strip().split()[0] == 'GP': # String that starts a new GP\\n #\\t\\t\\t\\t\\t\\tnGP = int(line.strip().split()[1].split('.')[1]) # GP id\\n tmp = [float(i) for i in line.strip().split()[4:10]] # Read the strains\\n strain = T_Strains(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n line = f.readline()\\n tmp = [float(i) for i in line.strip().split()[1:7]] # Read the stresses\\n stress = T_Stresses(tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5])\\n GPs.gp.append(\\n T_GP(stress, strain)) # Append stresses and strains of the current GP to the GP list\\n line = f.readline()\\n\\n\\n Elements.append(GPs) # Append GP list of the current element to the element list\\n\\n if verbose:\\n print('Step {}: GPs completed.\\\\n'.format(nSteps))\\n print('---------------------------------\\\\n')\\n\\n SimData.step.append(T_Step(Elements, Nodes)) # Append element and node list of the current step to the step list\\n #print('the file input ends')\\n #print(nSteps)\\n # only needed with a while loop\\n # Jump over the lines until we reach the next time step (Caught by if-clause)\\n try:\\n line = f.readline() # Will generate an error if files end is reached\\n if line == \\\"\\\":\\n raise EOFError\\n except:\\n if verbose: print(\\\"End of file reached.\\\\n\\\")\\n break # Break the 'while True' loop\\n\\n # -----------------------------------------------------------------------------\\n\\n\\n print('averaging the stress')\\n # Averaging of strains and stress of GPs of each element\\n for istep in range(len(SimData.step)):\\n\\n for ielement in range(len(SimData.step[istep].element)):\\n print(len)\\n # Initialization before each element\\n stresses = np.array([0., 0., 0., 0., 0., 0.])\\n strains = np.array([0., 0., 0., 0., 0., 0.])\\n\\n for igp in range(len(SimData.step[istep].element[ielement])):\\n print(igp)\\n # Add up all data of all GPs\\n #stresses[:] += SimData.step[istep].element[ielement].gp[igp].stress[:]\\n strains[:] += SimData.step[istep].element[ielement].gp[igp].strain[:]\\n\\n # Divide GP sum by number of GPs\\n stresses /= len(SimData.step[istep].element[ielement])\\n strains /= len(SimData.step[istep].element[ielement])\\n # Replace the field (initialized with 0) with new information\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstress=T_Stresses(stresses[0], stresses[1], stresses[2], stresses[3], stresses[4], stresses[5]))\\n SimData.step[istep].element[ielement] = SimData.step[istep].element[ielement]._replace(\\n avstrain=T_Strains(strains[0], strains[1], strains[2], strains[3], strains[4], strains[5]))\\n print('Analysis finished')\\n return SimData\",\n \"def read_input():\\n \\n argv = sys.argv\\n\\n # Read file names from sd input\\n f_dy = argv[1] # matdyn.modes\\n f_pat = argv[2] # path.out (should be in crystal coords)\\n f_ph = argv[3] # ph.x output (Gamma point)\\n\\n # Read input card\\n f_inp = open(\\\"input.dat\\\",'r')\\n l1 = f_inp.readline()\\n l2 = f_inp.readline()\\n l3 = f_inp.readline().split()\\n f_inp.close()\\n\\n # Open files\\n\\n f = open(f_dy,'r') # matdyn.modes \\n f_dyn = f.readlines()\\n f.close()\\n\\n f = open(f_pat,'r') # path.out\\n f_path = f.readlines()\\n f.close()\\n\\n f = open(f_ph,'r') # ph.x output\\n f_zs = f.readlines()\\n f.close()\\n\\n # Assign values to a0, nat, M, nqp\\n a0, vol = float(l1.split()[0]), float(l1.split()[1])\\n nat = int(l2) \\n mass = np.zeros(nat)\\n for iat in range(nat):\\n mass[iat] = float(l3[iat])\\n\\n # Assign values to G (reciprocal lattice vec)\\n ig = 0 ; i = 0\\n for line in f_zs:\\n if \\\"reciprocal axes:\\\" in line:\\n ig = i + 1 \\n break\\n i += 1 \\n\\n rG = np.zeros((3,3))\\n for ic in range(3):\\n rGtext = f_zs[ig+ic][23:48].split()\\n rG[ic,:] = np.array([float(rGtext[0]), float(rGtext[1]), float(rGtext[2])])\\n\\n # Read Z* tensor from f_zs\\n i = 0\\n iz = 0\\n zstart = []\\n for line in f_zs:\\n if \\\"(d P / du)\\\" in line:\\n iz = i + 3\\n if \\\"Px\\\" in line:\\n zstart.append(i)\\n\\n i += 1\\n\\n # Read the dielectric tensor from f_zs\\n i = 0\\n ie = 0\\n for line in f_zs:\\n if \\\"Dielectric constant in cartesian axis\\\" in line:\\n ie = i + 2\\n break\\n\\n i += 1\\n\\n # Assign Z* values\\n zs = np.zeros((nat,3,3)) # initialize Z*\\n\\n for iat in range(nat):\\n for ic in range(3):\\n ztext = f_zs[zstart[iat]+ic][19:56].split()\\n for jc in range(3):\\n zs[iat][ic][jc] = float(ztext[jc])\\n\\n # Assing the dielectric tensor\\n eps = np.zeros((3,3))\\n\\n for ic in range(3):\\n epstext = f_zs[ie+ic][16:66].split()\\n for jc in range(3):\\n eps[ic][jc] = float(epstext[jc])\\n\\n # Number of modes and q-points\\n nmodes = 3 * nat\\n nqpt = int(f_path[0].split()[0])\\n\\n # Read the q-points\\n q = np.zeros((nqpt,4)) # 4th dimension is lenght for q-points on a line, weights for q-points on a grid \\n for iq in range(1,nqpt+1):\\n q[iq-1,] = np.array([float(f_path[iq].split()[0]),float(f_path[iq].split()[1]), \\\\\\n float(f_path[iq].split()[2]),float(f_path[iq].split()[3])])\\n\\n # Read the eigenvalues(om) and eigenvectors(eig) \\n # Initiate first\\n om = np.zeros((nmodes,nqpt))\\n eig = np.zeros((nmodes,nqpt,nat,3), dtype=complex) \\n\\n # Get the starting lines for each q-pt\\n i = 0\\n i_q = []\\n for line in f_dyn:\\n if \\\"q =\\\" in line:\\n i_q.append(i+2)\\n i += 1\\n\\n #Assign values to om and eig\\n for iq in range(nqpt):\\n for imod in range(nmodes):\\n omtext = f_dyn[i_q[iq]+imod*(nat+1)][43:55]\\n om[imod][iq] = float(omtext)\\n for iat in range(nat):\\n etext = f_dyn[i_q[iq]+imod*(nat+1)+iat+1][2:72].split()\\n for ic in range(3):\\n eig.real[imod][iq][iat][ic]=float(etext[2*ic])*np.sqrt(mass[iat])\\n eig.imag[imod][iq][iat][ic]=float(etext[2*ic+1])*np.sqrt(mass[iat])\\n\\n #Normalize the eigenvectors\\n t1 = eig[imod,iq,:,:]\\n t_nu = np.sum(np.sum(np.conjugate(t1)*t1,axis=0))\\n eig[imod,iq,:,:] = eig[imod,iq,:,:]/np.sqrt(np.abs(t_nu))\\n\\n # Check normalization\\n delta = np.zeros((nmodes,nmodes), dtype=complex)\\n for iat in range(nat):\\n for ic in range(3):\\n t2 = eig[:,iq,iat,ic]\\n delta += np.outer(np.conjugate(t2),t2)\\n\\n unit = np.diag(np.diag(np.ones((nmodes,nmodes)))) # Unit vector\\n test = np.abs( (delta-unit) )\\n if ( np.max(test) > 1e-3):\\n print \\\"Non-orthonormal eigenvector at iq=\\\", q[iq,:]\\n\\n return om, eig, q, zs, eps, mass, a0, vol, rG, nmodes, nqpt, nat\",\n \"def t9_loadSMFile(self):\\n print \\\"spectrumFile\\\"\\n filename = tkFileDialog.askopenfilename()\\n filename = \\\"data/\\\" + self.filenameparser(filename)\\n orgin_file = self.filenameparser(filename).split('.')[0]\\n self.t9_smfilename = filename\\n self.t9_orginfilename = orgin_file\",\n \"def print_geometries(self, name) -> None:\\n\\n open(f\\\"{name}.xyz\\\", \\\"w\\\").close() # Empty the file\\n\\n for i, image in enumerate(self):\\n energy = image.energy if image.energy is not None else \\\"none\\\"\\n\\n title_line = (\\n f\\\"autodE path point {i}. E = {energy} \\\"\\n f\\\"charge = {image.charge} \\\"\\n f\\\"mult = {image.mult} \\\"\\n )\\n\\n if image.solvent is not None:\\n title_line += f\\\"solvent = {image.solvent.name} \\\"\\n\\n atoms_to_xyz_file(\\n image.atoms,\\n f\\\"{name}.xyz\\\",\\n title_line=title_line,\\n append=True,\\n )\\n return None\",\n \"def read_data(self):\\n data = np.genfromtxt(self.__file) # Planck SED\\n self.__nu = 10.0**data[:,0]\\n self.__nuF = 10.0**data[:,2]\\n self.__err = 10.0**data[:,3]\\n #self.__W = 10.0**data[:,4]\\n self.__yerr = [ self.__nuF - self.__nuF / self.__err, \\\\\\n self.__nuF * self.__err - self.__nuF ]\\n self.__maxY = max( self.__nuF )\\n self.__minY = min( self.__nuF )\",\n \"def load(self):\\n from time import time\\n from subprocess import Popen\\n logger_name = thisfile + '->EXR:load()'\\n assert self.exr_f is not None, \\\"Set the exr_f first\\\"\\n npz_f = '/tmp/%s_t%s.npz' % \\\\\\n (basename(self.exr_f).replace('.exr', ''), time())\\n # Convert to .npz\\n # cv2.imread() can't load more than three channels from .exr even with IMREAD_UNCHANGED\\n # Has to go through IO. Maybe there's a better way?\\n cwd = join(dirname(abspath(__file__)), '..', '..', 'cli')\\n bash_cmd = 'python2 exr2npz.py %s %s' % (self.exr_f, npz_f)\\n process = Popen(bash_cmd.split(), cwd=cwd)\\n _, _ = process.communicate()\\n # Load this .npz\\n data = np.load(npz_f)\\n logger.name = logger_name\\n logger.info(\\\"Loaded %s\\\", self.exr_f)\\n return data\",\n \"def run():\\n\\n if lm.scene_object().type == 'env':\\n read_layout(outFile=lm.scene_object().copy(ext='json').path_root)\\n\\n else:\\n read_layout()\",\n \"def create_e3d_file(self,path='./'):\\n dt=0.606*self.model_parameters['dh']/np.max(self.velocity_model['vp']) # dt needs to satify the courant condition\\n t=int(self.model_parameters['duration']/dt)\\n \\n # Check path exists, if not create one\\n if not os.path.exists(path):\\n os.makedirs(path)\\n \\n # Create e3d parameter file\\n f=open('%s%s_e3dmodel.txt'%(path,self.model_name),'w')\\n f.write(\\\"grid x=%s z=%s dh=%s b=2 q=1\\\\ntime dt=%0.5f t=%s\\\\n\\\"%(self.model_parameters['xmax'],self.model_parameters['zmax'],self.model_parameters['dh'],dt,t))\\n f.write(\\\"block p=%s s=%s r=%s Q=20 Qf=50\\\\n\\\"%(self.velocity_model['vp'][0],self.velocity_model['vs'][0],self.velocity_model['rho'][0]))\\n \\n for i in range(1,len(self.velocity_model['vp'])-1):\\n f.write(\\\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\\\n\\\"%(self.velocity_model['vp'][i],self.velocity_model['vs'][i],self.velocity_model['rho'][i],\\n self.velocity_model['depth'][i],self.velocity_model['depth'][i+1]))\\n \\n f.write(\\\"block p=%s s=%s r=%s z1=%s z2=%s Q=20 Qf=50\\\\n\\\\n\\\"%(self.velocity_model['vp'][i+1],self.velocity_model['vs'][i+1],self.velocity_model['rho'][i+1],\\n self.velocity_model['depth'][i+1],self.model_parameters['zmax'])) # extend to the based of the model \\n \\n f.write(\\\"visual movie=5\\\\n\\\\n\\\")\\n\\n if self.source['src_type']!=4:\\n f.write(\\\"source type=%s x=%s z=%s freq=%s amp=%s\\\\n\\\\n\\\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'])) \\n else:\\n f.write(\\\"source type=%s x=%s z=%s freq=%s amp=%s Mxx=%s Myy=%s Mzz=%s Mxy=%s Mxz=%s Myz=%s\\\\n\\\\n\\\"%(self.source['src_type'],self.source['srcx'],self.source['srcz'],self.source['freq'],self.source['amp'],self.source['mt'][0],self.source['mt'][1],self.source['mt'][2],self.source['mt'][3],self.source['mt'][4],self.source['mt'][5])) \\n\\n for r in range(len(self.receivers['recxs'])):\\n f.write('sac x=%0.3f z=%0.3f file=%s\\\\n'%(self.receivers['recxs'][r],self.receivers['reczs'][r],self.model_name))\\n\\n f.write(\\\"visual sample=0.1 movie=1 scale=10000000000/n\\\")\\n f.close()\\n \\n print('File created: %s%s_e3dmodel.txt'%(path,self.model_name))\",\n \"def read_all_poses(world):\\n dataset_root='./jsonfile'\\n path = os.path.join(dataset_root, world, 'image_structs.mat')\\n data = sio.loadmat(path)\\n\\n xyz = data['image_structs']['world_pos']\\n image_names = data['image_structs']['image_name'][0]\\n\\n dire=data['image_structs']['direction']\\n #rot = data['image_structs']['R'][0]\\n #scale = data['scale'][0][0]\\n\\n n = xyz.shape[1]\\n x = [xyz[0][i][0][0] for i in range(n)]\\n y = [0 for i in range(n)]\\n z = [xyz[0][i][2][0] for i in range(n)]\\n px= [dire[0][i][0][0] for i in range(n)]\\n py= [0 for i in range(n)]\\n pz= [dire[0][i][2][0] for i in range(n)]\\n#============================================================\\n names = [name[0][:-4] for name in image_names]\\n if len(names) != len(x):\\n raise ValueError('number of image names are not equal to the number of '\\n 'poses {} != {}'.format(len(names), len(x)))\\n output = {}\\n for i in range(n):\\n output[names[i]] = [x[i], z[i], px[i], pz[i]]\\n return output\",\n \"def main(dataset, n, ms=False, out=sys.stdout):\\n # build lists of paths previews files, tif, rpc and dzi files\\n prv_paths = ' '.join([os.path.join(dataset, 'prv_%02d.jpg' % (i+1)) for i in xrange(n)])\\n tif_paths = ' '.join([os.path.join(dataset, 'im_panchro_%02d.tif' % (i+1)) for i in xrange(n)])\\n rpc_paths = ' '.join([os.path.join(dataset, 'rpc_%02d.xml' % (i+1)) for i in xrange(n)])\\n dzi8_paths, dzi16_paths = None, None\\n if ms:\\n ms_paths = ' '.join([os.path.join(dataset, 'im_ms_%02d.tif' % (i+1)) for i in xrange(n)])\\n if os.path.isfile(os.path.abspath(os.path.join(dataset,\\n 'im_panchro_8BITS_01.dzi'))):\\n dzi8_paths = ' '.join([os.path.join('input', dataset,\\n 'im_panchro_8BITS_%02d.dzi' %\\n (i+1)) for i in xrange(n)])\\n if os.path.isfile(os.path.abspath(os.path.join(dataset,\\n 'im_panchro_16BITS_01.dzi'))):\\n dzi16_paths = ' '.join([os.path.join('input', dataset,\\n 'im_panchro_16BITS_%02d.dzi' %\\n (i+1)) for i in xrange(n)])\\n\\n # read infos in DIM*.XML file\\n dim_xml_file = os.path.join(dataset, 'dim_01.xml')\\n tif_file = os.path.join(dataset, 'im_panchro_01.tif')\\n if os.path.isfile(dim_xml_file): # check if the link points to an existing file\\n date = grep_xml(dim_xml_file, \\\"IMAGING_DATE\\\")\\n satellite = grep_xml(dim_xml_file, \\\"INSTRUMENT_INDEX\\\")\\n elif os.path.isfile(tif_file):\\n date = extract_date_from_pleiades_filename(os.readlink(tif_file))\\n satellite = extract_satellite_from_pleiades_filename(os.readlink(tif_file))\\n else:\\n date = 'DD-MM-YYYY'\\n satellite = 'Pleiades 1X'\\n\\n # print to stdout\\n if dzi8_paths or dzi16_paths:\\n print('[%s]' % dataset, file=out)\\n print('files = ', prv_paths, file=out)\\n print('tif = ', tif_paths, file=out)\\n print('rpc = ', rpc_paths, file=out)\\n if ms:\\n print('clr = ', ms_paths, file=out)\\n if dzi8_paths:\\n print('dzi8 = ', dzi8_paths, file=out)\\n if dzi16_paths:\\n print('dzi16 = ', dzi16_paths, file=out)\\n s = dataset.split(os.path.sep)\\n if len(s) == 3: # ie the path is of the kind 'pleiades/reunion/dataset_1'\\n print('title = %s (%s)' % (s[1].capitalize(), s[2][-1]), file=out) # ie 'Reunion (1)'\\n elif len(s) == 2: # ie the path is of the kind 'pleiades/reunion'\\n print('title = %s' % s[1].capitalize(), file=out) # ie 'Reunion'\\n else:\\n print('path %s not expected by the author of the script: ' % dataset, s, file=sys.stderr)\\n print('date = %s' % date, file=out)\\n print('satellite = Pleiades %s' % satellite, file=out)\\n print('nb_img = %d' % n, file=out)\\n if ms:\\n print('color = panchro_xs', file=out)\\n else:\\n print('color = panchro', file=out)\",\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 read_input_file(self):\\n\\n # Check if input file exists in current directory, if not kill process\\n if not os.path.isfile('./visualise.inpt'):\\n print('Cannot find input file \\\"visualise.inpt\\\" in current directory')\\n sys.exit()\\n\\n # Read input file and analysis options and parameters\\n print('Reading input file')\\n with open('visualise.inpt','r') as f:\\n f.readline()\\n self.prefix = f.readline().split()[0]\\n f.readline()\\n f.readline()\\n self.frame = int(f.readline().split()[0])\\n f.readline()\\n f.readline()\\n self.vis_particles = int(f.readline().split()[0])\\n self.vis_vortype = int(f.readline().split()[0])\\n self.vis_cellcolour = int(f.readline().split()[0])\\n self.vis_save = int(f.readline().split()[0])\",\n \"def load_vo_txt(*, fname, sampling='1M', sv_spacing):\\n # Load GVO MF and sigmas from txt file\\n df_mf = load_vo_txt_raw(fname=fname, sampling=sampling)\\n df_sigma = pd.DataFrame({'sigma_r': df_mf['sigma_r'],\\n 'sigma_theta': df_mf['sigma_theta'],\\n 'sigma_phi': df_mf['sigma_phi'],\\n 'N_data': df_mf['N_data']})\\n\\n # Rearrange to dataframe of timeseries at each GVO location\\n dates = df_mf[\\\"date\\\"].unique() # timeseries for all GVO\\n # dates_mjd2000 = df_mf[\\\"mjd2000\\\"].unique()\\n\\n # Array of GVO positions [t, p, r]\\n positions = df_mf.drop_duplicates(subset=[\\\"theta\\\", \\\"phi\\\"])\\n positions = positions[[\\\"theta\\\", \\\"phi\\\"]].to_numpy()\\n positions = np.column_stack((positions,\\n np.repeat(df_mf[\\\"r\\\"].dropna().unique(),\\n len(positions)))) # txt file\\n\\n df_mf_pos = pd.DataFrame({\\\"date\\\": dates})\\n for pos in range(len(positions)):\\n df_mf_pos[\\\"X\\\"] = df_mf[\\\"X\\\"].loc[(df_mf[\\\"theta\\\"] == positions[pos, 0])\\n & (df_mf[\\\"phi\\\"]\\n == positions[pos, 1])].values\\n df_mf_pos[\\\"Y\\\"] = df_mf[\\\"Y\\\"].loc[(df_mf[\\\"theta\\\"] == positions[pos, 0])\\n & (df_mf[\\\"phi\\\"]\\n == positions[pos, 1])].values\\n df_mf_pos[\\\"Z\\\"] = df_mf[\\\"Z\\\"].loc[(df_mf[\\\"theta\\\"] == positions[pos, 0])\\n & (df_mf[\\\"phi\\\"]\\n == positions[pos, 1])].values\\n\\n # Get SV, then rename SV columns\\n if sampling == '1M':\\n df_sv = calculate_sv(df_mf_pos, mean_spacing=sv_spacing)\\n elif sampling == '4M':\\n # Calculate SV as annual differences of four-monthly GVO MF and set\\n # the SV date to be between the two MF dates\\n df_sv = pd.DataFrame()\\n df_sv['date'] = df_mf_pos['date'] - \\\\\\n pd.tseries.offsets.DateOffset(months=6)\\n df_sv['dx'] = df_mf_pos['X'].diff(periods=3)\\n df_sv['dy'] = df_mf_pos['Y'].diff(periods=3)\\n df_sv['dz'] = df_mf_pos['Z'].diff(periods=3)\\n df_sv.drop(df_sv.head(3).index, inplace=True)\\n df_sv.reset_index(drop=True, inplace=True)\\n if pos == 0: # keep date and data columns in first instance\\n df_sv_pos = df_sv\\n df_sv_pos.rename(columns={\\\"dx\\\": \\\"dx_\\\"+str(pos).zfill(3),\\n \\\"dy\\\": \\\"dy_\\\"+str(pos).zfill(3),\\n \\\"dz\\\": \\\"dz_\\\"+str(pos).zfill(3)},\\n inplace=True)\\n else: # only keep data columns otherwise\\n df_sv_pos[[\\\"dx_\\\"+str(pos).zfill(3),\\n \\\"dy_\\\"+str(pos).zfill(3),\\n \\\"dz_\\\"+str(pos).zfill(3)]] = df_sv[[\\\"dx\\\", \\\"dy\\\", \\\"dz\\\"]]\\n\\n # Rename MF columns starting from GVO 000\\n df_mf_pos.rename(columns={\\\"X\\\": \\\"X_\\\"+str(pos).zfill(3),\\n \\\"Y\\\": \\\"Y_\\\"+str(pos).zfill(3),\\n \\\"Z\\\": \\\"Z_\\\"+str(pos).zfill(3)}, inplace=True)\\n\\n return df_mf_pos, df_sv_pos, positions, dates, df_sigma\",\n \"def test_to_multiframe_xyz(self):\\n\\n # load in an SDF of butane with multiple conformers in it\\n molecules = Molecule.from_file(\\n get_data_file_path(\\\"molecules/butane_multi.sdf\\\"), \\\"sdf\\\"\\n )\\n # now we want to combine the conformers to one molecule\\n butane = molecules[0]\\n for mol in molecules[1:]:\\n butane.add_conformer(mol._conformers[0])\\n\\n # make sure we have the 7 conformers\\n assert butane.n_conformers == 7\\n with NamedTemporaryFile(suffix=\\\".xyz\\\") as iofile:\\n # try and write out the xyz file\\n butane.to_file(iofile.name, \\\"xyz\\\")\\n\\n # now lets check whats in the file\\n with open(iofile.name) as xyz_data:\\n data = xyz_data.readlines()\\n # make sure we have the correct amount of lines writen\\n assert len(data) == 112\\n # make sure all headers and frame data was writen\\n assert data.count(\\\"14\\\\n\\\") == 7\\n for i in range(1, 8):\\n assert f\\\"C4H10 Frame {i}\\\\n\\\" in data\\n\\n # now make sure the first line of the coordinates are correct in every frame\\n coords = [\\n \\\"C 1.8902000189 0.0425999984 0.2431000024\\\\n\\\",\\n \\\"C 1.8976000547 -0.0232999995 0.2845999897\\\\n\\\",\\n \\\"C -1.8794000149 -0.1792999953 -0.2565000057\\\\n\\\",\\n \\\"C -1.5205999613 -0.0164999999 0.2786999941\\\\n\\\",\\n \\\"C -1.4889999628 -0.2619000077 0.4871000051\\\\n\\\",\\n \\\"C -1.4940999746 -0.2249000072 -0.0957999974\\\\n\\\",\\n \\\"C -1.8826999664 -0.0372000001 0.1937000006\\\\n\\\",\\n ]\\n for coord in coords:\\n assert coord in data\",\n \"def __init__(self, filepath='multidrcl', suffix='DRCL', extension='.IMG', lblext='.LBL', force_read=True, unit='s', feature='sh', eye='L', do_print=True, initdatadir=None, initdata=None, readintuple=None):\\n\\n Dataset.__init__(self, None, \\\"mastcam\\\")\\n\\n if readintuple != None:\\n (self.data, self.fullimages, self.segmentation, self.labels, self.xlabel, self.ylabel, self.xvals, self.rgbdict, self.lblext) = readintuple[0:9]\\n if initdata != None:\\n self.initdata = initdata\\n if self.initfilename != None:\\n self.initfilename = initarchive\\n else:\\n self.initfilename = 'param'\\n return\\n \\n if do_print: print(filepath)\\n \\n if filepath == '388':\\n filepath = '/proj/imbue/data/msl-mastcam/sol388/'\\n \\n if filepath == 'multidrcl':\\n filepath = '/proj/imbue/data/msl-mastcam/multispectral_drcl/'\\n \\n self.filepath = filepath\\n self.xlabel = 'TBD'\\n self.ylabel = 'TBD'\\n \\n #dirname = filepath[:-1]\\n #subsetname = dirname.split('/')[-1]\\n subsetname = os.path.basename(filepath)\\n self.name += \\\"-\\\" + subsetname\\n if len(suffix) > 0:\\n self.name += \\\"-\\\" + eye + '-' + suffix + '-' + unit + '-' + feature\\n if do_print: print(\\\"Dataset name: \\\" + self.name)\\n \\n self.data = []\\n self.cadence = []\\n \\n self.unit = unit\\n self.feature = feature\\n self.eye = eye\\n\\n self.rgbdict = {}\\n self.extension = extension\\n self.lblext = lblext\\n self.suffix = suffix\\n \\n self.archive = os.path.join(filepath,\\n subsetname + eye + \\\"_\\\" + suffix + '_' + unit + '_' + feature + \\\".pkl\\\")\\n\\n if initdata != None:\\n self.initdata = initdata\\n if self.initfilename != None:\\n self.initfilename = initarchive\\n else:\\n self.initfilename = 'param'\\n elif initdatadir != None:\\n print(\\\"Reading in initialization data...\\\")\\n #initsubsetname = initdatadir[:-1].split('/')[-1]\\n initsubsetname = os.path.basename(initdatadir)\\n initarchive = os.path.join(initdatadir,\\n initsubsetname + eye + \\\"_\\\" + suffix + '_' + unit + '_' + feature + \\\".pkl\\\")\\n if os.path.exists(initarchive):\\n with open(initarchive, 'r') as f:\\n self.initdata = pickle.load(f)[0]\\n self.initfilename = initarchive\\n print(\\\"...done!\\\")\\n print(\\\"initdata.shape:\\\", self.initdata.shape)\\n else:\\n print(\\\"...initialization data does not exist!\\\")\\n print(\\\"Desired pickle was: %s\\\" % initarchive)\\n \\n # Determine if we need to preprocess the data\\n if (not os.path.exists(self.archive)) or force_read:\\n self.read_mastcam_dir(filepath, suffix, unit, feature, extension, lblext, eye)\\n else:\\n if do_print: print(\\\"Found pickle at \\\" + self.archive)\\n \\n self.readin()\",\n \"def plotsources(self): \\n mainDir = Inverse.mainDir\\n folder_name = self.folder_name\\n os.chdir(mainDir)\\n \\n folder = os.listdir(u'.')\\n subfolders = [f for f in folder if f[0] == 'S']\\n\\n for subject in subfolders:\\n # go to the directory\\n curdir = os.path.join(mainDir, subject)\\n os.chdir(curdir)\\n # locate source files\\n stcfiles = glob.glob('*-rh.stc')\\n\\n for ii, fname in enumerate(stcfiles):\\n # read the source files\\n print(fname)\\n stc = mne.read_source_estimate(os.path.join(curdir, fname))\\n plottitle = fname.split('_c')[0]\\n\\n try:# plot the surface\\n # Get labels for FreeSurfer 'aparc' cortical parcellation with 34 labels/hemi\\n labels_parc = mne.read_labels_from_annot(subject, parc='aparc', subjects_dir = mainDir)\\n\\n # plot the sources\\n brain = stc.plot(subject=subject, surface='pial', hemi='both', colormap='auto',\\n time_label='auto', smoothing_steps=10, transparent=True, alpha=0.8,\\n time_viewer=False, subjects_dir=None, figure=None, views='dor',\\n colorbar=True, clim='auto', cortex='classic', size=800, background='black',\\n foreground='white',\\n initial_time = self.initial_time, time_unit='s', backend='auto', spacing='oct5')\\n\\n vertno_max, time_max = stc.get_peak(hemi='lh')\\n brain.add_foci(vertno_max, coords_as_verts=True, hemi='lh', color='red')\\n\\n vertno_max_rh, time_max_rh = stc.get_peak(hemi='rh')\\n brain.add_foci(vertno_max_rh, coords_as_verts=True, hemi='rh', color='blue')\\n\\n brain.add_text(0.1, 0.9, plottitle, 'title', font_size=36)\\n\\n except Exception as errMessage:\\n print('Something went wrong with subject >>>', fname)\\n print(errMessage)\\n pass\\n \\\"\\\"\\\"\\n views : str | list\\n View to use. See surfer.Brain(). Supported views: ['lat', 'med', 'fos',\\n 'cau', 'dor' 'ven', 'fro', 'par']. Using multiple views is not\\n supported for mpl backend.\\n \\\"\\\"\\\"\\n labelo = []\\n try:\\n #brain.add_annotation\\n labelo.append([label for label in labels_parc if label.name == 'postcentral-lh'][0])\\n labelo.append([label for label in labels_parc if label.name == 'postcentral-rh'][0])\\n labelo.append([label for label in labels_parc if label.name == 'precentral-lh'][0] )\\n labelo.append([label for label in labels_parc if label.name == 'precentral-rh'][0] )\\n# labelo.append([label for label in labels_parc if label.name == 'inferiorparietal-lh'][0])\\n# labelo.append([label for label in labels_parc if label.name == 'inferiorparietal-rh'][0])\\n# labelo.append([label for label in labels_parc if label.name == 'superiorfrontal-rh'][0])\\n# labelo.append([label for label in labels_parc if label.name == 'superiorfrontal-lh'][0])\\n\\n for label in labelo:\\n brain.add_label(label, borders=1)\\n\\n except Exception as errMessage:\\n print(errMessage)\\n pass\\n\\n try: # make a directory called 'results'\\n os.mkdir(os.path.join(curdir, folder_name))\\n except Exception as errMessage:\\n print(errMessage)\\n\\n finally:\\n os.chdir(os.path.join(curdir, folder_name))\\n brain.save_image(fname.split('_c')[0])\\n brain.close()\\n\\n os.chdir(mainDir)\",\n \"def sim12_g_simulation(datafiles, simulation_mag_zeropoint, simulation_exposure):\\n return stuff.Simulation(datafiles / 'sim12' / 'sim12_g.list', simulation_mag_zeropoint, simulation_exposure)\",\n \"def load_data(self):\\n x_vector = pickle.load(open(self.file_stem + \\\"x.pickle\\\", \\\"rb\\\"))\\n ode_sols = pickle.load(open(self.file_stem + \\\"sols.pickle\\\", \\\"rb\\\"))\\n forcings = pickle.load(open(self.file_stem + \\\"fs.pickle\\\", \\\"rb\\\"))\\n sl_coeffs = pickle.load(open(self.file_stem + \\\"coeffs.pickle\\\", \\\"rb\\\"))\\n\\n return x_vector, ode_sols, forcings, sl_coeffs\",\n \"def import_file(self):\\n\\n t0 = datetime.now()\\n\\n print(\\\"\\\\n\\\" + \\\"Importing {}...\\\".format(self.filepath))\\n\\n file = pyedflib.EdfReader(self.filepath)\\n\\n self.sample_rate = file.getSampleFrequencies()[0]\\n self.accel_sample_rate = file.getSampleFrequencies()[1]\\n\\n # READS IN ECG DATA ===========================================================================================\\n if self.end_offset == 0:\\n print(\\\"Importing file from index {} to the end...\\\".format(self.start_offset))\\n self.raw = file.readSignal(chn=0, start=self.start_offset)\\n\\n if self.load_accel:\\n self.x = file.readSignal(chn=1, start=int(self.start_offset *\\n self.accel_sample_rate / self.sample_rate))\\n self.y = file.readSignal(chn=2, start=int(self.start_offset *\\n self.accel_sample_rate / self.sample_rate))\\n self.z = file.readSignal(chn=3, start=int(self.start_offset *\\n self.accel_sample_rate / self.sample_rate))\\n\\n if self.end_offset != 0:\\n print(\\\"Importing file from index {} to {}...\\\".format(self.start_offset,\\n self.start_offset + self.end_offset))\\n self.raw = file.readSignal(chn=0, start=self.start_offset, n=self.end_offset)\\n\\n if self.load_accel:\\n self.x = file.readSignal(chn=1,\\n start=int(self.start_offset * self.accel_sample_rate / self.sample_rate),\\n n=int(self.end_offset * self.accel_sample_rate / self.sample_rate))\\n\\n self.y = file.readSignal(chn=2,\\n start=int(self.start_offset * self.accel_sample_rate / self.sample_rate),\\n n=int(self.end_offset * self.accel_sample_rate / self.sample_rate))\\n\\n self.z = file.readSignal(chn=3,\\n start=int(self.start_offset * self.accel_sample_rate / self.sample_rate),\\n n=int(self.end_offset * self.accel_sample_rate / self.sample_rate))\\n\\n # Calculates gravity-subtracted vector magnitude. Converts from mg to G\\n # Negative values become zero\\n if self.load_accel:\\n self.vm = (np.sqrt(np.square(np.array([self.x, self.y, self.z])).sum(axis=0)) - 1000) / 1000\\n self.vm[self.vm < 0] = 0\\n\\n print(\\\"ECG data import complete.\\\")\\n\\n self.starttime = file.getStartdatetime() + timedelta(seconds=self.start_offset/self.sample_rate)\\n self.file_dur = round(file.getFileDuration() / 3600, 3)\\n\\n # Data filtering\\n self.filtered = Filtering.filter_signal(data=self.raw, low_f=self.low_f, high_f=self.high_f,\\n filter_type=self.f_type, sample_f=self.sample_rate, filter_order=3)\\n\\n # TIMESTAMP GENERATION ========================================================================================\\n t0_stamp = datetime.now()\\n\\n print(\\\"\\\\n\\\" + \\\"Creating timestamps...\\\")\\n\\n # Timestamps\\n end_time = self.starttime + timedelta(seconds=len(self.raw)/self.sample_rate)\\n self.timestamps = np.asarray(pd.date_range(start=self.starttime, end=end_time, periods=len(self.raw)))\\n self.epoch_timestamps = self.timestamps[::self.epoch_len * self.sample_rate]\\n\\n t1_stamp = datetime.now()\\n stamp_time = (t1_stamp - t0_stamp).seconds\\n print(\\\"Complete ({} seconds).\\\".format(round(stamp_time, 2)))\\n\\n t1 = datetime.now()\\n proc_time = (t1 - t0).seconds\\n print(\\\"\\\\n\\\" + \\\"Import complete ({} seconds).\\\".format(round(proc_time, 2)))\",\n \"def main(name, line1, line2, orbital_filename):\\n #name = \\\"TERRA\\\"\\n #line1 = \\\"1 25994U 99068A 16048.43680378 .00000258 00000-0 67198-4 0 9999\\\"\\n #line2 = \\\"2 25994 98.1982 124.4247 0001352 105.3907 254.7441 14.57126067859938\\\"\\n satellite = ephem.readtle(name, line1, line2)\\n \\n\\n # Landsat 8\\n #name = \\\"Landsat8\\\"\\n #line1=\\\"1 39084U 13008A 16051.82349873 .00000188 00000-0 51829-4 0 9999\\\"\\n #line2=\\\"2 39084 98.1988 123.2603 0001265 89.4360 270.6984 14.57110027160810\\\"\\n #LD8 = ephem.readtle(name, line1, line2)\\n \\n\\n sun = ephem.Sun()\\n fov = np.radians(68.6)\\n\\n \\\"\\\"\\\"\\n Make pandas dataframe to store swath information\\n \\\"\\\"\\\"\\n import pandas as pd\\n data = {\\\"DateTime\\\": [],\\\"DOY\\\":[],\\\"Month\\\": [],\\n \\\"orbit_id\\\":[], \\\"ground_lat\\\": [], \\n \\\"ground_lon\\\": [], \\\"swath_width\\\": []}\\n swaths = pd.DataFrame(data)\\n swaths.set_index(keys=\\\"DateTime\\\")\\n # generate shapefile\\n\\n orbit_id = 0\\n # need to do splitted by hemisphere unfortunately..\\n for orbit in make_an_orbit(satellite):\\n #import pdb; pdb.set_trace()\\n if len(orbit) > 1:\\n \\\"\\\"\\\"\\n So worth doing processing on orbit...\\n\\n \\\"\\\"\\\"\\n sun = ephem.Sun()\\n\\n print(orbit[0].datetime)\\n\\n for overpass in orbit:\\n overpass.only_daytime_overpasses(sun)\\n overpass.derive_swath_width(fov)\\n \\\"\\\"\\\"\\n Create a tempoary dataframe for this orbit\\n \\\"\\\"\\\"\\n epoch = datetime.datetime(1970, 1, 1)\\n #import pdb; pdb.set_trace()\\n tmp_d = {\\\"DateTime\\\": [(o.datetime - epoch).total_seconds() for o in orbit],\\n \\\"DOY\\\":[int(o.datetime.strftime('%j')) for o in orbit],\\n \\\"Month\\\": [o.datetime.month for o in orbit],\\n \\\"orbit_id\\\": orbit_id * np.ones(len(orbit)),\\n \\\"ground_lat\\\": [o.lat for o in orbit],\\n \\\"ground_lon\\\": [o.long for o in orbit],\\n \\\"swath_width\\\": [o.swath_width for o in orbit]}\\n tmp = pd.DataFrame(tmp_d)\\n tmp.set_index(keys=\\\"DateTime\\\")\\n #import pdb; pdb.set_trace()\\n orbit_id +=1 \\n \\\"\\\"\\\"\\n Append to main dataframe\\n \\\"\\\"\\\"\\n swaths = swaths.append(tmp)\\n #swaths.set_index(keys=\\\"DateTime\\\")\\n\\n \\\"\\\"\\\"\\n Save the DataFrame to a file\\n \\\"\\\"\\\"\\n swaths = swaths.set_index(keys=\\\"DateTime\\\")\\n #swaths.set_index(keys=\\\"DateTime\\\")\\n #import pdb; pdb.set_trace()\\n swaths.to_csv(orbital_filename, header=True)\",\n \"def extract_relevant_data( case_list = [], exceptions = [], y_delta_locs = [],\\n x_2h_locs = [] , plot = False, output_root = '',\\n overwrite = False, just_plot = False ):\\n\\n from os import listdir\\n from os.path import join,split,isfile\\n from pandas import DataFrame, HDFStore\\n from boundary_layer_routines import return_bl_parameters\\n from progressbar import ProgressBar,Percentage\\n from progressbar import Bar,ETA,SimpleProgress\\n from numpy import array, round, linspace, nan, sign\\n from data_cleaning_routines import show_surface_from_df\\n\\n x_2h_locs = round( array( x_2h_locs ), 2 )\\n y_delta_locs = round( array( y_delta_locs ), 2 )\\n\\n if not output_root:\\n output_root = '/media/carlos/6E34D2CD34D29783/' +\\\\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\\n\\n # Get the available HDF5 files #############################################\\n hdf5_root = '/media/carlos/6E34D2CD34D29783/' +\\\\\\n '2015-02_SerrationPIV/TR_Data_Location_Calibrated_Article3'\\n\\n if not len(case_list):\\n hdf5_files = [f for f in listdir( hdf5_root ) \\\\\\n if f.endswith('.hdf5') \\\\\\n and not f in exceptions ]\\n else:\\n hdf5_files = [f for f in listdir( hdf5_root ) \\\\\\n if f.endswith('.hdf5') \\\\\\n and f in case_list ]\\n # ##########################################################################\\n\\n for hf in [join( hdf5_root, f ) for f in hdf5_files]:\\n\\n suffix = '_AirfoilNormal'\\n\\n mean_flow_rotated = False\\n if hf.endswith(\\\"MeanFlowRotated.hdf5\\\"):\\n mean_flow_rotated = True\\n suffix = ('_MeanFlowRotated')\\n\\n f = split( hf )[1].replace(suffix,'')\\\\\\n .replace('_Aligned.hdf5','').replace('.hdf5','')\\n if mean_flow_rotated:\\n f = f + '_mfr'\\n\\n # Get the normalization locations depending on the case ################\\n if 'z00' in f and not 'STE' in f:\\n x_bl_loc = 38\\n elif 'z05' in f:\\n x_bl_loc = 18\\n elif 'z10' in f or 'STE' in f:\\n x_bl_loc = -2\\n\\n #if mean_flow_rotated:\\n # mean_flow_df = read_pickle( mean_flow_pickle )\\n # mean_flow_angle = mean_flow_df.T.ix[ \\n # f.replace('.hdf5','')\\n # ].ix[0].values[0]\\n\\n # yshift = - x_bl_loc * sin( radians( mean_flow_angle ) )\\n #else:\\n # yshift = 0\\n\\n print \\\" Processing {0}\\\".format( f )\\n if not overwrite and isfile( 'ReservedData/' + f + '.hdf5' ):\\n print \\\" File exists; skipping\\\"\\n continue\\n\\n\\n hdf_t = HDFStore( hf, 'r' )\\n\\n # Get the available coordinates ########################################\\n hf_coords = hdf_t.select('data', where = [ 't = 0' ], \\n columns = [ 'x', 'y' , 'u' ] )\\n # ######################################################################\\n\\n # Turn the non-dim requested locations into physical coords ############\\n requested_locations = []\\n requested_normalized_locations = []\\n #for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\\n # for y_d in y_delta_locs:\\n # bl_params = return_bl_parameters( f , [x] )\\n # d_99 = bl_params.delta_99.values[0]\\n # #if \\\"STE\\\" in f:\\n # # d_99 = 9.4\\n # y = y_d * d_99\\n # requested_locations.append( (x,y) )\\n # requested_normalized_locations.append( ( x_norm, y_d ) )\\n\\n bl_params = return_bl_parameters( \\n f.replace( '_mfr', '' ) , \\n [x_bl_loc] )\\n d_99 = bl_params.delta_99.values[0]\\n\\n for x,x_norm in zip(x_2h_locs * tooth_length, x_2h_locs):\\n for y_d in y_delta_locs:\\n y = y_d * d_99\\n requested_locations.append( (x,y) )\\n requested_normalized_locations.append( ( x_norm, y_d ) )\\n print \\\" Normalizing to a BL thickness of {0:.2f} mm\\\".\\\\\\n format(d_99)\\n # ######################################################################\\n\\n hf_coords = hf_coords.replace( 0, nan )\\n hf_coords = hf_coords.dropna()\\n\\n min_x_real_loc = min( x_2h_locs ) * tooth_length\\n max_x_real_loc = max( x_2h_locs ) * tooth_length\\n\\n # This is the max y location for a full square in the rotated FoV ######\\n max_y_field_of_view = min(\\n hf_coords[ \\n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\\\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \\n ].y.max(),\\n\\n hf_coords[ \\n ( hf_coords.x < \\\\\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\\\\n ( hf_coords.x > \\\\\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \\n ].y.max()\\n )\\n # ######################################################################\\n\\n # This is the minimum (and x_loc aligned) y location for a full square\\n # in the rotated FoV ###################################################\\n min_y_field_of_view = max(\\n hf_coords[ \\n ( hf_coords.x < \\\\\\n min_x_real_loc * ( 1 + sign( min_x_real_loc ) * 0.1 ) ) & \\\\\\n ( hf_coords.x > \\\\\\n min_x_real_loc * ( 1 - sign( min_x_real_loc ) * 0.1 ) ) \\n ].y.min(), \\n hf_coords[ \\n ( hf_coords.x < max_x_real_loc * 1.1 ) & \\\\\\n ( hf_coords.x > max_x_real_loc * 0.9 ) \\n ].y.min()\\n )\\n\\n # ######################################################################\\n\\n if max( y_delta_locs ) * d_99 < max_y_field_of_view:\\n max_y_loc = max( y_delta_locs ) * d_99\\n else:\\n max_y_loc = max_y_field_of_view\\n\\n if min( y_delta_locs ) * d_99 > min_y_field_of_view:\\n min_y_loc = min( y_delta_locs ) * d_99\\n else:\\n min_y_loc = min_y_field_of_view\\n\\n available_xy_locs = hf_coords[\\n ( hf_coords.x > min( x_2h_locs ) * 40. ) & \\\\\\n ( hf_coords.x < max( x_2h_locs ) * 40. ) & \\\\\\n ( hf_coords.y > min_y_loc ) & \\\\\\n ( hf_coords.y < max_y_loc )\\n ][ ['x','y'] ]\\n\\n if available_xy_locs.empty:\\n return 0\\n \\n available_xy_locs = [ tuple(x) for x in available_xy_locs.values ]\\n\\n #if mean_flow_rotated:\\n # y_correction = - x_bl_loc * sin( radians( mean_flow_angle ) )\\n\\n #if plot:\\n\\n # trailing_edge,phi,alpha,U,z = decript_case_name( f )\\n\\n # if trailing_edge == 'serrated': device = 'Sr20R21'\\n # elif trailing_edge == 'straight': device = 'STE'\\n # elif trailing_edge == 'slitted': device = 'Slit20R21'\\n\\n # case_name = \\\"{0}_phi{1}_alpha{2}_U{3}_loc{4}_tr.dat\\\".format(\\n # device, phi, alpha, U, z\\n # )\\n\\n # plot_name = ''\\n # if mean_flow_rotated:\\n # average_pickle_name = 'averaged_data/' + case_name + \\\\\\n # '_mean_flow_rotated.p'\\n # else:\\n # average_pickle_name = 'averaged_data/' + case_name + '.p'\\n # df_av = read_pickle( average_pickle_name )\\n\\n # if mean_flow_rotated:\\n # df_av.y = df_av.y - yshift\\n\\n # plot_name = 'ReservedData/' + f + '.png'\\n # show_surface_from_df( \\n # df_av , \\n # points = available_xy_locs ,\\n # plot_name = plot_name,\\n # point_correction = ( 0 , 0 )\\n # )\\n # if not plot_name:\\n # continue\\n\\n # Don't try to get it all at once; split the vertical in 4 pieces\\n vertical_split_blocks = 10\\n\\n y_ranges = linspace( \\n min_y_loc,\\n max_y_loc,\\n vertical_split_blocks\\n ) \\n\\n xmin = min(x_2h_locs) * tooth_length\\n xmax = max(x_2h_locs) * tooth_length\\n\\n print \\\" Extracting data from {0}\\\".format(f)\\n print \\\" at the streamwise locations:\\\",\\n print \\\" {0:.2f} to {1:.2f}\\\".format( xmin, xmax )\\n print \\\" at the wall-normal locations:\\\",\\n print \\\" {0:.2f} to {1:.2f}\\\".format( min_y_loc, max_y_loc )\\n\\n if plot:\\n query = \\\" x>={0} & x<{1} & y>={2} & y<{3} & t=0\\\".\\\\\\n format( xmin, xmax, min_y_loc, max_y_loc )\\n\\n df0 = hdf_t.select(\\n key = 'data',\\n where = [ query ],\\n )\\n\\n plot_name = 'ReservedData/' + f + '.png'\\n if mean_flow_rotated:\\n plot_name = plot_name.replace( '.png', '_mfr.png' )\\n\\n show_surface_from_df( \\n df0,\\n plot_name = plot_name,\\n point_correction = ( 0 , 0 )\\n )\\n if just_plot:\\n return 0\\n\\n query = ''\\n cnt_all = 0\\n\\n cnt = 0\\n time_series_hdf = HDFStore( 'ReservedData/' + f + '.hdf5', 'w' )\\n\\n progress = ProgressBar(\\n widgets=[\\n Bar(),' ',\\n Percentage(),' ',\\n ETA(), ' (query bunch ',\\n SimpleProgress(),')'], \\n maxval = vertical_split_blocks\\n ).start()\\n\\n for ymin, ymax in zip( y_ranges[:-1], y_ranges[1:] ):\\n\\n query = \\\" x>={0} & x<{1} & y>={2} & y<{3} \\\".\\\\\\n format( xmin, xmax, ymin, ymax )\\n\\n df_t = hdf_t.select(\\n key = 'data',\\n where = [ query ],\\n )\\n\\n df_t['near_x_2h'] = round( df_t.x / 40., 4 )\\n df_t['near_y_delta'] = round( df_t.y / d_99, 4 )\\n\\n # If it has been flow rotated, the zero y direction needs to be\\n # brought back to the location of the wall at the reference x\\n # location #########################################################\\n #if mean_flow_rotated:\\n # df_t.y = df_t.y - y_correction\\n # ##################################################################\\n # The translation now happens when pickling the raw data\\n\\n if not cnt:\\n time_series_hdf.put( 'data', df_t , \\n data_columns = [\\n 'near_x_2h',\\n 'near_y_delta',\\n 't'\\n ],\\n format = 't')\\n else:\\n time_series_hdf.append( 'data', df_t , \\n data_columns = [\\n 'near_x_2h',\\n 'near_y_delta',\\n 't'\\n ],\\n format = 't')\\n\\n cnt_all += 1\\n cnt += 1\\n\\n progress.update(cnt_all)\\n\\n df_t = DataFrame()\\n\\n\\n progress.finish()\\n hdf_t.close()\\n time_series_hdf.close()\",\n \"def hxb_data_experiment(directory):\\n\\n #######################################################################\\n #LOADING DATA\\n #######################################################################\\n\\n #Loading all files in the folder\\n xyz_files = []\\n blur_files = []\\n\\n #Spliting files in xyz coordinates and voxels data.\\n files = os.listdir(directory)\\n files.sort()\\n for f in files:\\n if os.path.isfile(os.path.join(directory, f)):\\n if f.startswith('C'):\\n xyz_files.append(f)\\n if f.startswith('F'):\\n blur_files.append(f)\\n\\n #Loading xyz data\\n dict_xyz = {}\\n for f in xyz_files:\\n #The name of the subject is given by the four last letter.\\n dict_xyz[f[1]] = np.genfromtxt(os.path.join(directory, f),\\n dtype = float)\\n print \\\"xyz_file for subject %s was loaded.\\\" %(f[1])\\n\\n #Loading voxels data and creating the intermediate representation objects\\n inter_reps = []\\n for f in blur_files:\\n #Name of the subject is always in positions [7:11]\\n s_name = f[1]\\n #Class is in possition 5\\n cls = str(f[3:-4])\\n arr_voxels = np.genfromtxt(os.path.join(directory, f), dtype = float, delimiter = ' ')\\n inter_reps.append(ir.IntermRep(arr_voxels, dict_xyz[s_name], s_name,\\n cls))\\n\\n print \\\"Intermediate representation for subject %s and class %s created.\\\" %(s_name, cls)\\n\\n #######################################################################\\n\\n\\n #######################################################################\\n #Computing the Graph Encoding\\n #######################################################################\\n\\n graphs = []\\n classes = []\\n subjects = []\\n\\n #Cluster based graph encoding with a fixed threshold\\n #-----------------------------\\n# fc = ge.GE_ClusterBased()\\n# for i_rep in inter_reps:\\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\\n# n_clusters = -1, clust_ratio = 170,\\n# similarity_measure=\\\"pearson\\\",\\n# threshold=0.1, n_jobs = 1))\\n# classes.append(i_rep.cls)\\n# subjects.append(i_rep.subj_name)\\n# print \\\"Graph built for subject %s and class %s.\\\" %(i_rep.subj_name, i_rep.cls)\\n# print \\\"Number of nodes: %i, number of edges: %i\\\" %(graphs[-1].number_of_nodes(),\\n# graphs[-1].number_of_edges())\\n# print \\\"\\\"\\n #---------------------------\\n\\n #Cluster based graph encoding with percentage of completeness\\n #-----------------------------\\n# fc = gpc.GE_ClustBased_PercCompleteness()\\n# for i_rep in inter_reps:\\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\\n# n_clusters = -1, clust_ratio = 110,\\n# similarity_measure=\\\"pearson\\\",\\n# completeness=0.3, n_jobs = 1))\\n# classes.append(i_rep.cls)\\n# subjects.append(i_rep.subj_name)\\n# print \\\"Graph built for subject %s and class %s.\\\" %(i_rep.subj_name, i_rep.cls)\\n# print \\\"Number of nodes: %i, number of edges: %i\\\" %(graphs[-1].number_of_nodes(),\\n# graphs[-1].number_of_edges())\\n# print \\\"\\\"\\n #---------------------------\\n\\n #Cluster based graph encoding with categories for node degree\\n #-----------------------------\\n# fc = gnd.GE_ClustBased_DiscNodeDegree()\\n# for i_rep in inter_reps:\\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\\n# n_clusters = -1, clust_ratio = 170,\\n# similarity_measure=\\\"pearson\\\",\\n# threshold=0.1, n_categ=10, n_jobs = 1))\\n# classes.append(i_rep.cls)\\n# subjects.append(i_rep.subj_name)\\n# print \\\"Graph built for subject %s and class %s.\\\" %(i_rep.subj_name, i_rep.cls)\\n# print \\\"Number of nodes: %i, number of edges: %i\\\" %(graphs[-1].number_of_nodes(),\\n# graphs[-1].number_of_edges())\\n# print \\\"\\\"\\n #---------------------------\\n\\n\\n #Weighted version of graph encoding with a fixed threshold\\n #-----------------------------\\n# fc = gwe.GE_FuncConn_WeightedEncoding()\\n# for i_rep in inter_reps:\\n# graphs.append(fc.encode(i_rep, clust_alg = 'MiniBatchKMeans',\\n# n_clusters = -1, clust_ratio = 200,\\n# similarity_measure=\\\"pearson\\\",\\n# threshold=0.5, n_jobs = 1))\\n# classes.append(i_rep.cls)\\n# subjects.append(i_rep.subj_name)\\n# print \\\"Graph built for subject %s and class %s.\\\" %(i_rep.subj_name, i_rep.cls)\\n# print \\\"Number of nodes: %i, number of edges: %i\\\" %(graphs[-1].number_of_nodes(),\\n# graphs[-1].number_of_edges())\\n# print \\\"\\\"\\n #---------------------------\\n\\n # Graph encoding based on Neirghboring connections and hierarchical clustering algorithm.\\n #-----------------------------\\n fc = gnc.GE_NeighConst_HCA()\\n for i_rep in inter_reps:\\n graphs.append(fc.encode(i_rep, clust_ratio=8, encoding='geometrical', threshold=0.2))\\n classes.append(i_rep.cls)\\n subjects.append(i_rep.subj_name)\\n print \\\"Graph built for subject %s and class %s.\\\" %(i_rep.subj_name, i_rep.cls)\\n print \\\"Number of nodes: %i, number of edges: %i\\\" %(graphs[-1].number_of_nodes(),\\n graphs[-1].number_of_edges())\\n print \\\"\\\"\\n #---------------------------\\n\\n #######################################################################\\n\\n\\n #######################################################################\\n #Reordering data for the leave-one-subject-out cross-validation\\n #######################################################################\\n\\n #Permutting elements for a further leave-two-out cv (leaving out\\n #two samples corresponding to the same subject avoiding problems with\\n #unbalanced data).\\n# nm_graphs = [None] * len(graphs)\\n# nm_classes = [None] * len(classes)\\n# nm_subjects = [None] * len(subjects)\\n#\\n# for i in range(len(graphs) / 2):\\n# nm_graphs[i*2] = graphs[i]\\n# nm_graphs[i*2 + 1] = graphs[(len(graphs) / 2) + i]\\n# nm_classes[i*2] = classes[i]\\n# nm_classes[i*2 + 1] = classes[(len(classes) / 2) + i]\\n# nm_subjects[i*2] = subjects[i]\\n# nm_subjects[i*2 + 1] = subjects[(len(subjects) / 2) + i]\\n#\\n print subjects\\n print classes\\n\\n\\n# #Testing if I get chance level when I permutted the class label...\\n# np.random.shuffle(nm_classes)\\n# np.random.shuffle(nm_classes)\\n# print nm_classes\\n\\n\\n #######################################################################\\n\\n\\n #######################################################################\\n #Computing the Graph Kernel\\n #######################################################################\\n\\n #Computing the kernel matrix by using WL graph kernel.\\n gk_wl = gk.GK_WL()\\n k_matrix = gk_wl.compare_list_normalized(graphs, h = 1, nl = True)\\n\\n #Computing the kernel matrix with the normalized vectors graph kernel\\n# gk_wl = gknv.GK_WL_NV()\\n# k_norm_mat = gk_wl.compare_list_normalized(nm_graphs, h = 2, nl = False)\\n\\n #Computing the kernel matrix by using the weighted version of WL.\\n# gk_wl = gkw.GK_WL_Weights()\\n# k_matrix = gk_wl.compare_list_normalized(nm_graphs, h = 0, nl = False)\\n\\n #######################################################################\\n\\n\\n #######################################################################\\n #Ploting the similarity matrix\\n #######################################################################\\n\\n #Ploting the similarity matrix, the matrix is permuted to have all\\n #samples belonging to the first class at the beggining.\\n# perm_matrix = ut.PermuteMatrix(k_matrix, nm_classes)\\n# vs.PlotMatrix(perm_matrix)\\n\\n #Making a list with number of nodes and edges of all graphs. They will be\\n #used in the plotting.\\n n_nodes = []\\n n_edges = []\\n for g in graphs:\\n n_nodes.append(g.number_of_nodes())\\n n_edges.append(g.number_of_edges())\\n\\n #Plotting the vectorial representation of each graph. In the picture we\\n #include number_of_nodes and number_of_edges, original_vectors and\\n #normalized_vectors.\\n #vs.PlotFeatureVectors(n_nodes, n_edges, gk_wl.vectors, gk_wl_nv.vectors, nm_classes)\\n vs.PlotFeatureVectors(n_nodes, n_edges, gk_wl.vectors, gk_wl.vectors, classes)\\n\\n #######################################################################\\n\\n\\n #######################################################################\\n #Leave-one-subject-out cross-validation\\n #######################################################################\\n\\n preds, scores = cl.subject_fold_cv(k_matrix, np.array(classes),\\n n_subjects = 6)\\n print \\\"\\\"\\n print \\\"Predictions: \\\"\\n print preds\\n print \\\"\\\"\\n print \\\"Scores:\\\"\\n print scores\\n\\n #######################################################################\\n\\n\\n return scores\",\n \"def open_files(self):\\n if not self.unbalanced:\\n if not self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest.nc')\\n return datas\\n if self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_valid.nc')\\n return datas\\n if self.unbalanced:\\n if not self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced.nc')\\n return datas\\n if self.validation:\\n datas={}\\n for var in self.variables:\\n datas[var]=xr.open_dataset(\\n f'/{self.dlfile_directory}/{self.climate}_{self.variable_translate(var).lower()}_{self.mask_str}_dldata_traintest_unbalanced_valid.nc')\\n return datas\",\n \"def main(folder, quiet=0):\\n\\n if quiet:\\n output_stream = StringIO()\\n else:\\n output_stream = sys.stdout\\n\\n\\n\\n color1 = \\\"I4\\\" #filter system for first color of CMD\\n color2 = \\\"M1\\\" #filter system for second color of CMD\\n zeromagc1 = zero.zero_mag[color1]\\n zeromagc2 = zero.zero_mag[color2]\\n min_mag = 8. #minimal observation limit\\n max_mag = 0. #maximal observation limit\\n\\n#getting file list\\n files = sorted(os.listdir('%s/%s' % (os.getcwdu(), folder))) \\n out = []\\n\\n for fil in files:\\n#only using files created by the automated simulation\\n if fil.startswith('sim_') and not 'settings' in fil.encode(\\\"ascii\\\"):\\n print(\\\"%s/%s\\\" % (folder,fil.encode(\\\"ascii\\\")), file=output_stream)\\n \\n\\n # Read in\\n hdulist = fits.open('%s/%s' %(folder,fil))\\n data = hdulist[1].data\\n\\n #calculating magnitudes from fluxes and converting to CMD-data\\n x = -2.5*(np.log10(data['c%s' % color1]/zeromagc1) - np.log10(data['c%s' % color2]/zeromagc2))\\n y = -2.5*(np.log10(data['c%s' % color2]/zeromagc2))\\n\\n \\n sel = np.logical_and( (y > -10./3. * (x-1.) + 10.), np.logical_and(max_mag < y, y < min_mag))\\n sel = np.logical_and(sel, y < -x + 12.)\\n n = sum(sel)\\n t = Table(hdulist[1].data)\\n if 'sel' in t.columns:\\n t.remove_column('sel')\\n t.add_column(Column(name='sel', data=sel.astype('int')))\\n \\n hdulist[1].data = np.array(t)\\n tmp, av, apera, age = fil.split('_')\\n fits.update('%s/%s' %(folder,fil), np.array(t), ext = 1, clobber=True)\\n out.append([av, apera, age, n])\\n\\n #writing obtained data to \\\"folder/__expected_number\\\"\\n head = ['#', 'AV', 'Aperature_size', 'Age', 'Expected_number']\\n f = open('%s/__expected_number' % folder, 'w')\\n f.write(','.join(head)+'\\\\n' )\\n np.savetxt(f, np.asarray(out).astype(int))\\n f.close()\\n \\n print (\\\"Analysed %s files and saved output to %s\\\" % (len(out),'%s/__expected_number' % folder), file=output_stream)\",\n \"def open_file(self):\\n file = open(self.file_name_dat, \\\"r\\\")\\n rows = []\\n hashlinecount = 0 # looking at commented lines in order to extract fermi energy\\n for line in file:\\n rows.append(line)\\n\\n # Getting information from the comments section\\n xdatatemp = []\\n ydatatemp = []\\n for row in rows:\\n if \\\"#\\\" in row: # Getting information from the comments\\n hashlinecount += 1\\n if hashlinecount == 7: # Getting the E_f value\\n temp = row.split()\\n if len(temp) == 4:\\n self.E_f = temp[3]\\n elif len(temp) == 7:\\n self.E_f = temp[6]\\n self.Efshift = True\\n continue\\n elif hashlinecount == 9: # Getting the min and max band energies\\n temp = row.split()\\n self.E_min = float(temp[4])\\n self.E_max = float(temp[5])\\n continue\\n elif hashlinecount == 11: # Gettiing the minimum and maximum band numbers to plot\\n temp = row.split()\\n self.band_number_min = int(temp[5])\\n self.band_number_max = int(temp[6])\\n continue\\n\\n elif row.strip() == \\\"\\\": # saving individual bands the first save will be a null band\\n self.band_data_x.append(xdatatemp) # Saving in a 2d list.\\n self.band_data_y.append(ydatatemp)\\n xdatatemp = []\\n ydatatemp = []\\n else:\\n t = row.split()\\n xdatatemp.append(float(t[0]))\\n ydatatemp.append(float(t[1]))\\n\\n # Getting rid of empty lists\\n self.band_data_x = [x for x in self.band_data_x if x]\\n self.band_data_y = [x for x in self.band_data_y if x]\\n\\n # opening the bands file to get the kpath\\n bands_file = open(self.file_name_bands, \\\"r\\\")\\n bands_file_rows = []\\n hashlinecount = 0 # looking at commented lines in order to extract fermi energy\\n for bands_file_line in bands_file:\\n bands_file_rows.append(bands_file_line)\\n\\n length_bands_file_rows = len(bands_file_rows)\\n for i in range(length_bands_file_rows-1, 0, -1):\\n temperary = bands_file_rows[i].split()\\n if len(temperary) == 2:\\n self.kpath_k.append(float(temperary[0].strip()))\\n self.kpath_symbol.append(str(temperary[1].strip(\\\"'\\\")))\\n elif len(temperary) is not 2:\\n break\\n self.kpath_symbol = latexify(self.kpath_symbol)\",\n \"def main():\\n parser = argparse.ArgumentParser(description=\\n ('Plot and save data from DS9 projections. If only labels are '\\n 'given, it will just plot existing dat files.'\\n 'Other regions/objects in file are ignored.'))\\n\\n parser.add_argument('infile', help='Input DS9 region file (fk5 coords)')\\n parser.add_argument('datroot', help='Stem for output profile data')\\n\\n parser.add_argument('-p', '--pltroot', help='Stem for output plots')\\n parser.add_argument('-f', '--files', help=('Files (.fits) to be processed,'\\n ' one for each energy band'),\\n nargs='*')\\n\\n parser.add_argument('-l', '--labels', help='Band labels for plots/files',\\n nargs='+')\\n parser.add_argument('-v', '--verbose', action='store_true',\\n help='verbose mode')\\n parser.add_argument('-s', '--subplot', action='store_true',\\n help='Generate subplot plots')\\n\\n # Parse arguments\\n args = parser.parse_args()\\n regions_file = args.infile\\n pltroot, datroot = args.pltroot, args.datroot\\n bands, labels = args.files, args.labels # NOTE bands = args.files...\\n verbose, subplot = args.verbose, args.subplot\\n\\n # Check arguments for sanity\\n # If -p is supplied, output plots\\n # If -b is supplied, output data\\n if bands is None:\\n if not pltroot:\\n parser.error('Nothing to be done! Need bands or pltroot.')\\n else:\\n print 'No bands supplied, generating plots only'\\n else:\\n if len(bands) != len(labels):\\n raise ValueError(('Non-zero number of bands '\\n 'does not match number of labels!'))\\n elif not pltroot:\\n print 'No pltroot supplied, generating data only'\\n\\n # Parse projections\\n rspecs = get_projection_params(regions_file)\\n if verbose:\\n print 'Projections parsed from region file'\\n\\n # Generate data files, if desired\\n if bands is not None:\\n regparse.check_dir(datroot, verbose) # only create if saving data\\n generate_dat_files(rspecs, datroot, bands, labels)\\n\\n # Generate plots, if desired\\n if pltroot:\\n regparse.check_dir(pltroot, verbose)\\n generate_plots(rspecs, datroot, pltroot, labels, verbose, subplot)\\n\\n if verbose:\\n print 'Done!'\",\n \"def read_fluxes(self, time_step,\\n periodic_directions=[],\\n directory=None,\\n **kwargs):\\n print('[time-step {}] reading fluxes from files ...'.format(time_step)),\\n dim3 = (len(self.grid) == 3)\\n # directory with numerical solution\\n if not directory:\\n directory = os.path.join(self.directory, '{:0>7}'.format(time_step))\\n # read grid-stations and fluxes\\n x, y = self.grid[:2]\\n nx, ny = x.size - 1, y.size - 1\\n qx_file_path = os.path.join(directory, 'qx.dat')\\n qx = PetscBinaryIO.PetscBinaryIO().readBinaryFile(qx_file_path)[0]\\n qy_file_path = os.path.join(directory, 'qy.dat')\\n qy = PetscBinaryIO.PetscBinaryIO().readBinaryFile(qy_file_path)[0]\\n if dim3:\\n z = self.grid[2]\\n nz = z.size - 1\\n qz_file_path = os.path.join(directory, 'qz.dat')\\n qz = PetscBinaryIO.PetscBinaryIO().readBinaryFile(qz_file_path)[0]\\n # create flux Field objects in staggered arrangement\\n # reshape fluxes in multi-dimensional arrays\\n if dim3:\\n qx = qx.reshape((nz, ny, (nx if 'x' in periodic_directions else nx - 1)))\\n qx = qx[:, :, :(-1 if 'x' in periodic_directions else None)]\\n qx = Field(label='x-flux',\\n time_step=time_step,\\n x=x[1:-1],\\n y=0.5 * (y[:-1] + y[1:]),\\n z=0.5 * (z[:-1] + z[1:]),\\n values=qx)\\n qy = qy.reshape((nz, (ny if 'y' in periodic_directions else ny - 1), nx))\\n qy = qy[:, :(-1 if 'y' in periodic_directions else None), :]\\n qy = Field(label='y-flux',\\n time_step=time_step,\\n x=0.5 * (x[:-1] + x[1:]),\\n y=y[1:-1],\\n z=0.5 * (z[:-1] + z[1:]),\\n values=qy)\\n qz = qz.reshape(((nz if 'z' in periodic_directions else nz - 1), ny, nx))\\n qz = qz[:(-1 if 'z' in periodic_directions else None), :, :]\\n qz = Field(label='z-flux',\\n time_step=time_step,\\n x=0.5 * (x[:-1] + x[1:]),\\n y=0.5 * (y[:-1] + y[1:]),\\n z=z[1:-1],\\n values=qz)\\n print('done')\\n return qx, qy, qz\\n else:\\n qx = qx.reshape((ny, (nx if 'x' in periodic_directions else nx - 1)))\\n qx = qx[:, :(-1 if 'x' in periodic_directions else None)]\\n qx = Field(label='x-flux',\\n time_step=time_step,\\n x=x[1:-1],\\n y=0.5 * (y[:-1] + y[1:]),\\n values=qx)\\n qy = qy.reshape(((ny if 'y' in periodic_directions else ny - 1), nx))\\n qy = qy[:(-1 if 'y' in periodic_directions else None), :]\\n qy = Field(label='y-flux',\\n time_step=time_step,\\n x=0.5 * (x[:-1] + x[1:]),\\n y=y[1:-1],\\n values=qy)\\n print('done')\\n return qx, qy\",\n \"def run_script(input_dir, output_dir):\\n\\n \\\"\\\"\\\"+++++++++++++++++++++++++++++++++++\\\"\\\"\\\"\\n \\\"\\\"\\\"Step 1. load dataset \\\"\\\"\\\"\\n print(\\\"loading data ......\\\")\\n print(\\\"+++++++Read the surface shape data+++++++\\\")\\n shape_file_name = input_dir + \\\"aligned_shapes.mat\\\"\\n mat = loadmat(shape_file_name)\\n y_design = mat['aligned_shape']\\n n, l, m = y_design.shape\\n print(\\\"The dimension of shape matrix is \\\" + str(y_design.shape))\\n print(\\\"+++++++Read the sphere coordinate data+++++++\\\")\\n template_file_name = input_dir + \\\"template.mat\\\"\\n mat = loadmat(template_file_name)\\n coord_mat = mat['template']\\n # d = coord_mat.shape[1]\\n print(\\\"+++++++Read the design matrix+++++++\\\")\\n design_data_file_name = input_dir + \\\"design_data.txt\\\"\\n design_data = np.loadtxt(design_data_file_name)\\n # read the covariate type\\n var_type_file_name = input_dir + \\\"var_type.txt\\\"\\n var_type = np.loadtxt(var_type_file_name)\\n print(\\\"+++++++Construct the design matrix: normalization+++++++\\\")\\n x_design = read_x(design_data, var_type)\\n p = x_design.shape[1]\\n print(\\\"The dimension of design matrix is \\\" + str(x_design.shape))\\n\\n \\\"\\\"\\\"+++++++++++++++++++++++++++++++++++\\\"\\\"\\\"\\n \\\"\\\"\\\"Step 2. Statistical analysis: including (1) smoothing and (2) hypothesis testing\\\"\\\"\\\"\\n gpvals, lpvals_fdr, clu_pvals, efit_beta, efity_design, efit_eta = mfsda.run_stats(y_design, coord_mat, design_data, var_type)\\n\\n \\\"\\\"\\\"+++++++++++++++++++++++++++++++++++\\\"\\\"\\\"\\n \\\"\\\"\\\"Step3. Save all the results\\\"\\\"\\\"\\n gpvals_file_name = output_dir + \\\"global_pvalue.txt\\\"\\n np.savetxt(gpvals_file_name, gpvals)\\n lpvals_fdr_file_name = output_dir + \\\"local_pvalue_fdr.txt\\\"\\n np.savetxt(lpvals_fdr_file_name, lpvals_fdr)\\n clu_pvals_file_name = output_dir + \\\"cluster_pvalue.txt\\\"\\n np.savetxt(clu_pvals_file_name, clu_pvals)\",\n \"def read(self, **kwargs):\\n\\n if not os.path.isfile(self.file_name):\\n self.build()\\n elif 'clobber' in self.kwargs.keys():\\n if self.kwargs['clobber']: \\n self.build()\\n\\n # read dLOS file from parent class\\n super(DlosPhotoz, self).read()\\n\\n self.dlos, self.dlos_photoz = np.loadtxt(\\n self.file_name, \\n skiprows=1, \\n unpack=True, \\n usecols=[0, 1]\\n )\\n return None\",\n \"def test_to_single_xyz_rdkit(self):\\n from openff.toolkit.utils import RDKitToolkitWrapper\\n\\n tkw = RDKitToolkitWrapper()\\n\\n # load a molecule with a single conformation\\n toluene = Molecule.from_file(\\n get_data_file_path(\\\"molecules/toluene.sdf\\\"), \\\"sdf\\\", toolkit_registry=tkw\\n )\\n # make sure it has one conformer\\n assert toluene.n_conformers == 1\\n\\n with NamedTemporaryFile(suffix=\\\".xyz\\\") as iofile:\\n # try and write out the xyz file\\n toluene.to_file(iofile.name, \\\"xyz\\\", toolkit_registry=tkw)\\n\\n # now lets check the file contents\\n with open(iofile.name) as xyz_data:\\n data = xyz_data.readlines()\\n # make sure we have the correct amount of lines writen\\n assert len(data) == 17\\n # make sure all headers and frame data was writen\\n assert data.count(\\\"15\\\\n\\\") == 1\\n assert data.count(\\\"C7H8\\\\n\\\") == 1\\n # now check that we can find the first and last coords\\n coords = [\\n \\\"C 22.3700000000 21.6800000000 29.7700000000\\\\n\\\",\\n \\\"H 26.7900000000 23.1900000000 28.7200000000\\\\n\\\",\\n ]\\n for coord in coords:\\n assert coord in data\",\n \"def Test(self):\\n\\t\\tself.filename = \\\"NC-Xy_norm_bgsub.txt\\\"\\n\\t\\tself.dirname = \\\"data\\\"\\n\\t\\tself.FileText.SetLabel(\\\"File: \\\"+self.filename)\\n\\t\\t#self.raw_file = self.LoadData(os.path.join(self.dirname, self.filename))\\n\\t\\tself.AddBackgroundCheckBox.SetValue(True)\\n\\t\\tself.combine_data()\\n\\t\\tself.PP_AlgorithmRadio.SetValue(True)\\n\\t\\tself.plot_data()\",\n \"def Plot_RCWA_Ssim(Path) :\\n #/Users/simonvassant/Documents/20090707_TestsPython/Result_Champ/SSim_O21Pr_2000H_res1000F1.res\\n x,y=[],[]\\n fs = open(Path, 'r') \\n#index_array = 0\\n while 1: \\n txt = fs.readline()\\n if txt =='': \\n break\\n x.append(float(txt[0:12]))\\n y.append(float(txt[13:-1]))\\n #x[index_array],y[index_array] = float(txt[0:9]),float(txt[10:17])\\n #index_array = index_array+1\\n \\n fs.close()\\n plt.figure(1)\\n plt.plot(x,y)\\n plt.xlabel(r\\\"Longueur d'onde $(\\\\mu m)$\\\")\\n plt.ylabel('R')\",\n \"def run(self):\\r\\n # Close any open models\\r\\n self.cleanUp()\\r\\n # Dynamically select file to preview\\r\\n self.selectTrial() \\r\\n # Add adjusted COM (RRA/CMC) model\\r\\n self.loadAdjustedModel()\\r\\n # Hide the markers from view\\r\\n self.hideModelMarkers()\\r\\n # Load CMC motion to model\\r\\n self.loadCMCMotion()\",\n \"def load(fnames, tag='', inst_id=''):\\n\\n # Save each file to the output DataFrame\\n data = load_csv_data(fnames, read_csv_kwargs={'index_col': 0,\\n 'parse_dates': True})\\n\\n # Assign the meta data\\n meta, status_desc = mm_ace.common_metadata()\\n flux_desc = '5-min averaged Differential '\\n\\n meta['status_e'] = {meta.labels.units: '',\\n meta.labels.name: 'Diff e- Flux Status',\\n meta.labels.notes: '',\\n meta.labels.desc: status_desc,\\n meta.labels.fill_val: np.nan,\\n meta.labels.min_val: 0,\\n meta.labels.max_val: 9}\\n meta['status_p'] = {meta.labels.units: '',\\n meta.labels.name: 'Diff Proton Flux Status',\\n meta.labels.notes: '',\\n meta.labels.desc: status_desc,\\n meta.labels.fill_val: np.nan,\\n meta.labels.min_val: 0,\\n meta.labels.max_val: 9}\\n meta['anis_ind'] = {meta.labels.units: '',\\n meta.labels.name: 'Anisotropy Index',\\n meta.labels.notes: '',\\n meta.labels.desc: 'Range: 0.0 - 2.0',\\n meta.labels.fill_val: -1.0,\\n meta.labels.min_val: 0.0,\\n meta.labels.max_val: 2.0}\\n meta['eflux_38-53'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff e- Flux 38-53 eV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Electron Flux between 35-53 eV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['eflux_175-315'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff e- Flux 175-315 eV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Electron Flux between 175-315 eV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_47-68'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 47-68 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 47-68 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_115-195'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 115-195 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 115-195 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_310-580'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 310-580 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 310-580 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_795-1193'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name: 'Diff Proton Flux 795-1193 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 795-1193 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n meta['pflux_1060-1900'] = {meta.labels.units: 'particles/cm2-s-ster-MeV',\\n meta.labels.name:\\n 'Diff Proton Flux 1060-1900 keV',\\n meta.labels.notes: '',\\n meta.labels.desc:\\n ''.join([flux_desc,\\n 'Proton Flux between 1060-1900 keV']),\\n meta.labels.fill_val: -1.0e5,\\n meta.labels.min_val: -np.inf,\\n meta.labels.max_val: np.inf}\\n return data, meta\",\n \"def txt2hdf5_mudis(config, init_file=0, final_file=100, step=1, expo='100'):\\n # --------SKYMAP--------------\\n # Create the directory to save the results\\n os.makedirs(os.path.dirname(cwd + '/config_files/'), exist_ok=True)\\n\\n alignment = add_align()\\n\\n # Extract skymap from alignment file\\n skymap = np.zeros((len(alignment), 2))\\n\\n for i in np.arange(len(skymap)):\\n skymap[i] = alignment['Azimuth'][i], alignment['Zenith'][i]\\n\\n # Save Skymap information\\n with h5py.File(cwd + '/config_files/skymap_radiance.h5', 'w') as sky:\\n\\n if not list(sky.items()):\\n sky.create_dataset('/skymap', data=skymap)\\n else:\\n del sky['skymap']\\n\\n sky.create_dataset('/skymap', data=skymap, dtype='f4')\\n sky['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\\n sky['skymap'].dims[0].label = 'channel'\\n sky['skymap'].dims[1].label = 'Azimuth, Zenith'\\n\\n config['skymap'] = skymap\\n\\n # Save MUDIS file information\\n\\n # Import the radiance data from sensor\\n files = sorted(\\n glob.glob(config['raw_dir'] + '/radiance/{}/data/data_*.txt'.format(config['date'])))\\n\\n print('Total files in the directory: ' + str(len(files)) + ' files')\\n\\n ans = input('convert all files? (y/n): ')\\n\\n if ans == 'n':\\n print('configure initial and final file index in the function options')\\n else:\\n init_file = 0\\n final_file = len(files)\\n\\n for fil in np.arange(init_file, final_file):\\n # Import the data from the file\\n file = np.genfromtxt(files[fil], delimiter='', skip_header=11)\\n\\n # ------------RADIANCE DATA RAW---------------\\n # create the radiance matrix\\n data = np.zeros([113, 992])\\n\\n for i in np.arange(113):\\n if str(alignment.iloc[i][3]) == 'nan':\\n data[i] = np.nan\\n else:\\n try:\\n data[i] = file[:, int(alignment.iloc[i][3] + config['channel_pixel_adj'])] #\\n except:\\n pass #\\n # read the pixels index\\n # in the alignment file and copy the\\n # data in the radiance matrix']))\\n\\n # Correct time for the file UTC\\n name = os.path.split(files[fil])\\n\\n # Read name of the file (correct time)\\n time = name[1][6:25]\\n # convert time to datetime format\\n time = datetime.datetime.strptime(time, '%d.%m.%Y_%H_%M_%S')\\n # print(time)\\n new_name = datetime.datetime.strftime(time, '%Y%m%d_%H%M%S')\\n\\n with open(files[fil], 'r') as file:\\n dat = file.readlines()\\n\\n # Extract information from .dat file\\n exposure = int(dat[4][12:-1])\\n NumAve = int(dat[7][17:-1])\\n CCDTemp = int(dat[8][15:-1])\\n NumSingMes = int(dat[10][27:-1])\\n ElectrTemp = int(dat[9][23:-1])\\n\\n # Create the directory to save the results\\n os.makedirs(os.path.dirname(config['str_dir'] + '/radiance/{}/data/').format(config['date']),\\n exist_ok=True)\\n\\n if exposure == expo:\\n # Create a file in the disk\\n with h5py.File(config['str_dir'] + '/radiance/{}/data/{}.h5'.format(config['date'], new_name),\\n 'w') as datos:\\n\\n if not list(datos.items()):\\n # Create two datasets(use only one time)\\n datos.create_dataset('/data', data=data, dtype='f4')\\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n else:\\n del datos['data']\\n del datos['skymap']\\n print('data deleted and corrected')\\n datos.create_dataset('/data', data=data, dtype='f4')\\n datos.create_dataset('/skymap', data=skymap, dtype='f4')\\n\\n # Add attributes to datasets\\n datos['data'].attrs['time'] = str(time)\\n datos['data'].attrs['Exposure'] = exposure\\n datos['data'].attrs['NumAver'] = NumAve\\n datos['data'].attrs['CCDTemp'] = CCDTemp\\n datos['data'].attrs['NumSingMes'] = NumSingMes\\n datos['data'].attrs['ElectrTemp'] = ElectrTemp\\n datos['data'].attrs['Latitude'] = '52.39N'\\n datos['data'].attrs['Longitude'] = '9.7E'\\n datos['data'].attrs['Altitude'] = '65 AMSL'\\n datos['data'].dims[0].label = 'channel'\\n datos['data'].dims[1].label = 'wavelength'\\n\\n datos['skymap'].attrs['Columns'] = 'Azimuth, Zenith'\\n\\n datos.close()\\n\\n print('File ' + str(fil + init_file + 1) + ' of ' +\\n str((final_file - init_file)) + ' saved')\\n else:\\n print('Exposure are not same', expo, exposure)\\n break\\n\\n print('Completed')\",\n \"def test_run_experiment_from_gromacs_files():\\n complex_path = examples_paths()['pxylene-complex']\\n solvent_path = examples_paths()['pxylene-solvent']\\n include_path = examples_paths()['pxylene-gro-include']\\n with mmtools.utils.temporary_directory() as tmp_dir:\\n yaml_script = get_template_script(tmp_dir)\\n yaml_script['options']['anisotropic_dispersion_cutoff'] = None\\n del yaml_script['molecules'] # we shouldn't need any molecule\\n yaml_script['systems'] = {'explicit-system':\\n {'phase1_path': complex_path, 'phase2_path': solvent_path,\\n 'ligand_dsl': 'resname \\\"p-xylene\\\"', 'solvent': 'PME',\\n 'gromacs_include_dir': include_path}}\\n yaml_script['experiments']['system'] = 'explicit-system'\\n\\n exp_builder = ExperimentBuilder(yaml_script)\\n exp_builder._check_resume() # check_resume should not raise exceptions\\n exp_builder.run_experiments()\\n\\n # The experiments folders are correctly named and positioned\\n output_dir = exp_builder._get_experiment_dir('')\\n assert os.path.isdir(output_dir)\\n assert os.path.isfile(os.path.join(output_dir, 'complex.nc'))\\n assert os.path.isfile(os.path.join(output_dir, 'solvent.nc'))\\n assert os.path.isfile(os.path.join(output_dir, 'experiments.yaml'))\\n assert os.path.isfile(os.path.join(output_dir, 'experiments.log'))\\n\\n # Analysis script is correct\\n analysis_script_path = os.path.join(output_dir, 'analysis.yaml')\\n with open(analysis_script_path, 'r') as f:\\n assert yaml.load(f, Loader=yaml.FullLoader) == [['complex', 1], ['solvent', -1]]\",\n \"def load_raw_data(self, input_files):\\n\\n log.debug(f\\\"Loading dataset {input_files}\\\") \\n print(f\\\"Loading dataset\\\")\\n\\n # Load stroke information from XML files\\n for file in input_files:\\n new_strokeset = strokeset.StrokeSet(file)\\n self.strokesets.append(new_strokeset)\\n self.stroke_matrix.append(new_strokeset.as_delta_array())\\n self.stroke_ascii.append(new_strokeset.get_text())\\n\\n done_msg = \\\"Finished parsing dataset. Imported {} lines\\\".format(len(self.get_strokesets()))\\n print (done_msg)\\n log.info(done_msg)\",\n \"def useZstat(zstat, file_path_name_save, file_path_conte, file_path_name_resting_atlas):\\n\\n import matplotlib.pyplot as plt\\n import os\\n from glob import glob\\n import numpy as np\\n import nibabel as nb\\n import nibabel.gifti as gifti\\n\\n # Crucial: xvfb must be imported and started before importing mayavi\\n from xvfbwrapper import Xvfb\\n print('XVb pre')\\n vdisplay = Xvfb()\\n vdisplay.start()\\n\\n print('pre maya')\\n # Crashes on this line if run with plain python (not xvfb-run ... python) and if xvfbwrapper is after it.\\n from mayavi import mlab\\n print('post maya')\\n from tvtk.api import tvtk\\n print('post tvtk')\\n import math\\n\\n print('display')\\n mlab.options.offscreen = True #offscreen window for rendering\\n\\n img = nb.load(file_path_name_resting_atlas)\\n #img = nb.load('/Users/MathiasMacbook/Desktop/rfMRI_REST1_LR_Atlas.dtseries.nii')\\n mim = img.header.matrix.mims[1]\\n #for idx, bm in enumerate(mim.brainModels):\\n # print((idx, bm.indexOffset, bm.brainStructure))\\n bm1 = mim.brainModels[0]\\n lidx = bm1.vertexIndices.indices\\n bm2 = mim.brainModels[1]\\n ridx = bm1.surfaceNumberOfVertices + bm2.vertexIndices.indices\\n bidx = np.concatenate((lidx, ridx))\\n\\n axis = [0, 0, 1]\\n theta = np.pi\\n\\n inflated = True\\n split_brain = True\\n\\n surf = gifti.read(file_path_conte + '/Conte69.L.midthickness.32k_fs_LR.surf.gii') \\n verts_L_data = surf.darrays[0].data\\n faces_L_data = surf.darrays[1].data\\n\\n surf = gifti.read(file_path_conte + '/Conte69.R.midthickness.32k_fs_LR.surf.gii') \\n verts_R_data = surf.darrays[0].data\\n faces_R_data = surf.darrays[1].data\\n\\n if inflated:\\n surf = gifti.read(file_path_conte + '/Conte69.L.inflated.32k_fs_LR.surf.gii')\\n verts_L_display = surf.darrays[0].data\\n faces_L_display = surf.darrays[1].data\\n surf = gifti.read(file_path_conte + '/Conte69.R.inflated.32k_fs_LR.surf.gii')\\n verts_R_display = surf.darrays[0].data\\n faces_R_display = surf.darrays[1].data\\n else:\\n verts_L_display = verts_L_data.copy()\\n verts_R_display = verts_R_data.copy()\\n faces_L_display = faces_L_data.copy()\\n faces_R_display = faces_R_data.copy()\\n\\n verts_L_display[:, 0] -= max(verts_L_display[:, 0])\\n verts_R_display[:, 0] -= min(verts_R_display[:, 0])\\n verts_L_display[:, 1] -= (max(verts_L_display[:, 1]) + 1)\\n verts_R_display[:, 1] -= (max(verts_R_display[:, 1]) + 1)\\n\\n faces = np.vstack((faces_L_display, verts_L_display.shape[0] + faces_R_display))\\n\\n if split_brain:\\n verts2 = rotation_matrix(axis, theta).dot(verts_R_display.T).T\\n else:\\n verts_L_display[:, 1] -= np.mean(verts_L_display[:, 1])\\n verts_R_display[:, 1] -= np.mean(verts_R_display[:, 1])\\n verts2 = verts_R_display\\n\\n verts_rot = np.vstack((verts_L_display, verts2))\\n verts = np.vstack((verts_L_data, verts_R_data))\\n #print verts.shape\\n #print faces.shape\\n\\n if not os.path.exists(os.path.split(file_path_name_save)[0]):\\n os.makedirs(os.path.split(file_path_name_save)[0]) \\n\\n print('use zstat')\\n img = nb.load(zstat)\\n print('loaded img')\\n \\n threshold = 2.3 # 1000, lower limit\\n display_threshold = 6 #8000, upper limit\\n\\n data = img.get_data()\\n aff = img.affine\\n indices = np.round((np.linalg.pinv(aff).dot(np.hstack((verts, \\n np.ones((verts.shape[0], 1)))).T))[:3, :].T).astype(int)\\n scalars2 = data[indices[:, 0], indices[:, 1], indices[:, 2]]\\n scalars2[np.abs(scalars2) < threshold] = 0.\\n scalars = np.zeros(verts.shape[0])\\n scalars[bidx] = scalars2[bidx]\\n\\n negative = positive = False\\n if np.any(scalars < 0):\\n negative = True\\n if np.any(scalars > 0):\\n positive = True\\n\\n nlabels = 2\\n vmin = 0\\n vmax = 0\\n if negative and positive:\\n maxval = max(-scalars.min(), scalars.max())\\n if maxval > display_threshold:\\n maxval = display_threshold\\n vmin = -maxval\\n vmax = maxval\\n nlabels = 3\\n vmin = -display_threshold ######\\n vmax = display_threshold ######\\n elif negative:\\n vmin = scalars.min()\\n if vmin < -display_threshold:\\n vmin = -display_threshold\\n vmax = 0\\n vmin = -display_threshold ######\\n elif positive:\\n vmax = scalars.max()\\n if vmax > display_threshold:\\n vmax = display_threshold\\n vmin = 0\\n vmax = display_threshold ######\\n #print zstat\\n \\n dual_split = True\\n\\n fig1 = mlab.figure(1, bgcolor=(0, 0, 0))\\n mlab.clf()\\n mesh = tvtk.PolyData(points=verts_rot, polys=faces)\\n mesh.point_data.scalars = scalars\\n mesh.point_data.scalars.name = 'scalars'\\n surf = mlab.pipeline.surface(mesh, colormap='autumn', vmin=vmin, vmax=vmax)\\n if dual_split:\\n verts_rot_shifted = verts_rot.copy()\\n verts_rot_shifted = rotation_matrix(axis, theta).dot(verts_rot_shifted.T).T\\n verts_rot_shifted[:, 2] -= (np.max(verts_rot_shifted[:, 2]) - np.min(verts_rot_shifted[:, 2]))\\n verts_rot_shifted[:, 0] -= np.max(verts_rot_shifted[:, 0])\\n mesh2 = tvtk.PolyData(points=verts_rot_shifted, polys=faces)\\n mesh2.point_data.scalars = scalars\\n mesh2.point_data.scalars.name = 'scalars'\\n surf2 = mlab.pipeline.surface(mesh2, colormap='autumn', vmin=vmin, vmax=vmax)\\n colorbar = mlab.colorbar(surf, nb_labels=nlabels) #, orientation='vertical')\\n lut = surf.module_manager.scalar_lut_manager.lut.table.to_array()\\n\\n if negative and positive:\\n half_index = lut.shape[0] / 2\\n index = int(half_index * threshold / vmax)\\n lut[(half_index - index + 1):(half_index + index), :] = 192\\n lut[(half_index + index):, :] = 255 * plt.cm.autumn(np.linspace(0, 255, half_index - index).astype(int))\\n lut[:(half_index - index), :] = 255 * plt.cm.cool(np.linspace(0, 255, half_index - index).astype(int))\\n elif negative:\\n index = int(lut.shape[0] * threshold / abs(vmin))\\n lut[(lut.shape[0] - index):, :] = 192\\n lut[:(lut.shape[0] - index), :] = 255 * plt.cm.cool(np.linspace(0, 255, lut.shape[0] - index).astype(int))\\n elif positive:\\n index = int(lut.shape[0] * threshold / vmax)\\n lut[:index, :] = 192\\n lut[index:, :] = 255 * plt.cm.autumn(np.linspace(0, 255, lut.shape[0] - index).astype(int))\\n lut[:, -1] = 255\\n\\n surf.module_manager.scalar_lut_manager.lut.table = lut\\n if dual_split:\\n surf2.module_manager.scalar_lut_manager.lut.table = lut\\n surf.module_manager.scalar_lut_manager.show_scalar_bar = False\\n surf.module_manager.scalar_lut_manager.show_legend = False\\n surf.module_manager.scalar_lut_manager.label_text_property.font_size = 10\\n surf.module_manager.scalar_lut_manager.show_scalar_bar = True\\n surf.module_manager.scalar_lut_manager.show_legend = True\\n mlab.draw()\\n\\n translate = [0, 0, 0]\\n if inflated:\\n zoom = -700\\n else:\\n zoom = -600\\n if dual_split:\\n if inflated:\\n translate = [0, 0, -104.01467148]\\n else:\\n translate = [0, 0, -54.76305802] \\n if inflated:\\n zoom = -750\\n else:\\n zoom = -570\\n \\n #mlab.view(0, 90.0, zoom, translate)\\n mlab.view(9, 90.0)\\n\\n print(file_path_name_save)\\n \\n mlab.savefig(file_path_name_save, figure=fig1, magnification=5)\\n\\n vdisplay.stop()\",\n \"def main(args):\\n args = parse_args(args)\\n setup_logging(args.loglevel)\\n _logger.debug(\\\"Generating NUFEB simulation files\\\")\\n\\n # create nutrients\\n light = Nutrient(1e-1, None, None, \\\"g\\\", \\\"nn\\\")\\n co2 = Nutrient(float(args.co2), 1.9e-09, 44.01, \\\"l\\\", \\\"nn\\\")\\n o2 = Nutrient(0.28125, 2.30e-9, 32, \\\"l\\\", \\\"nn\\\")\\n sucrose = Nutrient(float(args.sucrose), 5.2e-10, 342.3, \\\"l\\\", \\\"nn\\\")\\n gco2 = Nutrient(0, None, 44.01, \\\"g\\\", \\\"nn\\\")\\n TEMPLATES_DIR = (Path(__file__).parent) / \\\"templates\\\"\\n\\n captureRate = round(1000 / args.timestep)\\n # define dump parameters\\n dump_list = {\\n \\\"vtk_dump\\\": f\\\"dump atom_vtk all vtk {captureRate} dump*.vtu id type diameter vx vy vz fx fy fz \\\\n dump grid_vtk all grid/vtk {captureRate} dump_%_*.vti con\\\",\\n \\\"image_dump\\\": f\\\"dump du_image all image {captureRate} image.*.jpg type diameter zoom 2 bacillus type size 1280 720 view 45 60 \\\\n dump_modify du_image acolor 1 green acolor 2 red\\\",\\n \\\"movie_dump\\\": f\\\"dump du_mov all movie {captureRate} movie.avi type diameter zoom 1.5 bacillus type size 1280 720 view 0 0 \\\\n dump_modify du_mov acolor 1 green acolor 2 red\\\",\\n \\\"hdf_dump\\\": f\\\"dump du_h5 all nufeb/hdf5 {captureRate} dump.h5 id type x y z vx vy vz fx fy fz radius conc reac\\\",\\n }\\n\\n dumps = defaultdict(list)\\n for i in range(4):\\n tmp = [\\\"vtk_dump\\\", \\\"image_dump\\\", \\\"movie_dump\\\", \\\"hdf_dump\\\"]\\n dumps[tmp[i]]\\n\\n for dump, dump_var in zip(\\n [args.vtk, args.img, args.movie, args.hdf],\\n [\\\"vtk_dump\\\", \\\"image_dump\\\", \\\"movie_dump\\\", \\\"hdf_dump\\\"],\\n ):\\n if dump is True or dump == \\\"True\\\":\\n dumps[dump_var] = dump_list[dump_var]\\n else:\\n dumps[dump_var] = \\\"\\\"\\n\\n ## Species-specific parameters\\n\\n # check for runs folder\\n if not os.path.isdir(\\\"runs\\\"):\\n os.mkdir(\\\"runs\\\")\\n x = float(args.dims.split(\\\",\\\")[0])\\n y = float(args.dims.split(\\\",\\\")[1])\\n z = float(args.dims.split(\\\",\\\")[2])\\n for n in range(1, int(args.num) + 1):\\n culture = Culture(args)\\n atoms_list = []\\n bacilli_list = []\\n # Create list of atoms and bacilli for atom definition file\\n for cell in culture.cells:\\n atoms_list.append(cell.Atom())\\n bacilli_list.append(cell.Bacillus())\\n # make atom definition file\\n for r in range(1, int(args.reps) + 1):\\n L = [\\n \\\" NUFEB Simulation\\\\r\\\\n\\\\n\\\",\\n f\\\" {args.cells_init} atoms \\\\n\\\",\\n f\\\" {len(culture.cell_types)} atom types \\\\n\\\",\\n f\\\" {args.cells_init} bacilli \\\\n\\\\n\\\",\\n f\\\" 0.0e-4 {x :.2e} xlo xhi \\\\n\\\",\\n f\\\" 0.0e-4 {y :.2e} ylo yhi \\\\n\\\",\\n f\\\" 0.0e-4 {z :.2e} zlo zhi \\\\n\\\\n\\\",\\n \\\" Atoms \\\\n\\\\n\\\",\\n ]\\n atoms = L + atoms_list\\n atoms.append(\\\"\\\\n\\\")\\n atoms.append(\\\" Bacilli \\\\n\\\\n\\\")\\n atoms = atoms + bacilli_list\\n # write atom definition file\\n f = open(\\n f\\\"runs/atom_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{r}.in\\\",\\n \\\"w+\\\",\\n )\\n f.writelines(atoms)\\n RUN_DIR = (\\n Path(\\\"runs\\\")\\n / f\\\"Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}\\\"\\n )\\n if not os.path.isdir(RUN_DIR):\\n os.mkdir(RUN_DIR)\\n # os.mkdir(f'runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}')\\n # write initial conditions json file\\n dumpfile = open(RUN_DIR / \\\"metadata.json\\\", \\\"w\\\")\\n # dumpfile = open(f\\\"/runs/Run_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}_{args.reps}/metadata.json\\\",'w')\\n json.dump(CellInfo, dumpfile, indent=6)\\n dumpfile.close()\\n ###\\n\\n # write Inputscript\\n # open the file\\n filein = open(TEMPLATES_DIR / \\\"bacillus.txt\\\")\\n # filein = resources.read_text(\\\"nufeb_tools.templates\\\", \\\"Bacillus.txt\\\")\\n # read it\\n src = Template(filein.read())\\n # do the substitution\\n result = src.safe_substitute(\\n {\\n \\\"n\\\": args.cells_init,\\n \\\"SucRatio\\\": culture.SucRatio,\\n \\\"SucPct\\\": culture.SucPct,\\n \\\"n_cyanos\\\": culture.n_cyanos,\\n \\\"n_ecw\\\": culture.n_ecw,\\n \\\"Replicates\\\": args.reps,\\n \\\"Timesteps\\\": args.ntimesteps,\\n \\\"ts\\\": args.timestep,\\n \\\"CYANOGroup\\\": culture.cyGroup,\\n \\\"ECWGroup\\\": culture.ecwGroup,\\n \\\"Zheight\\\": float(args.dims.split(\\\",\\\")[2]),\\n \\\"CYANODiv\\\": culture.cyDiv,\\n \\\"ECWDiv\\\": culture.ecwDiv,\\n \\\"light\\\": light.concentration,\\n \\\"co2\\\": co2.concentration,\\n \\\"o2\\\": o2.concentration,\\n \\\"sucrose\\\": sucrose.concentration,\\n \\\"gco2\\\": gco2.concentration,\\n \\\"CYANOMonod\\\": culture.cyMonod,\\n \\\"ECWMonod\\\": culture.ecwMonod,\\n \\\"CYANOcount\\\": culture.cyanoCount,\\n \\\"ECWcount\\\": culture.ecwCount,\\n \\\"v_ncyano\\\": culture.vcyano,\\n \\\"v_necw\\\": culture.vecw,\\n \\\"vtk_dump\\\": dumps[\\\"vtk_dump\\\"],\\n \\\"image_dump\\\": dumps[\\\"image_dump\\\"],\\n \\\"movie_dump\\\": dumps[\\\"movie_dump\\\"],\\n \\\"hdf_dump\\\": dumps[\\\"hdf_dump\\\"],\\n }\\n )\\n f = open(\\n f\\\"./runs/Inputscript_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.lmp\\\",\\n \\\"w+\\\",\\n )\\n f.writelines(result)\\n\\n # write local run script\\n # open the file\\n filein = open(TEMPLATES_DIR / \\\"local.txt\\\")\\n # filein = resources.read_text(\\\"nufeb_tools.templates\\\", \\\"local.txt\\\")\\n # read it\\n src = Template(filein.read())\\n # do the substitution\\n result = src.safe_substitute(\\n {\\n \\\"n\\\": n,\\n \\\"SucRatio\\\": culture.SucRatio,\\n \\\"SucPct\\\": culture.SucPct,\\n \\\"n_cyanos\\\": culture.n_cyanos,\\n \\\"n_ecw\\\": culture.n_ecw,\\n \\\"Reps\\\": args.reps,\\n }\\n )\\n f = open(\\n f\\\"./runs/local_{culture.n_cyanos}_{culture.n_ecw}_{culture.SucPct}.sh\\\", \\\"w+\\\"\\n )\\n f.writelines(result)\\n # write slurm script\\n # open the file\\n filein = open(TEMPLATES_DIR / \\\"slurm_dev.txt\\\")\\n # filein = resources.read_text(\\\"nufeb_tools.templates\\\", \\\"Slurm.txt\\\")\\n # read it\\n src = Template(filein.read())\\n # do the substitution\\n result = src.safe_substitute(\\n {\\n \\\"n\\\": args.cells_init,\\n \\\"job\\\": f\\\"NUFEB_cyano{n}\\\",\\n \\\"USER\\\": args.user,\\n \\\"Replicates\\\": args.reps,\\n \\\"SucPct\\\": culture.SucPct,\\n \\\"n_cyanos\\\": culture.n_cyanos,\\n \\\"n_ecw\\\": culture.n_ecw,\\n }\\n )\\n _logger.info(\\\"Script ends here\\\")\",\n \"def _read(self):\\n # initializng data dictionary\\n self.data={}\\n\\n f = FortranFile(self.filename)\\n # Default omnivor binary header\\n self.data['MK'] = f.readInts('i')\\n self.data['itime'] = f.readInts('i')\\n self.data['version'] = f.readString()\\n self.data['file_id'] = f.readInts('i')\\n self.data['sversion'] = f.readString()\\n # Velocity field\\n self.data['stype'] = f.readString()\\n self.data['is_grid'] = f.readInts('i')\\n nCPs = f.readInts('i')\\n self.data['nCPs'] = nCPs\\n if self.data['MK'] == 8:\\n real_char='d'\\n else:\\n real_char='f'\\n if self.data['is_grid']:\\n #print('File is a velocity grid file')\\n n1 = f.readInts('i')\\n n2 = f.readInts('i')\\n n3 = f.readInts('i')\\n self.data['n1'] = n1\\n self.data['n2'] = n2\\n self.data['n3'] = n3\\n self.data['is_straight'] = f.readInts('i')\\n self.data['v1'] = f.readReals(real_char)\\n self.data['v2'] = f.readReals(real_char)\\n self.data['v3'] = f.readReals(real_char)\\n\\n CPs_raw = f.readReals(real_char)\\n Utot_raw = f.readReals(real_char)\\n CPs = np.reshape(CPs_raw,(3,nCPs),order = 'F')\\n Utot = np.reshape(Utot_raw,(3,nCPs),order = 'F')\\n\\n acc=-1\\n CPsTab = np.zeros((3, n1,n2,n3))\\n UtotTab = np.zeros((3, n1,n2,n3))\\n # Reshaping the nasty way (this is natural order). \\n for i in range(0,n1):\\n for j in range(0,n2):\\n for k in range(0,n3):\\n acc=acc+1\\n CPsTab[0:3,i,j,k] = CPs[0:3,acc]\\n UtotTab[0:3,i,j,k] = Utot[0:3,acc]\\n\\n self.data['CPs'] = CPs\\n self.data['CPsTab'] = CPsTab\\n self.data['Utot'] = Utot\\n self.data['UtotTab'] = UtotTab\",\n \"def test_readfile(self):\\n fname = os.path.join(self.datadir, 'monol_testA_E3-50_rebin4_gti') + \\\\\\n HEN_FILE_EXTENSION\\n command = \\\"{0}\\\".format(fname)\\n\\n hen.io.main(command.split())\",\n \"def generate_data(path=resource_filename('locals', 'data/fake/'), mag_range=(11.13,18)):\\n # Get some random spectra\\n try:\\n files = glob.glob('/user/jfilippazzo/Models/ACES/default/*.fits')[::50]\\n except:\\n files = glob.glob('/Users/jfilippazzo/Documents/Modules/_DEPRECATED/limb_dark_jeff/limb/specint/*.fits')[::20]\\n \\n # Make a fake source catalog (with only essential columns for now)\\n catpath = os.path.join(path,'fake_source_catalog.ecsv')\\n ids = list(range(len(files)))\\n coords = SkyCoord([89.7455]*len(ids), [-29.05744]*len(ids), unit='deg', frame='icrs')\\n cat = at.QTable([ids,coords], names=('id','icrs_centroid'))\\n cat.write(catpath)\\n \\n # Open the x1d file\\n header = fits.getheader(resource_filename('locals', 'data/template_x1d.fits'))\\n \\n # Make Spectrum objects from models at R=150\\n wavelength = np.arange(0.05,2.6,0.0001)[::66]*q.um\\n \\n # Normalize the spectra to a random F200W magnitude\\n spectra = []\\n f200w = Bandpass('NIRISS.F200W')\\n f200w.wave_units = q.um\\n for file in files:\\n \\n # Create Spectrum\\n flux = fits.getdata(file)[-1][::66]*q.erg/q.s/q.cm**2/q.AA\\n unc = flux/50.\\n spec = Spectrum(wavelength, flux, unc)\\n \\n # Normalize to F200W\\n mag = np.random.uniform(*mag_range)\\n norm_spec = spec.renormalize(mag, f200w)\\n spectra.append(norm_spec)\\n \\n # Make a separate x1d file and photometry file for each bandpass\\n # containing data for each source\\n for band in NIRISS_bands:\\n \\n try:\\n \\n # Get the Bandpass object\\n bp = Bandpass(band)\\n bp.wave_units = q.um\\n \\n # Make x1d file for spectra\\n x1d_file = os.path.join(path,'{}_x1d.fits'.format(band))\\n x1d_hdu = fits.HDUList(fits.PrimaryHDU(header=header))\\n \\n # Make csv file for photometry\\n phot_file = os.path.join(path,'{}_phot.csv'.format(band))\\n phot_data = at.Table(names=('id','band','magnitude','magnitude_unc'), dtype=(int,'S20',float,float))\\n \\n # Iterate over spectra\\n for id,(f,spec) in enumerate(zip(files,spectra)):\\n \\n # Trim spectrum to bandpass for x1d file\\n spec = Spectrum(*spec.spectrum, trim=[(0*q.um,bp.WavelengthMin*1E-4*q.um),(bp.WavelengthMax*1E-4*q.um,10*q.um)])\\n \\n # Calculate magnitude and add to photometry table\\n mag, mag_unc = spec.synthetic_magnitude(bp, force=True)\\n phot_data.add_row([id, band, mag, mag_unc])\\n \\n # Add source spectrum params for verification\\n params = f.split('/')[-1].split('-')\\n header['TEFF'] = int(params[0].replace('lte',''))\\n header['LOGG'] = float(params[1][:4])\\n header['FEH'] = float(params[-6][:-8].split('+')[-1])\\n header['FILEPATH'] = f\\n header['PUPIL'] = band\\n\\n # Put spectrum in x1d fits file\\n data = fits.BinTableHDU(data=np.rec.array(list(zip(*spec.data)),\\n formats='float32,float32,float32',\\n names='WAVELENGTH,FLUX,ERROR'),\\n header=header)\\n data.name = 'EXTRACT1D'\\n \\n x1d_hdu.append(data)\\n \\n # Write the photometry file\\n phot_data.write(phot_file, format='ascii.csv')\\n del phot_data\\n \\n # Write the x1d file\\n x1d_hdu.writeto(x1d_file, overwrite=True)\\n del x1d_hdu\\n \\n except IOError:\\n pass\",\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 readExperi(directory,varid,experi,level):\\n print('\\\\n>>> Using readExperi function! \\\\n')\\n \\n ### Import modules\\n import numpy as np\\n from netCDF4 import Dataset\\n \\n ### Call files\\n totaldirectory = directory + experi + '/monthly/'\\n filename = totaldirectory + varid + '_1900-2000.nc'\\n \\n if any([experi == 'FPOL',experi == 'FSUB']):\\n directory = '/home/zlabe/green/simu/'\\n totaldirectory = directory + experi + '/monthly/'\\n filename = totaldirectory + varid + '_1900-2000.nc'\\n \\n ### Read in Data\\n if level == 'surface': # 3d variables\\n data = Dataset(filename,'r')\\n varq = data.variables['%s' % varid][:,:,:,0]\\n data.close()\\n \\n dataq = Dataset(totaldirectory + 'T2M_1900-2000.nc')\\n time = dataq.variables['time'][:]\\n lev = 'surface'\\n lat = dataq.variables['latitude'][:]\\n lon = dataq.variables['longitude'][:]\\n dataq.close()\\n elif level == 'profile': # 4d variables\\n data = Dataset(filename,'r')\\n varq = data.variables['%s' % varid][:,:,:,0]\\n data.close()\\n \\n dataq = Dataset(totaldirectory + 'TEMP_1900-2000.nc')\\n time = dataq.variables['time'][:]\\n lev = dataq.variables['level'][:]\\n lat = dataq.variables['latitude'][:]\\n lon = dataq.variables['longitude'][:]\\n dataq.close()\\n else:\\n print(ValueError('Selected wrong height - (surface or profile!)!')) \\n print('Completed: Read data for *%s* : %s!' % (experi[:4],varid))\\n \\n ### Reshape to split years and months\\n months = 12\\n if level == 'surface': # 3d variables\\n var = np.reshape(varq,(int(varq.shape[0]/12),months,\\n int(lat.shape[0])))\\n elif level == 'profile': # 4d variables\\n var = np.reshape(varq,(int(varq.shape[0]/12),months,int(lev.shape[0]),\\n int(lat.shape[0])))\\n else:\\n print(ValueError('Selected wrong height - (surface or profile!)!')) \\n print('Completed: Reshaped %s array!' % (varid))\\n \\n ### Convert units\\n if varid in ('TEMP','T2M'):\\n var = var - 273.15 # Kelvin to degrees Celsius \\n print('Completed: Changed units (K to C)!')\\n\\n print('\\\\n*Completed: Finished readExperi function!')\\n return lat,lon,time,lev,var\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.61848754","0.6042058","0.59669006","0.59361804","0.58964205","0.5878065","0.58193845","0.57807654","0.57697374","0.57643694","0.5762156","0.5759421","0.57102454","0.56983227","0.56967455","0.569428","0.56905067","0.5686337","0.56723523","0.5671769","0.56500834","0.5650014","0.5634908","0.56230783","0.5621661","0.5601556","0.55970126","0.55885977","0.55826056","0.5573147","0.555902","0.55477744","0.55475754","0.553562","0.55337095","0.5532261","0.55212194","0.55140835","0.5511843","0.54949707","0.5489733","0.5488901","0.548602","0.54786396","0.5474472","0.5474146","0.5473728","0.54719186","0.54569846","0.54492","0.5445627","0.54450566","0.5442201","0.543869","0.54364437","0.5424609","0.54121804","0.5393718","0.5391966","0.53909457","0.5384381","0.5380993","0.5380589","0.537772","0.53772986","0.5377033","0.5372724","0.5372576","0.5371796","0.5368484","0.5365399","0.5364059","0.5361298","0.5356614","0.53560317","0.5351755","0.5349979","0.5343624","0.5343546","0.5342814","0.5341547","0.5330253","0.53297484","0.5328655","0.53269535","0.5325648","0.53192514","0.53190655","0.5316545","0.5313506","0.53076935","0.5307387","0.530662","0.5304737","0.53008145","0.5294829","0.52891594","0.5284364","0.52803403","0.5274455"],"string":"[\n \"0.61848754\",\n \"0.6042058\",\n \"0.59669006\",\n \"0.59361804\",\n \"0.58964205\",\n \"0.5878065\",\n \"0.58193845\",\n \"0.57807654\",\n \"0.57697374\",\n \"0.57643694\",\n \"0.5762156\",\n \"0.5759421\",\n \"0.57102454\",\n \"0.56983227\",\n \"0.56967455\",\n \"0.569428\",\n \"0.56905067\",\n \"0.5686337\",\n \"0.56723523\",\n \"0.5671769\",\n \"0.56500834\",\n \"0.5650014\",\n \"0.5634908\",\n \"0.56230783\",\n \"0.5621661\",\n \"0.5601556\",\n \"0.55970126\",\n \"0.55885977\",\n \"0.55826056\",\n \"0.5573147\",\n \"0.555902\",\n \"0.55477744\",\n \"0.55475754\",\n \"0.553562\",\n \"0.55337095\",\n \"0.5532261\",\n \"0.55212194\",\n \"0.55140835\",\n \"0.5511843\",\n \"0.54949707\",\n \"0.5489733\",\n \"0.5488901\",\n \"0.548602\",\n \"0.54786396\",\n \"0.5474472\",\n \"0.5474146\",\n \"0.5473728\",\n \"0.54719186\",\n \"0.54569846\",\n \"0.54492\",\n \"0.5445627\",\n \"0.54450566\",\n \"0.5442201\",\n \"0.543869\",\n \"0.54364437\",\n \"0.5424609\",\n \"0.54121804\",\n \"0.5393718\",\n \"0.5391966\",\n \"0.53909457\",\n \"0.5384381\",\n \"0.5380993\",\n \"0.5380589\",\n \"0.537772\",\n \"0.53772986\",\n \"0.5377033\",\n \"0.5372724\",\n \"0.5372576\",\n \"0.5371796\",\n \"0.5368484\",\n \"0.5365399\",\n \"0.5364059\",\n \"0.5361298\",\n \"0.5356614\",\n \"0.53560317\",\n \"0.5351755\",\n \"0.5349979\",\n \"0.5343624\",\n \"0.5343546\",\n \"0.5342814\",\n \"0.5341547\",\n \"0.5330253\",\n \"0.53297484\",\n \"0.5328655\",\n \"0.53269535\",\n \"0.5325648\",\n \"0.53192514\",\n \"0.53190655\",\n \"0.5316545\",\n \"0.5313506\",\n \"0.53076935\",\n \"0.5307387\",\n \"0.530662\",\n \"0.5304737\",\n \"0.53008145\",\n \"0.5294829\",\n \"0.52891594\",\n \"0.5284364\",\n \"0.52803403\",\n \"0.5274455\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74568313"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88393,"cells":{"query":{"kind":"string","value":"Visualise particles and polygons"},"document":{"kind":"string","value":"def visualise(self):\n\n # Initialise figure\n params = {\"figure.figsize\": (5, 5)}\n pylab.rcParams.update(params)\n self.fig = plt.figure()\n self.ax = self.fig.add_subplot(111)\n\n # Add particles if selected\n print(self.crds)\n cmap=cm.get_cmap('coolwarm')\n norm=Normalize(0,20)\n print(np.max(self.radii))\n print(np.max(self.weights))\n if self.vis_particles:\n if self.vis_vortype==-2:\n radii=self.weights\n if self.param>10:\n self.param=(self.param-10)/2+10\n colour=cmap(norm(self.param))\n else:\n radii=self.radii\n radii=self.weights\n colour='orange'\n colour=(0.8,0.687,0.287,1)\n colour='gold'\n patches = []\n patches_pnts = []\n patches_absent = []\n for i,c in enumerate(self.crds):\n patches.append(Circle(c,radius=radii[i]))\n if radii[i]>0:\n patches_pnts.append(Circle(c,radius=0.1))\n else:\n patches_absent.append(Circle(c,radius=0.1))\n self.ax.add_collection(PatchCollection(patches, facecolor=colour, edgecolor='k', alpha=0.5))\n self.ax.add_collection(PatchCollection(patches_pnts, facecolor='k', alpha=1,zorder=1))\n if self.vis_vortype==2:\n self.ax.add_collection(PatchCollection(patches_absent, facecolor='k', alpha=0.5,zorder=1))\n else:\n self.ax.add_collection(PatchCollection(patches_absent, facecolor='k', alpha=1,zorder=1))\n\n # Add voronoi\n if self.vis_vortype!=0:\n patches = []\n colours = []\n if self.vis_cellcolour==1:\n cell_colours = self.init_cell_colours()\n else:\n cell_colours = [(0,0,0,0)]*100\n for i in range(self.m):\n patches.append(Polygon(self.rings[i],True))\n colours.append(cell_colours[self.rings[i][:,0].size])\n self.ax.add_collection(PatchCollection(patches, facecolor=colours, edgecolor='k', linewidth=1, zorder=0))\n\n # Sandbox\n # print(np.max(self.radii))\n # cmap=cm.get_cmap('coolwarm')\n # norm=Normalize(0,np.max(20))\n sandbox=False\n if sandbox:\n # z=16\n # w=np.zeros_like(self.radii)\n # mask=2*self.radii>z\n # w[mask]=z**0.5*np.sqrt(2*self.radii[mask]-z)\n # patches = []\n # for i,c in enumerate(self.crds):\n # patches.append(Circle(c,radius=w[i]))\n # self.ax.add_collection(PatchCollection(patches, facecolor=cmap(norm(z)), edgecolor='k'))\n with open('./phi.dat','w') as f:\n for z in np.arange(0,np.max(self.radii)*2+0.5,0.01):\n w=np.zeros_like(self.radii)\n mask=2*self.radii>z\n w[mask]=z**0.5*np.sqrt(2*self.radii[mask]-z)\n phi=np.sum(np.pi*w**2)/52359.9\n # phi=np.sum(np.pi*w**2)/1309\n f.write('{:.6f} {:.6f}\\n'.format(z,phi))\n\n\n\n # Set axes\n buffer = 1.6\n lim = buffer*np.max(np.abs(self.crds))\n self.ax.set_xlim((-lim,lim))\n self.ax.set_ylim((-lim,lim))\n self.ax.set_axis_off()\n\n # Show figure\n if self.vis_save:\n plt.savefig('{}_{}_{}.png'.format(self.prefix,self.frame,self.vis_vortype),dpi=400)\n plt.show()"},"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 visualize(title, particles):\n\n plt.figure(figsize=(10,10))\n plt.title(\"Best configuration for \" + str(len(particles)) + \" particles\", size=25)\n plt.xlabel(\"xcoordinate\", size=18)\n plt.ylabel(\"ycoordinate\", size=18)\n\n plt.xticks(size=13)\n plt.yticks(size=13)\n\n circle = plt.Circle((0, 0), 1)\n circle.set_edgecolor(\"red\")\n circle.set_facecolor(\"none\")\n fig = plt.gcf()\n ax = fig.gca()\n\n ax.add_artist(circle)\n plt.xlim(-1.1,1.1)\n plt.ylim(-1.1,1.1)\n\n # draw all the particles\n for particle in particles:\n plt.scatter(particle.x, particle.y)\n\n fig.savefig(title)","def draw_particles(self):\n for particle in self.particles:\n particle.draw()","def test_visualize():\n # Instantiate three particles for testing\n particles = [Particle(0.3, 0.5, 1), \n Particle(0.0, -0.5, -1), \n Particle(-0.1, -0.4, 3)]\n simulator = ParticleSimulator(particles)\n visualize(simulator)","def visualize_scan(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.scatter(self.p1_points[:, 0], self.p1_points[:, 1], self.p1_points[:, 2], c='r')\n ax.scatter(self.p2_points[:, 0], self.p2_points[:, 1], self.p2_points[:, 2], c='g')\n ax.scatter(self.p3_points[:, 0], self.p3_points[:, 1], self.p3_points[:, 2], c='b')\n ax.scatter(self.p4_points[:, 0], self.p4_points[:, 1], self.p4_points[:, 2])\n\n ax.set_xlabel('x')\n ax.set_ylabel('y')\n ax.set_zlabel('z')\n plt.show()","def initiate(self):\n pts = []\n for point in self.points:\n pt = gr.Point(point[0],point[1])\n pts.append(pt)\n\n self.vis = [gr.Polygon(pts)]\n\n self.draw()","def show_path_2D(start, end, coordinates, polygons, clear = True):\n global L, N, delta_t\n\n # start interactive mode\n plt.ion()\n\n # crete eempty figure on which data will go and first subplot\n fig = plt.figure()\n\n # get into the correct time step\n for time_step in range(start, end):\n # list of colours used for animation\n colours = cm.rainbow(np.linspace(0, 1, N))\n\n # loop over each particle and colour\n for i in range(N):\n # plot x, y poistion of particle in a given colour and set axis to size of box\n plt.scatter(coordinates[time_step][i][0], coordinates[time_step][i][1], s = 1, color = 'r')\n\n # plot the object\n if i < M:\n polygon = np.array(polygons[time_step][i])\n # get the points of the polygon to plot it\n x, y = polygon.T\n\n # print(x, y)\n\n x = np.append(x, x[0])\n y = np.append(y, y[0])\n\n # print(x, y)\n\n # plot the polygon\n plt.plot(x , y)\n # plt.scatter(polygons_com[time_step][i][0], polygons_com[time_step][i][1], s = 5, color = 'g')\n\n if bound_cond == True:\n plt.axis([0, L, 0, L])\n plt.axis([0, L, 0, L])\n # plt.axis([-L*2, L*2, -L*2, L*2])\n\n # show graph\n plt.show()\n plt.pause(time_pause)\n\n # decide if you want to clear\n if clear == True:\n plt.clf()\n\n return None","def visualize(self):\n self.octree.updateInnerOccupancy()\n print(\"Start Octomap Visualization\")\n\n # define parameters\n data = imgviz.data.arc2017()\n camera_info = data['camera_info']\n K = np.array(camera_info['K']).reshape(3, 3)\n width=camera_info['width']\n height=camera_info['height']\n\n # get free and occupied grid\n occupied, _ = self.octree.extractPointCloud()\n #frontier = self.gen_frontier()\n \n print(\"load point cloud\")\n window = pyglet.window.Window(\n width=int(1280), height=int(960)\n )\n\n @window.event\n def on_key_press(symbol, modifiers):\n if modifiers == 0:\n if symbol == pyglet.window.key.Q:\n window.on_close()\n\n gui = glooey.Gui(window)\n hbox = glooey.HBox()\n hbox.set_padding(5)\n\n camera = trimesh.scene.Camera(\n resolution=(width, height), focal=(K[0, 0], K[1, 1])\n )\n\n # initial camera pose\n camera_transform = np.array(\n [\n [1, 0, 0, 0],\n [0, -1, 0, 0],\n [0, 0, -1, -5],\n [0.0, 0.0, 0.0, 1.0],\n ],\n )\n\n \n\n occupied_geom = trimesh.voxel.ops.multibox(\n occupied, pitch=self.resolution, colors=[0.0, 0.0, 0.0, 0.5]\n )\n\n # frontier_geom = trimesh.voxel.ops.multibox(\n # frontier, pitch=self.resolution, colors=[1.0, 0, 0, 0.5]\n # )\n scene = trimesh.Scene(camera=camera, geometry=[occupied_geom])#, frontier_geom])\n scene.camera_transform = camera_transform\n hbox.add(self.labeled_scene_widget(scene, label='octomap'))\n\n\n gui.add(hbox)\n pyglet.app.run()","def decorate_scene():\n make_polygon( (100,100),(120,140),(270,70) )\n make_polygon( (300,10), (300,550), (340,452),(380,300), (330,50))\n make_polygon( (200,450), (100,450), (100,500), (200,500) )\n make_polygon( (130,320), (150,300), (140,280) )\n return","def main():\n # Initialize the Serpinski set\n print(\"==> Making serpinski set...\")\n my_serpinski = Serpinski(400, 400, 0)\n num = 8\n print(\"==> Generating\", num, \"levels of subsets :)\")\n for _ in range(9):\n my_serpinski.add_subset()\n # Draw Serpinski\n # print(\"==> Drawing the set. This might take quite some time!\\\n # Damn Inefficient!\")\n # my_serpinski.draw_me()\n\n # Initialize Coordinates\n length = 50000 # Number of random dots\n x_coord = []\n y_coord = []\n index = 0\n\n # try length particles in serp set\n print(\"==> Randomly choosing\", length, \"dots...\")\n while index < length:\n # Chech if dot in bound\n rand_y = np.random.uniform(low=400.0 - 200.0 * np.sqrt(3) / 2.0,\n high=400.0)\n # rand_x in triangle // condition //\n diff = 400.0 - rand_y\n x_diff = diff / np.sqrt(3)\n rand_x = np.random.uniform(low=400.0 - x_diff,\n high=400 + x_diff)\n\n if my_serpinski.is_bound(rand_x, rand_y):\n x_coord.append(rand_x)\n y_coord.append(rand_y)\n index += 1\n\n # Draw image using scatter\n print(\"Scattering the dots ;)\")\n plt.scatter(x_coord, y_coord, s=0.1)\n # Show image\n dpi = 600\n print(\"==> Saving to .jpg with dpi=\", dpi)\n plt.savefig(\"fractalstuff.jpg\", dpi=dpi, bbox_inches='tight')","def draw_world(est_pose, particles, world):\r\n\r\n # Fix the origin of the coordinate system\r\n offsetX = 100\r\n offsetY = 250\r\n\r\n # Constant needed for transforming from world coordinates to screen coordinates (flip the y-axis)\r\n ymax = world.shape[0]\r\n\r\n world[:] = CWHITE # Clear background to white\r\n\r\n # Find largest weight\r\n max_weight = 0\r\n for particle in particles:\r\n max_weight = max(max_weight, particle.getWeight())\r\n\r\n # Draw particles\r\n for particle in particles:\r\n x = int(particle.getX()) + offsetX\r\n y = ymax - (int(particle.getY()) + offsetY)\r\n colour = jet(particle.getWeight() / max_weight)\r\n cv2.circle(world, (x, y), 2, colour, 2)\r\n b = (int(particle.getX() + 15.0 * np.cos(particle.getTheta())) + offsetX,\r\n ymax - (int(particle.getY() - 15.0 * np.sin(particle.getTheta())) + offsetY))\r\n cv2.line(world, (x, y), b, colour, 2)\r\n\r\n # Draw landmarks\r\n lm0 = (int(landmarks[0][0] + offsetX),\r\n int(ymax - (landmarks[0][1] + offsetY)))\r\n lm1 = (int(landmarks[1][0] + offsetX),\r\n int(ymax - (landmarks[1][1] + offsetY)))\r\n lm2 = (int(landmarks[2][0] + offsetX),\r\n int(ymax - (landmarks[2][1] + offsetY)))\r\n lm3 = (int(landmarks[3][0] + offsetX),\r\n int(ymax - (landmarks[3][1] + offsetY)))\r\n \r\n cv2.circle(world, lm0, 5, CRED, 2)\r\n cv2.circle(world, lm1, 5, CGREEN, 2)\r\n cv2.circle(world, lm2, 5, CBLUE, 2)\r\n cv2.circle(world, lm3, 5, CYELLOW, 2)\r\n cv2.putText(world, 'LM 1',lm0, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\r\n cv2.putText(world, 'LM 2',lm1, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\r\n cv2.putText(world, 'LM 3',lm2, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\r\n cv2.putText(world, 'LM 4',lm3, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\r\n\r\n\r\n\r\n\r\n # Draw estimated robot pose\r\n a = (int(est_pose.getX()) + offsetX, ymax - (int(est_pose.getY()) + offsetY))\r\n b = (int(est_pose.getX() + 15.0 * np.cos(est_pose.getTheta())) + offsetX,\r\n ymax - (int(est_pose.getY() - 15.0 * np.sin(est_pose.getTheta())) + offsetY))\r\n cv2.circle(world, a, 5, CMAGENTA, 2)\r\n cv2.line(world, a, b, CMAGENTA, 2)","def visualize(self):\n\n evidence = self.create_evidence(use_success=False)\n\n conditional_model = self.model.conditional_jpt(evidence)\n\n for leaf in conditional_model.leaves.values():\n\n success = leaf.distributions[\"status\"].p({\"SUCCEEDED\"})\n\n if success == 0:\n continue\n\n x_intervals = leaf.distributions[\"x\"].cdf.intervals\n y_intervals = leaf.distributions[\"y\"].cdf.intervals\n\n x_range = np.array([x_intervals[0].upper, x_intervals[-1].lower])\n y_range = np.array([y_intervals[0].upper, y_intervals[-1].lower])\n\n center = np.array([sum(x_range) / 2, sum(y_range) / 2])\n\n visual = pybullet.createVisualShape(pybullet.GEOM_BOX,\n halfExtents=[(x_range[1] - x_range[0]) / 2,\n (y_range[1] - y_range[0]) / 2, 0.001],\n rgbaColor=[1, 0, 0, success],\n visualFramePosition=[*center, 0])\n\n self.visual_ids.append(visual)\n\n for id_list in np.array_split(np.array(self.visual_ids), np.ceil(len(self.visual_ids) / 127)):\n # Dummy paramater since these are needed to spawn visual shapes as a multibody.\n link_poses = [[0, 0, 0] for c in id_list]\n link_orientations = [[0, 0, 0, 1] for c in id_list]\n link_masses = [1.0 for c in id_list]\n link_parent = [0 for c in id_list]\n link_joints = [pybullet.JOINT_FIXED for c in id_list]\n link_collision = [-1 for c in id_list]\n link_joint_axis = [[1, 0, 0] for c in id_list]\n\n # The position at which the multibody will be spawned. Offset such that\n # the origin referes to the centre of the costmap.\n origin_pose = self.target.get_position_and_orientation()\n base_position = list(origin_pose[0])\n base_position[2] = 0\n\n map_obj = pybullet.createMultiBody(baseVisualShapeIndex=-1, linkVisualShapeIndices=id_list,\n basePosition=base_position, baseOrientation=origin_pose[1],\n linkPositions=link_poses,\n linkMasses=link_masses, linkOrientations=link_orientations,\n linkInertialFramePositions=link_poses,\n linkInertialFrameOrientations=link_orientations,\n linkParentIndices=link_parent,\n linkJointTypes=link_joints, linkJointAxis=link_joint_axis,\n linkCollisionShapeIndices=link_collision)\n self.visual_ids.append(map_obj)","def drawShapes(self):\n self.draw_polygon(self.poly3.get_points() , color = \"#000\")\n self.draw_polygon(self.poly2.get_points() , color = \"#000\")\n self.draw_polygon(self.poly1.get_points() , color = \"#000\")\n self.draw_rect(0, 0, self.width, self.height, color= \"#000\")\n \"\"\"These statements are used to determine if a point is inside any of the\n 3 polygons and if so changes the point's color\"\"\"\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\n or self.poly3.point_inside_polygon(self.p1)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\n\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\n or self.poly3.point_inside_polygon(self.p2)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\n or self.poly3.point_inside_polygon(self.p3)):\n color = \"#0F0\"\n else:\n color = \"#F00\"\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)","def render(self, scene):\n if self.degenerate:\n return\n # The number of subdivisions around the hoop's radial direction.\n if self.thickness:\n band_coverage = scene.pixel_coverage(self.pos, self.thickness)\n else:\n band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)\n if band_coverage < 0:\n band_coverage = 1000\n bands = sqrt(band_coverage * 4.0)\n bands = clamp(4, bands, 40)\n # The number of subdivisions around the hoop's tangential direction.\n ring_coverage = scene.pixel_coverage(self.pos, self.radius)\n if ring_coverage < 0:\n ring_coverage = 1000\n rings = sqrt(ring_coverage * 4.0)\n rings = clamp(4, rings, 80)\n slices = int(rings)\n inner_slices = int(bands)\n radius = self.radius\n inner_radius = self.thickness\n\n # Create the vertex and normal arrays.\n vertices = []\n normals = []\n\n outer_angle_step = 2 * pi / (slices - 1)\n inner_angle_step = 2 * pi / (inner_slices - 1)\n outer_angle = 0.\n for i in range(slices):\n cos_outer_angle = cos(outer_angle)\n sin_outer_angle = sin(outer_angle)\n inner_angle = 0.\n for j in range(inner_slices):\n cos_inner_angle = cos(inner_angle)\n sin_inner_angle = sin(inner_angle)\n\n diameter = (radius + inner_radius * cos_inner_angle)\n vertex_x = diameter * cos_outer_angle\n vertex_y = diameter * sin_outer_angle\n vertex_z = inner_radius * sin_inner_angle\n\n normal_x = cos_outer_angle * cos_inner_angle\n normal_y = sin_outer_angle * cos_inner_angle\n normal_z = sin_inner_angle\n\n vertices.extend([vertex_x, vertex_y, vertex_z])\n normals.extend([normal_x, normal_y, normal_z])\n inner_angle += inner_angle_step\n outer_angle += outer_angle_step\n\n # Create ctypes arrays of the lists\n vertices = (gl.GLfloat *len(vertices))(*vertices)\n normals = (gl.GLfloat * len(normals))(*normals)\n\n # Create a list of triangle indices.\n indices = []\n for i in range(slices - 1):\n for j in range(inner_slices - 1):\n pos = i * inner_slices + j\n indices.extend([pos, pos + inner_slices, pos + inner_slices +\n 1])\n indices.extend([pos, pos + inner_slices + 1, pos + 1])\n indices = (gl.GLuint * len(indices))(*indices)\n\n # Compile a display list\n self.list = gl.glGenLists(1)\n gl.glNewList(self.list, gl.GL_COMPILE)\n self.color.gl_set(self.opacity)\n\n gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)\n gl.glEnableClientState(gl.GL_VERTEX_ARRAY)\n gl.glEnableClientState(gl.GL_NORMAL_ARRAY)\n self.model_world_transform(scene.gcf,\n Vector([self.radius, self.radius,\n self.radius])).gl_mult()\n\n gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)\n gl.glNormalPointer(gl.GL_FLOAT, 0, normals)\n gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,\n indices)\n gl.glPopClientAttrib()\n\n gl.glEndList()\n gl.glCallList(self.list)","def visualiser(filename):\n\tcollection = mongo.db[filename]\n\tjsonEncoder = hepmcio_json.HepMCJSONEncoder()\n\thepMCDecoder = hepmcio_json.HepMCJSONDecoder()\n\tjsonDecoder = json.JSONDecoder()\n\t#Get first event data in file and decode to HepMCIO objects.\n\tevent = collection.find_one({\"type\":\"event\", \"no\":1}, {\"_id\":False})\n\tparticleJson = collection.find({\"type\":\"particle\", \"event\":event[\"barcode\"]}, {\"_id\":False})\n\tparticles = []\n\tfor particle in particleJson:\n\t\tparticles.append(jsonEncoder.encode(particle))\n\t\n\tvertices = []\n\tvertexJson = collection.find({\"type\":\"vertex\", \"event\":event[\"barcode\"]}, {\"_id\":False})\n\tfor vertex in vertexJson:\n\t\tvertices.append(jsonEncoder.encode(vertex))\n\tevent = jsonEncoder.encode(event)\n\t\n\t\n\t#Decode event to find interesting particles, i.e. particles above PT_CUTOFF and their ancestors..\n\teventObject = hepmcio_json.EventJSONObject(event, particles, vertices)\n\tdecodedEvent = hepMCDecoder.decode(eventObject)\n\n\tPT_CUTOFF = 0.0\n\tintParticles = [particle for particle in decodedEvent.particles.values() if particle.status!=1 and \\\n\t\tparticle.mom[0]**2 + particle.mom[1]**2 > PT_CUTOFF**2]\n\t#Build a single list from the individual particle ancestor lists.\n\tintParticleAncestors = reduce(operator.concat, [hepmcio.get_ancestors(particle)[:-1] for particle in intParticles])\n\n\tparticles = []\n\tfor particle in (intParticles + intParticleAncestors):\n\t\t#Encode particle to JSON, decode to Python dicts.\n\t\tparticles.append(jsonDecoder.decode(jsonEncoder.encode(particle)))\n\t#Decode to Python dicts.\n\tvertices = list(map(jsonDecoder.decode, vertices))\n\t\n\treturn render_template(\"visualiser.html\", title=\"Visualiser\", file=filename, particles=particles, vertices=vertices)","def generate(pts):\n cmds.polyCreateFacet(name=\"shirt\", p=points)\n cmds.polyTriangulate()\n cmds.polySubdivideFacet(dv=SUBDIVISIONS)\n cmds.polyTriangulate()","def plot(self):\n\t\tself.plotOfXray().plot()","def sample_and_plot(self):\n fig = plt.figure()\n ax = plt.axes(projection = '3d')\n ax.plot_surface(self.X, self.Y, self.sample(), cmap = plt.cm.jet, rstride = 2, cstride = 2, linewidth = 1)\n plt.show()","def visualize(z_in, azimuth=25., elevation=30.,\n thresholds=[0.95, .9, .75, .5, .25, .125], opacities=[1, .9, .7, .5, .2, .1],\n# thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],\n# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],\n# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],\n fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},\n filename=None, do_axis=True, do_grids=False, draw_projections=True,\n colorbar=False, f_N=2., f_tN=2., figsize=figsize, dpi=300, figpath=figpath, **kwargs):\n z = z_in.copy()\n N_X, N_Y, N_frame = z.shape\n fx, fy, ft = get_grids(N_X, N_Y, N_frame)\n\n # Normalize the amplitude.\n z /= z.max()\n\n from vispy import app, scene, use\n try:\n AffineTransform = scene.transforms.AffineTransform\n except:\n AffineTransform = scene.transforms.MatrixTransform\n\n use(app='pyglet', gl='pyopengl2')\n #from vispy.util.transforms import perspective, translate, rotate\n from vispy.color import Color\n transparent = Color(color='black', alpha=0.)\n import colorsys\n canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=dpi)\n view = canvas.central_widget.add_view()\n\n vol_data = np.rollaxis(np.rollaxis(z, 1), 2)\n# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)\n center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))\n# volume.transform = center\n# volume.cmap = 'blues'\n\n if draw_projections:\n from vispy.color import Colormap\n cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])\n opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}\n\n energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)#[:, ::-1]\n fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)\n tr_xy = AffineTransform()\n tr_xy.rotate(90, (0, 0, 1))\n tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))\n fourier_xy.transform = tr_xy\n\n energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]\n fourier_xt = scene.visuals.Image(energy_xt, **opts)\n tr_xt = AffineTransform()\n tr_xt.rotate(90, (1, 0, 0))\n tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))\n fourier_xt.transform = tr_xt\n\n energy_yt = np.max(z, axis=0)[:, ::-1]\n fourier_yt = scene.visuals.Image(energy_yt, **opts)\n tr_yt = AffineTransform()\n tr_yt.rotate(90, (0, 1, 0))\n tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))\n fourier_yt.transform = tr_yt\n\n # Generate iso-surfaces at different energy levels\n surfaces = []\n for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):\n surfaces.append(scene.visuals.Isosurface(z, level=threshold,\n# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),\n color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),\n shading='smooth', parent=view.scene)\n )\n surfaces[-1].transform = center\n\n # Draw a sphere at the origin\n axis = scene.visuals.XYZAxis(parent=view.scene)\n for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],\n [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],\n [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):\n line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)\n\n axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)\n axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)\n axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)\n\n if do_axis:\n t = {}\n for text in ['f_x', 'f_y', 'f_t']:\n t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')\n t[text].font_size = 8\n t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8\n t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6\n t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2\n\n cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')\n cam.fov = 48\n cam.scale_factor = N_X * 1.8\n if do_axis: margin = 1.35\n else: margin = 1\n cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))\n view.camera = cam\n\n render_im = canvas.render()\n app.quit()\n if not(filename is None):\n import vispy.io as io\n io.write_png(filename, render_im)\n else:\n return render_im","def render(self):\r\n super().render()\r\n layers, titles, latVect, lonVect = self.make_layers()\r\n LON, LAT = np.meshgrid(lonVect, latVect)\r\n lon = LON.flatten()\r\n lat = LAT.flatten()\r\n for i in range(len(layers)):\r\n vals = layers[i].flatten()\r\n hovertext = []\r\n for k in range(len(vals)):\r\n hovertext.append('lon: {:.2f}<br>lat: {:.2f}<br>{}: {:.1e}'.format(lon[k], lat[k], self.variable + self.unit,vals[k]))\r\n if self.levels == 0:\r\n data = [\r\n go.Heatmap(\r\n x=lon,\r\n y=lat,\r\n z=vals,\r\n colorscale=self.cmap,\r\n zmin=self.vmin,\r\n zmax=self.vmax,\r\n hoverinfo='text',\r\n text=hovertext \r\n )\r\n ]\r\n elif self.levels > 0:\r\n data = [\r\n go.Contour(\r\n x=lon,\r\n y=lat,\r\n z=vals,\r\n colorscale=self.cmap,\r\n hoverinfo='text',\r\n text=hovertext, \r\n connectgaps=False,\r\n contours=dict(\r\n coloring='heatmap',\r\n showlabels=True,\r\n start=self.vmin,\r\n end=self.vmax,\r\n size=(self.vmax-self.vmin) / float(self.levels)\r\n )\r\n # line=dict(smoothing=0.85) \r\n )\r\n ] \r\n\r\n\r\n layout = go.Layout(\r\n autosize=False,\r\n title=titles[i],\r\n width=self.width,\r\n height=self.height,\r\n xaxis={'title': self.xlabel},\r\n yaxis={'title': self.ylabel}\r\n ) \r\n\r\n\r\n\r\n if self.surface3D:\r\n data = [\r\n go.Surface(\r\n x=lonVect,\r\n y=latVect,\r\n z=layers[i],\r\n colorscale=self.cmap,\r\n # hoverinfo='text',\r\n # text=hovertext \r\n )\r\n ]\r\n\r\n layout = go.Layout(\r\n autosize=False,\r\n title=titles[i],\r\n width=self.width,\r\n height=self.height,\r\n scene = dict(\r\n xaxis={'title': self.xlabel},\r\n yaxis={'title': self.ylabel},\r\n zaxis={'title': self.variable + self.unit}\r\n )\r\n ) \r\n\r\n\r\n self._save_plotly_(go, data, layout)","def viewer(\n self, units='nm', \n draw_edges=True, draw_vertices=True,\n color_by='radius'\n ):\n try:\n import matplotlib.pyplot as plt\n from mpl_toolkits.mplot3d import Axes3D \n from matplotlib import cm\n except ImportError:\n print(\"Skeleton.viewer requires matplotlib. Try: pip install matplotlib --upgrade\")\n return\n\n RADII_KEYWORDS = ('radius', 'radii', 'r')\n COMPONENT_KEYWORDS = ('component', 'components', 'c')\n\n fig = plt.figure(figsize=(10,10))\n ax = Axes3D(fig)\n ax.set_xlabel(units)\n ax.set_ylabel(units)\n ax.set_zlabel(units)\n\n # Set plot axes equal. Matplotlib doesn't have an easier way to\n # do this for 3d plots.\n X = self.vertices[:,0]\n Y = self.vertices[:,1]\n Z = self.vertices[:,2]\n\n max_range = np.array([X.max()-X.min(), Y.max()-Y.min(), Z.max()-Z.min()]).max() / 2.0\n\n mid_x = (X.max()+X.min()) * 0.5\n mid_y = (Y.max()+Y.min()) * 0.5\n mid_z = (Z.max()+Z.min()) * 0.5\n ax.set_xlim(mid_x - max_range, mid_x + max_range)\n ax.set_ylim(mid_y - max_range, mid_y + max_range)\n ax.set_zlim(mid_z - max_range, mid_z + max_range)\n ### END EQUALIZATION CODE ###\n\n component_colors = ['k', 'deeppink', 'dodgerblue', 'mediumaquamarine', 'gold' ]\n\n def draw_component(i, skel):\n component_color = component_colors[ i % len(component_colors) ]\n\n if draw_vertices:\n xs = skel.vertices[:,0]\n ys = skel.vertices[:,1]\n zs = skel.vertices[:,2]\n\n if color_by in RADII_KEYWORDS:\n colmap = cm.ScalarMappable(cmap=cm.get_cmap('rainbow'))\n colmap.set_array(skel.radii)\n\n normed_radii = skel.radii / np.max(skel.radii)\n yg = ax.scatter(xs, ys, zs, c=cm.rainbow(normed_radii), marker='o')\n cbar = fig.colorbar(colmap)\n cbar.set_label('radius (' + units + ')', rotation=270)\n elif color_by in COMPONENT_KEYWORDS:\n yg = ax.scatter(xs, ys, zs, color=component_color, marker='.')\n else:\n yg = ax.scatter(xs, ys, zs, color='k', marker='.')\n\n if draw_edges:\n for e1, e2 in skel.edges:\n pt1, pt2 = skel.vertices[e1], skel.vertices[e2]\n ax.plot( \n [ pt1[0], pt2[0] ],\n [ pt1[1], pt2[1] ],\n zs=[ pt1[2], pt2[2] ],\n color=(component_color if not draw_vertices else 'silver'),\n linewidth=1,\n )\n\n if color_by in COMPONENT_KEYWORDS:\n for i, skel in enumerate(self.components()):\n draw_component(i, skel)\n else:\n draw_component(0, self)\n\n plt.show()","def plotVolumeContours(self):\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Particle Positions Colored by Voronoi Volumes', fontsize=22)\n ax.set_xlabel('x [m]', fontsize=18)\n ax.set_ylabel('y [m]', fontsize=18)\n ax.set_zlabel('z [m]', fontsize=18)\n pos = ax.scatter(self.data[self.nonB, 0], self.data[self.nonB, 1], self.data[self.nonB, 2], s=10, c=self.volumes, cmap='plasma')\n cbar = fig.colorbar(pos, ax=ax)\n cbar.ax.tick_params(labelsize=15)","def showPoints(surface, points):\n for point in points:\n point.show(surface)","def generatePolygons():","def display(self):\n scatter_plot(self.points, self.hull_points, self.color, self.title)","def render(self):\r\n super().render()\r\n layers, titles, lat, lon = self.make_layers()\r\n plots = []\r\n for i in range(len(layers)):\r\n p = figure(\r\n tools=self.tools, \r\n toolbar_location=self.toolbarLocation, \r\n plot_width=self.width, \r\n plot_height=self.height,\r\n x_range=(np.min(lon), np.max(lon)),\r\n y_range=(np.min(lat), np.max(lat)),\r\n title=titles[i]\r\n )\r\n p.xaxis.axis_label = self.xlabel\r\n p.yaxis.axis_label = self.ylabel\r\n colorMapper = LinearColorMapper(palette=self.cmap, low=self.vmin, high=self.vmax)\r\n p.image(\r\n image=[layers[i]], \r\n color_mapper=colorMapper, \r\n x=np.min(lon), \r\n y=np.min(lat), \r\n dw=np.max(lon)-np.min(lon), \r\n dh=np.max(lat)-np.min(lat)\r\n )\r\n\r\n p.add_tools(HoverTool(\r\n tooltips=[\r\n ('longitude', '$x'),\r\n ('latitude', '$y'),\r\n (self.variable + self.unit, '@image'),\r\n ],\r\n mode='mouse'\r\n )\r\n )\r\n\r\n colorBar = ColorBar(\r\n color_mapper=colorMapper, \r\n ticker=BasicTicker(),\r\n label_standoff=12, \r\n border_line_color=None, \r\n location=(0,0)\r\n )\r\n\r\n p.add_layout(colorBar, 'right')\r\n plots.append(p)\r\n \r\n \r\n if not inline(): output_file(get_figure_dir() + self.variable + \".html\", title=self.variable) \r\n show(column(plots))","def show_geometry(self):\n import matplotlib.pyplot as plt\n fig_geom = plt.figure()\n ax_geom = fig_geom.add_subplot(111)\n rectangle = []\n for i in range(len(self.coordinates)):\n rectangle.append(plt.Rectangle((self.coordinates[i][0],\n self.coordinates[i][1]),\n self.size[i][0], self.size[i][1], alpha=0.5))\n ax_geom.add_patch(rectangle[i])\n plt.axis('auto')\n plt.show()","def plot(self):\n # Find only unmasked data :\n # xyz, sData, sColor, _ = self._select_unmasked()\n xyz, sData, sColor = self.xyz, self.sData, self.sColor\n\n # Render as cloud points :\n self.mesh = visu.Markers(name='Sources')\n self.mesh.set_data(xyz, edge_color=self.edgecolor, face_color=sColor,\n size=sData, scaling=self.scaling,\n edge_width=self.edgewidth, symbol=self.symbol)\n self.mesh.set_gl_state('translucent')","def draw_world_state(self):\n self.fig.clf()\n t = time.time()\n subplot = self.fig.add_subplot(2,1,1)\n for w in self.world_model.walls:\n subplot.plot([w,w],[0,1],'b-')\n subplot.hold(True)\n subplot.set_xlim([min(self.walls)-0.2,max(self.walls)+.2])\n subplot.set_ylim([0,1])\n subplot.scatter([p.position for p in self.pf.particles],\n [0.5]*len(self.pf.particles),\n c='r',\n s=[p.weight**0.5*1000 for p in self.pf.particles])\n\n subplot.scatter([p.position for p in self.pf.particles],\n [0.2]*len(self.pf.particles),\n c='k',\n s=[10]*len(self.pf.particles))\n\n if self.true_position != None:\n subplot.scatter([self.true_position], [0.8], c='g', s=[100])\n\n histogram = self.fig.add_subplot(2,1,2)\n\n histogram.hist([p.position for p in self.pf.particles],\n weights=[p.weight for p in self.pf.particles],\n bins=np.arange(-0.5+min(self.walls),0.5+max(self.walls),.02))\n\n histogram.set_xlim([-.2+min(self.walls),0.2+max(self.walls)])\n histogram.set_ylim([0,1])\n plt.draw()\n plt.pause(.01)","def __init__(self):\n Page.__init__(self, u\"Esfera, parametrización por proyecciones estereográficas\")\n\n r = .998\n esf = ParametricPlot3D(lambda t, f: (r * sin(t) * cos(f), r * sin(t) * sin(f), r * cos(t)), (0, pi, 70), (0, 2 * pi, 70))\n# esf.setAmbientColor(_1(99,136,63))\n esf.setDiffuseColor(_1(99, 136, 63))\n esf.setSpecularColor(_1(99, 136, 63))\n\n\n def proyZm1(u, v, t1):\n \"\"\"proy desde el polo norte al plano z=-1\"\"\"\n den = u ** 2 + v ** 2 + 4\n x = u - t1 * (u - 4 * u / den)\n y = v - t1 * (v - 4 * v / den)\n z = -1 - t1 * (-2 + 8 / den)\n return (x, y, z)\n\n def proyZ1(u, v, t2):\n \"\"\"proy desde el polo sur al plano z=1\"\"\"\n den = u ** 2 + v ** 2 + 4\n x = u - t2 * (u - 4 * u / den)\n y = v - t2 * (v - 4 * v / den)\n z = 1 - t2 * (2 - 8 / den)\n return (x, y, z)\n\n stereo = ParametricPlot3D(proyZm1, (-3, 3, 70), (-3, 3, 70))\n stereo.setLinesVisible(True)\n stereo.setMeshVisible(False)\n stereo.setMeshDiffuseColor(_1(117, 55, 79))\n\n stereo2 = ParametricPlot3D(proyZ1, (-3, 3, 70), (-3, 3, 70))\n stereo2.setLinesVisible(True)\n stereo2.setMeshVisible(False)\n stereo2.setMeshDiffuseColor(_1(80, 87, 193))\n stereo2.setTransparency(0.5)\n stereo2.setTransparencyType(8)\n\n\n baseplane = BasePlane()\n baseplane.setHeight(-1.005)\n baseplane.setRange((-4, 4, 7))\n self.addChild(esf)\n self.addChild(stereo2)\n self.addChild(stereo)\n self.addChild(baseplane)\n\n params = [stereo,stereo2]\n\n ## no queremos los controles\n for i,p in enumerate(params):\n p.parameters['t%d' % (i+1)].hide()\n\n anims = [p.parameters['t%d' % (i+1)].asAnimation() for i,p in enumerate(params)]\n self.setupAnimations(anims)","def draw(self, fig, ax):\n\n\t\tpoints = self.apply_transformations() \n\t\tax.scatter3D(points[:, 0], points[:, 1], points[:, 2])\n\n\t\t# cube polygons collection\n\t\tverts = [\n\t\t\t[points[0], points[1], points[2], points[3]],\n\t\t\t[points[4], points[5], points[6], points[7]], \n\t\t\t[points[0], points[1], points[5], points[4]], \n\t\t\t[points[2], points[3], points[7], points[6]], \n\t\t\t[points[1], points[2], points[6], points[5]],\n\t\t\t[points[4], points[7], points[3], points[0]]\n\t\t]\n\t\t\n\t\t# render polygons\n\t\tax.add_collection3d(Poly3DCollection(verts, \n\t\tfacecolors='blue', linewidths=1, edgecolors='b', alpha=0.3))","def show(self):\n if self.nodes_ is None:\n logging.debug(\"Segment - Nothing to show. Skipping.\")\n return\n\n if len(self.polygons_) != 0:\n logging.debug(\"Segment - Showing 3D Segments using `vedo`.\")\n logging.warning(\"Segment - Showing 3D Segments can be slow!.\")\n\n import vedo\n\n points = vedo.Points(self.nodes)\n lines = []\n for p in self.polygons:\n p = np.asarray(p).astype(np.int32)\n lines.append(vedo.Line(self.nodes[p]))\n\n vedo.show([points, *lines]).show().close()\n\n else:\n logging.debug(\"Segment - Showing 2D Segments using `matplotlib`.\")\n\n import matplotlib.pyplot as plt\n\n plt.scatter(\n self.nodes_[:, 0],\n self.nodes_[:, 1],\n c=\"pink\",\n zorder=1000,\n )\n\n for c in self.connectivity_:\n plt.plot(\n self.nodes_[c][:,0],\n self.nodes_[c][:,1],\n c=\"grey\",\n lw=2,\n zorder=10,\n )\n\n plt.show()","def __init__(self):\n Page.__init__(self, u\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\")\n\n z = 0.5\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\n\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\n\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\n mesh1.setLinesVisible(True)\n mesh1.setMeshVisible(False)\n mesh1.setBoundingBox(zrange=(-1, 1.5))\n par.setAmbientColor(_1(145, 61, 74))\n par.setDiffuseColor(_1(145, 61, 74))\n par.setSpecularColor(_1(145, 61, 74))\n baseplane = BasePlane()\n baseplane.setHeight(0)\n baseplane.setRange((-2, 2, 7))\n\n self.addChild(par)\n self.addChild(mesh1)\n self.addChild(baseplane)","def plot_plasma(self):\n x = self.geom.x\n fig, axes = plt.subplots(1, 2, figsize=(8, 3),\n constrained_layout=True)\n # plot densities\n ax = axes[0]\n ax.plot(x, self.ne, 'b-')\n ax.plot(x, self.ni, 'r-')\n ax.legend(['E', 'Ion'])\n ax.set_xlabel('Position (m)')\n ax.set_ylabel('Density (m^-3)')\n # plot temperature\n ax = axes[1]\n ax.plot(x, self.Te, 'b-')\n ax.plot(x, self.Ti, 'r-')\n ax.legend(['Te', 'Ti'])\n ax.set_xlabel('Position (m)')\n ax.set_ylabel('Temperature (eV)')\n plt.show()","def visualize(self):\n colors = {'outline': (220, 220, 220),\n 'inlier': (0, 255, 0),\n 'outlier': (0, 0, 255),\n 'lines': (128, 220, 128)}\n # Create output image for visualization\n gap = 5\n h1, w1 = self.target.image.shape[:2]\n h2, w2 = self.image.shape[:2]\n vis = np.zeros((max(h1, h2), w1 + w2 + gap, 3), np.uint8)\n vis[:h1, :w1, :] = self.target.image\n w1 += gap\n vis[:h2, w1:w1+w2, :] = self.image\n \n # Draw the located object \n quad = np.float32(self.quad) + np.float32([w1, 0])\n self.draw(vis, colors['outline'], 2, quad)\n \n # draw point details\n inliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.inliers]\n outliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.outliers]\n if colors['outlier'] is not None: # draw x on each point\n r = 2 # radius\n thickness = 2\n for x0, y0, x1, y1 in outliers:\n cv2.line(vis, (x0 - r, y0 - r), (x0 + r, y0 + r), colors['outlier'], thickness)\n cv2.line(vis, (x0 + r, y0 - r), (x0 - r, y0 + r), colors['outlier'], thickness)\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), colors['outlier'], thickness)\n cv2.line(vis, (x1 + r, y1 - r), (x1 - r, y1 + r), colors['outlier'], thickness)\n if colors['lines'] is not None:\n for x0, y0, x1, y1 in inliers:\n cv2.line(vis, (x0, y0), (x1, y1), colors['lines'], 1)\n if colors['inlier'] is not None:\n for x0, y0, x1, y1 in inliers:\n cv2.circle(vis, (x0, y0), 2, colors['inlier'], -1)\n cv2.circle(vis, (x1, y1), 2, colors['inlier'], -1)\n return vis","def plot_frames(beads, sim, ti, tf, savebase):\n \n ### define the color for the spheres\n\n print 'defining colors'\n sphere_rgbcolor = gen_colors(sim.nbeads)\n\n ### create povray settings\n\n print 'creating povray settings'\n sphere_radius, img_widthpx, img_heightpx, povray_includes, \\\n povray_defaults, sun1, sun2, background, povray_cam, quality \\\n = gen_img_settings_quality(sim.lx)\n \n zi = np.zeros((sim.nbeads))\n \n ### set general plot properties\n\n os.system(\"mkdir -p \" + savebase)\n savebase += 'eps_' + str(sim.eps) + '_fp_' + str(sim.fp) + \\\n '_areak_' + str(sim.areak) + '_kappa_' + str(sim.kappa) + '/'\n os.system(\"mkdir -p \" + savebase)\n \n ### plot the frames\n \n for step in range(ti, tf):\n \n time = step*sim.dt\n print 'Step / Total : ', step, tf\n \n ### create povray items\n \n print 'generating povray item'\n particles = vapory.Object( \\\n vapory.Union( \\\n *[ vapory.Sphere([beads.xi[step, 0, j], beads.xi[step, 1, j],zi[j]], \\\n sphere_radius, vapory.Texture( \\\n vapory.Pigment('color', sphere_rgbcolor[j]), \\\n vapory.Finish('phong',1)) ) for j in range(0, sim.nbeads ) ] ) )\n\n ### generate povray objects\n\n print 'generating povray objects'\n povray_objects = [sun1, sun2, background, particles]\n ### create the scene\n scene = vapory.Scene( camera = povray_cam,\n objects = povray_objects, \n included = povray_includes, \n defaults = povray_defaults )\n \n ### render image\n \n print 'rendering scene'\n savename = \"pov-frame-\" + \"{0:05d}\".format(int(step)) + \".png\"\n scene.render(outfile=savename, width=img_widthpx, height=img_heightpx, \\\n antialiasing=0.001, quality=quality, remove_temp=True)\n \n ### move the image to the correct destination\n \n os.system('mv ' + savename + ' ' + savebase)\n \n return","def plot_projection(self, normal=(1, 1, 1), index_row=0, index_col=0, show=True, texture=None, cmap=\"jet\", f=None,\n plotter=None, title='', font_size=10, font_color='black'):\n if not plotter:\n plotter = pv.Plotter()\n plotter.subplot(index_column=index_col, index_row=index_row)\n\n plotter.add_text(title, position=\"upper_edge\", font_size=font_size, color=font_color)\n tex = None\n if texture:\n\n if isinstance(texture, np.ndarray):\n tex = pv.numpy_to_texture(texture)\n else:\n tex = pv.read_texture(texture)\n self.pv_mesh.texture_map_to_plane(inplace=True)\n # plotter.add_mesh(pv_mesh, texture=tex)\n\n og = self.pv_mesh.center\n projected = self.pv_mesh.project_points_to_plane(origin=og, normal=normal)\n projected.texture_map_to_plane()\n plotter.add_mesh(projected, texture=tex)\n if show:\n plotter.show()\n return plotter","def draw(self):\n pt = self.getPoint() # Centre of prism\n\n # Form top,left,right corners\n top = Vector2d(pt.z, pt.y + self.height/2)\n d = self.height*math.tan(self.angle/2)\n left = Vector2d(pt.z - d , pt.y - self.height/2)\n right = Vector2d(pt.z + d, pt.y - self.height/2)\n\n\n top.rotate(self.tilt)\n left.rotate(self.tilt)\n right.rotate(self.tilt)\n\n # Plot them out with plt.plot\n plot([top[0],left[0],right[0],top[0]],[top[1],left[1],right[1],top[1]],\"k\",lw=2.0)","def render(pictures):\n # Display the background\n display.fill(BLACK)\n\n # Draw each picture\n i = 0 # Number of pictures drawn\n for picture in pictures:\n offsets = get_offsets(i)\n\n for polygon in picture.polygons:\n # Adjust vertices so pictures aren't overlapping\n adjusted_vertices = []\n\n for v in polygon.vertices:\n adjusted_vertices.append((v[0] + offsets[0], v[1] + offsets[1]))\n pygame.draw.polygon(display, polygon.color, adjusted_vertices)\n\n i += 1\n\n pygame.display.update()","def show(self):\n from matplotlib import pyplot as plt\n from mpl_toolkits.mplot3d import Axes3D\n\n fig = plt.figure()\n ax = Axes3D(fig)\n pos = self.cluster.get_positions()\n from itertools import combinations\n for tri in self.mesh.simplices:\n for comb in combinations(tri, 2):\n x1 = pos[comb[0], 0]\n x2 = pos[comb[1], 0]\n y1 = pos[comb[0], 1]\n y2 = pos[comb[1], 1]\n z1 = pos[comb[0], 2]\n z2 = pos[comb[1], 2]\n ax.plot([x1, x2], [y1, y2], zs=[z1, z2], color=\"black\")\n plt.show()","def plot(self, X, sids, nids):\n X = tocontig(X) # ensure it's contig\n gw = self.glWidget\n gw.points = X\n gw.npoints = len(X)\n gw.sids = sids\n gw.nids = nids\n gw.color() # set colors\n gw.updateGL()","def plot(self, X, sids, nids):\n X = tocontig(X) # ensure it's contig\n gw = self.glWidget\n gw.points = X\n gw.npoints = len(X)\n gw.sids = sids\n gw.nids = nids\n gw.color() # set colors\n gw.updateGL()","def __init__(self, **kwargs):\n super().__init__(**kwargs)\n self.__iteration_number = kwargs['iteration_number']\n self.__particles = [\n PSOParticle(**kwargs, bit_generator=self._random)\n for _ in range(kwargs['particles'])\n ]\n\n # The library stores particles in the visualizer .... groan\n positions = [particle.position for particle in self.__particles]\n self._visualizer = NoVisualizer(**kwargs)\n self._visualizer.add_data(positions=positions)","def draw(self):\n\t\tif self.image != None:\n\t\t\treturn\n\n\t\tself.image = Image.new(\"RGBA\", \n\t\t\t(self.__class__._width, self.__class__._height), (0,0,0,0))\n\t\tdr = aggdraw.Draw(self.image)\n\n\t\tzIndexList = [] # list of z-indexes\n\t\tgIndexList = [] # list of gene indexes\n\n\t\tgeneIdx = 0\n\t\tfor gene in self.chromosome: \n\t\t\tzIndexList.append(gene[0])\n\t\t\tgIndexList.append(geneIdx)\n\t\t\tgeneIdx+=1\n\n\t\twhile len(zIndexList) > 0:\n\t\t\tzIndexMin = zIndexList.index(min(zIndexList))\n\t\t\tgeneIdx = gIndexList[zIndexMin]\n\t\t\tz = self.chromosome[geneIdx,0]\n\t\t\tcolor = self.chromosome[geneIdx,1]\n\t\t\tpoly = self.chromosome[geneIdx,2]\n\n\t\t\tcol = color.getColor()\n\t\t\tcords = poly.getCords()\n\t\t\tbrush = aggdraw.Brush(col)\n\n\t\t\t#dr.ellipse((x, y, x+rad, y+rad), None, brush)\n\t\t\tdr.polygon(cords, None, brush)\n\t\t\tdr.flush()\n\n\t\t\tif 0: # Debug - draw dot in center of polygon\n\t\t\t\tcenter = (poly.xAnchor, poly.yAnchor, poly.xAnchor+5, poly.yAnchor+5)\n\t\t\t\tdr.ellipse(center, None, aggdraw.Brush((255,0,0,255)))\n\t\t\t\tdr.flush()\n\n\t\t\tzIndexList.pop(zIndexMin)\n\t\t\tgIndexList.pop(zIndexMin)\n\n\t\tself.image = self.image.convert(\"RGB\")","def plot_all(self) -> None:\n self.__plot_si_cf_plane()\n self.__plot_convex_hull()\n self.__plot_fixed_radius()\n self.__plot_delaunay()","def showAsPoints(self): \n MonkeyPatchMayaVi()\n #import enthought.mayavi.mlab as mlab\n from mayavi import mlab\n \n @mlab.show\n def _showSimple():\n morphPts = [ SVVisitorFactory.Array4AllPoints(morph)() for morph in self.morphs ]\n pts = numpy.concatenate( morphPts)\n return mlab.points3d(pts[:, 0], pts[:, 1], pts[:, 2], pts[:, 3], colormap=self.colormap, scale_factor=self.scale_factor)\n _showSimple()","def draw_pyramid(self):\n for item in self.subdivision_list:\n glBegin(GL_POLYGON)\n glColor3f(0.5, 0.5, 0.5)\n glVertex3f(item[0].x, item[0].y, item[0].z)\n glVertex3f(item[1].x, item[1].y, item[1].z)\n glVertex3f(item[2].x, item[2].y, item[2].z)\n glEnd()","def get_plot(sample):\n scale = (CANVAS_DIM/PATCH_DIM)\n ego_pose = sample[0]\n map_mask = sample[2]\n\n fig, ax = plt.subplots()\n ax.set_ylim([0, CANVAS_DIM]) # set the bounds to be 10, 10\n ax.set_xlim([0, CANVAS_DIM])\n ax.imshow(map_mask[0])\n\n for vehicle in sample[1]:\n plot_vehicle(ax, vehicle, ego_pose, scale)\n\n plt.show()","def render_point_cloud(frame_id):\n point_cloud_world_coordinates = get_point_cloud_world_coordinates(frame_id)\n # pptk\n v = pptk.viewer(point_cloud_world_coordinates)\n v.set(point_size=0.0001)\n v.color_map('cool', scale=[0, 5])","def plot(self):\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection=Axes3D.name)\n\n # TODO Use numpy to rotate esp_points matrix for faster variable access.\n ax.scatter(\n xs=[i[0][0] for i in self.esp_points],\n ys=[i[0][1] for i in self.esp_points],\n zs=[i[0][2] for i in self.esp_points],\n c=[i[1] for i in self.esp_points],\n marker='o',\n s=2,\n alpha=0.5\n )\n\n ax.scatter(\n xs=[i[0][0] for i in self.atom_points],\n ys=[i[0][1] for i in self.atom_points],\n zs=[i[0][2] for i in self.atom_points],\n c=[i[1] for i in self.atom_points],\n marker='X',\n s=100\n )\n\n plt.show()","def plot_surface(self):\n X, Y = np.meshgrid(self.x, self.y)\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n ax.plot_surface(X=X, Y=Y, Z=self.z)\n plt.show()","def visualize(simulator):\n from matplotlib import animation\n import matplotlib.pyplot as plt\n\n X = [particle.x for particle in simulator.particles]\n Y = [particle.y for particle in simulator.particles]\n\n fig = plt.figure()\n ax = plt.subplot(111, aspect=\"equal\")\n line, = ax.plot(X, Y, \"ro\")\n\n # Axial limits\n plt.xlim(-1, 1)\n plt.ylim(-1, 1)\n\n def _init():\n \"\"\"\n Custom initializer closure for visualizer function.\n\n PARAMS: N/A\n RETURN: {line}, : Single subplot object. \n \"\"\"\n line.set_data([], [])\n return line, \n\n def _animate(foo):\n \"\"\"\n Helper closure for animating particle simulator using MatPlotLib's PyPlot library. \n\n PARAMS: N/A\n RETURN: {line}, : Single subplot object with updated particle data.\n \"\"\"\n simulator.evolve(0.01)\n X = [particle.x for particle in simulator.particles]\n Y = [particle.y for particle in simulator.particles]\n\n line.set_data(X, Y)\n return line,\n\n anim = animation.FuncAnimation(fig, _animate, init_func=_init, blit=True, interval=10)\n plt.show()","def visualize(self):\n import matplotlib.pyplot as plt\n import numpy as np\n\n plt.figure()\n sw_ = np.linspace(0.0, 1.0, 50)\n plt.plot(sw_, self.krw(sw_), label=\"Water\")\n plt.plot(sw_, self.kro(sw_), label=\"Oil\")\n plt.xlabel(\"Water saturation\")\n plt.ylabel(\"Relative permeability\")\n plt.legend()","def _plot_sr_surface(self, varname):\n\n fig = plt.figure()\n varname = self.layer_lookup[varname]\n data = self.node_data[varname]\n x_node_loc = np.arange(self.mins[0], self.maxs[0], self.min_grid_size) + self.min_grid_size/2\n y_node_loc = np.arange(self.mins[1], self.maxs[1], self.min_grid_size) + self.min_grid_size/2\n lon2d, lat2d = np.meshgrid(x_node_loc, y_node_loc)\n\n # mask NaN values\n data_m = np.ma.array(data, mask=np.isnan(data))\n plt.pcolormesh(lon2d, lat2d, data_m.T, vmin=data_m.min(), vmax=data_m.max())","def plot3d(self):\n plot_rupture_wire3d(self)","def pontos(self):\n \n self.sc = 1. \n self.x = self.sc*np.array([-155., -139.4, -124., -108.5, -93., -77.5, -62., -46.5, -31., -15.5, 0, 15.5, 31., 46.5, 62., 77.5, 93., 108.5, 124., 139.5, 155.])\n self.y = self.sc*np.array([ 9.23, 14.37, 18.98, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 21.55, 14.37, 3.59])\n self.px_index = len(self.x)\n #self.py_index = len(self.x)/2\n\n self.coord = np.array([self.x,self.y,np.full(len(self.x),self.z)])\n \n self.x = self.x[::-1]\n self.y = -self.y[::-1] \n self.new = np.array([self.x,self.y,np.full(len(self.x),self.z)])\n self.coord = np.array([np.append(self.coord[0],self.new[0]),np.append(self.coord[1],self.new[1]),np.append(self.coord[2],self.new[2])])\n self.coord = np.array([np.append(self.coord[0],self.coord[0,0]),np.append(self.coord[1],self.coord[1,0]),np.append(self.coord[2],self.coord[2,0])])\n\n self.coord[0] = self.coord[0] - (np.amax(self.coord[0])+np.amin(self.coord[0]))/2\n self.coord[1] = self.coord[1] + (np.amax(self.coord[1])-np.amin(self.coord[1]))/2 \n \n self.coordi = np.array(self.coord)\n \n self.cg = np.array([0 + self.dx, self.H/2 + self.dy, self.z]) \n self.cgi = np.array(self.cg)\n \n self.thi = 0. + self.dth \n self.th = float(self.thi) \n \n self.coordnav(self.dx,self.dy,self.dth)","def plotsite(self):\n if self.dimension==1 or self.dimension==2:\n for site in self.sites.flatten():\n plt.scatter(site.coordinate[0],site.coordinate[1],marker=site.marker,s=site.markersize,c=site.color)\n elif self.dimension==3:\n from mpl_toolkits.mplot3d import Axes3D\n fig = plt.figure()\n ax = Axes3D(fig)\n for site in self.sites.flatten():\n ax.scatter(site.coordinate[0],site.coordinate[1],site.coordinate[2],marker=site.marker,s=site.markersize,c=site.color)","def visualise(self) -> None:\n nx_graph = nx.DiGraph()\n\n for v in self._vertices:\n if not v.predicate:\n name = v.name.split(\"/\")[-1]\n nx_graph.add_node(name, name=name, pred=v.predicate)\n\n for v in self._vertices:\n if not v.predicate:\n v_name = v.name.split(\"/\")[-1]\n # Neighbors are predicates\n for pred in self.get_neighbors(v):\n pred_name = pred.name.split(\"/\")[-1]\n for obj in self.get_neighbors(pred):\n obj_name = obj.name.split(\"/\")[-1]\n nx_graph.add_edge(v_name, obj_name, name=pred_name)\n\n plt.figure(figsize=(10, 10))\n _pos = nx.circular_layout(nx_graph)\n nx.draw_networkx_nodes(nx_graph, pos=_pos)\n nx.draw_networkx_edges(nx_graph, pos=_pos)\n nx.draw_networkx_labels(nx_graph, pos=_pos)\n names = nx.get_edge_attributes(nx_graph, \"name\")\n nx.draw_networkx_edge_labels(nx_graph, pos=_pos, edge_labels=names)","def render(self):\n\n theta = self.angle*math.pi/180.0\n cth = math.cos(theta)\n sth = math.sin(theta)\n pts = []\n cornerpts = []\n\n for vertex in self.points:\n x = vertex[0] + self.pos[0] - self.anchor[0]\n y = vertex[1] + self.pos[1] - self.anchor[1]\n\n xt = x * cth - y * sth\n yt = x * sth + y * cth\n\n x = xt + self.anchor[0]\n y = yt + self.anchor[1]\n\n cornerpts.append([x,y])\n pts.append(gr.Point(self.scale * x, self.win.getHeight() - self.scale*y))\n\n self.corners = cornerpts\n self.vis = [gr.Polygon(pts)]","def _plot_map(self):\n\n # Plot points if they exist\n\n if len(self._laserX) > 0:\n self._plot_laser()\n\n if len(self._goalX) > 0:\n self._plot_goal()\n\n if len(self._summitX) > 0:\n self._plot_summit()\n\n self._plot_objects()\n\n # Update Plot\n self._fig.canvas.draw_idle()\n\n plt.pause(0.01)","def open3dpaint(nppoints, color_map = 'jet', reduce_for_vis = False, voxel_size = 0.1, pointsize = 0.1):\n assert (type(nppoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(nppoints) == pclpy.pcl.PointCloud.PointXYZ) or (type(nppoints) == np.ndarray) or (type(nppoints) is list) or (type(nppoints) is tuple), 'Not valid point_cloud'\n \n if (type(nppoints) is not list) & (type(nppoints) is not tuple):\n nppoints = [nppoints]\n try:\n visualizer = open3d.visualization.Visualizer()\n visualizer.create_window()\n options = visualizer.get_render_option()\n options.background_color = np.asarray([0, 0, 0])\n options.point_size = pointsize\n\n if len(nppoints) > 1:\n for n,i in enumerate(nppoints):\n workpoints = i\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\n workpoints = workpoints.xyz\n\n if reduce_for_vis:\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\n\n points = convertcloud(workpoints)\n color_coef = n/len(nppoints)/2 + n%2*.5\n if type(color_map) == np.ndarray:\n color = color_map\n elif color_map == 'jet':\n color=cm.jet(color_coef)[:3]\n else:\n color=cm.Set1(color_coef)[:3]\n points.colors = open3d.utility.Vector3dVector(np.ones_like(workpoints)*color)\n #points.colors = open3d.utility.Vector3dVector(color)\n visualizer.add_geometry(points)\n else:\n workpoints = nppoints[0]\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\n workpoints = workpoints.xyz\n \n if reduce_for_vis:\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\n points = convertcloud(workpoints)\n visualizer.add_geometry(points)\n visualizer.run()\n visualizer.destroy_window()\n \n except Exception as e:\n print(type(e))\n print(e.args)\n print(e)\n visualizer.destroy_window()","def render(self):\n canvas_id = 'zdog_{}'.format(self.CANVAS_INDEX)\n illo_id = 'illo_{}'.format(self.CANVAS_INDEX)\n Scene.CANVAS_INDEX += 1\n\n html_lines = []\n\n js_lines = []\n\n euler = -rowan.to_euler(\n self.rotation, convention='xyz', axis_type='intrinsic')\n translation = self.translation*(1, -1, 1)\n\n pan_cfg = self.get_feature_config('pan')\n pan = pan_cfg.get('value', True) if pan_cfg is not None else False\n\n js_lines.append(\"\"\"\n let {illo_id} = new Zdog.Illustration({{\n element: '#{canvas_id}',\n zoom: {zoom},\n dragRotate: {rotation_enabled},\n rotate: {{x: {angle[0]}, y: {angle[1]}, z: {angle[2]}}},\n translate: {{x: {pos[0]}, y: {pos[1]}, z: {pos[2]}}},\n }});\n \"\"\".format(\n illo_id=illo_id, canvas_id=canvas_id, zoom=self.zoom*self.pixel_scale,\n angle=euler, pos=translation,\n rotation_enabled=('false' if pan else 'true')))\n\n config = self.get_feature_config('ambient_light')\n ambient_light = 0 if config is None else config.get('value', .4)\n\n config = self.get_feature_config('directional_light')\n directional_light = ([(0, 0, 0)] if config is None else\n config.get('value', [(0, 0, 0)]))\n directional_light = np.atleast_2d(directional_light)\n\n shapeIndex = 0\n for i, prim in enumerate(self._primitives):\n js_lines.extend(prim.render(\n rotation=self.rotation, illo_id=illo_id,\n name_suffix=i, ambient_light=ambient_light,\n directional_light=directional_light))\n\n (width, height) = map(int, self.size_pixels)\n html_lines.append(\"\"\"\n <canvas id=\"{canvas_id}\" width=\"{width}\" height=\"{height}\"></canvas>\n \"\"\".format(canvas_id=canvas_id, width=width, height=height))\n\n html_lines.append(\"\"\"<script>\n var fill_{canvas_id} = function() {{\n \"\"\".format(canvas_id=canvas_id))\n html_lines.append(LOCAL_HELPER_SCRIPT)\n html_lines.extend(js_lines)\n\n pan_snippet = \"\"\"\n new Zdog.Dragger({{\n startElement: {illo_id}.element,\n onDragStart: function( pointer, moveX, moveY) {{\n this.lastX = 0;\n this.lastY = 0;\n }},\n onDragMove: function( pointer, moveX, moveY ) {{\n let deltax = moveX - this.lastX;\n let deltay = moveY - this.lastY;\n let scale = 1.0/{illo_id}.zoom;\n {illo_id}.translate.x += deltax*scale;\n {illo_id}.translate.y += deltay*scale;\n this.lastX = moveX;\n this.lastY = moveY;\n }}\n }});\"\"\".format(illo_id=illo_id)\n if pan:\n html_lines.append(pan_snippet)\n\n html_lines.append(\"\"\"\n let this_canvas = document.querySelector(\"#{canvas_id}\");\n \"\"\".format(canvas_id=canvas_id))\n html_lines.append(\"\"\"\n let animate_{canvas_id} = function() {{\n if(is_in_view(this_canvas))\n {{\n {illo_id}.updateRenderGraph();\n }}\n if(document.contains(this_canvas))\n {{\n requestAnimationFrame(animate_{canvas_id});\n }}\n }};\n animate_{canvas_id}();\"\"\".format(canvas_id=canvas_id, illo_id=illo_id))\n # remove the global reference to this function after using it\n html_lines.append('fill_{canvas_id} = null;'.format(canvas_id=canvas_id))\n html_lines.append('};') # end of fill_{canvas_id}\n # now call fill_{canvas_id}, possibly after loading zdog\n html_lines.append(\"\"\"\n if (typeof Zdog == 'undefined')\n {{\n var script = document.createElement('script');\n script.addEventListener('load', fill_{canvas_id}, false);\n script.src = 'https://unpkg.com/zdog@1/dist/zdog.dist.min.js';\n document.getElementsByTagName('head')[0].appendChild(script);\n }}\n else\n fill_{canvas_id}();\n \"\"\".format(canvas_id=canvas_id))\n html_lines.append('</script>')\n\n return '\\n'.join(html_lines)","def render(self, mode = 'human'):\n if mode == 'human':\n\n if self.is_2d:\n fig = plt.figure()\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n plt.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n plt.scatter(*index, c='blue', s=1000, alpha=0.2)\n plt.xlim(-1, self.dim[0])\n plt.ylim(-1, self.dim[1])\n plt.xticks([])\n plt.yticks([])\n plt.grid(True)\n\n if self.is_3d:\n fig = plt.figure()\n ax = Axes3D(fig)\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\n ax.set_xlim(0, self.dim[0] - 1)\n ax.set_ylim(0, self.dim[1] - 1)\n ax.set_zlim(0, self.dim[2] - 1)\n\n else:\n fig = plt.figure()\n ax = Axes3D(fig)\n for index, value in np.ndenumerate(self.board):\n if value == 1:\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\n elif value == -1:\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\n\n ax.set_xlim(0, self.dim[0] - 1)\n ax.set_ylim(0, self.dim[1] - 1)\n ax.set_zlim(0, self.dim[2] - 1)\n ax.set_title('Nr of steps: ' + str(self.steps))\n\n plt.show()\n return fig","def plot_tomo_vel(self, period=6., projection='lambert',geopolygons=None, showfig=True, vmin=None, vmax=None, sta=True, hillshade=False):\n\t\tif hillshade:\n\t\t\talpha = 0.5\n\t\telse:\n\t\t\talpha =1.\n\t\tm = self._get_basemap(projection=projection, geopolygons=geopolygons,hillshade=hillshade)\n\t\tgroup = self['%g_sec'%( period )]\n\t\tx, y = m(group['lonArr'].value, group['latArr'].value)\n\t\tmy_cmap = pycpt.load.gmtColormap('./cv.cpt')\n\t\ttomo_data = group['tomo_data'].value\n\t\ttomo_data_msk = group['tomo_data_msk'].value\n\t\tif vmin == None:\n\t\t\tvmin = np.nanmin(tomo_data[~tomo_data_msk])\n\t\t\tvmin = np.ceil(vmin*20.)/20.\n\t\tif vmax == None:\n\t\t\tvmax = np.nanmax(tomo_data[~tomo_data_msk])\n\t\t\tvmax = np.floor(vmax*20.)/20.\n\t\tim = m.pcolormesh(x, y, np.ma.masked_array(tomo_data,mask=tomo_data_msk), cmap=my_cmap, shading='gouraud', vmin=vmin, vmax=vmax, alpha=alpha)\n\t\tcb = m.colorbar(im, \"bottom\", size=\"3%\", pad='2%', format='%.2f')\n\t\tcb.set_label('vel (km/s)', fontsize=12, rotation=0)\n\t\tcb.set_alpha(1)\n\t\tcb.draw_all()\n\t\tax = plt.gca() # only plot the oceanic part for JdF\n\t\t#x_cobb,y_cobb = m(-130.0000,46.0000) #cobb hotspot\n\t\t#ax.plot(x_cobb,y_cobb,'o', color='white',alpha=.6,ms=8,mec='white')\n\t\tif sta:\n\t\t\tself.sta_on_plot(ax,m,period)\n\t\t# ax.set_xlim(right=x_max)\n\t\tfig = plt.gcf()\n\t\tfig.suptitle(str(period)+' sec', fontsize=14,y=0.95)\n\t\tif showfig:\n\t\t\tplt.show()\n\t\treturn m","def plot_root(self, root):\n vessel = Marker()\n #visualizations points and lines..\n vessel.header.frame_id = \"map\"\n vessel.header.stamp = rospy.get_rostime()\n vessel.ns = \"markers\"\n vessel.id = 1\n vessel.type = vessel.ARROW\n vessel.action = vessel.ADD\n \n vessel.scale.x = 10*self.rviz_tuning_plt\n vessel.scale.y = 2*self.rviz_tuning_plt\n vessel.scale.z = 2*self.rviz_tuning_plt\n vessel.color.r = 0.0\n vessel.color.g = 0.0\n vessel.color.b = 1.0\n vessel.color.a = 1.0\n # A value of ros.Duration() means never to auto-delete.\n vessel.lifetime = rospy.Duration()\n # Add x,y,z position to pose\n vessel.pose.position.x = root.x\n vessel.pose.position.y = root.y\n vessel.pose.position.z = 0\n # add quaternion to pose\n quat = self.euler_to_quaternion(0, 0, root.alpha)\n vessel.pose.orientation.x = quat[0]\n vessel.pose.orientation.y = quat[1]\n vessel.pose.orientation.z = quat[2]\n vessel.pose.orientation.w = quat[3]\n self.pub_root.publish(vessel)","def __init__(self, particles):\n self.particles = particles","def drawScene(self):\n glBegin(GL_LINES)\n # draw axes\n glColor3f(1, 0, 0)\n glVertex3f(0, 0, 0)\n glVertex3f(self.worldSize / 2, 0, 0)\n glColor3f(0, 1, 0)\n glVertex3f(0, 0, 0)\n glVertex3f(0, self.worldSize / 2, 0)\n glColor3f(0, 0, 1)\n glVertex3f(0, 0, 0)\n glVertex3f(0, 0, self.worldSize / 2)\n # draw bounding box\n glColor3f(1, 1, 1)\n scalar = (self.worldSize - 1) / 2\n for x in [-1, 1]:\n for y in [-1, 1]:\n for z in [-1, 1]:\n glVertex3f(scalar * x, scalar * y, scalar * z)\n for z in [-1, 1]:\n for x in [-1, 1]:\n for y in [-1, 1]:\n glVertex3f(scalar * x, scalar * y, scalar * z)\n for y in [-1, 1]:\n for z in [-1, 1]:\n for x in [-1, 1]:\n glVertex3f(scalar * x, scalar * y, scalar * z)\n glEnd()\n # draw spheres if in POINTS mode\n if self.displayMode is self.DISPLAYMODE_POINTS:\n prev = (0, 0, 0)\n offset = int(self.worldSize / 2)\n for x in range(self.worldSize):\n for y in range(self.worldSize):\n for z in range(self.worldSize):\n glTranslatef(x - offset - prev[0], y - offset - prev[1], z - offset - prev[2])\n # use threshold for black/white coloring\n if self.world[x][y][z] > self.worldThreshold:\n glColor3f(1, 1, 1)\n else:\n glColor3f(0, 0, 0)\n gluSphere(self.sphere, 0.1, 8, 4)\n prev = (x - offset, y - offset, z - offset)\n # draw mesh if in MESH mode\n elif self.displayMode is self.DISPLAYMODE_MESH:\n offset = int(self.worldSize / 2)\n for x in range(self.worldSize - 1):\n for y in range(self.worldSize - 1):\n for z in range(self.worldSize - 1):\n if self.polygons[x][y][z]:\n glBegin(GL_POLYGON)\n glColor3f(x / self.worldSize, y / self.worldSize, z / self.worldSize)\n for vertex in self.polygons[x][y][z]:\n glVertex3f(x + vertex[0] - offset, y + vertex[1] - offset, z + vertex[2] - offset)\n glEnd()\n # draw wireframe in in WIRE mode\n elif self.displayMode is self.DISPLAYMODE_WIREFRAME:\n offset = int(self.worldSize / 2)\n for x in range(self.worldSize - 1):\n for y in range(self.worldSize - 1):\n for z in range(self.worldSize - 1):\n glBegin(GL_LINES)\n glColor3f(x / self.worldSize, y / self.worldSize, z / self.worldSize)\n for vertex in self.polygons[x][y][z]:\n glVertex3f(x + vertex[0] - offset, y + vertex[1] - offset, z + vertex[2] - offset)\n glEnd()\n # draw background in the distance\n glLoadIdentity()\n glBegin(GL_QUADS)\n glColor3f(59 / 256, 102 / 256, 212 / 256)\n glVertex3f(-30, -23, -49.5)\n glVertex3f(30, -23, -49.5)\n glColor3f(184 / 256, 201 / 256, 242 / 256)\n glVertex3f(30, 23, -49.5)\n glVertex3f(-30, 23, -49.5)\n glEnd()\n # HUD in white\n glColor3f(1, 1, 1)\n # lower left\n glWindowPos2f(10, 10)\n for ch in 'WASD: Rotate':\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\n glWindowPos2f(10, 25)\n for ch in 'Wheel: Thresh':\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\n glWindowPos2f(10, 40)\n for ch in 'R: Randomize':\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\n glWindowPos2f(10, 55)\n for ch in 'O: Object':\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\n glWindowPos2f(10, 70)\n for ch in 'I: Wireframe':\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\n glWindowPos2f(10, 85)\n for ch in 'P: Points':\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\n # upper right\n glWindowPos2f(self.displaySize[0] - 118, self.displaySize[1] - 25)\n for ch in 'Thresh: %0.2f' % self.worldThreshold:\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))","def plot(self):\n pass","def render(self):\n self.axial.Render()\n self.coronal.Render()\n self.sagittal.Render()\n #self.isosurface.Render()\n #self.rwi_pcp.Render()","def plotFeatures(self):\n fl=np.array(self.xp)*0.0+0.25*self.farr.max()\n self.splines=self.axes.plot(self.xp, fl , ls='', marker='|', ms=20, color='#00FF00')\n #set up the text position\n tsize=0.83\n self.ymin, self.ymax = self.axes.get_ylim()\n ppp=(self.ymax-self.ymin)/(self.arcfigure.figure.get_figheight()*self.arcfigure.figure.get_dpi())\n f=self.ymax-10*tsize*ppp\n for x,w in zip(self.xp, self.wp):\n w='%6.2f' % float(w)\n self.axes.text(x, f, w, size='small', rotation='vertical', color='#00FF00')","def plotVoronoiCell(self, cells):\n for i in cells:\n #i indexes volumes\n i = self.nonBI[i] #now i indexes vor.point_region\n\n vI = self.vor.regions[self.vor.point_region[i]]\n v = self.vor.vertices[vI, :]\n r = v\n\n fig = plt.figure()\n ax = fig.add_subplot(111, projection='3d')\n fig.set_size_inches(18.5, 9.5)\n ax.set_title('Voronoi Cell of Particle ' + str(i))\n ax.set_xlabel('x [m]')\n ax.set_ylabel('y [m]')\n ax.set_zlabel('z [m]')\n ax.scatter(r[:, 0], r[:, 1], r[:, 2], s=5, alpha=0.5, label='Cell Boundaries')\n ax.scatter(self.data[i, 0], self.data[i, 1], self.data[i, 2], s=25, label='Cell Center')\n ax.set_xlim3d(np.min(self.data[:, 0]), np.max(self.data[:, 0]))\n ax.set_ylim3d(np.min(self.data[:, 1]), np.max(self.data[:, 1]))\n ax.set_zlim3d(np.min(self.data[:, 2]), np.max(self.data[:, 2]))\n # limits = np.vstack((np.array([np.max(self.data[:, 0]), np.max(self.data[:, 1]), np.max(self.data[:, 2])]), np.array([np.min(self.data[:, 0]), np.min(self.data[:, 1]), np.min(self.data[:, 2])])))\n # ax.scatter(limits[:, 0], limits[:, 1], limits[:, 2], s=1)\n ax.legend()","def show():\n setup()\n plt.show()","def draw(self):\n #for (x, y) in self.coords:\n # pyxel.rect(\n # (x + self.x) * 4,\n # (y + self.y) * 4,\n # (x + self.x) * 4 + 3,\n # (y + self.y) * 4 + 3,\n # self.color)","def plot_3d_object(object_):\n \n # Initialize renderer instance\n r = Renderer()\n\n # Add surfaces and goal regions to the renderer instance\n for surf in object_:\n r.add((object_[surf][0],'b',1))\n if len(object_[surf])>2:\n r.add((object_[surf][2],'r',1))\n r.add((gPoint(-15,-15,-15),'k',1))\n r.show()","def visualisation(self):\n plt.plot(self.x, self.y, 'o', label = 'Example data')\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\n plt.xlim([-1,1])\n plt.ylim([-1,1])","def generatePolygons(self, *args, **kwargs): \n return 'var PloneMapPolygons = [' + \\\n ''.join([\"{ 'id': '%s', 'path' : %s,'title':'%s'},\" % (object.id, object.polygon, object.Title()) \n for object in self.context.objectValues() \n if hasattr(object, 'polygon') and len(object.polygon) > 0 ])[:-1] \\\n + '];'","def plot_vertices(self, f=None, index_row=0, index_col=0, show=True, plotter=None, cmap='jet', title='',\n title_location=\"upper_edge\", font_size=10, font_color='black', camera=None):\n\n if not plotter:\n plotter = pv.Plotter()\n plotter.subplot(index_column=index_col, index_row=index_row)\n plotter.add_text(title, position=title_location, font_size=font_size, color=font_color)\n if camera is not None:\n plotter.set_position(camera[0])\n plotter.set_focus(camera[1])\n plotter.set_viewup(camera[2])\n plotter.add_mesh(self.vertices, scalars=f, cmap=cmap, render_points_as_spheres=True)\n if show:\n plotter.show()\n return plotter","def plot_vor_colored(self,x,ax,cmap):\n\n L = self.L\n grid_x, grid_y = np.mgrid[-1:2, -1:2]\n grid_x[0, 0], grid_x[1, 1] = grid_x[1, 1], grid_x[0, 0]\n grid_y[0, 0], grid_y[1, 1] = grid_y[1, 1], grid_y[0, 0]\n y = np.vstack([x + np.array([i * L, j * L]) for i, j in np.array([grid_x.ravel(), grid_y.ravel()]).T])\n\n cmap_print = np.tile(cmap.T,9).T\n bleed = 0.1\n cmap_print = cmap_print[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\n y = y[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(y))\n\n\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\n if type(self.c_types) is list:\n # ax.scatter(x[:, 0], x[:, 1],color=\"grey\",zorder=1000)\n for region in regions:\n polygon = vertices[region]\n plt.fill(*zip(*polygon), alpha=0.4, color=\"grey\")\n\n else:\n patches = []\n for i, region in enumerate(regions):\n patches.append(Polygon(vertices[region], True,facecolor=cmap_print[i],edgecolor=\"white\",alpha=0.5))\n\n p = PatchCollection(patches, match_original=True)\n # p.set_array(c_types_print)\n ax.add_collection(p)","def draw( self ):\r\n print \"Drawing cuboid!\"\r\n glTranslated( *self.pos3D ) # This moves the origin of drawing , so that we can use the above coordinates at each draw location\r\n if self.rotnByOGL:\r\n glRotated( self.thetaDeg , *self.rotAxis )\r\n # glTranslated( 0 , 0 , 0 ) # This moves the origin of drawing , so that we can use the above coordinates at each draw location\r\n print \"DEBUG:\" , \"Translated to\" , 0 , 0 , 0\r\n glColor3ub( *self.color ) # Get the color according to the voxel type\r\n print \"DEBUG:\" , \"Set color to\" , self.color\r\n pyglet.graphics.draw_indexed( \r\n 8 , # --------------------- Number of seqential triplet in vertex list\r\n GL_QUADS , # -------------- Draw quadrilaterals\r\n self.indices , # ---------- Indices where the coordinates are stored\r\n ( 'v3f' , self.vertX ) # vertex list , OpenGL offers an optimized vertex list object , but this is not it\r\n ) # 'v3i' # This is for integers I suppose!\r\n \r\n glColor3ub( *self.colorLine )\r\n pyglet.gl.glLineWidth( 3 )\r\n pyglet.graphics.draw_indexed( \r\n 8 , # --------------------- Number of seqential triplet in vertex list\r\n GL_LINES , # -------------- Draw quadrilaterals\r\n self.linDices , # ---------- Indices where the coordinates are stored\r\n ( 'v3f' , self.vertX ) # vertex list , OpenGL offers an optimized vertex list object , but this is not it\r\n ) # 'v3i' # This is for integers I suppose!\r\n \r\n print \"DEBUG:\" , \"Indices\"\r\n print self.indices \r\n print \"DEBUG:\" , \"Vertices\"\r\n print self.vertices \r\n \"\"\" URL: http://pyglet.readthedocs.io/en/pyglet-1.2-maintenance/programming_guide/graphics.html#vertex-lists\r\n \r\n There is a significant overhead in using pyglet.graphics.draw and pyglet.graphics.draw_indexed due to pyglet \r\n interpreting and formatting the vertex data for the video device. Usually the data drawn in each frame (of an animation) \r\n is identical or very similar to the previous frame, so this overhead is unnecessarily repeated.\r\n \r\n A VertexList is a list of vertices and their attributes, stored in an efficient manner that’s suitable for direct \r\n upload to the video card. On newer video cards (supporting OpenGL 1.5 or later) the data is actually stored in video memory.\r\n \"\"\"\r\n if self.rotnByOGL:\r\n glRotated( -self.thetaDeg , *self.rotAxis )\r\n glTranslated( *np.multiply( self.pos3D , -1 ) ) # Reset the transform coordinates\r\n print \"DEBUG:\" , \"Translated to\" , 0 , 0 , 0\r\n print \"Done drawing!\"","def visualizeObs():\n fcontourf(fObs, [-2, 2], [-1, 1], [0, 10])","def plot_vor(self,x,ax,tri=False):\n\n L = self.L\n grid_x, grid_y = np.mgrid[-1:2, -1:2]\n grid_x[0, 0], grid_x[1, 1] = grid_x[1, 1], grid_x[0, 0]\n grid_y[0, 0], grid_y[1, 1] = grid_y[1, 1], grid_y[0, 0]\n y = np.vstack([x + np.array([i * L, j * L]) for i, j in np.array([grid_x.ravel(), grid_y.ravel()]).T])\n\n c_types_print = np.tile(self.c_types,9)\n bleed = 0.1\n c_types_print = c_types_print[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\n y = y[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(y))\n\n\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\n if type(self.c_types) is list:\n # ax.scatter(x[:, 0], x[:, 1],color=\"grey\",zorder=1000)\n for region in regions:\n polygon = vertices[region]\n plt.fill(*zip(*polygon), alpha=0.4, color=\"grey\")\n\n else:\n cols = self.cols\n if self.plot_scatter is True:\n for j,i in enumerate(np.unique(self.c_types)):\n ax.scatter(x[self.c_types==i, 0], x[self.c_types==i, 1],color=cols[i],zorder=1000)\n patches = []\n for i, region in enumerate(regions):\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],ec=(1,1,1,1)))\n\n p = PatchCollection(patches, match_original=True)\n # p.set_array(c_types_print)\n ax.add_collection(p)\n if tri is not False:\n for TRI in tri:\n for j in range(3):\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\n if (a >= 0) and (b >= 0):\n X = np.stack((x[a], x[b])).T\n ax.plot(X[0], X[1], color=\"black\")","def figura(self):\n\n dx=10.6\n dy=11.5\n ###################\n #primero a dibujar#\n ###################\n glBegin(GL_POLYGON)\n glVertex2f(1.0,2*dy)\n glVertex2f(dx,5*dy/2)\n glVertex2f(1.0,45.0)\n glVertex2f(3*dx/2,3*dy)\n glVertex2f(5*dx/2,45.0)\n glVertex2f(7*dx/2,3*dy)\n glVertex2f(52.0,45.0)\n glVertex2f(4*dx,5*dy/2)\n glVertex2f(52.0,2*dy)\n glVertex2f(4*dx,3*dy/2)\n glVertex2f(52.0,1.0)\n glVertex2f(7*dx/2,dy)\n glVertex2f(5*dx/2,1.0)\n glVertex2f(3*dx/2,dy)\n glVertex2f(1.0,1.0)\n glVertex2f(dx,3*dy/2)\n glEnd()\n glColor3f(138.0/255,138.0/255,138.0/255)\n glBegin(GL_TRIANGLES)\n glVertex2f(1.0,1.0)\n glVertex2f(1.0,2*dy)\n glVertex2f(2*dx/3,3*dy/2)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(1.0,2*dy)\n glVertex2f(2*dx/3,5*dy/2)\n glVertex2f(1.0,45.0)\n glEnd()\n ###################\n #segundo a dibujar#\n ###################\n glColor3f(249.0/255,135.0/255,21.0/255)\n glBegin(GL_TRIANGLES)\n glVertex2f(3*dx/2,2*dy)\n glVertex2f(3*dx/2,3*dy)\n glVertex2f(3*dx/2+dx,3*dy)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(3*dx/2+dx,3*dy)\n glVertex2f(7*dx/2,3*dy)\n glVertex2f(7*dx/2,2*dy)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(7*dx/2,2*dy)\n glVertex2f(7*dx/2,dy)\n glVertex2f(5*dx/2,dy)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(5*dx/2,dy)\n glVertex2f(3*dx/2,dy)\n glVertex2f(3*dx/2,2*dy)\n glEnd()\n #segundos triangulos naranjos\n glBegin(GL_TRIANGLES)\n glVertex2f(3*dx/2,5*dy/2)\n glVertex2f(3*dx/2,3*dy/2)\n glVertex2f(dx,2*dy)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(2*dx,3*dy)\n glVertex2f(5*dx/2,7*dy/2)\n glVertex2f(3*dx,3*dy)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(7*dx/2,5*dy/2)\n glVertex2f(4*dx,2*dy)\n glVertex2f(7*dx/2,3*dy/2)\n glEnd()\n glBegin(GL_TRIANGLES)\n glVertex2f(3*dx,dy)\n glVertex2f(5*dx/2,dy/2)\n glVertex2f(2*dx,dy)\n glEnd()\n ##################\n #ultimo a dibujar#\n ##################\n xini=3*dx/2\n yini=2*dy\n glColor3f(0.8,0.0,0.0)\n glBegin(GL_QUADS)\n glVertex2f(xini,yini)\n glVertex2f(xini+dx,yini+dy)\n glVertex2f(xini+2*dx,yini)\n glVertex2f(xini+dx,yini-dy)\n glEnd()","def plot_visual_abstract():\n # Which generations to plot\n GENERATIONS = [100, 230, 350]\n\n # LunarLander CMA-ES\n experiment_path = glob(\"experiments/wann_LunarLander-v2_CMAES*\")\n assert len(experiment_path) == 1, \"There should be only one CMA-ES experiment with LunarLander-v2\"\n experiment_path = experiment_path[0]\n\n pivector_paths = glob(os.path.join(experiment_path, \"pivectors\", \"*\"))\n\n tsnes = []\n rewards = []\n for generation in GENERATIONS:\n # Find pivector files for specific generation, load them and store points\n generation_paths = [path for path in pivector_paths if \"gen_{}_\".format(generation) in path]\n\n population = [np.load(path) for path in generation_paths]\n population_tsnes = np.array([x[\"tsne\"] for x in population])\n population_rewards = np.array([x[\"average_episodic_reward\"] for x in population])\n tsnes.append(population_tsnes)\n rewards.append(population_rewards)\n\n figure, axs = pyplot.subplots(\n figsize=[2.5 * 3, 2.5],\n nrows=1,\n ncols=len(GENERATIONS),\n sharex=\"all\",\n sharey=\"all\"\n )\n\n min_reward = min(x.min() for x in rewards)\n max_reward = max(x.max() for x in rewards)\n scatter = None\n\n for idx in range(len(GENERATIONS)):\n population_tsne = tsnes[idx]\n population_rewards = rewards[idx]\n generation = GENERATIONS[idx]\n ax = axs[idx]\n\n scatter = ax.scatter(\n population_tsne[:, 0],\n population_tsne[:, 1],\n c=population_rewards,\n vmin=min_reward,\n vmax=max_reward,\n cmap=\"plasma\"\n )\n ax.set_title(\"Generation {}\".format(generation))\n ax.set_xticks([])\n ax.set_yticks([])\n ax.axis(\"off\")\n\n # Making room for colorbar\n # Stackoverflow #13784201\n figure.subplots_adjust(right=1.0)\n cbar = figure.colorbar(scatter)\n cbar.set_ticks([])\n cbar.ax.set_ylabel(\"Reward $\\\\rightarrow$\", rotation=90, fontsize=\"large\")\n\n figure.tight_layout()\n figure.savefig(\"figures/visual_abstract.pdf\", bbox_inches=\"tight\", pad_inches=0.05)","def inclass1():\n import numpy as np\n import matplotlib.pyplot as plt\n\n\n N = 50\n x = np.random.rand(N)\n y = np.random.rand(N)\n colors = np.random.rand(N)\n area = np.pi * (15 * np.random.rand(N))**2 # 0 to 15 point radiuses\n\n plt.scatter(x, y, s=area, c=colors, alpha=0.5)\n plt.show()","def scatter_plot(self, speed=0.001):\n FPARTX, FPARTY, FPARTST = self.get_particles_props('x', 'y', 'state')\n plt.clf()\n plt.scatter(FPARTX, FPARTY, FPARTST*5 + 0.01, c=FPARTST, cmap=\"jet\")\n plt.clim(0, 1)\n plt.colorbar()\n plt.pause(speed)","def _plot_objects(self):\n\n # Remove Existing Annotations\n for annotation in self._objectAnnotations:\n annotation.remove()\n self._objectAnnotations[:] = []\n\n # Set Offsets\n self._objectPoints.set_offsets(np.c_[self._objectX, self._objectZ])\n\n # Update Annotations\n for name, x, z in zip(self._objectNames, self._objectX, self._objectZ):\n self._objectAnnotations.append(self._scatPlot.annotate(name, (x, z)))","def generate_plot(self):\r\n\t\tx, y = zip(*[p.p for p in self.universe])\r\n\t\tself.ax.cla()\r\n\t\tself.ax.plot(x, y, '.')\r\n\t\tself.ax.set_title('Universe at time: %d' % self.universe.time)\r\n\t\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\r\n\t\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])","def plotOverlays(self):\n if self.overlayFluxSurfaces:\n self.plotFluxSurfaces()\n if self.overlayMagneticAxis:\n self.plotMagneticAxis()\n if self.overlaySeparatrix:\n self.plotSeparatrix()\n if self.overlayWallCrossSection:\n self.plotWallCrossSection()","def PlotSphere():\n sphere = vtkInterface.PolyData(spherefile)\n sphere.Plot()","def update_particles(self):\n for particle in self.particles:\n particle.update_coordinates(self.bounds)","def show(self, with_particles=True, show_time=None, field=None, domain=None, projection=None,\n land=True, vmin=None, vmax=None, savefile=None, animation=False, **kwargs):\n from parcels.plotting import plotparticles\n plotparticles(particles=self, with_particles=with_particles, show_time=show_time, field=field, domain=domain,\n projection=projection, land=land, vmin=vmin, vmax=vmax, savefile=savefile, animation=animation, **kwargs)","def plot(self):\n\t\tself.plotOfSpect()","def petropeakcenter_graph(self):\n \n R_PETRO = self['R_PETRO']\n \n xcenter = self['X_IMAGE'] ; ycenter = self['Y_IMAGE']\n xcenter = xcenter - self['MXMIN_IMAGE']\n ycenter = ycenter - self['MYMIN_IMAGE']\n center = (xcenter,ycenter)\n \n ellip = self['ELLIPTICITY'] \n q = 1. - ellip\n pa = self['THETA_IMAGE'] # Astronomical position angle.\n \n if 'M_XPEAK' in self:\n xpeak = self['M_XPEAK'] - self['MXMIN_IMAGE']\n ypeak = self['M_YPEAK'] - self['MYMIN_IMAGE']\n peak = (xpeak,ypeak)\n \n stamp = self['STAMP'].copy()\n mask = self['MASK'].copy()\n sky = self['BACKGROUND']\n Img = stamp - sky\n Img[num.where(mask != 0)] = 0.\n \n id = self._getGraphId()\n root = 'petropeakcenter_%s' % (id,)\n pngname = root + '.png' ; epsname = root + '.eps'\n jpgname = root + '.jpg'\n doStamp(Img,pngname,format='PNG')\n Convert(pngname,jpgname)\n \n Painted = Paint(jpgname)\n Painted.load()\n if R_PETRO >0. : \n Painted.DrawEllipse(center,R_PETRO,q,pa,color='red',linewidth=2)\n Painted.DrawCross(center,length=20,color='green')\n try : Painted.DrawCross(peak,length=20,color='red')\n except : pass\n \n text = 'RP=%6.2f' % R_PETRO\n \n # Painted.Graffiti(text,commtextpos)\n \n Painted.save(jpgname) \n Painted.release()\n \n Convert(jpgname,epsname)\n os.system('rm %s %s' % (pngname,jpgname))\n \n self['figures']['petropeakcenter'] = epsname\n self['figcomms']['petropeakcenter'] = text","def view_polygons(polygons):\n # create the figure and add the surfaces\n plt.figure()\n ax = plt.axes(projection='3d')\n\n collections = _make_collections(polygons, opacity=0.5)\n\n for c in collections:\n ax.add_collection3d(c)\n\n # calculate and set the axis limits\n limits = _get_limits(polygons=polygons)\n ax.set_xlim(limits['x'])\n ax.set_ylim(limits['y'])\n ax.set_zlim(limits['z'])\n\n plt.show()","def view_polygons(polygons):\n # create the figure and add the surfaces\n plt.figure()\n ax = plt.axes(projection=\"3d\")\n\n collections = _make_collections(polygons, opacity=0.5)\n\n for c in collections:\n ax.add_collection3d(c)\n\n # calculate and set the axis limits\n limits = _get_limits(polygons=polygons)\n ax.set_xlim(limits[\"x\"])\n ax.set_ylim(limits[\"y\"])\n ax.set_zlim(limits[\"z\"])\n\n plt.show()","def generate_pointcloud(rgb_file, mask_file,depth_file,ply_file):\n rgb = Image.open(rgb_file)\n # depth = Image.open(depth_file)\n depth = Image.open(depth_file).convert('I')\n mask = Image.open(mask_file).convert('I')\n\n # if rgb.size != depth.size:\n # raise Exception(\"Color and depth image do not have the same resolution.\")\n # if rgb.mode != \"RGB\":\n # raise Exception(\"Color image is not in RGB format\")\n # if depth.mode != \"I\":\n # raise Exception(\"Depth image is not in intensity format\")\n\n\n points = [] \n for v in range(rgb.size[1]):\n for u in range(rgb.size[0]):\n color = rgb.getpixel((u,v))\n # Z = depth.getpixel((u,v)) / scalingFactor\n # if Z==0: continue\n # X = (u - centerX) * Z / focalLength\n # Y = (v - centerY) * Z / focalLength\n if (mask.getpixel((u,v))<55):\n Z = depth.getpixel((u, v))*.22 \n if Z == 0: continue\n Y = .22 * v\n X = .22 * u\n points.append(\"%f %f %f %d %d %d 0\\n\"%(X,Y,Z,color[0],color[1],color[2]))\n file = open(ply_file,\"w\")\n file.write('''ply\nformat ascii 1.0\nelement vertex %d\nproperty float x\nproperty float y\nproperty float z\nproperty uchar red\nproperty uchar green\nproperty uchar blue\nproperty uchar alpha\nend_header\n%s\n'''%(len(points),\"\".join(points)))\n file.close()","def visualize(vis, features, label):\n if vis == 'PCA':\n #n_components = st.sidebar.slider(\"n_components\", 2, 10)\n #alpha = st.sidebar.slider(\"alpha\", 0.8, 2.0)\n #pca = PCA(n_components)\n pca = PCA(2)\n\n X_projected = pca.fit_transform(features)\n \n x1 = X_projected[:, 0]\n x2 = X_projected[:, 1]\n\n\n fig = plt.figure()\n plt.scatter(x1, x2, c=label, alpha=0.8, cmap='viridis')\n plt.xlabel(\"Principal Component 1\")\n plt.ylabel(\"Principal Component 2\")\n plt.colorbar()\n\n st.pyplot()","def plot_vor_boundary(self,x,ax,tri=False):\n\n x = x[~np.isnan(x[:,0])]\n c_types_print = np.ones(x.shape[0],dtype=np.int32)*-1\n c_types_print[:self.n_C] = self.c_types\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(x))\n\n\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\n if type(self.c_types) is list:\n # ax.scatter(x[:, 0], x[:, 1],color=\"grey\",zorder=1000)\n for region in regions:\n polygon = vertices[region]\n plt.fill(*zip(*polygon), alpha=0.4, color=\"grey\")\n\n else:\n cols = self.cols\n patches = []\n if self.plot_scatter is True:\n ax.scatter(x[:self.n_C, 0], x[:self.n_C, 1], color=\"black\", zorder=1000)\n ax.scatter(x[self.n_C:, 0], x[self.n_C:, 1], color=\"grey\", zorder=1000)\n\n for i, region in enumerate(regions):\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],edgecolor=\"white\",alpha=0.5))\n\n p = PatchCollection(patches, match_original=True)\n # p.set_array(c_types_print)\n ax.add_collection(p)\n if tri is not False:\n for TRI in tri:\n for j in range(3):\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\n if (a >= 0) and (b >= 0):\n X = np.stack((x[a], x[b])).T\n ax.plot(X[0], X[1], color=\"black\")","def plot_orbit(self) :\r\n self.x_vals = np.zeros((self.n_bodies,len(self.hist)))\r\n self.y_vals = np.zeros((self.n_bodies,len(self.hist)))\r\n self.z_vals = np.zeros((self.n_bodies,len(self.hist))) \r\n self.r_vals = np.zeros((self.n_bodies,len(self.hist)))\r\n \r\n for i in range(self.n_bodies) : \r\n ioff = i*6\r\n for j in range(len(self.hist)) : \r\n self.x_vals[i][j] = self.hist[j][ioff]\r\n self.y_vals[i][j] = self.hist[j][ioff+1]\r\n self.z_vals[i][j] = self.hist[j][ioff+2]\r\n self.r_vals[i][j] = np.sqrt((self.x_vals[i][j]**2) + (self.y_vals[i][j]**2) + (self.z_vals[i][j]**2))","def plot( self, N, square = False, filename = None ):\n\n # compute all points for all triangles for all arms\n self.get_all_triangles( N = N )\n\n # compute spatial bounds of the tessellation\n x_min = np.min( self.all_triangles[ :, :, :, 0 ] ) * 1.02\n x_max = np.max( self.all_triangles[ :, :, :, 0 ] ) * 1.02\n y_min = np.min( self.all_triangles[ :, :, :, 1 ] ) * 1.02\n y_max = np.max( self.all_triangles[ :, :, :, 1 ] ) * 1.02\n\n # compute aspect ratio of visualization\n if square:\n ratio = 1\n y_max = y_min + ( x_max - x_min )\n else:\n ratio = ( y_max - y_min ) / ( x_max - x_min )\n\n # initialize figure and axis of visualization\n fig, ax = plt.subplots( figsize = ( 8, 8 * ratio ) )\n\n # get list of colors used to color each arm of the tessellation\n colors = get_cmap( 'tab10' ).colors\n\n # loop over arms\n for i , color in zip( range( self.m ), colors ):\n\n # initialize list of matplotlib Polygons\n patches = list( )\n\n # loop over all triangles in the arm\n for triangle in self.all_triangles[ i ]:\n\n # append a matplotlib Polygon of the given triangle to the the\n # polygon list\n polygon = Polygon(\n xy = triangle,\n closed = True,\n joinstyle = 'miter' )\n patches.append( polygon )\n\n # create a matplotlib PatchCollection of the list of polygons\n p = PatchCollection(\n patches = patches,\n color = color,\n edgecolor = 'k',\n linewidth = 1.0, )\n\n # add the PatchCollection to the figure axis\n ax.add_collection( p )\n\n # set bounds of visualization, and remove axis box and tickmarks\n ax.set_xlim( x_min, x_max )\n ax.set_ylim( y_min, y_max )\n ax.axis( 'off' )\n\n # ensure scaling is consistent between the two axes\n plt.subplots_adjust( 0, 0, 1, 1 )\n\n # if ``filename`` is specified, save to file, otherwise show`\n if filename is None:\n return ax\n else:\n plt.savefig( filename, bbox_inches = 'tight' )\n plt.close( )","def create_point_cloud(self):\n pixels = []\n colors = []\n my_pixels = []\n for j in range(self.height):\n for i in range(self.width):\n depth = self.depth[j, i]\n pixels.append(\n [i * depth, j * depth, depth]\n )\n my_pixels.append(\n [i, j, 1]\n )\n # make rgb with flip()\n colors.append(np.flip(self.bgr[j, i, :]))\n # colors.append(self.bgr[j, i, :])\n self.my_pixels = my_pixels\n pixels = np.array(pixels)\n\n # project pixels to camera space\n self.xyz_points = self.intrinsics_inv @ np.transpose(pixels)\n self.color_points = colors\n\n # now add 1s to the points for homogenous coordinates\n num_points = self.get_num_xyz_points()\n ones = np.ones((1, num_points))\n self.xyzw_points = np.concatenate((self.xyz_points, ones), axis=0)\n\n self.scene = None\n self.camera_pose = None\n self.nm = None\n self.nl = None\n self.nc = None\n self.create_mesh()"],"string":"[\n \"def visualize(title, particles):\\n\\n plt.figure(figsize=(10,10))\\n plt.title(\\\"Best configuration for \\\" + str(len(particles)) + \\\" particles\\\", size=25)\\n plt.xlabel(\\\"xcoordinate\\\", size=18)\\n plt.ylabel(\\\"ycoordinate\\\", size=18)\\n\\n plt.xticks(size=13)\\n plt.yticks(size=13)\\n\\n circle = plt.Circle((0, 0), 1)\\n circle.set_edgecolor(\\\"red\\\")\\n circle.set_facecolor(\\\"none\\\")\\n fig = plt.gcf()\\n ax = fig.gca()\\n\\n ax.add_artist(circle)\\n plt.xlim(-1.1,1.1)\\n plt.ylim(-1.1,1.1)\\n\\n # draw all the particles\\n for particle in particles:\\n plt.scatter(particle.x, particle.y)\\n\\n fig.savefig(title)\",\n \"def draw_particles(self):\\n for particle in self.particles:\\n particle.draw()\",\n \"def test_visualize():\\n # Instantiate three particles for testing\\n particles = [Particle(0.3, 0.5, 1), \\n Particle(0.0, -0.5, -1), \\n Particle(-0.1, -0.4, 3)]\\n simulator = ParticleSimulator(particles)\\n visualize(simulator)\",\n \"def visualize_scan(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n ax.scatter(self.p1_points[:, 0], self.p1_points[:, 1], self.p1_points[:, 2], c='r')\\n ax.scatter(self.p2_points[:, 0], self.p2_points[:, 1], self.p2_points[:, 2], c='g')\\n ax.scatter(self.p3_points[:, 0], self.p3_points[:, 1], self.p3_points[:, 2], c='b')\\n ax.scatter(self.p4_points[:, 0], self.p4_points[:, 1], self.p4_points[:, 2])\\n\\n ax.set_xlabel('x')\\n ax.set_ylabel('y')\\n ax.set_zlabel('z')\\n plt.show()\",\n \"def initiate(self):\\n pts = []\\n for point in self.points:\\n pt = gr.Point(point[0],point[1])\\n pts.append(pt)\\n\\n self.vis = [gr.Polygon(pts)]\\n\\n self.draw()\",\n \"def show_path_2D(start, end, coordinates, polygons, clear = True):\\n global L, N, delta_t\\n\\n # start interactive mode\\n plt.ion()\\n\\n # crete eempty figure on which data will go and first subplot\\n fig = plt.figure()\\n\\n # get into the correct time step\\n for time_step in range(start, end):\\n # list of colours used for animation\\n colours = cm.rainbow(np.linspace(0, 1, N))\\n\\n # loop over each particle and colour\\n for i in range(N):\\n # plot x, y poistion of particle in a given colour and set axis to size of box\\n plt.scatter(coordinates[time_step][i][0], coordinates[time_step][i][1], s = 1, color = 'r')\\n\\n # plot the object\\n if i < M:\\n polygon = np.array(polygons[time_step][i])\\n # get the points of the polygon to plot it\\n x, y = polygon.T\\n\\n # print(x, y)\\n\\n x = np.append(x, x[0])\\n y = np.append(y, y[0])\\n\\n # print(x, y)\\n\\n # plot the polygon\\n plt.plot(x , y)\\n # plt.scatter(polygons_com[time_step][i][0], polygons_com[time_step][i][1], s = 5, color = 'g')\\n\\n if bound_cond == True:\\n plt.axis([0, L, 0, L])\\n plt.axis([0, L, 0, L])\\n # plt.axis([-L*2, L*2, -L*2, L*2])\\n\\n # show graph\\n plt.show()\\n plt.pause(time_pause)\\n\\n # decide if you want to clear\\n if clear == True:\\n plt.clf()\\n\\n return None\",\n \"def visualize(self):\\n self.octree.updateInnerOccupancy()\\n print(\\\"Start Octomap Visualization\\\")\\n\\n # define parameters\\n data = imgviz.data.arc2017()\\n camera_info = data['camera_info']\\n K = np.array(camera_info['K']).reshape(3, 3)\\n width=camera_info['width']\\n height=camera_info['height']\\n\\n # get free and occupied grid\\n occupied, _ = self.octree.extractPointCloud()\\n #frontier = self.gen_frontier()\\n \\n print(\\\"load point cloud\\\")\\n window = pyglet.window.Window(\\n width=int(1280), height=int(960)\\n )\\n\\n @window.event\\n def on_key_press(symbol, modifiers):\\n if modifiers == 0:\\n if symbol == pyglet.window.key.Q:\\n window.on_close()\\n\\n gui = glooey.Gui(window)\\n hbox = glooey.HBox()\\n hbox.set_padding(5)\\n\\n camera = trimesh.scene.Camera(\\n resolution=(width, height), focal=(K[0, 0], K[1, 1])\\n )\\n\\n # initial camera pose\\n camera_transform = np.array(\\n [\\n [1, 0, 0, 0],\\n [0, -1, 0, 0],\\n [0, 0, -1, -5],\\n [0.0, 0.0, 0.0, 1.0],\\n ],\\n )\\n\\n \\n\\n occupied_geom = trimesh.voxel.ops.multibox(\\n occupied, pitch=self.resolution, colors=[0.0, 0.0, 0.0, 0.5]\\n )\\n\\n # frontier_geom = trimesh.voxel.ops.multibox(\\n # frontier, pitch=self.resolution, colors=[1.0, 0, 0, 0.5]\\n # )\\n scene = trimesh.Scene(camera=camera, geometry=[occupied_geom])#, frontier_geom])\\n scene.camera_transform = camera_transform\\n hbox.add(self.labeled_scene_widget(scene, label='octomap'))\\n\\n\\n gui.add(hbox)\\n pyglet.app.run()\",\n \"def decorate_scene():\\n make_polygon( (100,100),(120,140),(270,70) )\\n make_polygon( (300,10), (300,550), (340,452),(380,300), (330,50))\\n make_polygon( (200,450), (100,450), (100,500), (200,500) )\\n make_polygon( (130,320), (150,300), (140,280) )\\n return\",\n \"def main():\\n # Initialize the Serpinski set\\n print(\\\"==> Making serpinski set...\\\")\\n my_serpinski = Serpinski(400, 400, 0)\\n num = 8\\n print(\\\"==> Generating\\\", num, \\\"levels of subsets :)\\\")\\n for _ in range(9):\\n my_serpinski.add_subset()\\n # Draw Serpinski\\n # print(\\\"==> Drawing the set. This might take quite some time!\\\\\\n # Damn Inefficient!\\\")\\n # my_serpinski.draw_me()\\n\\n # Initialize Coordinates\\n length = 50000 # Number of random dots\\n x_coord = []\\n y_coord = []\\n index = 0\\n\\n # try length particles in serp set\\n print(\\\"==> Randomly choosing\\\", length, \\\"dots...\\\")\\n while index < length:\\n # Chech if dot in bound\\n rand_y = np.random.uniform(low=400.0 - 200.0 * np.sqrt(3) / 2.0,\\n high=400.0)\\n # rand_x in triangle // condition //\\n diff = 400.0 - rand_y\\n x_diff = diff / np.sqrt(3)\\n rand_x = np.random.uniform(low=400.0 - x_diff,\\n high=400 + x_diff)\\n\\n if my_serpinski.is_bound(rand_x, rand_y):\\n x_coord.append(rand_x)\\n y_coord.append(rand_y)\\n index += 1\\n\\n # Draw image using scatter\\n print(\\\"Scattering the dots ;)\\\")\\n plt.scatter(x_coord, y_coord, s=0.1)\\n # Show image\\n dpi = 600\\n print(\\\"==> Saving to .jpg with dpi=\\\", dpi)\\n plt.savefig(\\\"fractalstuff.jpg\\\", dpi=dpi, bbox_inches='tight')\",\n \"def draw_world(est_pose, particles, world):\\r\\n\\r\\n # Fix the origin of the coordinate system\\r\\n offsetX = 100\\r\\n offsetY = 250\\r\\n\\r\\n # Constant needed for transforming from world coordinates to screen coordinates (flip the y-axis)\\r\\n ymax = world.shape[0]\\r\\n\\r\\n world[:] = CWHITE # Clear background to white\\r\\n\\r\\n # Find largest weight\\r\\n max_weight = 0\\r\\n for particle in particles:\\r\\n max_weight = max(max_weight, particle.getWeight())\\r\\n\\r\\n # Draw particles\\r\\n for particle in particles:\\r\\n x = int(particle.getX()) + offsetX\\r\\n y = ymax - (int(particle.getY()) + offsetY)\\r\\n colour = jet(particle.getWeight() / max_weight)\\r\\n cv2.circle(world, (x, y), 2, colour, 2)\\r\\n b = (int(particle.getX() + 15.0 * np.cos(particle.getTheta())) + offsetX,\\r\\n ymax - (int(particle.getY() - 15.0 * np.sin(particle.getTheta())) + offsetY))\\r\\n cv2.line(world, (x, y), b, colour, 2)\\r\\n\\r\\n # Draw landmarks\\r\\n lm0 = (int(landmarks[0][0] + offsetX),\\r\\n int(ymax - (landmarks[0][1] + offsetY)))\\r\\n lm1 = (int(landmarks[1][0] + offsetX),\\r\\n int(ymax - (landmarks[1][1] + offsetY)))\\r\\n lm2 = (int(landmarks[2][0] + offsetX),\\r\\n int(ymax - (landmarks[2][1] + offsetY)))\\r\\n lm3 = (int(landmarks[3][0] + offsetX),\\r\\n int(ymax - (landmarks[3][1] + offsetY)))\\r\\n \\r\\n cv2.circle(world, lm0, 5, CRED, 2)\\r\\n cv2.circle(world, lm1, 5, CGREEN, 2)\\r\\n cv2.circle(world, lm2, 5, CBLUE, 2)\\r\\n cv2.circle(world, lm3, 5, CYELLOW, 2)\\r\\n cv2.putText(world, 'LM 1',lm0, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\\r\\n cv2.putText(world, 'LM 2',lm1, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\\r\\n cv2.putText(world, 'LM 3',lm2, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\\r\\n cv2.putText(world, 'LM 4',lm3, cv2.FONT_HERSHEY_SIMPLEX, 1, 255)\\r\\n\\r\\n\\r\\n\\r\\n\\r\\n # Draw estimated robot pose\\r\\n a = (int(est_pose.getX()) + offsetX, ymax - (int(est_pose.getY()) + offsetY))\\r\\n b = (int(est_pose.getX() + 15.0 * np.cos(est_pose.getTheta())) + offsetX,\\r\\n ymax - (int(est_pose.getY() - 15.0 * np.sin(est_pose.getTheta())) + offsetY))\\r\\n cv2.circle(world, a, 5, CMAGENTA, 2)\\r\\n cv2.line(world, a, b, CMAGENTA, 2)\",\n \"def visualize(self):\\n\\n evidence = self.create_evidence(use_success=False)\\n\\n conditional_model = self.model.conditional_jpt(evidence)\\n\\n for leaf in conditional_model.leaves.values():\\n\\n success = leaf.distributions[\\\"status\\\"].p({\\\"SUCCEEDED\\\"})\\n\\n if success == 0:\\n continue\\n\\n x_intervals = leaf.distributions[\\\"x\\\"].cdf.intervals\\n y_intervals = leaf.distributions[\\\"y\\\"].cdf.intervals\\n\\n x_range = np.array([x_intervals[0].upper, x_intervals[-1].lower])\\n y_range = np.array([y_intervals[0].upper, y_intervals[-1].lower])\\n\\n center = np.array([sum(x_range) / 2, sum(y_range) / 2])\\n\\n visual = pybullet.createVisualShape(pybullet.GEOM_BOX,\\n halfExtents=[(x_range[1] - x_range[0]) / 2,\\n (y_range[1] - y_range[0]) / 2, 0.001],\\n rgbaColor=[1, 0, 0, success],\\n visualFramePosition=[*center, 0])\\n\\n self.visual_ids.append(visual)\\n\\n for id_list in np.array_split(np.array(self.visual_ids), np.ceil(len(self.visual_ids) / 127)):\\n # Dummy paramater since these are needed to spawn visual shapes as a multibody.\\n link_poses = [[0, 0, 0] for c in id_list]\\n link_orientations = [[0, 0, 0, 1] for c in id_list]\\n link_masses = [1.0 for c in id_list]\\n link_parent = [0 for c in id_list]\\n link_joints = [pybullet.JOINT_FIXED for c in id_list]\\n link_collision = [-1 for c in id_list]\\n link_joint_axis = [[1, 0, 0] for c in id_list]\\n\\n # The position at which the multibody will be spawned. Offset such that\\n # the origin referes to the centre of the costmap.\\n origin_pose = self.target.get_position_and_orientation()\\n base_position = list(origin_pose[0])\\n base_position[2] = 0\\n\\n map_obj = pybullet.createMultiBody(baseVisualShapeIndex=-1, linkVisualShapeIndices=id_list,\\n basePosition=base_position, baseOrientation=origin_pose[1],\\n linkPositions=link_poses,\\n linkMasses=link_masses, linkOrientations=link_orientations,\\n linkInertialFramePositions=link_poses,\\n linkInertialFrameOrientations=link_orientations,\\n linkParentIndices=link_parent,\\n linkJointTypes=link_joints, linkJointAxis=link_joint_axis,\\n linkCollisionShapeIndices=link_collision)\\n self.visual_ids.append(map_obj)\",\n \"def drawShapes(self):\\n self.draw_polygon(self.poly3.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly2.get_points() , color = \\\"#000\\\")\\n self.draw_polygon(self.poly1.get_points() , color = \\\"#000\\\")\\n self.draw_rect(0, 0, self.width, self.height, color= \\\"#000\\\")\\n \\\"\\\"\\\"These statements are used to determine if a point is inside any of the\\n 3 polygons and if so changes the point's color\\\"\\\"\\\"\\n if (self.poly2.point_inside_polygon(self.p1) or self.poly1.point_inside_polygon(self.p1)\\n or self.poly3.point_inside_polygon(self.p1)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p1.x, self.p1.y, 7, 7, color)\\n\\n if (self.poly2.point_inside_polygon(self.p2) or self.poly1.point_inside_polygon(self.p2)\\n or self.poly3.point_inside_polygon(self.p2)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p2.x, self.p2.y, 7, 7, color)\\n if (self.poly2.point_inside_polygon(self.p3) or self.poly1.point_inside_polygon(self.p3)\\n or self.poly3.point_inside_polygon(self.p3)):\\n color = \\\"#0F0\\\"\\n else:\\n color = \\\"#F00\\\"\\n self.fill_oval(self.p3.x, self.p3.y, 7, 7, color)\",\n \"def render(self, scene):\\n if self.degenerate:\\n return\\n # The number of subdivisions around the hoop's radial direction.\\n if self.thickness:\\n band_coverage = scene.pixel_coverage(self.pos, self.thickness)\\n else:\\n band_coverage = scene.pixel_coverage(self.pos, self.radius * 0.1)\\n if band_coverage < 0:\\n band_coverage = 1000\\n bands = sqrt(band_coverage * 4.0)\\n bands = clamp(4, bands, 40)\\n # The number of subdivisions around the hoop's tangential direction.\\n ring_coverage = scene.pixel_coverage(self.pos, self.radius)\\n if ring_coverage < 0:\\n ring_coverage = 1000\\n rings = sqrt(ring_coverage * 4.0)\\n rings = clamp(4, rings, 80)\\n slices = int(rings)\\n inner_slices = int(bands)\\n radius = self.radius\\n inner_radius = self.thickness\\n\\n # Create the vertex and normal arrays.\\n vertices = []\\n normals = []\\n\\n outer_angle_step = 2 * pi / (slices - 1)\\n inner_angle_step = 2 * pi / (inner_slices - 1)\\n outer_angle = 0.\\n for i in range(slices):\\n cos_outer_angle = cos(outer_angle)\\n sin_outer_angle = sin(outer_angle)\\n inner_angle = 0.\\n for j in range(inner_slices):\\n cos_inner_angle = cos(inner_angle)\\n sin_inner_angle = sin(inner_angle)\\n\\n diameter = (radius + inner_radius * cos_inner_angle)\\n vertex_x = diameter * cos_outer_angle\\n vertex_y = diameter * sin_outer_angle\\n vertex_z = inner_radius * sin_inner_angle\\n\\n normal_x = cos_outer_angle * cos_inner_angle\\n normal_y = sin_outer_angle * cos_inner_angle\\n normal_z = sin_inner_angle\\n\\n vertices.extend([vertex_x, vertex_y, vertex_z])\\n normals.extend([normal_x, normal_y, normal_z])\\n inner_angle += inner_angle_step\\n outer_angle += outer_angle_step\\n\\n # Create ctypes arrays of the lists\\n vertices = (gl.GLfloat *len(vertices))(*vertices)\\n normals = (gl.GLfloat * len(normals))(*normals)\\n\\n # Create a list of triangle indices.\\n indices = []\\n for i in range(slices - 1):\\n for j in range(inner_slices - 1):\\n pos = i * inner_slices + j\\n indices.extend([pos, pos + inner_slices, pos + inner_slices +\\n 1])\\n indices.extend([pos, pos + inner_slices + 1, pos + 1])\\n indices = (gl.GLuint * len(indices))(*indices)\\n\\n # Compile a display list\\n self.list = gl.glGenLists(1)\\n gl.glNewList(self.list, gl.GL_COMPILE)\\n self.color.gl_set(self.opacity)\\n\\n gl.glPushClientAttrib(gl.GL_CLIENT_VERTEX_ARRAY_BIT)\\n gl.glEnableClientState(gl.GL_VERTEX_ARRAY)\\n gl.glEnableClientState(gl.GL_NORMAL_ARRAY)\\n self.model_world_transform(scene.gcf,\\n Vector([self.radius, self.radius,\\n self.radius])).gl_mult()\\n\\n gl.glVertexPointer(3, gl.GL_FLOAT, 0, vertices)\\n gl.glNormalPointer(gl.GL_FLOAT, 0, normals)\\n gl.glDrawElements(gl.GL_TRIANGLES, len(indices), gl.GL_UNSIGNED_INT,\\n indices)\\n gl.glPopClientAttrib()\\n\\n gl.glEndList()\\n gl.glCallList(self.list)\",\n \"def visualiser(filename):\\n\\tcollection = mongo.db[filename]\\n\\tjsonEncoder = hepmcio_json.HepMCJSONEncoder()\\n\\thepMCDecoder = hepmcio_json.HepMCJSONDecoder()\\n\\tjsonDecoder = json.JSONDecoder()\\n\\t#Get first event data in file and decode to HepMCIO objects.\\n\\tevent = collection.find_one({\\\"type\\\":\\\"event\\\", \\\"no\\\":1}, {\\\"_id\\\":False})\\n\\tparticleJson = collection.find({\\\"type\\\":\\\"particle\\\", \\\"event\\\":event[\\\"barcode\\\"]}, {\\\"_id\\\":False})\\n\\tparticles = []\\n\\tfor particle in particleJson:\\n\\t\\tparticles.append(jsonEncoder.encode(particle))\\n\\t\\n\\tvertices = []\\n\\tvertexJson = collection.find({\\\"type\\\":\\\"vertex\\\", \\\"event\\\":event[\\\"barcode\\\"]}, {\\\"_id\\\":False})\\n\\tfor vertex in vertexJson:\\n\\t\\tvertices.append(jsonEncoder.encode(vertex))\\n\\tevent = jsonEncoder.encode(event)\\n\\t\\n\\t\\n\\t#Decode event to find interesting particles, i.e. particles above PT_CUTOFF and their ancestors..\\n\\teventObject = hepmcio_json.EventJSONObject(event, particles, vertices)\\n\\tdecodedEvent = hepMCDecoder.decode(eventObject)\\n\\n\\tPT_CUTOFF = 0.0\\n\\tintParticles = [particle for particle in decodedEvent.particles.values() if particle.status!=1 and \\\\\\n\\t\\tparticle.mom[0]**2 + particle.mom[1]**2 > PT_CUTOFF**2]\\n\\t#Build a single list from the individual particle ancestor lists.\\n\\tintParticleAncestors = reduce(operator.concat, [hepmcio.get_ancestors(particle)[:-1] for particle in intParticles])\\n\\n\\tparticles = []\\n\\tfor particle in (intParticles + intParticleAncestors):\\n\\t\\t#Encode particle to JSON, decode to Python dicts.\\n\\t\\tparticles.append(jsonDecoder.decode(jsonEncoder.encode(particle)))\\n\\t#Decode to Python dicts.\\n\\tvertices = list(map(jsonDecoder.decode, vertices))\\n\\t\\n\\treturn render_template(\\\"visualiser.html\\\", title=\\\"Visualiser\\\", file=filename, particles=particles, vertices=vertices)\",\n \"def generate(pts):\\n cmds.polyCreateFacet(name=\\\"shirt\\\", p=points)\\n cmds.polyTriangulate()\\n cmds.polySubdivideFacet(dv=SUBDIVISIONS)\\n cmds.polyTriangulate()\",\n \"def plot(self):\\n\\t\\tself.plotOfXray().plot()\",\n \"def sample_and_plot(self):\\n fig = plt.figure()\\n ax = plt.axes(projection = '3d')\\n ax.plot_surface(self.X, self.Y, self.sample(), cmap = plt.cm.jet, rstride = 2, cstride = 2, linewidth = 1)\\n plt.show()\",\n \"def visualize(z_in, azimuth=25., elevation=30.,\\n thresholds=[0.95, .9, .75, .5, .25, .125], opacities=[1, .9, .7, .5, .2, .1],\\n# thresholds=[0.94, .89, .75, .5, .25, .1], opacities=[.9, .8, .7, .5, .2, .1],\\n# thresholds=[0.94, .89, .75], opacities=[.99, .7, .2],\\n# thresholds=[0.7, .5, .2], opacities=[.95, .5, .2],\\n fourier_label = {'f_x':'f_x', 'f_y':'f_y', 'f_t':'f_t'},\\n filename=None, do_axis=True, do_grids=False, draw_projections=True,\\n colorbar=False, f_N=2., f_tN=2., figsize=figsize, dpi=300, figpath=figpath, **kwargs):\\n z = z_in.copy()\\n N_X, N_Y, N_frame = z.shape\\n fx, fy, ft = get_grids(N_X, N_Y, N_frame)\\n\\n # Normalize the amplitude.\\n z /= z.max()\\n\\n from vispy import app, scene, use\\n try:\\n AffineTransform = scene.transforms.AffineTransform\\n except:\\n AffineTransform = scene.transforms.MatrixTransform\\n\\n use(app='pyglet', gl='pyopengl2')\\n #from vispy.util.transforms import perspective, translate, rotate\\n from vispy.color import Color\\n transparent = Color(color='black', alpha=0.)\\n import colorsys\\n canvas = scene.SceneCanvas(size=figsize, bgcolor='white', dpi=dpi)\\n view = canvas.central_widget.add_view()\\n\\n vol_data = np.rollaxis(np.rollaxis(z, 1), 2)\\n# volume = scene.visuals.Volume(vol_data, parent=view.scene)#frame)\\n center = scene.transforms.STTransform(translate=( -N_X/2, -N_Y/2, -N_frame/2))\\n# volume.transform = center\\n# volume.cmap = 'blues'\\n\\n if draw_projections:\\n from vispy.color import Colormap\\n cm = Colormap([(1.0, 1.0, 1.0, 1.0), 'k'])\\n opts = {'parent':view.scene, 'cmap':cm, 'clim':(0., 1.)}\\n\\n energy_xy = np.rot90(np.max(z, axis=2)[:, ::-1], 3)#[:, ::-1]\\n fourier_xy = scene.visuals.Image(np.rot90(energy_xy), **opts)\\n tr_xy = AffineTransform()\\n tr_xy.rotate(90, (0, 0, 1))\\n tr_xy.translate((N_X/2, -N_Y/2, -N_frame/2))\\n fourier_xy.transform = tr_xy\\n\\n energy_xt = np.rot90(np.max(z, axis=1)[:, ::-1], 3)[::-1, ::-1]\\n fourier_xt = scene.visuals.Image(energy_xt, **opts)\\n tr_xt = AffineTransform()\\n tr_xt.rotate(90, (1, 0, 0))\\n tr_xt.translate((-N_X/2, N_Y/2, -N_frame/2))\\n fourier_xt.transform = tr_xt\\n\\n energy_yt = np.max(z, axis=0)[:, ::-1]\\n fourier_yt = scene.visuals.Image(energy_yt, **opts)\\n tr_yt = AffineTransform()\\n tr_yt.rotate(90, (0, 1, 0))\\n tr_yt.translate((-N_X/2, -N_Y/2, N_frame/2))\\n fourier_yt.transform = tr_yt\\n\\n # Generate iso-surfaces at different energy levels\\n surfaces = []\\n for i_, (threshold, opacity) in enumerate(zip(thresholds, opacities)):\\n surfaces.append(scene.visuals.Isosurface(z, level=threshold,\\n# color=Color(np.array(colorsys.hsv_to_rgb(1.*i_/len(thresholds), 1., 1.)), alpha=opacity),\\n color=Color(np.array(colorsys.hsv_to_rgb(.66, 1., 1.)), alpha=opacity),\\n shading='smooth', parent=view.scene)\\n )\\n surfaces[-1].transform = center\\n\\n # Draw a sphere at the origin\\n axis = scene.visuals.XYZAxis(parent=view.scene)\\n for p in ([1, 1, 1, -1, 1, 1], [1, 1, -1, -1, 1, -1], [1, -1, 1, -1, -1, 1],[1, -1, -1, -1, -1, -1],\\n [1, 1, 1, 1, -1, 1], [-1, 1, 1, -1, -1, 1], [1, 1, -1, 1, -1, -1], [-1, 1, -1, -1, -1, -1],\\n [1, 1, 1, 1, 1, -1], [-1, 1, 1, -1, 1, -1], [1, -1, 1, 1, -1, -1], [-1, -1, 1, -1, -1, -1]):\\n line = scene.visuals.Line(pos=np.array([[p[0]*N_X/2, p[1]*N_Y/2, p[2]*N_frame/2], [p[3]*N_X/2, p[4]*N_Y/2, p[5]*N_frame/2]]), color='black', parent=view.scene)\\n\\n axisX = scene.visuals.Line(pos=np.array([[0, -N_Y/2, 0], [0, N_Y/2, 0]]), color='red', parent=view.scene)\\n axisY = scene.visuals.Line(pos=np.array([[-N_X/2, 0, 0], [N_X/2, 0, 0]]), color='green', parent=view.scene)\\n axisZ = scene.visuals.Line(pos=np.array([[0, 0, -N_frame/2], [0, 0, N_frame/2]]), color='blue', parent=view.scene)\\n\\n if do_axis:\\n t = {}\\n for text in ['f_x', 'f_y', 'f_t']:\\n t[text] = scene.visuals.Text(fourier_label[text], parent=canvas.scene, face='Helvetica', color='black')\\n t[text].font_size = 8\\n t['f_x'].pos = canvas.size[0] // 3, canvas.size[1] - canvas.size[1] // 8\\n t['f_y'].pos = canvas.size[0] - canvas.size[0] // 8, canvas.size[1] - canvas.size[1] // 6\\n t['f_t'].pos = canvas.size[0] // 8, canvas.size[1] // 2\\n\\n cam = scene.TurntableCamera(elevation=elevation, azimuth=azimuth, up='z')\\n cam.fov = 48\\n cam.scale_factor = N_X * 1.8\\n if do_axis: margin = 1.35\\n else: margin = 1\\n cam.set_range((-N_X/2*margin, N_X/2/margin), (-N_Y/2*margin, N_Y/2/margin), (-N_frame/2*margin, N_frame/2/margin))\\n view.camera = cam\\n\\n render_im = canvas.render()\\n app.quit()\\n if not(filename is None):\\n import vispy.io as io\\n io.write_png(filename, render_im)\\n else:\\n return render_im\",\n \"def render(self):\\r\\n super().render()\\r\\n layers, titles, latVect, lonVect = self.make_layers()\\r\\n LON, LAT = np.meshgrid(lonVect, latVect)\\r\\n lon = LON.flatten()\\r\\n lat = LAT.flatten()\\r\\n for i in range(len(layers)):\\r\\n vals = layers[i].flatten()\\r\\n hovertext = []\\r\\n for k in range(len(vals)):\\r\\n hovertext.append('lon: {:.2f}<br>lat: {:.2f}<br>{}: {:.1e}'.format(lon[k], lat[k], self.variable + self.unit,vals[k]))\\r\\n if self.levels == 0:\\r\\n data = [\\r\\n go.Heatmap(\\r\\n x=lon,\\r\\n y=lat,\\r\\n z=vals,\\r\\n colorscale=self.cmap,\\r\\n zmin=self.vmin,\\r\\n zmax=self.vmax,\\r\\n hoverinfo='text',\\r\\n text=hovertext \\r\\n )\\r\\n ]\\r\\n elif self.levels > 0:\\r\\n data = [\\r\\n go.Contour(\\r\\n x=lon,\\r\\n y=lat,\\r\\n z=vals,\\r\\n colorscale=self.cmap,\\r\\n hoverinfo='text',\\r\\n text=hovertext, \\r\\n connectgaps=False,\\r\\n contours=dict(\\r\\n coloring='heatmap',\\r\\n showlabels=True,\\r\\n start=self.vmin,\\r\\n end=self.vmax,\\r\\n size=(self.vmax-self.vmin) / float(self.levels)\\r\\n )\\r\\n # line=dict(smoothing=0.85) \\r\\n )\\r\\n ] \\r\\n\\r\\n\\r\\n layout = go.Layout(\\r\\n autosize=False,\\r\\n title=titles[i],\\r\\n width=self.width,\\r\\n height=self.height,\\r\\n xaxis={'title': self.xlabel},\\r\\n yaxis={'title': self.ylabel}\\r\\n ) \\r\\n\\r\\n\\r\\n\\r\\n if self.surface3D:\\r\\n data = [\\r\\n go.Surface(\\r\\n x=lonVect,\\r\\n y=latVect,\\r\\n z=layers[i],\\r\\n colorscale=self.cmap,\\r\\n # hoverinfo='text',\\r\\n # text=hovertext \\r\\n )\\r\\n ]\\r\\n\\r\\n layout = go.Layout(\\r\\n autosize=False,\\r\\n title=titles[i],\\r\\n width=self.width,\\r\\n height=self.height,\\r\\n scene = dict(\\r\\n xaxis={'title': self.xlabel},\\r\\n yaxis={'title': self.ylabel},\\r\\n zaxis={'title': self.variable + self.unit}\\r\\n )\\r\\n ) \\r\\n\\r\\n\\r\\n self._save_plotly_(go, data, layout)\",\n \"def viewer(\\n self, units='nm', \\n draw_edges=True, draw_vertices=True,\\n color_by='radius'\\n ):\\n try:\\n import matplotlib.pyplot as plt\\n from mpl_toolkits.mplot3d import Axes3D \\n from matplotlib import cm\\n except ImportError:\\n print(\\\"Skeleton.viewer requires matplotlib. Try: pip install matplotlib --upgrade\\\")\\n return\\n\\n RADII_KEYWORDS = ('radius', 'radii', 'r')\\n COMPONENT_KEYWORDS = ('component', 'components', 'c')\\n\\n fig = plt.figure(figsize=(10,10))\\n ax = Axes3D(fig)\\n ax.set_xlabel(units)\\n ax.set_ylabel(units)\\n ax.set_zlabel(units)\\n\\n # Set plot axes equal. Matplotlib doesn't have an easier way to\\n # do this for 3d plots.\\n X = self.vertices[:,0]\\n Y = self.vertices[:,1]\\n Z = self.vertices[:,2]\\n\\n max_range = np.array([X.max()-X.min(), Y.max()-Y.min(), Z.max()-Z.min()]).max() / 2.0\\n\\n mid_x = (X.max()+X.min()) * 0.5\\n mid_y = (Y.max()+Y.min()) * 0.5\\n mid_z = (Z.max()+Z.min()) * 0.5\\n ax.set_xlim(mid_x - max_range, mid_x + max_range)\\n ax.set_ylim(mid_y - max_range, mid_y + max_range)\\n ax.set_zlim(mid_z - max_range, mid_z + max_range)\\n ### END EQUALIZATION CODE ###\\n\\n component_colors = ['k', 'deeppink', 'dodgerblue', 'mediumaquamarine', 'gold' ]\\n\\n def draw_component(i, skel):\\n component_color = component_colors[ i % len(component_colors) ]\\n\\n if draw_vertices:\\n xs = skel.vertices[:,0]\\n ys = skel.vertices[:,1]\\n zs = skel.vertices[:,2]\\n\\n if color_by in RADII_KEYWORDS:\\n colmap = cm.ScalarMappable(cmap=cm.get_cmap('rainbow'))\\n colmap.set_array(skel.radii)\\n\\n normed_radii = skel.radii / np.max(skel.radii)\\n yg = ax.scatter(xs, ys, zs, c=cm.rainbow(normed_radii), marker='o')\\n cbar = fig.colorbar(colmap)\\n cbar.set_label('radius (' + units + ')', rotation=270)\\n elif color_by in COMPONENT_KEYWORDS:\\n yg = ax.scatter(xs, ys, zs, color=component_color, marker='.')\\n else:\\n yg = ax.scatter(xs, ys, zs, color='k', marker='.')\\n\\n if draw_edges:\\n for e1, e2 in skel.edges:\\n pt1, pt2 = skel.vertices[e1], skel.vertices[e2]\\n ax.plot( \\n [ pt1[0], pt2[0] ],\\n [ pt1[1], pt2[1] ],\\n zs=[ pt1[2], pt2[2] ],\\n color=(component_color if not draw_vertices else 'silver'),\\n linewidth=1,\\n )\\n\\n if color_by in COMPONENT_KEYWORDS:\\n for i, skel in enumerate(self.components()):\\n draw_component(i, skel)\\n else:\\n draw_component(0, self)\\n\\n plt.show()\",\n \"def plotVolumeContours(self):\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Particle Positions Colored by Voronoi Volumes', fontsize=22)\\n ax.set_xlabel('x [m]', fontsize=18)\\n ax.set_ylabel('y [m]', fontsize=18)\\n ax.set_zlabel('z [m]', fontsize=18)\\n pos = ax.scatter(self.data[self.nonB, 0], self.data[self.nonB, 1], self.data[self.nonB, 2], s=10, c=self.volumes, cmap='plasma')\\n cbar = fig.colorbar(pos, ax=ax)\\n cbar.ax.tick_params(labelsize=15)\",\n \"def showPoints(surface, points):\\n for point in points:\\n point.show(surface)\",\n \"def generatePolygons():\",\n \"def display(self):\\n scatter_plot(self.points, self.hull_points, self.color, self.title)\",\n \"def render(self):\\r\\n super().render()\\r\\n layers, titles, lat, lon = self.make_layers()\\r\\n plots = []\\r\\n for i in range(len(layers)):\\r\\n p = figure(\\r\\n tools=self.tools, \\r\\n toolbar_location=self.toolbarLocation, \\r\\n plot_width=self.width, \\r\\n plot_height=self.height,\\r\\n x_range=(np.min(lon), np.max(lon)),\\r\\n y_range=(np.min(lat), np.max(lat)),\\r\\n title=titles[i]\\r\\n )\\r\\n p.xaxis.axis_label = self.xlabel\\r\\n p.yaxis.axis_label = self.ylabel\\r\\n colorMapper = LinearColorMapper(palette=self.cmap, low=self.vmin, high=self.vmax)\\r\\n p.image(\\r\\n image=[layers[i]], \\r\\n color_mapper=colorMapper, \\r\\n x=np.min(lon), \\r\\n y=np.min(lat), \\r\\n dw=np.max(lon)-np.min(lon), \\r\\n dh=np.max(lat)-np.min(lat)\\r\\n )\\r\\n\\r\\n p.add_tools(HoverTool(\\r\\n tooltips=[\\r\\n ('longitude', '$x'),\\r\\n ('latitude', '$y'),\\r\\n (self.variable + self.unit, '@image'),\\r\\n ],\\r\\n mode='mouse'\\r\\n )\\r\\n )\\r\\n\\r\\n colorBar = ColorBar(\\r\\n color_mapper=colorMapper, \\r\\n ticker=BasicTicker(),\\r\\n label_standoff=12, \\r\\n border_line_color=None, \\r\\n location=(0,0)\\r\\n )\\r\\n\\r\\n p.add_layout(colorBar, 'right')\\r\\n plots.append(p)\\r\\n \\r\\n \\r\\n if not inline(): output_file(get_figure_dir() + self.variable + \\\".html\\\", title=self.variable) \\r\\n show(column(plots))\",\n \"def show_geometry(self):\\n import matplotlib.pyplot as plt\\n fig_geom = plt.figure()\\n ax_geom = fig_geom.add_subplot(111)\\n rectangle = []\\n for i in range(len(self.coordinates)):\\n rectangle.append(plt.Rectangle((self.coordinates[i][0],\\n self.coordinates[i][1]),\\n self.size[i][0], self.size[i][1], alpha=0.5))\\n ax_geom.add_patch(rectangle[i])\\n plt.axis('auto')\\n plt.show()\",\n \"def plot(self):\\n # Find only unmasked data :\\n # xyz, sData, sColor, _ = self._select_unmasked()\\n xyz, sData, sColor = self.xyz, self.sData, self.sColor\\n\\n # Render as cloud points :\\n self.mesh = visu.Markers(name='Sources')\\n self.mesh.set_data(xyz, edge_color=self.edgecolor, face_color=sColor,\\n size=sData, scaling=self.scaling,\\n edge_width=self.edgewidth, symbol=self.symbol)\\n self.mesh.set_gl_state('translucent')\",\n \"def draw_world_state(self):\\n self.fig.clf()\\n t = time.time()\\n subplot = self.fig.add_subplot(2,1,1)\\n for w in self.world_model.walls:\\n subplot.plot([w,w],[0,1],'b-')\\n subplot.hold(True)\\n subplot.set_xlim([min(self.walls)-0.2,max(self.walls)+.2])\\n subplot.set_ylim([0,1])\\n subplot.scatter([p.position for p in self.pf.particles],\\n [0.5]*len(self.pf.particles),\\n c='r',\\n s=[p.weight**0.5*1000 for p in self.pf.particles])\\n\\n subplot.scatter([p.position for p in self.pf.particles],\\n [0.2]*len(self.pf.particles),\\n c='k',\\n s=[10]*len(self.pf.particles))\\n\\n if self.true_position != None:\\n subplot.scatter([self.true_position], [0.8], c='g', s=[100])\\n\\n histogram = self.fig.add_subplot(2,1,2)\\n\\n histogram.hist([p.position for p in self.pf.particles],\\n weights=[p.weight for p in self.pf.particles],\\n bins=np.arange(-0.5+min(self.walls),0.5+max(self.walls),.02))\\n\\n histogram.set_xlim([-.2+min(self.walls),0.2+max(self.walls)])\\n histogram.set_ylim([0,1])\\n plt.draw()\\n plt.pause(.01)\",\n \"def __init__(self):\\n Page.__init__(self, u\\\"Esfera, parametrización por proyecciones estereográficas\\\")\\n\\n r = .998\\n esf = ParametricPlot3D(lambda t, f: (r * sin(t) * cos(f), r * sin(t) * sin(f), r * cos(t)), (0, pi, 70), (0, 2 * pi, 70))\\n# esf.setAmbientColor(_1(99,136,63))\\n esf.setDiffuseColor(_1(99, 136, 63))\\n esf.setSpecularColor(_1(99, 136, 63))\\n\\n\\n def proyZm1(u, v, t1):\\n \\\"\\\"\\\"proy desde el polo norte al plano z=-1\\\"\\\"\\\"\\n den = u ** 2 + v ** 2 + 4\\n x = u - t1 * (u - 4 * u / den)\\n y = v - t1 * (v - 4 * v / den)\\n z = -1 - t1 * (-2 + 8 / den)\\n return (x, y, z)\\n\\n def proyZ1(u, v, t2):\\n \\\"\\\"\\\"proy desde el polo sur al plano z=1\\\"\\\"\\\"\\n den = u ** 2 + v ** 2 + 4\\n x = u - t2 * (u - 4 * u / den)\\n y = v - t2 * (v - 4 * v / den)\\n z = 1 - t2 * (2 - 8 / den)\\n return (x, y, z)\\n\\n stereo = ParametricPlot3D(proyZm1, (-3, 3, 70), (-3, 3, 70))\\n stereo.setLinesVisible(True)\\n stereo.setMeshVisible(False)\\n stereo.setMeshDiffuseColor(_1(117, 55, 79))\\n\\n stereo2 = ParametricPlot3D(proyZ1, (-3, 3, 70), (-3, 3, 70))\\n stereo2.setLinesVisible(True)\\n stereo2.setMeshVisible(False)\\n stereo2.setMeshDiffuseColor(_1(80, 87, 193))\\n stereo2.setTransparency(0.5)\\n stereo2.setTransparencyType(8)\\n\\n\\n baseplane = BasePlane()\\n baseplane.setHeight(-1.005)\\n baseplane.setRange((-4, 4, 7))\\n self.addChild(esf)\\n self.addChild(stereo2)\\n self.addChild(stereo)\\n self.addChild(baseplane)\\n\\n params = [stereo,stereo2]\\n\\n ## no queremos los controles\\n for i,p in enumerate(params):\\n p.parameters['t%d' % (i+1)].hide()\\n\\n anims = [p.parameters['t%d' % (i+1)].asAnimation() for i,p in enumerate(params)]\\n self.setupAnimations(anims)\",\n \"def draw(self, fig, ax):\\n\\n\\t\\tpoints = self.apply_transformations() \\n\\t\\tax.scatter3D(points[:, 0], points[:, 1], points[:, 2])\\n\\n\\t\\t# cube polygons collection\\n\\t\\tverts = [\\n\\t\\t\\t[points[0], points[1], points[2], points[3]],\\n\\t\\t\\t[points[4], points[5], points[6], points[7]], \\n\\t\\t\\t[points[0], points[1], points[5], points[4]], \\n\\t\\t\\t[points[2], points[3], points[7], points[6]], \\n\\t\\t\\t[points[1], points[2], points[6], points[5]],\\n\\t\\t\\t[points[4], points[7], points[3], points[0]]\\n\\t\\t]\\n\\t\\t\\n\\t\\t# render polygons\\n\\t\\tax.add_collection3d(Poly3DCollection(verts, \\n\\t\\tfacecolors='blue', linewidths=1, edgecolors='b', alpha=0.3))\",\n \"def show(self):\\n if self.nodes_ is None:\\n logging.debug(\\\"Segment - Nothing to show. Skipping.\\\")\\n return\\n\\n if len(self.polygons_) != 0:\\n logging.debug(\\\"Segment - Showing 3D Segments using `vedo`.\\\")\\n logging.warning(\\\"Segment - Showing 3D Segments can be slow!.\\\")\\n\\n import vedo\\n\\n points = vedo.Points(self.nodes)\\n lines = []\\n for p in self.polygons:\\n p = np.asarray(p).astype(np.int32)\\n lines.append(vedo.Line(self.nodes[p]))\\n\\n vedo.show([points, *lines]).show().close()\\n\\n else:\\n logging.debug(\\\"Segment - Showing 2D Segments using `matplotlib`.\\\")\\n\\n import matplotlib.pyplot as plt\\n\\n plt.scatter(\\n self.nodes_[:, 0],\\n self.nodes_[:, 1],\\n c=\\\"pink\\\",\\n zorder=1000,\\n )\\n\\n for c in self.connectivity_:\\n plt.plot(\\n self.nodes_[c][:,0],\\n self.nodes_[c][:,1],\\n c=\\\"grey\\\",\\n lw=2,\\n zorder=10,\\n )\\n\\n plt.show()\",\n \"def __init__(self):\\n Page.__init__(self, u\\\"Paraboloide Elíptico<br><br>F(x,y)=(x, y, x<sup>2</sup>/a<sup>2</sup> + y<sup>2</sup>/b<sup>2</sup>)\\\")\\n\\n z = 0.5\\n par = RevolutionPlot3D(lambda r, t: r ** 2 + z, (0, 1), (0, 2 * pi))\\n\\n x, y, z2, u, v, cose, sen, t = createVars(['x', 'y', 'z', 'u', 'v', 'cos', 'sen', 't'])\\n\\n mesh1 = Plot3D(lambda x, y, h: h * (x ** 2 + y ** 2 + z - .01), (-1, 1), (-1, 1))\\n mesh1.addEqn(x**2+y**2 - z2**2 == 1)\\n mesh1.addFunction(lambda x, y, h: h * (x ** 2 + y ** 2 + z + .01))\\n mesh1.setLinesVisible(True)\\n mesh1.setMeshVisible(False)\\n mesh1.setBoundingBox(zrange=(-1, 1.5))\\n par.setAmbientColor(_1(145, 61, 74))\\n par.setDiffuseColor(_1(145, 61, 74))\\n par.setSpecularColor(_1(145, 61, 74))\\n baseplane = BasePlane()\\n baseplane.setHeight(0)\\n baseplane.setRange((-2, 2, 7))\\n\\n self.addChild(par)\\n self.addChild(mesh1)\\n self.addChild(baseplane)\",\n \"def plot_plasma(self):\\n x = self.geom.x\\n fig, axes = plt.subplots(1, 2, figsize=(8, 3),\\n constrained_layout=True)\\n # plot densities\\n ax = axes[0]\\n ax.plot(x, self.ne, 'b-')\\n ax.plot(x, self.ni, 'r-')\\n ax.legend(['E', 'Ion'])\\n ax.set_xlabel('Position (m)')\\n ax.set_ylabel('Density (m^-3)')\\n # plot temperature\\n ax = axes[1]\\n ax.plot(x, self.Te, 'b-')\\n ax.plot(x, self.Ti, 'r-')\\n ax.legend(['Te', 'Ti'])\\n ax.set_xlabel('Position (m)')\\n ax.set_ylabel('Temperature (eV)')\\n plt.show()\",\n \"def visualize(self):\\n colors = {'outline': (220, 220, 220),\\n 'inlier': (0, 255, 0),\\n 'outlier': (0, 0, 255),\\n 'lines': (128, 220, 128)}\\n # Create output image for visualization\\n gap = 5\\n h1, w1 = self.target.image.shape[:2]\\n h2, w2 = self.image.shape[:2]\\n vis = np.zeros((max(h1, h2), w1 + w2 + gap, 3), np.uint8)\\n vis[:h1, :w1, :] = self.target.image\\n w1 += gap\\n vis[:h2, w1:w1+w2, :] = self.image\\n \\n # Draw the located object \\n quad = np.float32(self.quad) + np.float32([w1, 0])\\n self.draw(vis, colors['outline'], 2, quad)\\n \\n # draw point details\\n inliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.inliers]\\n outliers = [(x0, y0, x1 + w1, y1) for (x0, y0), (x1, y1) in self.outliers]\\n if colors['outlier'] is not None: # draw x on each point\\n r = 2 # radius\\n thickness = 2\\n for x0, y0, x1, y1 in outliers:\\n cv2.line(vis, (x0 - r, y0 - r), (x0 + r, y0 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x0 + r, y0 - r), (x0 - r, y0 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x1 - r, y1 - r), (x1 + r, y1 + r), colors['outlier'], thickness)\\n cv2.line(vis, (x1 + r, y1 - r), (x1 - r, y1 + r), colors['outlier'], thickness)\\n if colors['lines'] is not None:\\n for x0, y0, x1, y1 in inliers:\\n cv2.line(vis, (x0, y0), (x1, y1), colors['lines'], 1)\\n if colors['inlier'] is not None:\\n for x0, y0, x1, y1 in inliers:\\n cv2.circle(vis, (x0, y0), 2, colors['inlier'], -1)\\n cv2.circle(vis, (x1, y1), 2, colors['inlier'], -1)\\n return vis\",\n \"def plot_frames(beads, sim, ti, tf, savebase):\\n \\n ### define the color for the spheres\\n\\n print 'defining colors'\\n sphere_rgbcolor = gen_colors(sim.nbeads)\\n\\n ### create povray settings\\n\\n print 'creating povray settings'\\n sphere_radius, img_widthpx, img_heightpx, povray_includes, \\\\\\n povray_defaults, sun1, sun2, background, povray_cam, quality \\\\\\n = gen_img_settings_quality(sim.lx)\\n \\n zi = np.zeros((sim.nbeads))\\n \\n ### set general plot properties\\n\\n os.system(\\\"mkdir -p \\\" + savebase)\\n savebase += 'eps_' + str(sim.eps) + '_fp_' + str(sim.fp) + \\\\\\n '_areak_' + str(sim.areak) + '_kappa_' + str(sim.kappa) + '/'\\n os.system(\\\"mkdir -p \\\" + savebase)\\n \\n ### plot the frames\\n \\n for step in range(ti, tf):\\n \\n time = step*sim.dt\\n print 'Step / Total : ', step, tf\\n \\n ### create povray items\\n \\n print 'generating povray item'\\n particles = vapory.Object( \\\\\\n vapory.Union( \\\\\\n *[ vapory.Sphere([beads.xi[step, 0, j], beads.xi[step, 1, j],zi[j]], \\\\\\n sphere_radius, vapory.Texture( \\\\\\n vapory.Pigment('color', sphere_rgbcolor[j]), \\\\\\n vapory.Finish('phong',1)) ) for j in range(0, sim.nbeads ) ] ) )\\n\\n ### generate povray objects\\n\\n print 'generating povray objects'\\n povray_objects = [sun1, sun2, background, particles]\\n ### create the scene\\n scene = vapory.Scene( camera = povray_cam,\\n objects = povray_objects, \\n included = povray_includes, \\n defaults = povray_defaults )\\n \\n ### render image\\n \\n print 'rendering scene'\\n savename = \\\"pov-frame-\\\" + \\\"{0:05d}\\\".format(int(step)) + \\\".png\\\"\\n scene.render(outfile=savename, width=img_widthpx, height=img_heightpx, \\\\\\n antialiasing=0.001, quality=quality, remove_temp=True)\\n \\n ### move the image to the correct destination\\n \\n os.system('mv ' + savename + ' ' + savebase)\\n \\n return\",\n \"def plot_projection(self, normal=(1, 1, 1), index_row=0, index_col=0, show=True, texture=None, cmap=\\\"jet\\\", f=None,\\n plotter=None, title='', font_size=10, font_color='black'):\\n if not plotter:\\n plotter = pv.Plotter()\\n plotter.subplot(index_column=index_col, index_row=index_row)\\n\\n plotter.add_text(title, position=\\\"upper_edge\\\", font_size=font_size, color=font_color)\\n tex = None\\n if texture:\\n\\n if isinstance(texture, np.ndarray):\\n tex = pv.numpy_to_texture(texture)\\n else:\\n tex = pv.read_texture(texture)\\n self.pv_mesh.texture_map_to_plane(inplace=True)\\n # plotter.add_mesh(pv_mesh, texture=tex)\\n\\n og = self.pv_mesh.center\\n projected = self.pv_mesh.project_points_to_plane(origin=og, normal=normal)\\n projected.texture_map_to_plane()\\n plotter.add_mesh(projected, texture=tex)\\n if show:\\n plotter.show()\\n return plotter\",\n \"def draw(self):\\n pt = self.getPoint() # Centre of prism\\n\\n # Form top,left,right corners\\n top = Vector2d(pt.z, pt.y + self.height/2)\\n d = self.height*math.tan(self.angle/2)\\n left = Vector2d(pt.z - d , pt.y - self.height/2)\\n right = Vector2d(pt.z + d, pt.y - self.height/2)\\n\\n\\n top.rotate(self.tilt)\\n left.rotate(self.tilt)\\n right.rotate(self.tilt)\\n\\n # Plot them out with plt.plot\\n plot([top[0],left[0],right[0],top[0]],[top[1],left[1],right[1],top[1]],\\\"k\\\",lw=2.0)\",\n \"def render(pictures):\\n # Display the background\\n display.fill(BLACK)\\n\\n # Draw each picture\\n i = 0 # Number of pictures drawn\\n for picture in pictures:\\n offsets = get_offsets(i)\\n\\n for polygon in picture.polygons:\\n # Adjust vertices so pictures aren't overlapping\\n adjusted_vertices = []\\n\\n for v in polygon.vertices:\\n adjusted_vertices.append((v[0] + offsets[0], v[1] + offsets[1]))\\n pygame.draw.polygon(display, polygon.color, adjusted_vertices)\\n\\n i += 1\\n\\n pygame.display.update()\",\n \"def show(self):\\n from matplotlib import pyplot as plt\\n from mpl_toolkits.mplot3d import Axes3D\\n\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n pos = self.cluster.get_positions()\\n from itertools import combinations\\n for tri in self.mesh.simplices:\\n for comb in combinations(tri, 2):\\n x1 = pos[comb[0], 0]\\n x2 = pos[comb[1], 0]\\n y1 = pos[comb[0], 1]\\n y2 = pos[comb[1], 1]\\n z1 = pos[comb[0], 2]\\n z2 = pos[comb[1], 2]\\n ax.plot([x1, x2], [y1, y2], zs=[z1, z2], color=\\\"black\\\")\\n plt.show()\",\n \"def plot(self, X, sids, nids):\\n X = tocontig(X) # ensure it's contig\\n gw = self.glWidget\\n gw.points = X\\n gw.npoints = len(X)\\n gw.sids = sids\\n gw.nids = nids\\n gw.color() # set colors\\n gw.updateGL()\",\n \"def plot(self, X, sids, nids):\\n X = tocontig(X) # ensure it's contig\\n gw = self.glWidget\\n gw.points = X\\n gw.npoints = len(X)\\n gw.sids = sids\\n gw.nids = nids\\n gw.color() # set colors\\n gw.updateGL()\",\n \"def __init__(self, **kwargs):\\n super().__init__(**kwargs)\\n self.__iteration_number = kwargs['iteration_number']\\n self.__particles = [\\n PSOParticle(**kwargs, bit_generator=self._random)\\n for _ in range(kwargs['particles'])\\n ]\\n\\n # The library stores particles in the visualizer .... groan\\n positions = [particle.position for particle in self.__particles]\\n self._visualizer = NoVisualizer(**kwargs)\\n self._visualizer.add_data(positions=positions)\",\n \"def draw(self):\\n\\t\\tif self.image != None:\\n\\t\\t\\treturn\\n\\n\\t\\tself.image = Image.new(\\\"RGBA\\\", \\n\\t\\t\\t(self.__class__._width, self.__class__._height), (0,0,0,0))\\n\\t\\tdr = aggdraw.Draw(self.image)\\n\\n\\t\\tzIndexList = [] # list of z-indexes\\n\\t\\tgIndexList = [] # list of gene indexes\\n\\n\\t\\tgeneIdx = 0\\n\\t\\tfor gene in self.chromosome: \\n\\t\\t\\tzIndexList.append(gene[0])\\n\\t\\t\\tgIndexList.append(geneIdx)\\n\\t\\t\\tgeneIdx+=1\\n\\n\\t\\twhile len(zIndexList) > 0:\\n\\t\\t\\tzIndexMin = zIndexList.index(min(zIndexList))\\n\\t\\t\\tgeneIdx = gIndexList[zIndexMin]\\n\\t\\t\\tz = self.chromosome[geneIdx,0]\\n\\t\\t\\tcolor = self.chromosome[geneIdx,1]\\n\\t\\t\\tpoly = self.chromosome[geneIdx,2]\\n\\n\\t\\t\\tcol = color.getColor()\\n\\t\\t\\tcords = poly.getCords()\\n\\t\\t\\tbrush = aggdraw.Brush(col)\\n\\n\\t\\t\\t#dr.ellipse((x, y, x+rad, y+rad), None, brush)\\n\\t\\t\\tdr.polygon(cords, None, brush)\\n\\t\\t\\tdr.flush()\\n\\n\\t\\t\\tif 0: # Debug - draw dot in center of polygon\\n\\t\\t\\t\\tcenter = (poly.xAnchor, poly.yAnchor, poly.xAnchor+5, poly.yAnchor+5)\\n\\t\\t\\t\\tdr.ellipse(center, None, aggdraw.Brush((255,0,0,255)))\\n\\t\\t\\t\\tdr.flush()\\n\\n\\t\\t\\tzIndexList.pop(zIndexMin)\\n\\t\\t\\tgIndexList.pop(zIndexMin)\\n\\n\\t\\tself.image = self.image.convert(\\\"RGB\\\")\",\n \"def plot_all(self) -> None:\\n self.__plot_si_cf_plane()\\n self.__plot_convex_hull()\\n self.__plot_fixed_radius()\\n self.__plot_delaunay()\",\n \"def showAsPoints(self): \\n MonkeyPatchMayaVi()\\n #import enthought.mayavi.mlab as mlab\\n from mayavi import mlab\\n \\n @mlab.show\\n def _showSimple():\\n morphPts = [ SVVisitorFactory.Array4AllPoints(morph)() for morph in self.morphs ]\\n pts = numpy.concatenate( morphPts)\\n return mlab.points3d(pts[:, 0], pts[:, 1], pts[:, 2], pts[:, 3], colormap=self.colormap, scale_factor=self.scale_factor)\\n _showSimple()\",\n \"def draw_pyramid(self):\\n for item in self.subdivision_list:\\n glBegin(GL_POLYGON)\\n glColor3f(0.5, 0.5, 0.5)\\n glVertex3f(item[0].x, item[0].y, item[0].z)\\n glVertex3f(item[1].x, item[1].y, item[1].z)\\n glVertex3f(item[2].x, item[2].y, item[2].z)\\n glEnd()\",\n \"def get_plot(sample):\\n scale = (CANVAS_DIM/PATCH_DIM)\\n ego_pose = sample[0]\\n map_mask = sample[2]\\n\\n fig, ax = plt.subplots()\\n ax.set_ylim([0, CANVAS_DIM]) # set the bounds to be 10, 10\\n ax.set_xlim([0, CANVAS_DIM])\\n ax.imshow(map_mask[0])\\n\\n for vehicle in sample[1]:\\n plot_vehicle(ax, vehicle, ego_pose, scale)\\n\\n plt.show()\",\n \"def render_point_cloud(frame_id):\\n point_cloud_world_coordinates = get_point_cloud_world_coordinates(frame_id)\\n # pptk\\n v = pptk.viewer(point_cloud_world_coordinates)\\n v.set(point_size=0.0001)\\n v.color_map('cool', scale=[0, 5])\",\n \"def plot(self):\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection=Axes3D.name)\\n\\n # TODO Use numpy to rotate esp_points matrix for faster variable access.\\n ax.scatter(\\n xs=[i[0][0] for i in self.esp_points],\\n ys=[i[0][1] for i in self.esp_points],\\n zs=[i[0][2] for i in self.esp_points],\\n c=[i[1] for i in self.esp_points],\\n marker='o',\\n s=2,\\n alpha=0.5\\n )\\n\\n ax.scatter(\\n xs=[i[0][0] for i in self.atom_points],\\n ys=[i[0][1] for i in self.atom_points],\\n zs=[i[0][2] for i in self.atom_points],\\n c=[i[1] for i in self.atom_points],\\n marker='X',\\n s=100\\n )\\n\\n plt.show()\",\n \"def plot_surface(self):\\n X, Y = np.meshgrid(self.x, self.y)\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n ax.plot_surface(X=X, Y=Y, Z=self.z)\\n plt.show()\",\n \"def visualize(simulator):\\n from matplotlib import animation\\n import matplotlib.pyplot as plt\\n\\n X = [particle.x for particle in simulator.particles]\\n Y = [particle.y for particle in simulator.particles]\\n\\n fig = plt.figure()\\n ax = plt.subplot(111, aspect=\\\"equal\\\")\\n line, = ax.plot(X, Y, \\\"ro\\\")\\n\\n # Axial limits\\n plt.xlim(-1, 1)\\n plt.ylim(-1, 1)\\n\\n def _init():\\n \\\"\\\"\\\"\\n Custom initializer closure for visualizer function.\\n\\n PARAMS: N/A\\n RETURN: {line}, : Single subplot object. \\n \\\"\\\"\\\"\\n line.set_data([], [])\\n return line, \\n\\n def _animate(foo):\\n \\\"\\\"\\\"\\n Helper closure for animating particle simulator using MatPlotLib's PyPlot library. \\n\\n PARAMS: N/A\\n RETURN: {line}, : Single subplot object with updated particle data.\\n \\\"\\\"\\\"\\n simulator.evolve(0.01)\\n X = [particle.x for particle in simulator.particles]\\n Y = [particle.y for particle in simulator.particles]\\n\\n line.set_data(X, Y)\\n return line,\\n\\n anim = animation.FuncAnimation(fig, _animate, init_func=_init, blit=True, interval=10)\\n plt.show()\",\n \"def visualize(self):\\n import matplotlib.pyplot as plt\\n import numpy as np\\n\\n plt.figure()\\n sw_ = np.linspace(0.0, 1.0, 50)\\n plt.plot(sw_, self.krw(sw_), label=\\\"Water\\\")\\n plt.plot(sw_, self.kro(sw_), label=\\\"Oil\\\")\\n plt.xlabel(\\\"Water saturation\\\")\\n plt.ylabel(\\\"Relative permeability\\\")\\n plt.legend()\",\n \"def _plot_sr_surface(self, varname):\\n\\n fig = plt.figure()\\n varname = self.layer_lookup[varname]\\n data = self.node_data[varname]\\n x_node_loc = np.arange(self.mins[0], self.maxs[0], self.min_grid_size) + self.min_grid_size/2\\n y_node_loc = np.arange(self.mins[1], self.maxs[1], self.min_grid_size) + self.min_grid_size/2\\n lon2d, lat2d = np.meshgrid(x_node_loc, y_node_loc)\\n\\n # mask NaN values\\n data_m = np.ma.array(data, mask=np.isnan(data))\\n plt.pcolormesh(lon2d, lat2d, data_m.T, vmin=data_m.min(), vmax=data_m.max())\",\n \"def plot3d(self):\\n plot_rupture_wire3d(self)\",\n \"def pontos(self):\\n \\n self.sc = 1. \\n self.x = self.sc*np.array([-155., -139.4, -124., -108.5, -93., -77.5, -62., -46.5, -31., -15.5, 0, 15.5, 31., 46.5, 62., 77.5, 93., 108.5, 124., 139.5, 155.])\\n self.y = self.sc*np.array([ 9.23, 14.37, 18.98, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 23.6, 21.55, 14.37, 3.59])\\n self.px_index = len(self.x)\\n #self.py_index = len(self.x)/2\\n\\n self.coord = np.array([self.x,self.y,np.full(len(self.x),self.z)])\\n \\n self.x = self.x[::-1]\\n self.y = -self.y[::-1] \\n self.new = np.array([self.x,self.y,np.full(len(self.x),self.z)])\\n self.coord = np.array([np.append(self.coord[0],self.new[0]),np.append(self.coord[1],self.new[1]),np.append(self.coord[2],self.new[2])])\\n self.coord = np.array([np.append(self.coord[0],self.coord[0,0]),np.append(self.coord[1],self.coord[1,0]),np.append(self.coord[2],self.coord[2,0])])\\n\\n self.coord[0] = self.coord[0] - (np.amax(self.coord[0])+np.amin(self.coord[0]))/2\\n self.coord[1] = self.coord[1] + (np.amax(self.coord[1])-np.amin(self.coord[1]))/2 \\n \\n self.coordi = np.array(self.coord)\\n \\n self.cg = np.array([0 + self.dx, self.H/2 + self.dy, self.z]) \\n self.cgi = np.array(self.cg)\\n \\n self.thi = 0. + self.dth \\n self.th = float(self.thi) \\n \\n self.coordnav(self.dx,self.dy,self.dth)\",\n \"def plotsite(self):\\n if self.dimension==1 or self.dimension==2:\\n for site in self.sites.flatten():\\n plt.scatter(site.coordinate[0],site.coordinate[1],marker=site.marker,s=site.markersize,c=site.color)\\n elif self.dimension==3:\\n from mpl_toolkits.mplot3d import Axes3D\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for site in self.sites.flatten():\\n ax.scatter(site.coordinate[0],site.coordinate[1],site.coordinate[2],marker=site.marker,s=site.markersize,c=site.color)\",\n \"def visualise(self) -> None:\\n nx_graph = nx.DiGraph()\\n\\n for v in self._vertices:\\n if not v.predicate:\\n name = v.name.split(\\\"/\\\")[-1]\\n nx_graph.add_node(name, name=name, pred=v.predicate)\\n\\n for v in self._vertices:\\n if not v.predicate:\\n v_name = v.name.split(\\\"/\\\")[-1]\\n # Neighbors are predicates\\n for pred in self.get_neighbors(v):\\n pred_name = pred.name.split(\\\"/\\\")[-1]\\n for obj in self.get_neighbors(pred):\\n obj_name = obj.name.split(\\\"/\\\")[-1]\\n nx_graph.add_edge(v_name, obj_name, name=pred_name)\\n\\n plt.figure(figsize=(10, 10))\\n _pos = nx.circular_layout(nx_graph)\\n nx.draw_networkx_nodes(nx_graph, pos=_pos)\\n nx.draw_networkx_edges(nx_graph, pos=_pos)\\n nx.draw_networkx_labels(nx_graph, pos=_pos)\\n names = nx.get_edge_attributes(nx_graph, \\\"name\\\")\\n nx.draw_networkx_edge_labels(nx_graph, pos=_pos, edge_labels=names)\",\n \"def render(self):\\n\\n theta = self.angle*math.pi/180.0\\n cth = math.cos(theta)\\n sth = math.sin(theta)\\n pts = []\\n cornerpts = []\\n\\n for vertex in self.points:\\n x = vertex[0] + self.pos[0] - self.anchor[0]\\n y = vertex[1] + self.pos[1] - self.anchor[1]\\n\\n xt = x * cth - y * sth\\n yt = x * sth + y * cth\\n\\n x = xt + self.anchor[0]\\n y = yt + self.anchor[1]\\n\\n cornerpts.append([x,y])\\n pts.append(gr.Point(self.scale * x, self.win.getHeight() - self.scale*y))\\n\\n self.corners = cornerpts\\n self.vis = [gr.Polygon(pts)]\",\n \"def _plot_map(self):\\n\\n # Plot points if they exist\\n\\n if len(self._laserX) > 0:\\n self._plot_laser()\\n\\n if len(self._goalX) > 0:\\n self._plot_goal()\\n\\n if len(self._summitX) > 0:\\n self._plot_summit()\\n\\n self._plot_objects()\\n\\n # Update Plot\\n self._fig.canvas.draw_idle()\\n\\n plt.pause(0.01)\",\n \"def open3dpaint(nppoints, color_map = 'jet', reduce_for_vis = False, voxel_size = 0.1, pointsize = 0.1):\\n assert (type(nppoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(nppoints) == pclpy.pcl.PointCloud.PointXYZ) or (type(nppoints) == np.ndarray) or (type(nppoints) is list) or (type(nppoints) is tuple), 'Not valid point_cloud'\\n \\n if (type(nppoints) is not list) & (type(nppoints) is not tuple):\\n nppoints = [nppoints]\\n try:\\n visualizer = open3d.visualization.Visualizer()\\n visualizer.create_window()\\n options = visualizer.get_render_option()\\n options.background_color = np.asarray([0, 0, 0])\\n options.point_size = pointsize\\n\\n if len(nppoints) > 1:\\n for n,i in enumerate(nppoints):\\n workpoints = i\\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\\n workpoints = workpoints.xyz\\n\\n if reduce_for_vis:\\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\\n\\n points = convertcloud(workpoints)\\n color_coef = n/len(nppoints)/2 + n%2*.5\\n if type(color_map) == np.ndarray:\\n color = color_map\\n elif color_map == 'jet':\\n color=cm.jet(color_coef)[:3]\\n else:\\n color=cm.Set1(color_coef)[:3]\\n points.colors = open3d.utility.Vector3dVector(np.ones_like(workpoints)*color)\\n #points.colors = open3d.utility.Vector3dVector(color)\\n visualizer.add_geometry(points)\\n else:\\n workpoints = nppoints[0]\\n if (type(workpoints) == pclpy.pcl.PointCloud.PointXYZRGB) or (type(workpoints) == pclpy.pcl.PointCloud.PointXYZ):\\n workpoints = workpoints.xyz\\n \\n if reduce_for_vis:\\n workpoints = seg_tree.voxelize(workpoints,voxel_size)\\n points = convertcloud(workpoints)\\n visualizer.add_geometry(points)\\n visualizer.run()\\n visualizer.destroy_window()\\n \\n except Exception as e:\\n print(type(e))\\n print(e.args)\\n print(e)\\n visualizer.destroy_window()\",\n \"def render(self):\\n canvas_id = 'zdog_{}'.format(self.CANVAS_INDEX)\\n illo_id = 'illo_{}'.format(self.CANVAS_INDEX)\\n Scene.CANVAS_INDEX += 1\\n\\n html_lines = []\\n\\n js_lines = []\\n\\n euler = -rowan.to_euler(\\n self.rotation, convention='xyz', axis_type='intrinsic')\\n translation = self.translation*(1, -1, 1)\\n\\n pan_cfg = self.get_feature_config('pan')\\n pan = pan_cfg.get('value', True) if pan_cfg is not None else False\\n\\n js_lines.append(\\\"\\\"\\\"\\n let {illo_id} = new Zdog.Illustration({{\\n element: '#{canvas_id}',\\n zoom: {zoom},\\n dragRotate: {rotation_enabled},\\n rotate: {{x: {angle[0]}, y: {angle[1]}, z: {angle[2]}}},\\n translate: {{x: {pos[0]}, y: {pos[1]}, z: {pos[2]}}},\\n }});\\n \\\"\\\"\\\".format(\\n illo_id=illo_id, canvas_id=canvas_id, zoom=self.zoom*self.pixel_scale,\\n angle=euler, pos=translation,\\n rotation_enabled=('false' if pan else 'true')))\\n\\n config = self.get_feature_config('ambient_light')\\n ambient_light = 0 if config is None else config.get('value', .4)\\n\\n config = self.get_feature_config('directional_light')\\n directional_light = ([(0, 0, 0)] if config is None else\\n config.get('value', [(0, 0, 0)]))\\n directional_light = np.atleast_2d(directional_light)\\n\\n shapeIndex = 0\\n for i, prim in enumerate(self._primitives):\\n js_lines.extend(prim.render(\\n rotation=self.rotation, illo_id=illo_id,\\n name_suffix=i, ambient_light=ambient_light,\\n directional_light=directional_light))\\n\\n (width, height) = map(int, self.size_pixels)\\n html_lines.append(\\\"\\\"\\\"\\n <canvas id=\\\"{canvas_id}\\\" width=\\\"{width}\\\" height=\\\"{height}\\\"></canvas>\\n \\\"\\\"\\\".format(canvas_id=canvas_id, width=width, height=height))\\n\\n html_lines.append(\\\"\\\"\\\"<script>\\n var fill_{canvas_id} = function() {{\\n \\\"\\\"\\\".format(canvas_id=canvas_id))\\n html_lines.append(LOCAL_HELPER_SCRIPT)\\n html_lines.extend(js_lines)\\n\\n pan_snippet = \\\"\\\"\\\"\\n new Zdog.Dragger({{\\n startElement: {illo_id}.element,\\n onDragStart: function( pointer, moveX, moveY) {{\\n this.lastX = 0;\\n this.lastY = 0;\\n }},\\n onDragMove: function( pointer, moveX, moveY ) {{\\n let deltax = moveX - this.lastX;\\n let deltay = moveY - this.lastY;\\n let scale = 1.0/{illo_id}.zoom;\\n {illo_id}.translate.x += deltax*scale;\\n {illo_id}.translate.y += deltay*scale;\\n this.lastX = moveX;\\n this.lastY = moveY;\\n }}\\n }});\\\"\\\"\\\".format(illo_id=illo_id)\\n if pan:\\n html_lines.append(pan_snippet)\\n\\n html_lines.append(\\\"\\\"\\\"\\n let this_canvas = document.querySelector(\\\"#{canvas_id}\\\");\\n \\\"\\\"\\\".format(canvas_id=canvas_id))\\n html_lines.append(\\\"\\\"\\\"\\n let animate_{canvas_id} = function() {{\\n if(is_in_view(this_canvas))\\n {{\\n {illo_id}.updateRenderGraph();\\n }}\\n if(document.contains(this_canvas))\\n {{\\n requestAnimationFrame(animate_{canvas_id});\\n }}\\n }};\\n animate_{canvas_id}();\\\"\\\"\\\".format(canvas_id=canvas_id, illo_id=illo_id))\\n # remove the global reference to this function after using it\\n html_lines.append('fill_{canvas_id} = null;'.format(canvas_id=canvas_id))\\n html_lines.append('};') # end of fill_{canvas_id}\\n # now call fill_{canvas_id}, possibly after loading zdog\\n html_lines.append(\\\"\\\"\\\"\\n if (typeof Zdog == 'undefined')\\n {{\\n var script = document.createElement('script');\\n script.addEventListener('load', fill_{canvas_id}, false);\\n script.src = 'https://unpkg.com/zdog@1/dist/zdog.dist.min.js';\\n document.getElementsByTagName('head')[0].appendChild(script);\\n }}\\n else\\n fill_{canvas_id}();\\n \\\"\\\"\\\".format(canvas_id=canvas_id))\\n html_lines.append('</script>')\\n\\n return '\\\\n'.join(html_lines)\",\n \"def render(self, mode = 'human'):\\n if mode == 'human':\\n\\n if self.is_2d:\\n fig = plt.figure()\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n plt.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n plt.scatter(*index, c='blue', s=1000, alpha=0.2)\\n plt.xlim(-1, self.dim[0])\\n plt.ylim(-1, self.dim[1])\\n plt.xticks([])\\n plt.yticks([])\\n plt.grid(True)\\n\\n if self.is_3d:\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\\n ax.set_xlim(0, self.dim[0] - 1)\\n ax.set_ylim(0, self.dim[1] - 1)\\n ax.set_zlim(0, self.dim[2] - 1)\\n\\n else:\\n fig = plt.figure()\\n ax = Axes3D(fig)\\n for index, value in np.ndenumerate(self.board):\\n if value == 1:\\n ax.scatter(*index, c='red', s=1000, alpha=0.2)\\n elif value == -1:\\n ax.scatter(*index, c='blue', s=1000, alpha=0.2)\\n\\n ax.set_xlim(0, self.dim[0] - 1)\\n ax.set_ylim(0, self.dim[1] - 1)\\n ax.set_zlim(0, self.dim[2] - 1)\\n ax.set_title('Nr of steps: ' + str(self.steps))\\n\\n plt.show()\\n return fig\",\n \"def plot_tomo_vel(self, period=6., projection='lambert',geopolygons=None, showfig=True, vmin=None, vmax=None, sta=True, hillshade=False):\\n\\t\\tif hillshade:\\n\\t\\t\\talpha = 0.5\\n\\t\\telse:\\n\\t\\t\\talpha =1.\\n\\t\\tm = self._get_basemap(projection=projection, geopolygons=geopolygons,hillshade=hillshade)\\n\\t\\tgroup = self['%g_sec'%( period )]\\n\\t\\tx, y = m(group['lonArr'].value, group['latArr'].value)\\n\\t\\tmy_cmap = pycpt.load.gmtColormap('./cv.cpt')\\n\\t\\ttomo_data = group['tomo_data'].value\\n\\t\\ttomo_data_msk = group['tomo_data_msk'].value\\n\\t\\tif vmin == None:\\n\\t\\t\\tvmin = np.nanmin(tomo_data[~tomo_data_msk])\\n\\t\\t\\tvmin = np.ceil(vmin*20.)/20.\\n\\t\\tif vmax == None:\\n\\t\\t\\tvmax = np.nanmax(tomo_data[~tomo_data_msk])\\n\\t\\t\\tvmax = np.floor(vmax*20.)/20.\\n\\t\\tim = m.pcolormesh(x, y, np.ma.masked_array(tomo_data,mask=tomo_data_msk), cmap=my_cmap, shading='gouraud', vmin=vmin, vmax=vmax, alpha=alpha)\\n\\t\\tcb = m.colorbar(im, \\\"bottom\\\", size=\\\"3%\\\", pad='2%', format='%.2f')\\n\\t\\tcb.set_label('vel (km/s)', fontsize=12, rotation=0)\\n\\t\\tcb.set_alpha(1)\\n\\t\\tcb.draw_all()\\n\\t\\tax = plt.gca() # only plot the oceanic part for JdF\\n\\t\\t#x_cobb,y_cobb = m(-130.0000,46.0000) #cobb hotspot\\n\\t\\t#ax.plot(x_cobb,y_cobb,'o', color='white',alpha=.6,ms=8,mec='white')\\n\\t\\tif sta:\\n\\t\\t\\tself.sta_on_plot(ax,m,period)\\n\\t\\t# ax.set_xlim(right=x_max)\\n\\t\\tfig = plt.gcf()\\n\\t\\tfig.suptitle(str(period)+' sec', fontsize=14,y=0.95)\\n\\t\\tif showfig:\\n\\t\\t\\tplt.show()\\n\\t\\treturn m\",\n \"def plot_root(self, root):\\n vessel = Marker()\\n #visualizations points and lines..\\n vessel.header.frame_id = \\\"map\\\"\\n vessel.header.stamp = rospy.get_rostime()\\n vessel.ns = \\\"markers\\\"\\n vessel.id = 1\\n vessel.type = vessel.ARROW\\n vessel.action = vessel.ADD\\n \\n vessel.scale.x = 10*self.rviz_tuning_plt\\n vessel.scale.y = 2*self.rviz_tuning_plt\\n vessel.scale.z = 2*self.rviz_tuning_plt\\n vessel.color.r = 0.0\\n vessel.color.g = 0.0\\n vessel.color.b = 1.0\\n vessel.color.a = 1.0\\n # A value of ros.Duration() means never to auto-delete.\\n vessel.lifetime = rospy.Duration()\\n # Add x,y,z position to pose\\n vessel.pose.position.x = root.x\\n vessel.pose.position.y = root.y\\n vessel.pose.position.z = 0\\n # add quaternion to pose\\n quat = self.euler_to_quaternion(0, 0, root.alpha)\\n vessel.pose.orientation.x = quat[0]\\n vessel.pose.orientation.y = quat[1]\\n vessel.pose.orientation.z = quat[2]\\n vessel.pose.orientation.w = quat[3]\\n self.pub_root.publish(vessel)\",\n \"def __init__(self, particles):\\n self.particles = particles\",\n \"def drawScene(self):\\n glBegin(GL_LINES)\\n # draw axes\\n glColor3f(1, 0, 0)\\n glVertex3f(0, 0, 0)\\n glVertex3f(self.worldSize / 2, 0, 0)\\n glColor3f(0, 1, 0)\\n glVertex3f(0, 0, 0)\\n glVertex3f(0, self.worldSize / 2, 0)\\n glColor3f(0, 0, 1)\\n glVertex3f(0, 0, 0)\\n glVertex3f(0, 0, self.worldSize / 2)\\n # draw bounding box\\n glColor3f(1, 1, 1)\\n scalar = (self.worldSize - 1) / 2\\n for x in [-1, 1]:\\n for y in [-1, 1]:\\n for z in [-1, 1]:\\n glVertex3f(scalar * x, scalar * y, scalar * z)\\n for z in [-1, 1]:\\n for x in [-1, 1]:\\n for y in [-1, 1]:\\n glVertex3f(scalar * x, scalar * y, scalar * z)\\n for y in [-1, 1]:\\n for z in [-1, 1]:\\n for x in [-1, 1]:\\n glVertex3f(scalar * x, scalar * y, scalar * z)\\n glEnd()\\n # draw spheres if in POINTS mode\\n if self.displayMode is self.DISPLAYMODE_POINTS:\\n prev = (0, 0, 0)\\n offset = int(self.worldSize / 2)\\n for x in range(self.worldSize):\\n for y in range(self.worldSize):\\n for z in range(self.worldSize):\\n glTranslatef(x - offset - prev[0], y - offset - prev[1], z - offset - prev[2])\\n # use threshold for black/white coloring\\n if self.world[x][y][z] > self.worldThreshold:\\n glColor3f(1, 1, 1)\\n else:\\n glColor3f(0, 0, 0)\\n gluSphere(self.sphere, 0.1, 8, 4)\\n prev = (x - offset, y - offset, z - offset)\\n # draw mesh if in MESH mode\\n elif self.displayMode is self.DISPLAYMODE_MESH:\\n offset = int(self.worldSize / 2)\\n for x in range(self.worldSize - 1):\\n for y in range(self.worldSize - 1):\\n for z in range(self.worldSize - 1):\\n if self.polygons[x][y][z]:\\n glBegin(GL_POLYGON)\\n glColor3f(x / self.worldSize, y / self.worldSize, z / self.worldSize)\\n for vertex in self.polygons[x][y][z]:\\n glVertex3f(x + vertex[0] - offset, y + vertex[1] - offset, z + vertex[2] - offset)\\n glEnd()\\n # draw wireframe in in WIRE mode\\n elif self.displayMode is self.DISPLAYMODE_WIREFRAME:\\n offset = int(self.worldSize / 2)\\n for x in range(self.worldSize - 1):\\n for y in range(self.worldSize - 1):\\n for z in range(self.worldSize - 1):\\n glBegin(GL_LINES)\\n glColor3f(x / self.worldSize, y / self.worldSize, z / self.worldSize)\\n for vertex in self.polygons[x][y][z]:\\n glVertex3f(x + vertex[0] - offset, y + vertex[1] - offset, z + vertex[2] - offset)\\n glEnd()\\n # draw background in the distance\\n glLoadIdentity()\\n glBegin(GL_QUADS)\\n glColor3f(59 / 256, 102 / 256, 212 / 256)\\n glVertex3f(-30, -23, -49.5)\\n glVertex3f(30, -23, -49.5)\\n glColor3f(184 / 256, 201 / 256, 242 / 256)\\n glVertex3f(30, 23, -49.5)\\n glVertex3f(-30, 23, -49.5)\\n glEnd()\\n # HUD in white\\n glColor3f(1, 1, 1)\\n # lower left\\n glWindowPos2f(10, 10)\\n for ch in 'WASD: Rotate':\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\\n glWindowPos2f(10, 25)\\n for ch in 'Wheel: Thresh':\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\\n glWindowPos2f(10, 40)\\n for ch in 'R: Randomize':\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\\n glWindowPos2f(10, 55)\\n for ch in 'O: Object':\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\\n glWindowPos2f(10, 70)\\n for ch in 'I: Wireframe':\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\\n glWindowPos2f(10, 85)\\n for ch in 'P: Points':\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\\n # upper right\\n glWindowPos2f(self.displaySize[0] - 118, self.displaySize[1] - 25)\\n for ch in 'Thresh: %0.2f' % self.worldThreshold:\\n glutBitmapCharacter(GLUT_BITMAP_9_BY_15, ord(ch))\",\n \"def plot(self):\\n pass\",\n \"def render(self):\\n self.axial.Render()\\n self.coronal.Render()\\n self.sagittal.Render()\\n #self.isosurface.Render()\\n #self.rwi_pcp.Render()\",\n \"def plotFeatures(self):\\n fl=np.array(self.xp)*0.0+0.25*self.farr.max()\\n self.splines=self.axes.plot(self.xp, fl , ls='', marker='|', ms=20, color='#00FF00')\\n #set up the text position\\n tsize=0.83\\n self.ymin, self.ymax = self.axes.get_ylim()\\n ppp=(self.ymax-self.ymin)/(self.arcfigure.figure.get_figheight()*self.arcfigure.figure.get_dpi())\\n f=self.ymax-10*tsize*ppp\\n for x,w in zip(self.xp, self.wp):\\n w='%6.2f' % float(w)\\n self.axes.text(x, f, w, size='small', rotation='vertical', color='#00FF00')\",\n \"def plotVoronoiCell(self, cells):\\n for i in cells:\\n #i indexes volumes\\n i = self.nonBI[i] #now i indexes vor.point_region\\n\\n vI = self.vor.regions[self.vor.point_region[i]]\\n v = self.vor.vertices[vI, :]\\n r = v\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111, projection='3d')\\n fig.set_size_inches(18.5, 9.5)\\n ax.set_title('Voronoi Cell of Particle ' + str(i))\\n ax.set_xlabel('x [m]')\\n ax.set_ylabel('y [m]')\\n ax.set_zlabel('z [m]')\\n ax.scatter(r[:, 0], r[:, 1], r[:, 2], s=5, alpha=0.5, label='Cell Boundaries')\\n ax.scatter(self.data[i, 0], self.data[i, 1], self.data[i, 2], s=25, label='Cell Center')\\n ax.set_xlim3d(np.min(self.data[:, 0]), np.max(self.data[:, 0]))\\n ax.set_ylim3d(np.min(self.data[:, 1]), np.max(self.data[:, 1]))\\n ax.set_zlim3d(np.min(self.data[:, 2]), np.max(self.data[:, 2]))\\n # limits = np.vstack((np.array([np.max(self.data[:, 0]), np.max(self.data[:, 1]), np.max(self.data[:, 2])]), np.array([np.min(self.data[:, 0]), np.min(self.data[:, 1]), np.min(self.data[:, 2])])))\\n # ax.scatter(limits[:, 0], limits[:, 1], limits[:, 2], s=1)\\n ax.legend()\",\n \"def show():\\n setup()\\n plt.show()\",\n \"def draw(self):\\n #for (x, y) in self.coords:\\n # pyxel.rect(\\n # (x + self.x) * 4,\\n # (y + self.y) * 4,\\n # (x + self.x) * 4 + 3,\\n # (y + self.y) * 4 + 3,\\n # self.color)\",\n \"def plot_3d_object(object_):\\n \\n # Initialize renderer instance\\n r = Renderer()\\n\\n # Add surfaces and goal regions to the renderer instance\\n for surf in object_:\\n r.add((object_[surf][0],'b',1))\\n if len(object_[surf])>2:\\n r.add((object_[surf][2],'r',1))\\n r.add((gPoint(-15,-15,-15),'k',1))\\n r.show()\",\n \"def visualisation(self):\\n plt.plot(self.x, self.y, 'o', label = 'Example data')\\n plt.plot(self.x, np.dot(self.w, self.X), label = 'Model')\\n plt.xlim([-1,1])\\n plt.ylim([-1,1])\",\n \"def generatePolygons(self, *args, **kwargs): \\n return 'var PloneMapPolygons = [' + \\\\\\n ''.join([\\\"{ 'id': '%s', 'path' : %s,'title':'%s'},\\\" % (object.id, object.polygon, object.Title()) \\n for object in self.context.objectValues() \\n if hasattr(object, 'polygon') and len(object.polygon) > 0 ])[:-1] \\\\\\n + '];'\",\n \"def plot_vertices(self, f=None, index_row=0, index_col=0, show=True, plotter=None, cmap='jet', title='',\\n title_location=\\\"upper_edge\\\", font_size=10, font_color='black', camera=None):\\n\\n if not plotter:\\n plotter = pv.Plotter()\\n plotter.subplot(index_column=index_col, index_row=index_row)\\n plotter.add_text(title, position=title_location, font_size=font_size, color=font_color)\\n if camera is not None:\\n plotter.set_position(camera[0])\\n plotter.set_focus(camera[1])\\n plotter.set_viewup(camera[2])\\n plotter.add_mesh(self.vertices, scalars=f, cmap=cmap, render_points_as_spheres=True)\\n if show:\\n plotter.show()\\n return plotter\",\n \"def plot_vor_colored(self,x,ax,cmap):\\n\\n L = self.L\\n grid_x, grid_y = np.mgrid[-1:2, -1:2]\\n grid_x[0, 0], grid_x[1, 1] = grid_x[1, 1], grid_x[0, 0]\\n grid_y[0, 0], grid_y[1, 1] = grid_y[1, 1], grid_y[0, 0]\\n y = np.vstack([x + np.array([i * L, j * L]) for i, j in np.array([grid_x.ravel(), grid_y.ravel()]).T])\\n\\n cmap_print = np.tile(cmap.T,9).T\\n bleed = 0.1\\n cmap_print = cmap_print[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\\n y = y[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(y))\\n\\n\\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\\n if type(self.c_types) is list:\\n # ax.scatter(x[:, 0], x[:, 1],color=\\\"grey\\\",zorder=1000)\\n for region in regions:\\n polygon = vertices[region]\\n plt.fill(*zip(*polygon), alpha=0.4, color=\\\"grey\\\")\\n\\n else:\\n patches = []\\n for i, region in enumerate(regions):\\n patches.append(Polygon(vertices[region], True,facecolor=cmap_print[i],edgecolor=\\\"white\\\",alpha=0.5))\\n\\n p = PatchCollection(patches, match_original=True)\\n # p.set_array(c_types_print)\\n ax.add_collection(p)\",\n \"def draw( self ):\\r\\n print \\\"Drawing cuboid!\\\"\\r\\n glTranslated( *self.pos3D ) # This moves the origin of drawing , so that we can use the above coordinates at each draw location\\r\\n if self.rotnByOGL:\\r\\n glRotated( self.thetaDeg , *self.rotAxis )\\r\\n # glTranslated( 0 , 0 , 0 ) # This moves the origin of drawing , so that we can use the above coordinates at each draw location\\r\\n print \\\"DEBUG:\\\" , \\\"Translated to\\\" , 0 , 0 , 0\\r\\n glColor3ub( *self.color ) # Get the color according to the voxel type\\r\\n print \\\"DEBUG:\\\" , \\\"Set color to\\\" , self.color\\r\\n pyglet.graphics.draw_indexed( \\r\\n 8 , # --------------------- Number of seqential triplet in vertex list\\r\\n GL_QUADS , # -------------- Draw quadrilaterals\\r\\n self.indices , # ---------- Indices where the coordinates are stored\\r\\n ( 'v3f' , self.vertX ) # vertex list , OpenGL offers an optimized vertex list object , but this is not it\\r\\n ) # 'v3i' # This is for integers I suppose!\\r\\n \\r\\n glColor3ub( *self.colorLine )\\r\\n pyglet.gl.glLineWidth( 3 )\\r\\n pyglet.graphics.draw_indexed( \\r\\n 8 , # --------------------- Number of seqential triplet in vertex list\\r\\n GL_LINES , # -------------- Draw quadrilaterals\\r\\n self.linDices , # ---------- Indices where the coordinates are stored\\r\\n ( 'v3f' , self.vertX ) # vertex list , OpenGL offers an optimized vertex list object , but this is not it\\r\\n ) # 'v3i' # This is for integers I suppose!\\r\\n \\r\\n print \\\"DEBUG:\\\" , \\\"Indices\\\"\\r\\n print self.indices \\r\\n print \\\"DEBUG:\\\" , \\\"Vertices\\\"\\r\\n print self.vertices \\r\\n \\\"\\\"\\\" URL: http://pyglet.readthedocs.io/en/pyglet-1.2-maintenance/programming_guide/graphics.html#vertex-lists\\r\\n \\r\\n There is a significant overhead in using pyglet.graphics.draw and pyglet.graphics.draw_indexed due to pyglet \\r\\n interpreting and formatting the vertex data for the video device. Usually the data drawn in each frame (of an animation) \\r\\n is identical or very similar to the previous frame, so this overhead is unnecessarily repeated.\\r\\n \\r\\n A VertexList is a list of vertices and their attributes, stored in an efficient manner that’s suitable for direct \\r\\n upload to the video card. On newer video cards (supporting OpenGL 1.5 or later) the data is actually stored in video memory.\\r\\n \\\"\\\"\\\"\\r\\n if self.rotnByOGL:\\r\\n glRotated( -self.thetaDeg , *self.rotAxis )\\r\\n glTranslated( *np.multiply( self.pos3D , -1 ) ) # Reset the transform coordinates\\r\\n print \\\"DEBUG:\\\" , \\\"Translated to\\\" , 0 , 0 , 0\\r\\n print \\\"Done drawing!\\\"\",\n \"def visualizeObs():\\n fcontourf(fObs, [-2, 2], [-1, 1], [0, 10])\",\n \"def plot_vor(self,x,ax,tri=False):\\n\\n L = self.L\\n grid_x, grid_y = np.mgrid[-1:2, -1:2]\\n grid_x[0, 0], grid_x[1, 1] = grid_x[1, 1], grid_x[0, 0]\\n grid_y[0, 0], grid_y[1, 1] = grid_y[1, 1], grid_y[0, 0]\\n y = np.vstack([x + np.array([i * L, j * L]) for i, j in np.array([grid_x.ravel(), grid_y.ravel()]).T])\\n\\n c_types_print = np.tile(self.c_types,9)\\n bleed = 0.1\\n c_types_print = c_types_print[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\\n y = y[(y<L*(1+bleed)).all(axis=1)+(y>-L*bleed).all(axis=1)]\\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(y))\\n\\n\\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\\n if type(self.c_types) is list:\\n # ax.scatter(x[:, 0], x[:, 1],color=\\\"grey\\\",zorder=1000)\\n for region in regions:\\n polygon = vertices[region]\\n plt.fill(*zip(*polygon), alpha=0.4, color=\\\"grey\\\")\\n\\n else:\\n cols = self.cols\\n if self.plot_scatter is True:\\n for j,i in enumerate(np.unique(self.c_types)):\\n ax.scatter(x[self.c_types==i, 0], x[self.c_types==i, 1],color=cols[i],zorder=1000)\\n patches = []\\n for i, region in enumerate(regions):\\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],ec=(1,1,1,1)))\\n\\n p = PatchCollection(patches, match_original=True)\\n # p.set_array(c_types_print)\\n ax.add_collection(p)\\n if tri is not False:\\n for TRI in tri:\\n for j in range(3):\\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\\n if (a >= 0) and (b >= 0):\\n X = np.stack((x[a], x[b])).T\\n ax.plot(X[0], X[1], color=\\\"black\\\")\",\n \"def figura(self):\\n\\n dx=10.6\\n dy=11.5\\n ###################\\n #primero a dibujar#\\n ###################\\n glBegin(GL_POLYGON)\\n glVertex2f(1.0,2*dy)\\n glVertex2f(dx,5*dy/2)\\n glVertex2f(1.0,45.0)\\n glVertex2f(3*dx/2,3*dy)\\n glVertex2f(5*dx/2,45.0)\\n glVertex2f(7*dx/2,3*dy)\\n glVertex2f(52.0,45.0)\\n glVertex2f(4*dx,5*dy/2)\\n glVertex2f(52.0,2*dy)\\n glVertex2f(4*dx,3*dy/2)\\n glVertex2f(52.0,1.0)\\n glVertex2f(7*dx/2,dy)\\n glVertex2f(5*dx/2,1.0)\\n glVertex2f(3*dx/2,dy)\\n glVertex2f(1.0,1.0)\\n glVertex2f(dx,3*dy/2)\\n glEnd()\\n glColor3f(138.0/255,138.0/255,138.0/255)\\n glBegin(GL_TRIANGLES)\\n glVertex2f(1.0,1.0)\\n glVertex2f(1.0,2*dy)\\n glVertex2f(2*dx/3,3*dy/2)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(1.0,2*dy)\\n glVertex2f(2*dx/3,5*dy/2)\\n glVertex2f(1.0,45.0)\\n glEnd()\\n ###################\\n #segundo a dibujar#\\n ###################\\n glColor3f(249.0/255,135.0/255,21.0/255)\\n glBegin(GL_TRIANGLES)\\n glVertex2f(3*dx/2,2*dy)\\n glVertex2f(3*dx/2,3*dy)\\n glVertex2f(3*dx/2+dx,3*dy)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(3*dx/2+dx,3*dy)\\n glVertex2f(7*dx/2,3*dy)\\n glVertex2f(7*dx/2,2*dy)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(7*dx/2,2*dy)\\n glVertex2f(7*dx/2,dy)\\n glVertex2f(5*dx/2,dy)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(5*dx/2,dy)\\n glVertex2f(3*dx/2,dy)\\n glVertex2f(3*dx/2,2*dy)\\n glEnd()\\n #segundos triangulos naranjos\\n glBegin(GL_TRIANGLES)\\n glVertex2f(3*dx/2,5*dy/2)\\n glVertex2f(3*dx/2,3*dy/2)\\n glVertex2f(dx,2*dy)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(2*dx,3*dy)\\n glVertex2f(5*dx/2,7*dy/2)\\n glVertex2f(3*dx,3*dy)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(7*dx/2,5*dy/2)\\n glVertex2f(4*dx,2*dy)\\n glVertex2f(7*dx/2,3*dy/2)\\n glEnd()\\n glBegin(GL_TRIANGLES)\\n glVertex2f(3*dx,dy)\\n glVertex2f(5*dx/2,dy/2)\\n glVertex2f(2*dx,dy)\\n glEnd()\\n ##################\\n #ultimo a dibujar#\\n ##################\\n xini=3*dx/2\\n yini=2*dy\\n glColor3f(0.8,0.0,0.0)\\n glBegin(GL_QUADS)\\n glVertex2f(xini,yini)\\n glVertex2f(xini+dx,yini+dy)\\n glVertex2f(xini+2*dx,yini)\\n glVertex2f(xini+dx,yini-dy)\\n glEnd()\",\n \"def plot_visual_abstract():\\n # Which generations to plot\\n GENERATIONS = [100, 230, 350]\\n\\n # LunarLander CMA-ES\\n experiment_path = glob(\\\"experiments/wann_LunarLander-v2_CMAES*\\\")\\n assert len(experiment_path) == 1, \\\"There should be only one CMA-ES experiment with LunarLander-v2\\\"\\n experiment_path = experiment_path[0]\\n\\n pivector_paths = glob(os.path.join(experiment_path, \\\"pivectors\\\", \\\"*\\\"))\\n\\n tsnes = []\\n rewards = []\\n for generation in GENERATIONS:\\n # Find pivector files for specific generation, load them and store points\\n generation_paths = [path for path in pivector_paths if \\\"gen_{}_\\\".format(generation) in path]\\n\\n population = [np.load(path) for path in generation_paths]\\n population_tsnes = np.array([x[\\\"tsne\\\"] for x in population])\\n population_rewards = np.array([x[\\\"average_episodic_reward\\\"] for x in population])\\n tsnes.append(population_tsnes)\\n rewards.append(population_rewards)\\n\\n figure, axs = pyplot.subplots(\\n figsize=[2.5 * 3, 2.5],\\n nrows=1,\\n ncols=len(GENERATIONS),\\n sharex=\\\"all\\\",\\n sharey=\\\"all\\\"\\n )\\n\\n min_reward = min(x.min() for x in rewards)\\n max_reward = max(x.max() for x in rewards)\\n scatter = None\\n\\n for idx in range(len(GENERATIONS)):\\n population_tsne = tsnes[idx]\\n population_rewards = rewards[idx]\\n generation = GENERATIONS[idx]\\n ax = axs[idx]\\n\\n scatter = ax.scatter(\\n population_tsne[:, 0],\\n population_tsne[:, 1],\\n c=population_rewards,\\n vmin=min_reward,\\n vmax=max_reward,\\n cmap=\\\"plasma\\\"\\n )\\n ax.set_title(\\\"Generation {}\\\".format(generation))\\n ax.set_xticks([])\\n ax.set_yticks([])\\n ax.axis(\\\"off\\\")\\n\\n # Making room for colorbar\\n # Stackoverflow #13784201\\n figure.subplots_adjust(right=1.0)\\n cbar = figure.colorbar(scatter)\\n cbar.set_ticks([])\\n cbar.ax.set_ylabel(\\\"Reward $\\\\\\\\rightarrow$\\\", rotation=90, fontsize=\\\"large\\\")\\n\\n figure.tight_layout()\\n figure.savefig(\\\"figures/visual_abstract.pdf\\\", bbox_inches=\\\"tight\\\", pad_inches=0.05)\",\n \"def inclass1():\\n import numpy as np\\n import matplotlib.pyplot as plt\\n\\n\\n N = 50\\n x = np.random.rand(N)\\n y = np.random.rand(N)\\n colors = np.random.rand(N)\\n area = np.pi * (15 * np.random.rand(N))**2 # 0 to 15 point radiuses\\n\\n plt.scatter(x, y, s=area, c=colors, alpha=0.5)\\n plt.show()\",\n \"def scatter_plot(self, speed=0.001):\\n FPARTX, FPARTY, FPARTST = self.get_particles_props('x', 'y', 'state')\\n plt.clf()\\n plt.scatter(FPARTX, FPARTY, FPARTST*5 + 0.01, c=FPARTST, cmap=\\\"jet\\\")\\n plt.clim(0, 1)\\n plt.colorbar()\\n plt.pause(speed)\",\n \"def _plot_objects(self):\\n\\n # Remove Existing Annotations\\n for annotation in self._objectAnnotations:\\n annotation.remove()\\n self._objectAnnotations[:] = []\\n\\n # Set Offsets\\n self._objectPoints.set_offsets(np.c_[self._objectX, self._objectZ])\\n\\n # Update Annotations\\n for name, x, z in zip(self._objectNames, self._objectX, self._objectZ):\\n self._objectAnnotations.append(self._scatPlot.annotate(name, (x, z)))\",\n \"def generate_plot(self):\\r\\n\\t\\tx, y = zip(*[p.p for p in self.universe])\\r\\n\\t\\tself.ax.cla()\\r\\n\\t\\tself.ax.plot(x, y, '.')\\r\\n\\t\\tself.ax.set_title('Universe at time: %d' % self.universe.time)\\r\\n\\t\\tself.ax.set_xlim([P_MU-4*P_STD, P_MU+4*P_STD])\\r\\n\\t\\tself.ax.set_ylim([P_MU-4*P_STD, P_MU+4*P_STD])\",\n \"def plotOverlays(self):\\n if self.overlayFluxSurfaces:\\n self.plotFluxSurfaces()\\n if self.overlayMagneticAxis:\\n self.plotMagneticAxis()\\n if self.overlaySeparatrix:\\n self.plotSeparatrix()\\n if self.overlayWallCrossSection:\\n self.plotWallCrossSection()\",\n \"def PlotSphere():\\n sphere = vtkInterface.PolyData(spherefile)\\n sphere.Plot()\",\n \"def update_particles(self):\\n for particle in self.particles:\\n particle.update_coordinates(self.bounds)\",\n \"def show(self, with_particles=True, show_time=None, field=None, domain=None, projection=None,\\n land=True, vmin=None, vmax=None, savefile=None, animation=False, **kwargs):\\n from parcels.plotting import plotparticles\\n plotparticles(particles=self, with_particles=with_particles, show_time=show_time, field=field, domain=domain,\\n projection=projection, land=land, vmin=vmin, vmax=vmax, savefile=savefile, animation=animation, **kwargs)\",\n \"def plot(self):\\n\\t\\tself.plotOfSpect()\",\n \"def petropeakcenter_graph(self):\\n \\n R_PETRO = self['R_PETRO']\\n \\n xcenter = self['X_IMAGE'] ; ycenter = self['Y_IMAGE']\\n xcenter = xcenter - self['MXMIN_IMAGE']\\n ycenter = ycenter - self['MYMIN_IMAGE']\\n center = (xcenter,ycenter)\\n \\n ellip = self['ELLIPTICITY'] \\n q = 1. - ellip\\n pa = self['THETA_IMAGE'] # Astronomical position angle.\\n \\n if 'M_XPEAK' in self:\\n xpeak = self['M_XPEAK'] - self['MXMIN_IMAGE']\\n ypeak = self['M_YPEAK'] - self['MYMIN_IMAGE']\\n peak = (xpeak,ypeak)\\n \\n stamp = self['STAMP'].copy()\\n mask = self['MASK'].copy()\\n sky = self['BACKGROUND']\\n Img = stamp - sky\\n Img[num.where(mask != 0)] = 0.\\n \\n id = self._getGraphId()\\n root = 'petropeakcenter_%s' % (id,)\\n pngname = root + '.png' ; epsname = root + '.eps'\\n jpgname = root + '.jpg'\\n doStamp(Img,pngname,format='PNG')\\n Convert(pngname,jpgname)\\n \\n Painted = Paint(jpgname)\\n Painted.load()\\n if R_PETRO >0. : \\n Painted.DrawEllipse(center,R_PETRO,q,pa,color='red',linewidth=2)\\n Painted.DrawCross(center,length=20,color='green')\\n try : Painted.DrawCross(peak,length=20,color='red')\\n except : pass\\n \\n text = 'RP=%6.2f' % R_PETRO\\n \\n # Painted.Graffiti(text,commtextpos)\\n \\n Painted.save(jpgname) \\n Painted.release()\\n \\n Convert(jpgname,epsname)\\n os.system('rm %s %s' % (pngname,jpgname))\\n \\n self['figures']['petropeakcenter'] = epsname\\n self['figcomms']['petropeakcenter'] = text\",\n \"def view_polygons(polygons):\\n # create the figure and add the surfaces\\n plt.figure()\\n ax = plt.axes(projection='3d')\\n\\n collections = _make_collections(polygons, opacity=0.5)\\n\\n for c in collections:\\n ax.add_collection3d(c)\\n\\n # calculate and set the axis limits\\n limits = _get_limits(polygons=polygons)\\n ax.set_xlim(limits['x'])\\n ax.set_ylim(limits['y'])\\n ax.set_zlim(limits['z'])\\n\\n plt.show()\",\n \"def view_polygons(polygons):\\n # create the figure and add the surfaces\\n plt.figure()\\n ax = plt.axes(projection=\\\"3d\\\")\\n\\n collections = _make_collections(polygons, opacity=0.5)\\n\\n for c in collections:\\n ax.add_collection3d(c)\\n\\n # calculate and set the axis limits\\n limits = _get_limits(polygons=polygons)\\n ax.set_xlim(limits[\\\"x\\\"])\\n ax.set_ylim(limits[\\\"y\\\"])\\n ax.set_zlim(limits[\\\"z\\\"])\\n\\n plt.show()\",\n \"def generate_pointcloud(rgb_file, mask_file,depth_file,ply_file):\\n rgb = Image.open(rgb_file)\\n # depth = Image.open(depth_file)\\n depth = Image.open(depth_file).convert('I')\\n mask = Image.open(mask_file).convert('I')\\n\\n # if rgb.size != depth.size:\\n # raise Exception(\\\"Color and depth image do not have the same resolution.\\\")\\n # if rgb.mode != \\\"RGB\\\":\\n # raise Exception(\\\"Color image is not in RGB format\\\")\\n # if depth.mode != \\\"I\\\":\\n # raise Exception(\\\"Depth image is not in intensity format\\\")\\n\\n\\n points = [] \\n for v in range(rgb.size[1]):\\n for u in range(rgb.size[0]):\\n color = rgb.getpixel((u,v))\\n # Z = depth.getpixel((u,v)) / scalingFactor\\n # if Z==0: continue\\n # X = (u - centerX) * Z / focalLength\\n # Y = (v - centerY) * Z / focalLength\\n if (mask.getpixel((u,v))<55):\\n Z = depth.getpixel((u, v))*.22 \\n if Z == 0: continue\\n Y = .22 * v\\n X = .22 * u\\n points.append(\\\"%f %f %f %d %d %d 0\\\\n\\\"%(X,Y,Z,color[0],color[1],color[2]))\\n file = open(ply_file,\\\"w\\\")\\n file.write('''ply\\nformat ascii 1.0\\nelement vertex %d\\nproperty float x\\nproperty float y\\nproperty float z\\nproperty uchar red\\nproperty uchar green\\nproperty uchar blue\\nproperty uchar alpha\\nend_header\\n%s\\n'''%(len(points),\\\"\\\".join(points)))\\n file.close()\",\n \"def visualize(vis, features, label):\\n if vis == 'PCA':\\n #n_components = st.sidebar.slider(\\\"n_components\\\", 2, 10)\\n #alpha = st.sidebar.slider(\\\"alpha\\\", 0.8, 2.0)\\n #pca = PCA(n_components)\\n pca = PCA(2)\\n\\n X_projected = pca.fit_transform(features)\\n \\n x1 = X_projected[:, 0]\\n x2 = X_projected[:, 1]\\n\\n\\n fig = plt.figure()\\n plt.scatter(x1, x2, c=label, alpha=0.8, cmap='viridis')\\n plt.xlabel(\\\"Principal Component 1\\\")\\n plt.ylabel(\\\"Principal Component 2\\\")\\n plt.colorbar()\\n\\n st.pyplot()\",\n \"def plot_vor_boundary(self,x,ax,tri=False):\\n\\n x = x[~np.isnan(x[:,0])]\\n c_types_print = np.ones(x.shape[0],dtype=np.int32)*-1\\n c_types_print[:self.n_C] = self.c_types\\n regions, vertices = self.voronoi_finite_polygons_2d(Voronoi(x))\\n\\n\\n ax.set(aspect=1,xlim=(0,self.L),ylim=(0,self.L))\\n if type(self.c_types) is list:\\n # ax.scatter(x[:, 0], x[:, 1],color=\\\"grey\\\",zorder=1000)\\n for region in regions:\\n polygon = vertices[region]\\n plt.fill(*zip(*polygon), alpha=0.4, color=\\\"grey\\\")\\n\\n else:\\n cols = self.cols\\n patches = []\\n if self.plot_scatter is True:\\n ax.scatter(x[:self.n_C, 0], x[:self.n_C, 1], color=\\\"black\\\", zorder=1000)\\n ax.scatter(x[self.n_C:, 0], x[self.n_C:, 1], color=\\\"grey\\\", zorder=1000)\\n\\n for i, region in enumerate(regions):\\n patches.append(Polygon(vertices[region], True,facecolor=cols[c_types_print[i]],edgecolor=\\\"white\\\",alpha=0.5))\\n\\n p = PatchCollection(patches, match_original=True)\\n # p.set_array(c_types_print)\\n ax.add_collection(p)\\n if tri is not False:\\n for TRI in tri:\\n for j in range(3):\\n a, b = TRI[j], TRI[np.mod(j + 1, 3)]\\n if (a >= 0) and (b >= 0):\\n X = np.stack((x[a], x[b])).T\\n ax.plot(X[0], X[1], color=\\\"black\\\")\",\n \"def plot_orbit(self) :\\r\\n self.x_vals = np.zeros((self.n_bodies,len(self.hist)))\\r\\n self.y_vals = np.zeros((self.n_bodies,len(self.hist)))\\r\\n self.z_vals = np.zeros((self.n_bodies,len(self.hist))) \\r\\n self.r_vals = np.zeros((self.n_bodies,len(self.hist)))\\r\\n \\r\\n for i in range(self.n_bodies) : \\r\\n ioff = i*6\\r\\n for j in range(len(self.hist)) : \\r\\n self.x_vals[i][j] = self.hist[j][ioff]\\r\\n self.y_vals[i][j] = self.hist[j][ioff+1]\\r\\n self.z_vals[i][j] = self.hist[j][ioff+2]\\r\\n self.r_vals[i][j] = np.sqrt((self.x_vals[i][j]**2) + (self.y_vals[i][j]**2) + (self.z_vals[i][j]**2))\",\n \"def plot( self, N, square = False, filename = None ):\\n\\n # compute all points for all triangles for all arms\\n self.get_all_triangles( N = N )\\n\\n # compute spatial bounds of the tessellation\\n x_min = np.min( self.all_triangles[ :, :, :, 0 ] ) * 1.02\\n x_max = np.max( self.all_triangles[ :, :, :, 0 ] ) * 1.02\\n y_min = np.min( self.all_triangles[ :, :, :, 1 ] ) * 1.02\\n y_max = np.max( self.all_triangles[ :, :, :, 1 ] ) * 1.02\\n\\n # compute aspect ratio of visualization\\n if square:\\n ratio = 1\\n y_max = y_min + ( x_max - x_min )\\n else:\\n ratio = ( y_max - y_min ) / ( x_max - x_min )\\n\\n # initialize figure and axis of visualization\\n fig, ax = plt.subplots( figsize = ( 8, 8 * ratio ) )\\n\\n # get list of colors used to color each arm of the tessellation\\n colors = get_cmap( 'tab10' ).colors\\n\\n # loop over arms\\n for i , color in zip( range( self.m ), colors ):\\n\\n # initialize list of matplotlib Polygons\\n patches = list( )\\n\\n # loop over all triangles in the arm\\n for triangle in self.all_triangles[ i ]:\\n\\n # append a matplotlib Polygon of the given triangle to the the\\n # polygon list\\n polygon = Polygon(\\n xy = triangle,\\n closed = True,\\n joinstyle = 'miter' )\\n patches.append( polygon )\\n\\n # create a matplotlib PatchCollection of the list of polygons\\n p = PatchCollection(\\n patches = patches,\\n color = color,\\n edgecolor = 'k',\\n linewidth = 1.0, )\\n\\n # add the PatchCollection to the figure axis\\n ax.add_collection( p )\\n\\n # set bounds of visualization, and remove axis box and tickmarks\\n ax.set_xlim( x_min, x_max )\\n ax.set_ylim( y_min, y_max )\\n ax.axis( 'off' )\\n\\n # ensure scaling is consistent between the two axes\\n plt.subplots_adjust( 0, 0, 1, 1 )\\n\\n # if ``filename`` is specified, save to file, otherwise show`\\n if filename is None:\\n return ax\\n else:\\n plt.savefig( filename, bbox_inches = 'tight' )\\n plt.close( )\",\n \"def create_point_cloud(self):\\n pixels = []\\n colors = []\\n my_pixels = []\\n for j in range(self.height):\\n for i in range(self.width):\\n depth = self.depth[j, i]\\n pixels.append(\\n [i * depth, j * depth, depth]\\n )\\n my_pixels.append(\\n [i, j, 1]\\n )\\n # make rgb with flip()\\n colors.append(np.flip(self.bgr[j, i, :]))\\n # colors.append(self.bgr[j, i, :])\\n self.my_pixels = my_pixels\\n pixels = np.array(pixels)\\n\\n # project pixels to camera space\\n self.xyz_points = self.intrinsics_inv @ np.transpose(pixels)\\n self.color_points = colors\\n\\n # now add 1s to the points for homogenous coordinates\\n num_points = self.get_num_xyz_points()\\n ones = np.ones((1, num_points))\\n self.xyzw_points = np.concatenate((self.xyz_points, ones), axis=0)\\n\\n self.scene = None\\n self.camera_pose = None\\n self.nm = None\\n self.nl = None\\n self.nc = None\\n self.create_mesh()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.717661","0.68778163","0.67623657","0.65606654","0.65092915","0.64102745","0.6362865","0.63186747","0.6282361","0.6227061","0.6184886","0.616295","0.61177635","0.6107491","0.6087164","0.6042589","0.59876037","0.59707433","0.5968525","0.5959219","0.5946568","0.59396625","0.5913501","0.5900825","0.589778","0.58930624","0.58913064","0.58529776","0.5837295","0.5831396","0.5826793","0.58010054","0.57897615","0.5789596","0.5784711","0.57805055","0.5778075","0.5777858","0.5760762","0.5753874","0.5753874","0.5722699","0.57220095","0.5705741","0.570076","0.56977755","0.5687382","0.5687039","0.5684292","0.5682606","0.56783044","0.5668045","0.5662666","0.5654227","0.56534773","0.5645465","0.5642988","0.56427777","0.56410545","0.56291676","0.5626488","0.5612929","0.5611942","0.55979097","0.55971324","0.5593031","0.55896854","0.5588348","0.55821264","0.55804586","0.5578356","0.557176","0.5570991","0.55708164","0.5566983","0.55650383","0.55634844","0.5562982","0.5561898","0.5554498","0.55368507","0.553412","0.55319405","0.5531307","0.5529102","0.5526647","0.5525569","0.5520446","0.5512949","0.551093","0.54999125","0.5498086","0.54973036","0.54970115","0.54958594","0.5494882","0.54926723","0.5489461","0.5478578","0.5475006"],"string":"[\n \"0.717661\",\n \"0.68778163\",\n \"0.67623657\",\n \"0.65606654\",\n \"0.65092915\",\n \"0.64102745\",\n \"0.6362865\",\n \"0.63186747\",\n \"0.6282361\",\n \"0.6227061\",\n \"0.6184886\",\n \"0.616295\",\n \"0.61177635\",\n \"0.6107491\",\n \"0.6087164\",\n \"0.6042589\",\n \"0.59876037\",\n \"0.59707433\",\n \"0.5968525\",\n \"0.5959219\",\n \"0.5946568\",\n \"0.59396625\",\n \"0.5913501\",\n \"0.5900825\",\n \"0.589778\",\n \"0.58930624\",\n \"0.58913064\",\n \"0.58529776\",\n \"0.5837295\",\n \"0.5831396\",\n \"0.5826793\",\n \"0.58010054\",\n \"0.57897615\",\n \"0.5789596\",\n \"0.5784711\",\n \"0.57805055\",\n \"0.5778075\",\n \"0.5777858\",\n \"0.5760762\",\n \"0.5753874\",\n \"0.5753874\",\n \"0.5722699\",\n \"0.57220095\",\n \"0.5705741\",\n \"0.570076\",\n \"0.56977755\",\n \"0.5687382\",\n \"0.5687039\",\n \"0.5684292\",\n \"0.5682606\",\n \"0.56783044\",\n \"0.5668045\",\n \"0.5662666\",\n \"0.5654227\",\n \"0.56534773\",\n \"0.5645465\",\n \"0.5642988\",\n \"0.56427777\",\n \"0.56410545\",\n \"0.56291676\",\n \"0.5626488\",\n \"0.5612929\",\n \"0.5611942\",\n \"0.55979097\",\n \"0.55971324\",\n \"0.5593031\",\n \"0.55896854\",\n \"0.5588348\",\n \"0.55821264\",\n \"0.55804586\",\n \"0.5578356\",\n \"0.557176\",\n \"0.5570991\",\n \"0.55708164\",\n \"0.5566983\",\n \"0.55650383\",\n \"0.55634844\",\n \"0.5562982\",\n \"0.5561898\",\n \"0.5554498\",\n \"0.55368507\",\n \"0.553412\",\n \"0.55319405\",\n \"0.5531307\",\n \"0.5529102\",\n \"0.5526647\",\n \"0.5525569\",\n \"0.5520446\",\n \"0.5512949\",\n \"0.551093\",\n \"0.54999125\",\n \"0.5498086\",\n \"0.54973036\",\n \"0.54970115\",\n \"0.54958594\",\n \"0.5494882\",\n \"0.54926723\",\n \"0.5489461\",\n \"0.5478578\",\n \"0.5475006\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.72570527"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88394,"cells":{"query":{"kind":"string","value":"When called with an instance of L{bytes}, L{bytes_to_str} decodes its input using I{ascii} and returns the resulting str string as an instance of L{str}."},"document":{"kind":"string","value":"def test_bytes(self):\n self.assertRaises(\n UnicodeDecodeError,\n lambda: bytes_to_str(\"\\N{SNOWMAN}\".encode(\"utf-8\")),\n )\n decoded = bytes_to_str(b\"hello world\")\n self.assertIsInstance(decoded, str)\n self.assertEqual(decoded, \"hello world\")"},"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 convert_to_string(_bytes: bytes)-> str:\n # print('input bytes: ', _bytes)\n # print('string: ', binascii.hexlify(_bytes))\n # print('string2: ', _bytes.hex())\n # print('string3: ', \" \".join([\"{:02x}\".format(x) for x in _bytes]))\n return \" \".join([\"{:02x}\".format(x) for x in _bytes])","def bytes_to_str(s, encoding='utf-8'):\n if isinstance(s, bytes):\n return s.decode(encoding)\n return s","def bytes_to_str(self, data):\n if isinstance(data, str):\n return data\n return data.decode(\"utf-8\")","def bytes_to_str(b, encoding='ascii'):\n return b.decode(encoding)","def _bytes_bytearray_to_str(s):\n if isinstance(s, (bytes, bytearray)):\n return s.decode()\n return s","def bytes_to_str(s, encoding='utf-8'):\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s","def bytes_to_str(s, encoding='utf-8'):\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s","def bytes2str(val):\n if isinstance(val, bytes):\n return str(val, \"utf8\")\n else:\n return val","def pystr(s):\n if six.PY2 and isinstance(s, six.text_type):\n return s.encode('ascii', 'ignore')\n elif six.PY3 and isinstance(s, six.binary_type):\n return s.decode('utf-8')\n else:\n return s","def to_str(source: Union[str, bytes, IO[bytes]]) -> str:\n if isinstance(source, str):\n return source\n elif isinstance(source, bytes):\n # XXX: Assume it's UTF-8 encoded!\n return source.decode('UTF-8')\n else:\n raise NotImplementedError","def _to_str(s, encoding=\"utf8\", errors=\"ignore\"):\n if isinstance(s, bytes):\n return s.decode(encoding=encoding, errors=errors)\n return str(s)","def to_str(value: bytes) -> str:\n if value is not None:\n out = value.decode(\"utf-8\")\n else:\n out = \"\"\n\n return out","def tostring(b):\n if isinstance(b, bytes):\n return bytes2str(b)\n else:\n return b","def decode_to_string(self, value):\n #if python3 or python 2.7\n ret = bytearray(value).decode(encoding='UTF-8')\n #if python2.7\n #ret = str(bytearray(value))\n return ret","def bytes_to_str(str1, logger=None, str_decode='default', py_version=3):\n if not ((py_version == 2 and isinstance(str1, str)) or\n (py_version == 3 and isinstance(str1, str))):\n try:\n if str_decode != 'default':\n str1 = str1.decode(str_decode.lower(), 'ignore')\n else:\n try:\n str1 = str1.decode('utf-8', 'ignore')\n except UnicodeDecodeError:\n try:\n str1 = str1.decode('gbk', 'ignore')\n except UnicodeDecodeError:\n str1 = str1.decode(sys.getfilesystemencoding(),\n 'ignore')\n except UnicodeDecodeError as err_message:\n if logger:\n logger.info('[err]bytes_to_str:decode %s to str failed', str1)\n logger.info(str(err_message))\n return str1","def bytes2str(data):\n # pylint: disable=multiple-statements\n\n if isinstance(data, bytes): return data.decode('utf-8')\n if isinstance(data, dict): return dict(map(bytes2str, data.items()))\n if isinstance(data, tuple): return map(bytes2str, data)\n return data","def toString(s):\n if type(s) == type(\"\"):\n return s\n else:\n return s.decode()","def convert_to_str(string):\n if type(string) is str:\n return string\n else:\n return bytes.decode(string)","def test_bytes_to_native_str(self):\n b = bytes(b'abc')\n s = bytes_to_native_str(b)\n if PY2:\n self.assertEqual(s, b)\n else:\n self.assertEqual(s, 'abc')\n self.assertTrue(isinstance(s, native_str))\n self.assertEqual(type(s), native_str)","def to_string(data):\n if isinstance(data, bytes):\n return data.decode('utf-8')\n else:\n return data","def text_(s, encoding='utf-8', errors='strict'):\n if isinstance(s, binary_type):\n return s.decode(encoding, errors)\n return s # pragma: no cover","def _encoded_string_to_string(encoded_blob):\n try:\n return encoded_blob.decode(\"base64\")\n except Exception:\n raise InvalidDeckDataException(\"Cannot decode deck data into anything readable.\")","def to_native_str(s):\n if not isinstance(s, str):\n return s.decode('ascii', 'strict')\n return s","def __decodeString(self,ascii):\n second = ascii%256\n first = (ascii-second)/256\n return str(chr(first))+str(chr(second))","def asbytes(s):\n if isinstance(s, bytes):\n return s\n else:\n return s.encode('utf-8')","def toString(data):\n\tif isString(data):\n\t\treturn data\n\telse:\n\t\treturn data.decode(\"latin-1\")","def to_string(msg):\n if type(msg) is bytes:\n msg = str(msg)\n msg = msg[2:]\n return msg[:-1]\n else:\n return msg","def _tostr(obj): # pragma: no cover\n return obj if isinstance(obj, str) else obj.decode()","def always_str(str_or_bytes: Union[None, str, bytes], *decode_args) -> Union[None, str]:\n if str_or_bytes is None or isinstance(str_or_bytes, str):\n return str_or_bytes\n elif isinstance(str_or_bytes, bytes):\n return str_or_bytes.decode(*decode_args)\n else:\n raise TypeError(\"Expected str or bytes, but got {}.\".format(type(str_or_bytes).__name__))","def _as_bytes(s):\n if isinstance(s, bytes):\n return s\n return bytes(s, encoding='latin_1')","def _as_bytes(s):\n if isinstance(s, bytes):\n return s\n # Assume it is a unicode string\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\n return codecs.latin_1_encode(s)[0]","def give_me_bytes(string):\n return string.encode('utf8') if isinstance(string, str) else string","def getBytesIOString(bytesIO):\n if _BytesIOValueIsStr:\n # We don't need to convert.\n return bytesIO.getvalue()\n else:\n # Assume value is a Python 3 bytes object. Convert to str.\n return \"\".join(map(_bytesElementToChr, bytesIO.getvalue()))","def decode_bytes(data: bytearray) -> str:\n pattern = re.compile('\\r', re.UNICODE)\n res = data.decode('utf-8', 'ignore')\n res = pattern.sub('', res)\n return res","def test_str(self):\n obj = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n expected = str(binascii.hexlify(self.bytes_a))\n observed = str(obj)\n self.assertEqual(expected, observed)","def as_text(bytes_or_text, encoding='utf-8'):\n if isinstance(bytes_or_text, _six.text_type):\n return bytes_or_text\n elif isinstance(bytes_or_text, bytes):\n return bytes_or_text.decode(encoding)\n else:\n raise TypeError(\n 'Expected binary or unicode string, got %r' % bytes_or_text\n )","def bytes_string_to_string(bytes_string):\n return str(bytes_string).split(\"'\")[1]","def native_(s, encoding='latin-1', errors='strict'):\n if isinstance(s, text_type):\n return s\n return str(s, encoding, errors)","def convert_to_string(value: Any) -> str:\n if isinstance(value, str):\n return value\n\n if isinstance(value, bytes):\n return value.decode(\"utf-8\")\n\n return str(value)","def as_str(self) -> str:\n if isinstance(self.data, str):\n return self.data\n elif isinstance(self.data, bytes):\n return self.data.decode()\n else:\n return bytes(self.data).decode()","def str_to_bytes(self, data):\n if isinstance(data, bytes):\n return data\n return data.encode(\"utf-8\")","def native_(s, encoding='latin-1', errors='strict'):\n if isinstance(s, text_type):\n return s.encode(encoding, errors)\n return str(s)","def kafka_bytestring(s):\n if isinstance(s, bytes):\n return s\n if isinstance(s, bytes):\n return s.encode('utf-8')\n raise TypeError(s)","def force_text(s: Union[str, bytes], encoding=\"utf-8\", errors=\"strict\") -> str:\n if isinstance(s, str):\n return s\n\n try:\n if not isinstance(s, str):\n if isinstance(s, bytes):\n s = str(s, encoding, errors)\n else:\n s = str(s)\n else:\n s = s.decode(encoding, errors)\n except UnicodeDecodeError as e:\n raise e\n return s","def decode_bytes(bytes_to_decode):\n if not bytes_to_decode:\n return ''\n\n try:\n return bytes_to_decode.decode('utf-8')\n except UnicodeError:\n return bytes_to_decode.decode(locale.getpreferredencoding(), errors='replace')","def to_str(s):\n return s.decode(sys.getdefaultencoding(), \"backslashreplace\") if hasattr(s, \"decode\") else str(s)","def to_string(value):\n if isinstance(value, encodingutils.binary_type):\n return encodingutils.bytes_to_string(value)\n else:\n return encodingutils.text_type(value)","def touni(x, enc='utf8', err='strict'):\r\n return str(x, enc, err) if isinstance(x, bytes) else str(x)","def read_str(self) -> str:\n t = self.pc\n while self.data[self.pc] != 0:\n self.pc += 1\n s = str(self.data[t:self.pc], encoding=\"utf8\")\n self.pc += 1 # jump '\\0'\n return s","def to_string(data):\n return to_bytes(data)","def str_to_bytes(data):\n u_type = type(b''.decode('utf8'))\n if isinstance(data, u_type):\n return data.encode('utf8')\n return data","def str_to_bytes(s, encoding='ascii'):\n return s.encode(encoding)","def decode_to_utf8(text) -> bytes: # pragma: no cover\n try:\n return text.decode(\"utf-8\")\n except (AttributeError, UnicodeEncodeError):\n return text","def ustr(obj):\n if IS_PY2:\n # If we are getting a string, then do an explicit decode\n # else, just call the unicode method of the object\n if type(obj) in [str, basestring]: # pragma: no cover # noqa\n return unicode(obj, DEFAULT_ENCODING) # pragma: no cover # noqa\n else:\n return unicode(obj) # pragma: no cover # noqa\n else:\n if type(obj) in [bytes]:\n return obj.decode(DEFAULT_ENCODING)\n else:\n return str(obj)","def polite_bytes(a_string):\n if is_py3():\n try:\n return bytes(a_string, 'utf-8')\n except TypeError:\n return a_string\n\n return a_string","def native_string(input_var):\n if isinstance(input_var, str):\n return input_var\n\n return input_var.decode('utf-8', 'replace')","def to_bytes(bytes_or_str):\r\n if isinstance(bytes_or_str, str):\r\n value = bytes_or_str.encode('utf-8')\r\n else:\r\n value = bytes_or_str\r\n return value","def bytes_to_text(byte_array, encoding='UTF-8'):\n return bytes(byte_array).decode(encoding)","def to_bytes(data):\n if isinstance(data, str):\n return data.encode(encoding='utf-8')\n else:\n return data","def bytes_string(text, encode=\"utf-8\"):\n if not PY3:\n if isinstance(text, unicode): # pylint: disable=undefined-variable\n result = text.encode(encode)\n else:\n result = text\n else:\n if isinstance(text, bytes):\n result = text\n else:\n result = bytes(text, encode)\n return result","def convert_to_str(input_string):\n\n if sys.version < '3':\n\n if isinstance(input_string, str) \\\n or isinstance(input_string, unicode): # pragma: no cover py3\n\n return input_string # pragma: no cover py3\n\n else:\n\n if isinstance(input_string, str): # pragma: no cover py3\n\n return input_string # pragma: no cover py3\n\n return str(input_string)","def test_bytesToString(self):\n self.assertNativeString(b\"hello\", \"hello\")","def base32_decode(encoded_bytes: bytes) -> str:\n\n # decode the bytes from base32\n # then, decode the bytes-like object to return as a string\n return base64.b32decode(encoded_bytes).decode(\"utf-8\")","def ToString(bval):\n return bval.decode('utf-8')","def __str__(self):\n return bytes_to_string(self._bytes)","def utfstr(stuff):\n if isinstance(stuff,basestring):\n return stuff\n else:\n return str(stuff)","def ascii_convert(the_bytes: bytes):\n return ANSI_ESCAPE_B.sub(rb\"\", the_bytes).decode(\"utf-8\")","def force_str(s):\n return (s.encode('utf8')\n if isinstance(s, unicode)\n else str(s))","def decode_string(encoded: bytes) -> str:\n if encoded.startswith(codecs.BOM_UTF8):\n return encoded.decode(\"utf-8-sig\")\n elif encoded.startswith(codecs.BOM_UTF16):\n encoded = encoded[len(codecs.BOM_UTF16) :]\n return encoded.decode(\"utf-16\")\n else:\n # No BOM to determine encoding, try utf-8\n return encoded.decode(\"utf-8\")","def _convert_to_str(self, data):\n raise NotImplementedError()","def ensure_native_str(data, encoding=\"utf8\"):\n if isinstance(data, str):\n return data\n elif isinstance(data, unicode_type):\n # Only executes on python 2\n return data.encode(encoding)\n elif isinstance(data, bytes):\n # Only executes on python 3\n return data.decode(encoding)\n else:\n str(data)","def as_str_any(value):\n if isinstance(value, bytes):\n return as_str(value)\n else:\n return str(value)","def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n return str(s)\n if isinstance(s, bytes):\n return s.decode(encoding, errors)\n return s","def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n return str(s)\n if isinstance(s, bytes):\n return s.decode(encoding, errors)\n return s","def conv_bytes_to_str(self, rcv: bytes, read_until: t.Union[str, None] = None, strip: bool = True) -> t.Union[str, None]:\n\n if (rcv is None):\n return None\n\n res = rcv.decode(\"utf-8\")\n\n try:\n ret = res[0:res.index(str(read_until))] # sliced string\n if (strip):\n return ret.strip()\n else:\n return ret\n\n except (ValueError, TypeError):\n # read_until does not exist or it is None, so return the entire thing\n if (strip):\n return res.strip()\n else:\n return res","def ensure_bytes(s, encoding):\n if isinstance(s, bytes):\n return s\n return s.encode(encoding)","def _to_bytes(value: Union[str, bytes]) -> bytes:\n return value if isinstance(value, bytes) else value.encode(\"utf-8\")","def _to_native_string(string, encoding='ascii'):\n if isinstance(string, str):\n out = string\n else:\n out = string.decode(encoding)\n\n return out","def asunicode(s):\n if isinstance(s, bytes):\n return s.decode('utf-8', 'replace')\n else:\n return s","def smart_str(s):\n # Handle the common case first for performance reasons.\n if issubclass(type(s), str) or isinstance(s, _PROTECTED_TYPES):\n return s\n if isinstance(s, bytes):\n return str(s, 'utf-8')\n return str(s)","def astr(obj):\n\treturn unicode(obj).encode(\"ascii\", \"replace\")","def decode(value, encoding='utf-8') -> str:\n return value.decode(encoding) if isinstance(value, bytes) else value","def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n s = str(s)\n if isinstance(s, str):\n return s.encode(encoding, errors)\n return s","def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n s = str(s)\n if isinstance(s, str):\n return s.encode(encoding, errors)\n return s","def test_to_str(self):\n sts = smdba.basegate.BaseGate.to_str(b'\\xd1\\x81\\xd0\\xbf\\xd0\\xb0\\xd0\\xbc \\xd1\\x96 \\xd1\\x8f\\xd0\\xb9\\xd1\\x86\\xd1\\x8f')\n assert sts == \"спам і яйця\"","def polite_string(a_string):\n if is_py3() and hasattr(a_string, 'decode'):\n try:\n return a_string.decode('utf-8')\n except UnicodeDecodeError:\n return a_string\n\n return a_string","def convert_from_bytes(output: ResponseOutput, ty: Optional[Type]) -> Any:\n if ty == str:\n return bytearray(output.data).decode(\"UTF-8\")\n else:\n py_str = bytearray(output.data).decode(\"UTF-8\")\n from ast import literal_eval\n\n return literal_eval(py_str)","def Astr(string):\n\n return unicode(string, encoding='utf-8')","def _text(string, encoding='utf8'):\n if isinstance(string, six.text_type):\n return string\n elif isinstance(string, six.binary_type):\n return string.decode(encoding)\n else:\n return six.text_type(string)","def _as_unicode(s):\n if isinstance(s, str):\n return s\n # Assume it is a bytes string\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\n return codecs.latin_1_decode(s)[0]","def as_bytes(string):\n return same_string_type_as(b\"\", string)","def to_ascii(s):\n return s.encode('ascii', 'ignore')","def unicode_to_str(str1, logger=None, str_encode='system', py_version=3):\n if str1 is None or str1 == \"\" or str1 == 'Null' or str1 == 'null':\n str1 = \"\"\n elif ((py_version == 2 and isinstance(str1, str)) or (\n py_version == 3 and isinstance(str1, str))):\n try:\n if str_encode.lower() == 'system':\n str1 = str1.encode(sys.getfilesystemencoding(), 'ignore')\n elif str_encode.lower() == 'utf-8':\n str1 = str1.encode('utf-8', 'ignore')\n elif str_encode.lower() == 'gbk':\n str1 = str1.encode('gbk', 'ignore')\n else:\n str1 = str1.encode(str_encode, 'ignore')\n except UnicodeDecodeError as err_message:\n if logger:\n logger.info('[err]unicode_to_str:encode %s to %s failed',\n str1, str_encode)\n logger.info(str(err_message))\n elif ((py_version == 2 and isinstance(str1, str)) or (\n py_version == 3 and isinstance(str1, bytes))):\n pass\n else:\n if logger:\n logger.info('%s is not unicode ', str1)\n return str(str1)","def base64str(s: str,\n encoding: str = 'utf-8',\n decoding='utf-8',\n encerrors='strict',\n decerrors='strict') -> str:\n enc = encoding\n if enc is None or enc == '':\n enc = 'utf-8'\n dec = decoding\n if dec is None or dec == '':\n dec = 'utf-8'\n\n bsIn = bytes(s, enc, encerrors)\n bsOut = base64.b64encode(bsIn)\n res = str(bsOut, dec, decerrors)\n return res","def decode_doomstring(byte_string):\n s = list()\n import sys\n if len(byte_string) > 0:\n for b in byte_string:\n if b == 0:\n break\n try:\n b = (b).to_bytes(1, 'little').decode('ascii')\n except Exception:\n # Encountered an invalid character, just ignore it\n continue\n s.append(b)\n return ''.join(s)\n else:\n return ''","def to_hex_str(data_bytes: bytes) -> str:\n if isinstance(data_bytes, bytes):\n data_bytes = bytearray(data_bytes)\n data_bytes.reverse()\n return '0x' + data_bytes.hex()","def ensure_bytes(str_or_bytes, binary_type=six.binary_type,\n text_type=six.text_type):\n if isinstance(str_or_bytes, binary_type):\n return str_or_bytes\n if isinstance(str_or_bytes, text_type):\n return str_or_bytes.encode('utf-8')\n raise TypeError(\n \"input must be a text or byte string, got {}\"\n .format(type(str_or_bytes).__name__))","def ensure_bytes(value: AnyStr) -> bytes:\n if isinstance(value, bytes):\n return value\n if isinstance(value, str):\n return value.encode('utf-8')\n raise TypeError(f\"input must be str or bytes, got {type(value).__name__}\")","def binary_encoding(string, encoding = 'utf-8'):\n try:\n return bytes(string, encoding)\n except TypeError: # We are in Python 2\n return str(string)","def to_bytes(string):\n assert isinstance(string, basestring)\n if sys.version_info[0] >= 3:\n if isinstance(string, str):\n return string.encode('utf-8')\n else:\n return string\n else:\n if isinstance(string, unicode):\n return string.encode('utf-8')\n else:\n return string"],"string":"[\n \"def convert_to_string(_bytes: bytes)-> str:\\n # print('input bytes: ', _bytes)\\n # print('string: ', binascii.hexlify(_bytes))\\n # print('string2: ', _bytes.hex())\\n # print('string3: ', \\\" \\\".join([\\\"{:02x}\\\".format(x) for x in _bytes]))\\n return \\\" \\\".join([\\\"{:02x}\\\".format(x) for x in _bytes])\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def bytes_to_str(self, data):\\n if isinstance(data, str):\\n return data\\n return data.decode(\\\"utf-8\\\")\",\n \"def bytes_to_str(b, encoding='ascii'):\\n return b.decode(encoding)\",\n \"def _bytes_bytearray_to_str(s):\\n if isinstance(s, (bytes, bytearray)):\\n return s.decode()\\n return s\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def bytes2str(val):\\n if isinstance(val, bytes):\\n return str(val, \\\"utf8\\\")\\n else:\\n return val\",\n \"def pystr(s):\\n if six.PY2 and isinstance(s, six.text_type):\\n return s.encode('ascii', 'ignore')\\n elif six.PY3 and isinstance(s, six.binary_type):\\n return s.decode('utf-8')\\n else:\\n return s\",\n \"def to_str(source: Union[str, bytes, IO[bytes]]) -> str:\\n if isinstance(source, str):\\n return source\\n elif isinstance(source, bytes):\\n # XXX: Assume it's UTF-8 encoded!\\n return source.decode('UTF-8')\\n else:\\n raise NotImplementedError\",\n \"def _to_str(s, encoding=\\\"utf8\\\", errors=\\\"ignore\\\"):\\n if isinstance(s, bytes):\\n return s.decode(encoding=encoding, errors=errors)\\n return str(s)\",\n \"def to_str(value: bytes) -> str:\\n if value is not None:\\n out = value.decode(\\\"utf-8\\\")\\n else:\\n out = \\\"\\\"\\n\\n return out\",\n \"def tostring(b):\\n if isinstance(b, bytes):\\n return bytes2str(b)\\n else:\\n return b\",\n \"def decode_to_string(self, value):\\n #if python3 or python 2.7\\n ret = bytearray(value).decode(encoding='UTF-8')\\n #if python2.7\\n #ret = str(bytearray(value))\\n return ret\",\n \"def bytes_to_str(str1, logger=None, str_decode='default', py_version=3):\\n if not ((py_version == 2 and isinstance(str1, str)) or\\n (py_version == 3 and isinstance(str1, str))):\\n try:\\n if str_decode != 'default':\\n str1 = str1.decode(str_decode.lower(), 'ignore')\\n else:\\n try:\\n str1 = str1.decode('utf-8', 'ignore')\\n except UnicodeDecodeError:\\n try:\\n str1 = str1.decode('gbk', 'ignore')\\n except UnicodeDecodeError:\\n str1 = str1.decode(sys.getfilesystemencoding(),\\n 'ignore')\\n except UnicodeDecodeError as err_message:\\n if logger:\\n logger.info('[err]bytes_to_str:decode %s to str failed', str1)\\n logger.info(str(err_message))\\n return str1\",\n \"def bytes2str(data):\\n # pylint: disable=multiple-statements\\n\\n if isinstance(data, bytes): return data.decode('utf-8')\\n if isinstance(data, dict): return dict(map(bytes2str, data.items()))\\n if isinstance(data, tuple): return map(bytes2str, data)\\n return data\",\n \"def toString(s):\\n if type(s) == type(\\\"\\\"):\\n return s\\n else:\\n return s.decode()\",\n \"def convert_to_str(string):\\n if type(string) is str:\\n return string\\n else:\\n return bytes.decode(string)\",\n \"def test_bytes_to_native_str(self):\\n b = bytes(b'abc')\\n s = bytes_to_native_str(b)\\n if PY2:\\n self.assertEqual(s, b)\\n else:\\n self.assertEqual(s, 'abc')\\n self.assertTrue(isinstance(s, native_str))\\n self.assertEqual(type(s), native_str)\",\n \"def to_string(data):\\n if isinstance(data, bytes):\\n return data.decode('utf-8')\\n else:\\n return data\",\n \"def text_(s, encoding='utf-8', errors='strict'):\\n if isinstance(s, binary_type):\\n return s.decode(encoding, errors)\\n return s # pragma: no cover\",\n \"def _encoded_string_to_string(encoded_blob):\\n try:\\n return encoded_blob.decode(\\\"base64\\\")\\n except Exception:\\n raise InvalidDeckDataException(\\\"Cannot decode deck data into anything readable.\\\")\",\n \"def to_native_str(s):\\n if not isinstance(s, str):\\n return s.decode('ascii', 'strict')\\n return s\",\n \"def __decodeString(self,ascii):\\n second = ascii%256\\n first = (ascii-second)/256\\n return str(chr(first))+str(chr(second))\",\n \"def asbytes(s):\\n if isinstance(s, bytes):\\n return s\\n else:\\n return s.encode('utf-8')\",\n \"def toString(data):\\n\\tif isString(data):\\n\\t\\treturn data\\n\\telse:\\n\\t\\treturn data.decode(\\\"latin-1\\\")\",\n \"def to_string(msg):\\n if type(msg) is bytes:\\n msg = str(msg)\\n msg = msg[2:]\\n return msg[:-1]\\n else:\\n return msg\",\n \"def _tostr(obj): # pragma: no cover\\n return obj if isinstance(obj, str) else obj.decode()\",\n \"def always_str(str_or_bytes: Union[None, str, bytes], *decode_args) -> Union[None, str]:\\n if str_or_bytes is None or isinstance(str_or_bytes, str):\\n return str_or_bytes\\n elif isinstance(str_or_bytes, bytes):\\n return str_or_bytes.decode(*decode_args)\\n else:\\n raise TypeError(\\\"Expected str or bytes, but got {}.\\\".format(type(str_or_bytes).__name__))\",\n \"def _as_bytes(s):\\n if isinstance(s, bytes):\\n return s\\n return bytes(s, encoding='latin_1')\",\n \"def _as_bytes(s):\\n if isinstance(s, bytes):\\n return s\\n # Assume it is a unicode string\\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\\n return codecs.latin_1_encode(s)[0]\",\n \"def give_me_bytes(string):\\n return string.encode('utf8') if isinstance(string, str) else string\",\n \"def getBytesIOString(bytesIO):\\n if _BytesIOValueIsStr:\\n # We don't need to convert.\\n return bytesIO.getvalue()\\n else:\\n # Assume value is a Python 3 bytes object. Convert to str.\\n return \\\"\\\".join(map(_bytesElementToChr, bytesIO.getvalue()))\",\n \"def decode_bytes(data: bytearray) -> str:\\n pattern = re.compile('\\\\r', re.UNICODE)\\n res = data.decode('utf-8', 'ignore')\\n res = pattern.sub('', res)\\n return res\",\n \"def test_str(self):\\n obj = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n expected = str(binascii.hexlify(self.bytes_a))\\n observed = str(obj)\\n self.assertEqual(expected, observed)\",\n \"def as_text(bytes_or_text, encoding='utf-8'):\\n if isinstance(bytes_or_text, _six.text_type):\\n return bytes_or_text\\n elif isinstance(bytes_or_text, bytes):\\n return bytes_or_text.decode(encoding)\\n else:\\n raise TypeError(\\n 'Expected binary or unicode string, got %r' % bytes_or_text\\n )\",\n \"def bytes_string_to_string(bytes_string):\\n return str(bytes_string).split(\\\"'\\\")[1]\",\n \"def native_(s, encoding='latin-1', errors='strict'):\\n if isinstance(s, text_type):\\n return s\\n return str(s, encoding, errors)\",\n \"def convert_to_string(value: Any) -> str:\\n if isinstance(value, str):\\n return value\\n\\n if isinstance(value, bytes):\\n return value.decode(\\\"utf-8\\\")\\n\\n return str(value)\",\n \"def as_str(self) -> str:\\n if isinstance(self.data, str):\\n return self.data\\n elif isinstance(self.data, bytes):\\n return self.data.decode()\\n else:\\n return bytes(self.data).decode()\",\n \"def str_to_bytes(self, data):\\n if isinstance(data, bytes):\\n return data\\n return data.encode(\\\"utf-8\\\")\",\n \"def native_(s, encoding='latin-1', errors='strict'):\\n if isinstance(s, text_type):\\n return s.encode(encoding, errors)\\n return str(s)\",\n \"def kafka_bytestring(s):\\n if isinstance(s, bytes):\\n return s\\n if isinstance(s, bytes):\\n return s.encode('utf-8')\\n raise TypeError(s)\",\n \"def force_text(s: Union[str, bytes], encoding=\\\"utf-8\\\", errors=\\\"strict\\\") -> str:\\n if isinstance(s, str):\\n return s\\n\\n try:\\n if not isinstance(s, str):\\n if isinstance(s, bytes):\\n s = str(s, encoding, errors)\\n else:\\n s = str(s)\\n else:\\n s = s.decode(encoding, errors)\\n except UnicodeDecodeError as e:\\n raise e\\n return s\",\n \"def decode_bytes(bytes_to_decode):\\n if not bytes_to_decode:\\n return ''\\n\\n try:\\n return bytes_to_decode.decode('utf-8')\\n except UnicodeError:\\n return bytes_to_decode.decode(locale.getpreferredencoding(), errors='replace')\",\n \"def to_str(s):\\n return s.decode(sys.getdefaultencoding(), \\\"backslashreplace\\\") if hasattr(s, \\\"decode\\\") else str(s)\",\n \"def to_string(value):\\n if isinstance(value, encodingutils.binary_type):\\n return encodingutils.bytes_to_string(value)\\n else:\\n return encodingutils.text_type(value)\",\n \"def touni(x, enc='utf8', err='strict'):\\r\\n return str(x, enc, err) if isinstance(x, bytes) else str(x)\",\n \"def read_str(self) -> str:\\n t = self.pc\\n while self.data[self.pc] != 0:\\n self.pc += 1\\n s = str(self.data[t:self.pc], encoding=\\\"utf8\\\")\\n self.pc += 1 # jump '\\\\0'\\n return s\",\n \"def to_string(data):\\n return to_bytes(data)\",\n \"def str_to_bytes(data):\\n u_type = type(b''.decode('utf8'))\\n if isinstance(data, u_type):\\n return data.encode('utf8')\\n return data\",\n \"def str_to_bytes(s, encoding='ascii'):\\n return s.encode(encoding)\",\n \"def decode_to_utf8(text) -> bytes: # pragma: no cover\\n try:\\n return text.decode(\\\"utf-8\\\")\\n except (AttributeError, UnicodeEncodeError):\\n return text\",\n \"def ustr(obj):\\n if IS_PY2:\\n # If we are getting a string, then do an explicit decode\\n # else, just call the unicode method of the object\\n if type(obj) in [str, basestring]: # pragma: no cover # noqa\\n return unicode(obj, DEFAULT_ENCODING) # pragma: no cover # noqa\\n else:\\n return unicode(obj) # pragma: no cover # noqa\\n else:\\n if type(obj) in [bytes]:\\n return obj.decode(DEFAULT_ENCODING)\\n else:\\n return str(obj)\",\n \"def polite_bytes(a_string):\\n if is_py3():\\n try:\\n return bytes(a_string, 'utf-8')\\n except TypeError:\\n return a_string\\n\\n return a_string\",\n \"def native_string(input_var):\\n if isinstance(input_var, str):\\n return input_var\\n\\n return input_var.decode('utf-8', 'replace')\",\n \"def to_bytes(bytes_or_str):\\r\\n if isinstance(bytes_or_str, str):\\r\\n value = bytes_or_str.encode('utf-8')\\r\\n else:\\r\\n value = bytes_or_str\\r\\n return value\",\n \"def bytes_to_text(byte_array, encoding='UTF-8'):\\n return bytes(byte_array).decode(encoding)\",\n \"def to_bytes(data):\\n if isinstance(data, str):\\n return data.encode(encoding='utf-8')\\n else:\\n return data\",\n \"def bytes_string(text, encode=\\\"utf-8\\\"):\\n if not PY3:\\n if isinstance(text, unicode): # pylint: disable=undefined-variable\\n result = text.encode(encode)\\n else:\\n result = text\\n else:\\n if isinstance(text, bytes):\\n result = text\\n else:\\n result = bytes(text, encode)\\n return result\",\n \"def convert_to_str(input_string):\\n\\n if sys.version < '3':\\n\\n if isinstance(input_string, str) \\\\\\n or isinstance(input_string, unicode): # pragma: no cover py3\\n\\n return input_string # pragma: no cover py3\\n\\n else:\\n\\n if isinstance(input_string, str): # pragma: no cover py3\\n\\n return input_string # pragma: no cover py3\\n\\n return str(input_string)\",\n \"def test_bytesToString(self):\\n self.assertNativeString(b\\\"hello\\\", \\\"hello\\\")\",\n \"def base32_decode(encoded_bytes: bytes) -> str:\\n\\n # decode the bytes from base32\\n # then, decode the bytes-like object to return as a string\\n return base64.b32decode(encoded_bytes).decode(\\\"utf-8\\\")\",\n \"def ToString(bval):\\n return bval.decode('utf-8')\",\n \"def __str__(self):\\n return bytes_to_string(self._bytes)\",\n \"def utfstr(stuff):\\n if isinstance(stuff,basestring):\\n return stuff\\n else:\\n return str(stuff)\",\n \"def ascii_convert(the_bytes: bytes):\\n return ANSI_ESCAPE_B.sub(rb\\\"\\\", the_bytes).decode(\\\"utf-8\\\")\",\n \"def force_str(s):\\n return (s.encode('utf8')\\n if isinstance(s, unicode)\\n else str(s))\",\n \"def decode_string(encoded: bytes) -> str:\\n if encoded.startswith(codecs.BOM_UTF8):\\n return encoded.decode(\\\"utf-8-sig\\\")\\n elif encoded.startswith(codecs.BOM_UTF16):\\n encoded = encoded[len(codecs.BOM_UTF16) :]\\n return encoded.decode(\\\"utf-16\\\")\\n else:\\n # No BOM to determine encoding, try utf-8\\n return encoded.decode(\\\"utf-8\\\")\",\n \"def _convert_to_str(self, data):\\n raise NotImplementedError()\",\n \"def ensure_native_str(data, encoding=\\\"utf8\\\"):\\n if isinstance(data, str):\\n return data\\n elif isinstance(data, unicode_type):\\n # Only executes on python 2\\n return data.encode(encoding)\\n elif isinstance(data, bytes):\\n # Only executes on python 3\\n return data.decode(encoding)\\n else:\\n str(data)\",\n \"def as_str_any(value):\\n if isinstance(value, bytes):\\n return as_str(value)\\n else:\\n return str(value)\",\n \"def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n return str(s)\\n if isinstance(s, bytes):\\n return s.decode(encoding, errors)\\n return s\",\n \"def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n return str(s)\\n if isinstance(s, bytes):\\n return s.decode(encoding, errors)\\n return s\",\n \"def conv_bytes_to_str(self, rcv: bytes, read_until: t.Union[str, None] = None, strip: bool = True) -> t.Union[str, None]:\\n\\n if (rcv is None):\\n return None\\n\\n res = rcv.decode(\\\"utf-8\\\")\\n\\n try:\\n ret = res[0:res.index(str(read_until))] # sliced string\\n if (strip):\\n return ret.strip()\\n else:\\n return ret\\n\\n except (ValueError, TypeError):\\n # read_until does not exist or it is None, so return the entire thing\\n if (strip):\\n return res.strip()\\n else:\\n return res\",\n \"def ensure_bytes(s, encoding):\\n if isinstance(s, bytes):\\n return s\\n return s.encode(encoding)\",\n \"def _to_bytes(value: Union[str, bytes]) -> bytes:\\n return value if isinstance(value, bytes) else value.encode(\\\"utf-8\\\")\",\n \"def _to_native_string(string, encoding='ascii'):\\n if isinstance(string, str):\\n out = string\\n else:\\n out = string.decode(encoding)\\n\\n return out\",\n \"def asunicode(s):\\n if isinstance(s, bytes):\\n return s.decode('utf-8', 'replace')\\n else:\\n return s\",\n \"def smart_str(s):\\n # Handle the common case first for performance reasons.\\n if issubclass(type(s), str) or isinstance(s, _PROTECTED_TYPES):\\n return s\\n if isinstance(s, bytes):\\n return str(s, 'utf-8')\\n return str(s)\",\n \"def astr(obj):\\n\\treturn unicode(obj).encode(\\\"ascii\\\", \\\"replace\\\")\",\n \"def decode(value, encoding='utf-8') -> str:\\n return value.decode(encoding) if isinstance(value, bytes) else value\",\n \"def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n s = str(s)\\n if isinstance(s, str):\\n return s.encode(encoding, errors)\\n return s\",\n \"def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n s = str(s)\\n if isinstance(s, str):\\n return s.encode(encoding, errors)\\n return s\",\n \"def test_to_str(self):\\n sts = smdba.basegate.BaseGate.to_str(b'\\\\xd1\\\\x81\\\\xd0\\\\xbf\\\\xd0\\\\xb0\\\\xd0\\\\xbc \\\\xd1\\\\x96 \\\\xd1\\\\x8f\\\\xd0\\\\xb9\\\\xd1\\\\x86\\\\xd1\\\\x8f')\\n assert sts == \\\"спам і яйця\\\"\",\n \"def polite_string(a_string):\\n if is_py3() and hasattr(a_string, 'decode'):\\n try:\\n return a_string.decode('utf-8')\\n except UnicodeDecodeError:\\n return a_string\\n\\n return a_string\",\n \"def convert_from_bytes(output: ResponseOutput, ty: Optional[Type]) -> Any:\\n if ty == str:\\n return bytearray(output.data).decode(\\\"UTF-8\\\")\\n else:\\n py_str = bytearray(output.data).decode(\\\"UTF-8\\\")\\n from ast import literal_eval\\n\\n return literal_eval(py_str)\",\n \"def Astr(string):\\n\\n return unicode(string, encoding='utf-8')\",\n \"def _text(string, encoding='utf8'):\\n if isinstance(string, six.text_type):\\n return string\\n elif isinstance(string, six.binary_type):\\n return string.decode(encoding)\\n else:\\n return six.text_type(string)\",\n \"def _as_unicode(s):\\n if isinstance(s, str):\\n return s\\n # Assume it is a bytes string\\n # Note ISO-8859-1 aka Latin-1 preserves first 256 chars\\n return codecs.latin_1_decode(s)[0]\",\n \"def as_bytes(string):\\n return same_string_type_as(b\\\"\\\", string)\",\n \"def to_ascii(s):\\n return s.encode('ascii', 'ignore')\",\n \"def unicode_to_str(str1, logger=None, str_encode='system', py_version=3):\\n if str1 is None or str1 == \\\"\\\" or str1 == 'Null' or str1 == 'null':\\n str1 = \\\"\\\"\\n elif ((py_version == 2 and isinstance(str1, str)) or (\\n py_version == 3 and isinstance(str1, str))):\\n try:\\n if str_encode.lower() == 'system':\\n str1 = str1.encode(sys.getfilesystemencoding(), 'ignore')\\n elif str_encode.lower() == 'utf-8':\\n str1 = str1.encode('utf-8', 'ignore')\\n elif str_encode.lower() == 'gbk':\\n str1 = str1.encode('gbk', 'ignore')\\n else:\\n str1 = str1.encode(str_encode, 'ignore')\\n except UnicodeDecodeError as err_message:\\n if logger:\\n logger.info('[err]unicode_to_str:encode %s to %s failed',\\n str1, str_encode)\\n logger.info(str(err_message))\\n elif ((py_version == 2 and isinstance(str1, str)) or (\\n py_version == 3 and isinstance(str1, bytes))):\\n pass\\n else:\\n if logger:\\n logger.info('%s is not unicode ', str1)\\n return str(str1)\",\n \"def base64str(s: str,\\n encoding: str = 'utf-8',\\n decoding='utf-8',\\n encerrors='strict',\\n decerrors='strict') -> str:\\n enc = encoding\\n if enc is None or enc == '':\\n enc = 'utf-8'\\n dec = decoding\\n if dec is None or dec == '':\\n dec = 'utf-8'\\n\\n bsIn = bytes(s, enc, encerrors)\\n bsOut = base64.b64encode(bsIn)\\n res = str(bsOut, dec, decerrors)\\n return res\",\n \"def decode_doomstring(byte_string):\\n s = list()\\n import sys\\n if len(byte_string) > 0:\\n for b in byte_string:\\n if b == 0:\\n break\\n try:\\n b = (b).to_bytes(1, 'little').decode('ascii')\\n except Exception:\\n # Encountered an invalid character, just ignore it\\n continue\\n s.append(b)\\n return ''.join(s)\\n else:\\n return ''\",\n \"def to_hex_str(data_bytes: bytes) -> str:\\n if isinstance(data_bytes, bytes):\\n data_bytes = bytearray(data_bytes)\\n data_bytes.reverse()\\n return '0x' + data_bytes.hex()\",\n \"def ensure_bytes(str_or_bytes, binary_type=six.binary_type,\\n text_type=six.text_type):\\n if isinstance(str_or_bytes, binary_type):\\n return str_or_bytes\\n if isinstance(str_or_bytes, text_type):\\n return str_or_bytes.encode('utf-8')\\n raise TypeError(\\n \\\"input must be a text or byte string, got {}\\\"\\n .format(type(str_or_bytes).__name__))\",\n \"def ensure_bytes(value: AnyStr) -> bytes:\\n if isinstance(value, bytes):\\n return value\\n if isinstance(value, str):\\n return value.encode('utf-8')\\n raise TypeError(f\\\"input must be str or bytes, got {type(value).__name__}\\\")\",\n \"def binary_encoding(string, encoding = 'utf-8'):\\n try:\\n return bytes(string, encoding)\\n except TypeError: # We are in Python 2\\n return str(string)\",\n \"def to_bytes(string):\\n assert isinstance(string, basestring)\\n if sys.version_info[0] >= 3:\\n if isinstance(string, str):\\n return string.encode('utf-8')\\n else:\\n return string\\n else:\\n if isinstance(string, unicode):\\n return string.encode('utf-8')\\n else:\\n return string\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7246639","0.7208778","0.7151885","0.71390045","0.7111041","0.7110607","0.7110607","0.70306545","0.70047045","0.6990467","0.6975962","0.6801189","0.6800496","0.6777518","0.6772956","0.6617866","0.65932745","0.65838194","0.652744","0.6471219","0.6455923","0.64424187","0.6436759","0.640181","0.63992304","0.63900954","0.6381755","0.63754994","0.6353707","0.633444","0.6327957","0.630904","0.6297829","0.6275634","0.62325364","0.6217009","0.62054205","0.6185532","0.6164418","0.61565524","0.61391205","0.61247265","0.6115042","0.6087288","0.6062011","0.60610795","0.6053735","0.60416466","0.6034356","0.6003643","0.6002298","0.599743","0.5984486","0.5984428","0.5972067","0.59396","0.59290457","0.59231293","0.5912963","0.5912111","0.5911697","0.590592","0.5903562","0.58935815","0.58725196","0.58685744","0.5848311","0.5846748","0.58312464","0.5825712","0.58221906","0.5817755","0.58151674","0.58151674","0.58026147","0.5790203","0.57900506","0.578704","0.5785086","0.5778927","0.5768551","0.5744179","0.57266754","0.57266754","0.5725303","0.5718209","0.5717137","0.570919","0.5707714","0.5706706","0.5706597","0.57063735","0.5704516","0.57004714","0.5681883","0.56759316","0.5657137","0.56543773","0.5645425","0.56446"],"string":"[\n \"0.7246639\",\n \"0.7208778\",\n \"0.7151885\",\n \"0.71390045\",\n \"0.7111041\",\n \"0.7110607\",\n \"0.7110607\",\n \"0.70306545\",\n \"0.70047045\",\n \"0.6990467\",\n \"0.6975962\",\n \"0.6801189\",\n \"0.6800496\",\n \"0.6777518\",\n \"0.6772956\",\n \"0.6617866\",\n \"0.65932745\",\n \"0.65838194\",\n \"0.652744\",\n \"0.6471219\",\n \"0.6455923\",\n \"0.64424187\",\n \"0.6436759\",\n \"0.640181\",\n \"0.63992304\",\n \"0.63900954\",\n \"0.6381755\",\n \"0.63754994\",\n \"0.6353707\",\n \"0.633444\",\n \"0.6327957\",\n \"0.630904\",\n \"0.6297829\",\n \"0.6275634\",\n \"0.62325364\",\n \"0.6217009\",\n \"0.62054205\",\n \"0.6185532\",\n \"0.6164418\",\n \"0.61565524\",\n \"0.61391205\",\n \"0.61247265\",\n \"0.6115042\",\n \"0.6087288\",\n \"0.6062011\",\n \"0.60610795\",\n \"0.6053735\",\n \"0.60416466\",\n \"0.6034356\",\n \"0.6003643\",\n \"0.6002298\",\n \"0.599743\",\n \"0.5984486\",\n \"0.5984428\",\n \"0.5972067\",\n \"0.59396\",\n \"0.59290457\",\n \"0.59231293\",\n \"0.5912963\",\n \"0.5912111\",\n \"0.5911697\",\n \"0.590592\",\n \"0.5903562\",\n \"0.58935815\",\n \"0.58725196\",\n \"0.58685744\",\n \"0.5848311\",\n \"0.5846748\",\n \"0.58312464\",\n \"0.5825712\",\n \"0.58221906\",\n \"0.5817755\",\n \"0.58151674\",\n \"0.58151674\",\n \"0.58026147\",\n \"0.5790203\",\n \"0.57900506\",\n \"0.578704\",\n \"0.5785086\",\n \"0.5778927\",\n \"0.5768551\",\n \"0.5744179\",\n \"0.57266754\",\n \"0.57266754\",\n \"0.5725303\",\n \"0.5718209\",\n \"0.5717137\",\n \"0.570919\",\n \"0.5707714\",\n \"0.5706706\",\n \"0.5706597\",\n \"0.57063735\",\n \"0.5704516\",\n \"0.57004714\",\n \"0.5681883\",\n \"0.56759316\",\n \"0.5657137\",\n \"0.56543773\",\n \"0.5645425\",\n \"0.56446\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7150879"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":88395,"cells":{"query":{"kind":"string","value":"When called with an instance of L{str}, L{bytes_to_str} returns its input unmodified."},"document":{"kind":"string","value":"def test_str(self):\n self.assertEqual(\n \"\\N{SNOWMAN}\",\n bytes_to_str(\"\\N{SNOWMAN}\"),\n )"},"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 always_str(str_or_bytes: Union[None, str, bytes], *decode_args) -> Union[None, str]:\n if str_or_bytes is None or isinstance(str_or_bytes, str):\n return str_or_bytes\n elif isinstance(str_or_bytes, bytes):\n return str_or_bytes.decode(*decode_args)\n else:\n raise TypeError(\"Expected str or bytes, but got {}.\".format(type(str_or_bytes).__name__))","def bytes_to_str(self, data):\n if isinstance(data, str):\n return data\n return data.decode(\"utf-8\")","def _force_string(x):\n if isinstance(x, basestring):\n return x\n else:\n return str(x)","def convert_to_str(string):\n if type(string) is str:\n return string\n else:\n return bytes.decode(string)","def test_bytes(self):\n self.assertRaises(\n UnicodeDecodeError,\n lambda: bytes_to_str(\"\\N{SNOWMAN}\".encode(\"utf-8\")),\n )\n decoded = bytes_to_str(b\"hello world\")\n self.assertIsInstance(decoded, str)\n self.assertEqual(decoded, \"hello world\")","def bytes2str(val):\n if isinstance(val, bytes):\n return str(val, \"utf8\")\n else:\n return val","def _tostr(obj): # pragma: no cover\n return obj if isinstance(obj, str) else obj.decode()","def test_bytes_to_native_str(self):\n b = bytes(b'abc')\n s = bytes_to_native_str(b)\n if PY2:\n self.assertEqual(s, b)\n else:\n self.assertEqual(s, 'abc')\n self.assertTrue(isinstance(s, native_str))\n self.assertEqual(type(s), native_str)","def ensure_bytes(value: AnyStr) -> bytes:\n if isinstance(value, bytes):\n return value\n if isinstance(value, str):\n return value.encode('utf-8')\n raise TypeError(f\"input must be str or bytes, got {type(value).__name__}\")","def force_text(s: Union[str, bytes], encoding=\"utf-8\", errors=\"strict\") -> str:\n if isinstance(s, str):\n return s\n\n try:\n if not isinstance(s, str):\n if isinstance(s, bytes):\n s = str(s, encoding, errors)\n else:\n s = str(s)\n else:\n s = s.decode(encoding, errors)\n except UnicodeDecodeError as e:\n raise e\n return s","def as_str_any(value):\n if isinstance(value, bytes):\n return as_str(value)\n else:\n return str(value)","def smart_str(s):\n # Handle the common case first for performance reasons.\n if issubclass(type(s), str) or isinstance(s, _PROTECTED_TYPES):\n return s\n if isinstance(s, bytes):\n return str(s, 'utf-8')\n return str(s)","def to_str(source: Union[str, bytes, IO[bytes]]) -> str:\n if isinstance(source, str):\n return source\n elif isinstance(source, bytes):\n # XXX: Assume it's UTF-8 encoded!\n return source.decode('UTF-8')\n else:\n raise NotImplementedError","def _to_str(s, encoding=\"utf8\", errors=\"ignore\"):\n if isinstance(s, bytes):\n return s.decode(encoding=encoding, errors=errors)\n return str(s)","def _bytes_bytearray_to_str(s):\n if isinstance(s, (bytes, bytearray)):\n return s.decode()\n return s","def test_str(self):\n obj = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\n expected = str(binascii.hexlify(self.bytes_a))\n observed = str(obj)\n self.assertEqual(expected, observed)","def force_str(s):\n return (s.encode('utf8')\n if isinstance(s, unicode)\n else str(s))","def native_(s, encoding='latin-1', errors='strict'):\n if isinstance(s, text_type):\n return s\n return str(s, encoding, errors)","def ensure_bytes(str_or_bytes, binary_type=six.binary_type,\n text_type=six.text_type):\n if isinstance(str_or_bytes, binary_type):\n return str_or_bytes\n if isinstance(str_or_bytes, text_type):\n return str_or_bytes.encode('utf-8')\n raise TypeError(\n \"input must be a text or byte string, got {}\"\n .format(type(str_or_bytes).__name__))","def test_to_String(self) -> None:\n assert to_String(1) == \"1\", to_String(1)\n assert to_String([1, 2, 3]) == str([1, 2, 3]), to_String([1, 2, 3])\n assert to_String(\"foo\") == \"foo\", to_String(\"foo\")\n assert to_String(None) == 'None'\n # test low level string converters too\n assert to_str(None) == 'None'\n assert to_bytes(None) == b'None'\n\n s1 = UserString('blah')\n assert to_String(s1) == s1, s1\n assert to_String(s1) == 'blah', s1\n\n class Derived(UserString):\n pass\n\n s2 = Derived('foo')\n assert to_String(s2) == s2, s2\n assert to_String(s2) == 'foo', s2","def _as_bytes(s):\n if isinstance(s, bytes):\n return s\n return bytes(s, encoding='latin_1')","def give_me_bytes(string):\n return string.encode('utf8') if isinstance(string, str) else string","def pystr(s):\n if six.PY2 and isinstance(s, six.text_type):\n return s.encode('ascii', 'ignore')\n elif six.PY3 and isinstance(s, six.binary_type):\n return s.decode('utf-8')\n else:\n return s","def toString(s):\n if type(s) == type(\"\"):\n return s\n else:\n return s.decode()","def _convert_to_str(self, data):\n raise NotImplementedError()","def enforce_bytes(value: Union[bytes, str], *, name: str) -> bytes:\n if isinstance(value, str):\n try:\n return value.encode(\"ascii\")\n except UnicodeEncodeError:\n raise TypeError(f\"{name} strings may not include unicode characters.\")\n elif isinstance(value, bytes):\n return value\n\n seen_type = type(value).__name__\n raise TypeError(f\"{name} must be bytes or str, but got {seen_type}.\")","def bytes_to_str(str1, logger=None, str_decode='default', py_version=3):\n if not ((py_version == 2 and isinstance(str1, str)) or\n (py_version == 3 and isinstance(str1, str))):\n try:\n if str_decode != 'default':\n str1 = str1.decode(str_decode.lower(), 'ignore')\n else:\n try:\n str1 = str1.decode('utf-8', 'ignore')\n except UnicodeDecodeError:\n try:\n str1 = str1.decode('gbk', 'ignore')\n except UnicodeDecodeError:\n str1 = str1.decode(sys.getfilesystemencoding(),\n 'ignore')\n except UnicodeDecodeError as err_message:\n if logger:\n logger.info('[err]bytes_to_str:decode %s to str failed', str1)\n logger.info(str(err_message))\n return str1","def ensure_bytes(s, encoding):\n if isinstance(s, bytes):\n return s\n return s.encode(encoding)","def test_str_to_str(self):\n @converters.wrap\n def inner_test(param: str):\n \"\"\"Make sure the parameter was converted correctly.\"\"\"\n self.assertEqual(param, 'Test string.')\n inner_test(param='Test string.')","def bytes_to_str(s, encoding='utf-8'):\n if isinstance(s, bytes):\n return s.decode(encoding)\n return s","def _stringify(obj):\r\n if isinstance(obj, unicode):\r\n return obj.encode('utf-8')\r\n elif isinstance(obj, str):\r\n return obj\r\n else:\r\n raise TypeError('Object is not a string.')","def tostring(b):\n if isinstance(b, bytes):\n return bytes2str(b)\n else:\n return b","def str_to_bytes(self, data):\n if isinstance(data, bytes):\n return data\n return data.encode(\"utf-8\")","def convert_to_string(value: Any) -> str:\n if isinstance(value, str):\n return value\n\n if isinstance(value, bytes):\n return value.decode(\"utf-8\")\n\n return str(value)","def bytes2str(data):\n # pylint: disable=multiple-statements\n\n if isinstance(data, bytes): return data.decode('utf-8')\n if isinstance(data, dict): return dict(map(bytes2str, data.items()))\n if isinstance(data, tuple): return map(bytes2str, data)\n return data","def test_bytes_to_string():\n\n @type_checked\n def _run_test(something:str):\n assert something == \"yep\"\n\n _run_test(bytes(\"yep\", \"utf-8\"))","def fs_str(string):\n if isinstance(string, str):\n return string\n if isinstance(string, bytes):\n raise AssertionError\n return string.encode(_fs_encoding)","def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n s = str(s)\n if isinstance(s, str):\n return s.encode(encoding, errors)\n return s","def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n s = str(s)\n if isinstance(s, str):\n return s.encode(encoding, errors)\n return s","def text_(s, encoding='utf-8', errors='strict'):\n if isinstance(s, binary_type):\n return s.decode(encoding, errors)\n return s # pragma: no cover","def clean_value(self, value):\n if isinstance(value, bytes):\n return value.decode('utf-8')\n else:\n return str(value)","def smart_bytes(s):\n # Handle the common case first for performance reasons.\n if isinstance(s, bytes) or isinstance(s, _PROTECTED_TYPES):\n return s\n if isinstance(s, memoryview):\n return bytes(s)\n return s.encode()","def bytes_to_str(s, encoding='utf-8'):\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s","def bytes_to_str(s, encoding='utf-8'):\n if six.PY3 and isinstance(s, bytes):\n return s.decode(encoding)\n return s","def asbytes(s):\n if isinstance(s, bytes):\n return s\n else:\n return s.encode('utf-8')","def to_str(value: bytes) -> str:\n if value is not None:\n out = value.decode(\"utf-8\")\n else:\n out = \"\"\n\n return out","def as_str(self) -> str:\n if isinstance(self.data, str):\n return self.data\n elif isinstance(self.data, bytes):\n return self.data.decode()\n else:\n return bytes(self.data).decode()","def from_str(cls, s):\n raise NotImplementedError","def test_str(self):\n dummy = DummyCryptographicObject()\n str(dummy)","def convert_to_str(input_string):\n\n if sys.version < '3':\n\n if isinstance(input_string, str) \\\n or isinstance(input_string, unicode): # pragma: no cover py3\n\n return input_string # pragma: no cover py3\n\n else:\n\n if isinstance(input_string, str): # pragma: no cover py3\n\n return input_string # pragma: no cover py3\n\n return str(input_string)","def egest(s):\n if isinstance(s, rawtype):\n return s\n elif isinstance(s, safetype): # On python 2 str is bytes.\n return str2raw(s)\n else:\n raise TypeError(\"Can't egest data of type %s\" % type(s))","def polite_bytes(a_string):\n if is_py3():\n try:\n return bytes(a_string, 'utf-8')\n except TypeError:\n return a_string\n\n return a_string","def as_bytes(string):\n return same_string_type_as(b\"\", string)","def str_to_python(self, value):\r\n return unicode_safe(value)","def to_bytes(bytes_or_str):\r\n if isinstance(bytes_or_str, str):\r\n value = bytes_or_str.encode('utf-8')\r\n else:\r\n value = bytes_or_str\r\n return value","def test_native_str(self):\n if PY2:\n import __builtin__\n builtin_str = __builtin__.str\n else:\n import builtins\n builtin_str = builtins.str\n\n inputs = [b'blah', u'blah', 'blah']\n for s in inputs:\n self.assertEqual(native_str(s), builtin_str(s))\n self.assertTrue(isinstance(native_str(s), builtin_str))","def safeToString():","def _to_bytes(value: Union[str, bytes]) -> bytes:\n return value if isinstance(value, bytes) else value.encode(\"utf-8\")","def test_bytesToString(self):\n self.assertNativeString(b\"hello\", \"hello\")","def native_(s, encoding='latin-1', errors='strict'):\n if isinstance(s, text_type):\n return s.encode(encoding, errors)\n return str(s)","def ensure_native_str(data, encoding=\"utf8\"):\n if isinstance(data, str):\n return data\n elif isinstance(data, unicode_type):\n # Only executes on python 2\n return data.encode(encoding)\n elif isinstance(data, bytes):\n # Only executes on python 3\n return data.decode(encoding)\n else:\n str(data)","def asString(obj):\n if type(obj) in _STR_TYPES:\n return obj\n return str(obj)","def kafka_bytestring(s):\n if isinstance(s, bytes):\n return s\n if isinstance(s, bytes):\n return s.encode('utf-8')\n raise TypeError(s)","def test_str(self):\n self.assertEqual(str(self.bs), str(self.wbs))\n self.assertEqual(str(self.be), str(self.be))\n # str(us) fails in Python 2\n self.assertEqual(str, type(str(self.wus)))\n # str(ue) fails in Python 2\n self.assertEqual(str, type(str(self.wue)))","def force_unicode(s, encoding=encoding, errors='strict'):\n if isinstance(s, unicode):\n return s\n elif hasattr(s, '__unicode__'):\n return unicode(s)\n elif isinstance(s, str):\n return s.decode(encoding, errors)\n else:\n return str(s).decode(encoding, errors)","def native_string(input_var):\n if isinstance(input_var, str):\n return input_var\n\n return input_var.decode('utf-8', 'replace')","def test_strmethod(self):\n b1 = BaseModel()\n self.assertEqual(type(str(b1)), str)","def safe(self, string):\n if sys.version_info.major >= 3 and isinstance(string, bytes):\n string = string.decode('utf8')\n elif sys.version_info.major < 3:\n if not isinstance(string, unicode):\n string = unicode(string, encoding='utf8')\n string = string.replace('\\n', '')\n string = string.replace('\\r', '')\n return string","def safestr(obj, encoding='utf-8'):\n if isinstance(obj, unicode):\n return obj.encode(encoding)\n elif isinstance(obj, str):\n return obj\n elif hasattr(obj, 'next') and hasattr(obj, '__iter__'): # iterator\n return itertools.imap(safestr, obj)\n else:\n return str(obj)","def force_bytes(value):\n if IS_PY3:\n if isinstance(value, str):\n value = value.encode(\"utf-8\", \"backslashreplace\")\n else:\n if isinstance(value, unicode): # NOQA: F821\n value = value.encode(\"utf-8\")\n\n return value","def convert_to_string(_bytes: bytes)-> str:\n # print('input bytes: ', _bytes)\n # print('string: ', binascii.hexlify(_bytes))\n # print('string2: ', _bytes.hex())\n # print('string3: ', \" \".join([\"{:02x}\".format(x) for x in _bytes]))\n return \" \".join([\"{:02x}\".format(x) for x in _bytes])","def _validate_str(val):\n if not isinstance(val, str):\n raise ValueError(\"Passed value {} is not a string\".format(val))\n return val","def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n return str(s)\n if isinstance(s, bytes):\n return s.decode(encoding, errors)\n return s","def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\n if isinstance(s, int):\n return str(s)\n if isinstance(s, bytes):\n return s.decode(encoding, errors)\n return s","def simple_str(self):\n pass","def str_to_bytes(data):\n u_type = type(b''.decode('utf8'))\n if isinstance(data, u_type):\n return data.encode('utf8')\n return data","def serialize(self, data):\n if isinstance(data, str):\n return data\n\n if hasattr(data, \"read\"):\n return data.read()\n\n raise ValueError(\"Unable to handle input format: %s\" % type(data))","def test_is_str_rep_string(self):\n self.assertIsInstance(cardutils.Card(10,1).__str__(), str)","def force_text(s):\n if s is None:\n return \"\"\n if not isinstance(s, six.string_types):\n return six.text_type(s)\n return s","def utfstr(stuff):\n if isinstance(stuff,basestring):\n return stuff\n else:\n return str(stuff)","def ensure_binary(s, encoding='utf-8', errors='strict'):\n if isinstance(s, six.text_type):\n return s.encode(encoding, errors)\n elif isinstance(s, six.binary_type):\n return s\n else:\n raise TypeError(\"not expecting type '%s'\" % type(s))","def _unicodeify(self, value, encoding=\"utf8\"):\n if isinstance(value, str):\n return value\n return str(value, encoding)","def convert_from_bytes(output: ResponseOutput, ty: Optional[Type]) -> Any:\n if ty == str:\n return bytearray(output.data).decode(\"UTF-8\")\n else:\n py_str = bytearray(output.data).decode(\"UTF-8\")\n from ast import literal_eval\n\n return literal_eval(py_str)","def from_str(cls, string):","def from_bytes(self, ???):","def ensure_utf8_bytes(v: Union[str, bytes]) -> bytes:\n if isinstance(v, str):\n v = v.encode(\"utf-8\")\n return v","def convert_str(input_obj):\n if isinstance(input_obj, str):\n return(input_obj)\n elif input_obj is True:\n return('1')\n elif (input_obj is None):\n return('none')\n elif input_obj is False:\n return('0')\n else:\n return(str(input_obj))","def ensure_unicode_string(value):\n if not isinstance(value, six.string_types):\n raise TypeError(u'Expected string value, got: {}'.format(value))\n return six.text_type(value)","def is_string(value):\n return isinstance(value, (str, bytes))","def test_str_(self):\n str(self.standardcode)\n repr(self.standardcode)","def as_text(bytes_or_text, encoding='utf-8'):\n if isinstance(bytes_or_text, _six.text_type):\n return bytes_or_text\n elif isinstance(bytes_or_text, bytes):\n return bytes_or_text.decode(encoding)\n else:\n raise TypeError(\n 'Expected binary or unicode string, got %r' % bytes_or_text\n )","def encodeString(*args, **kwargs)->AnyStr:\n pass","def to_bytes(data):\n if isinstance(data, str):\n return data.encode(encoding='utf-8')\n else:\n return data","def to_string(data):\n if isinstance(data, bytes):\n return data.decode('utf-8')\n else:\n return data","def test_str_with_no_data(self):\n data = b''\n digest_value = DigestValue(data)\n self._test_str(digest_value, str(data))","def byte2str(self, obj):\n encoding = \"utf-8\"\n if isinstance(obj, list):\n if len(obj)>0 and not isinstance(obj[0], str):\n self.helper.log_debug(\n \"conversion from list of %s onto list of <class 'str'>\" %\n type(obj[0]))\n return [ s.decode(encoding) for s in obj ]\n elif not isinstance(obj, str):\n self.helper.log_debug(\n \"conversion from %s onto <class 'str'>\" %\n type(obj))\n return obj.decode(encoding)\n return obj","def force_unicode(s):\n return (s.decode('utf8')\n if isinstance(s, str)\n else unicode(s))","def _text(string, encoding='utf8'):\n if isinstance(string, six.text_type):\n return string\n elif isinstance(string, six.binary_type):\n return string.decode(encoding)\n else:\n return six.text_type(string)","def safe_str(obj):\n try:\n return str(obj)\n except UnicodeEncodeError:\n # obj is unicode\n return unicode(obj).encode('unicode_escape')","def safe_str(obj):\n try:\n return str(obj)\n except UnicodeEncodeError:\n # obj is unicode\n return unicode(obj).encode('unicode_escape')","def safe_str(obj):\n try:\n return str(obj)\n except UnicodeEncodeError:\n # obj is unicode\n return unicode(obj).encode('unicode_escape')"],"string":"[\n \"def always_str(str_or_bytes: Union[None, str, bytes], *decode_args) -> Union[None, str]:\\n if str_or_bytes is None or isinstance(str_or_bytes, str):\\n return str_or_bytes\\n elif isinstance(str_or_bytes, bytes):\\n return str_or_bytes.decode(*decode_args)\\n else:\\n raise TypeError(\\\"Expected str or bytes, but got {}.\\\".format(type(str_or_bytes).__name__))\",\n \"def bytes_to_str(self, data):\\n if isinstance(data, str):\\n return data\\n return data.decode(\\\"utf-8\\\")\",\n \"def _force_string(x):\\n if isinstance(x, basestring):\\n return x\\n else:\\n return str(x)\",\n \"def convert_to_str(string):\\n if type(string) is str:\\n return string\\n else:\\n return bytes.decode(string)\",\n \"def test_bytes(self):\\n self.assertRaises(\\n UnicodeDecodeError,\\n lambda: bytes_to_str(\\\"\\\\N{SNOWMAN}\\\".encode(\\\"utf-8\\\")),\\n )\\n decoded = bytes_to_str(b\\\"hello world\\\")\\n self.assertIsInstance(decoded, str)\\n self.assertEqual(decoded, \\\"hello world\\\")\",\n \"def bytes2str(val):\\n if isinstance(val, bytes):\\n return str(val, \\\"utf8\\\")\\n else:\\n return val\",\n \"def _tostr(obj): # pragma: no cover\\n return obj if isinstance(obj, str) else obj.decode()\",\n \"def test_bytes_to_native_str(self):\\n b = bytes(b'abc')\\n s = bytes_to_native_str(b)\\n if PY2:\\n self.assertEqual(s, b)\\n else:\\n self.assertEqual(s, 'abc')\\n self.assertTrue(isinstance(s, native_str))\\n self.assertEqual(type(s), native_str)\",\n \"def ensure_bytes(value: AnyStr) -> bytes:\\n if isinstance(value, bytes):\\n return value\\n if isinstance(value, str):\\n return value.encode('utf-8')\\n raise TypeError(f\\\"input must be str or bytes, got {type(value).__name__}\\\")\",\n \"def force_text(s: Union[str, bytes], encoding=\\\"utf-8\\\", errors=\\\"strict\\\") -> str:\\n if isinstance(s, str):\\n return s\\n\\n try:\\n if not isinstance(s, str):\\n if isinstance(s, bytes):\\n s = str(s, encoding, errors)\\n else:\\n s = str(s)\\n else:\\n s = s.decode(encoding, errors)\\n except UnicodeDecodeError as e:\\n raise e\\n return s\",\n \"def as_str_any(value):\\n if isinstance(value, bytes):\\n return as_str(value)\\n else:\\n return str(value)\",\n \"def smart_str(s):\\n # Handle the common case first for performance reasons.\\n if issubclass(type(s), str) or isinstance(s, _PROTECTED_TYPES):\\n return s\\n if isinstance(s, bytes):\\n return str(s, 'utf-8')\\n return str(s)\",\n \"def to_str(source: Union[str, bytes, IO[bytes]]) -> str:\\n if isinstance(source, str):\\n return source\\n elif isinstance(source, bytes):\\n # XXX: Assume it's UTF-8 encoded!\\n return source.decode('UTF-8')\\n else:\\n raise NotImplementedError\",\n \"def _to_str(s, encoding=\\\"utf8\\\", errors=\\\"ignore\\\"):\\n if isinstance(s, bytes):\\n return s.decode(encoding=encoding, errors=errors)\\n return str(s)\",\n \"def _bytes_bytearray_to_str(s):\\n if isinstance(s, (bytes, bytearray)):\\n return s.decode()\\n return s\",\n \"def test_str(self):\\n obj = objects.OpaqueObject(self.bytes_a, enums.OpaqueDataType.NONE)\\n expected = str(binascii.hexlify(self.bytes_a))\\n observed = str(obj)\\n self.assertEqual(expected, observed)\",\n \"def force_str(s):\\n return (s.encode('utf8')\\n if isinstance(s, unicode)\\n else str(s))\",\n \"def native_(s, encoding='latin-1', errors='strict'):\\n if isinstance(s, text_type):\\n return s\\n return str(s, encoding, errors)\",\n \"def ensure_bytes(str_or_bytes, binary_type=six.binary_type,\\n text_type=six.text_type):\\n if isinstance(str_or_bytes, binary_type):\\n return str_or_bytes\\n if isinstance(str_or_bytes, text_type):\\n return str_or_bytes.encode('utf-8')\\n raise TypeError(\\n \\\"input must be a text or byte string, got {}\\\"\\n .format(type(str_or_bytes).__name__))\",\n \"def test_to_String(self) -> None:\\n assert to_String(1) == \\\"1\\\", to_String(1)\\n assert to_String([1, 2, 3]) == str([1, 2, 3]), to_String([1, 2, 3])\\n assert to_String(\\\"foo\\\") == \\\"foo\\\", to_String(\\\"foo\\\")\\n assert to_String(None) == 'None'\\n # test low level string converters too\\n assert to_str(None) == 'None'\\n assert to_bytes(None) == b'None'\\n\\n s1 = UserString('blah')\\n assert to_String(s1) == s1, s1\\n assert to_String(s1) == 'blah', s1\\n\\n class Derived(UserString):\\n pass\\n\\n s2 = Derived('foo')\\n assert to_String(s2) == s2, s2\\n assert to_String(s2) == 'foo', s2\",\n \"def _as_bytes(s):\\n if isinstance(s, bytes):\\n return s\\n return bytes(s, encoding='latin_1')\",\n \"def give_me_bytes(string):\\n return string.encode('utf8') if isinstance(string, str) else string\",\n \"def pystr(s):\\n if six.PY2 and isinstance(s, six.text_type):\\n return s.encode('ascii', 'ignore')\\n elif six.PY3 and isinstance(s, six.binary_type):\\n return s.decode('utf-8')\\n else:\\n return s\",\n \"def toString(s):\\n if type(s) == type(\\\"\\\"):\\n return s\\n else:\\n return s.decode()\",\n \"def _convert_to_str(self, data):\\n raise NotImplementedError()\",\n \"def enforce_bytes(value: Union[bytes, str], *, name: str) -> bytes:\\n if isinstance(value, str):\\n try:\\n return value.encode(\\\"ascii\\\")\\n except UnicodeEncodeError:\\n raise TypeError(f\\\"{name} strings may not include unicode characters.\\\")\\n elif isinstance(value, bytes):\\n return value\\n\\n seen_type = type(value).__name__\\n raise TypeError(f\\\"{name} must be bytes or str, but got {seen_type}.\\\")\",\n \"def bytes_to_str(str1, logger=None, str_decode='default', py_version=3):\\n if not ((py_version == 2 and isinstance(str1, str)) or\\n (py_version == 3 and isinstance(str1, str))):\\n try:\\n if str_decode != 'default':\\n str1 = str1.decode(str_decode.lower(), 'ignore')\\n else:\\n try:\\n str1 = str1.decode('utf-8', 'ignore')\\n except UnicodeDecodeError:\\n try:\\n str1 = str1.decode('gbk', 'ignore')\\n except UnicodeDecodeError:\\n str1 = str1.decode(sys.getfilesystemencoding(),\\n 'ignore')\\n except UnicodeDecodeError as err_message:\\n if logger:\\n logger.info('[err]bytes_to_str:decode %s to str failed', str1)\\n logger.info(str(err_message))\\n return str1\",\n \"def ensure_bytes(s, encoding):\\n if isinstance(s, bytes):\\n return s\\n return s.encode(encoding)\",\n \"def test_str_to_str(self):\\n @converters.wrap\\n def inner_test(param: str):\\n \\\"\\\"\\\"Make sure the parameter was converted correctly.\\\"\\\"\\\"\\n self.assertEqual(param, 'Test string.')\\n inner_test(param='Test string.')\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def _stringify(obj):\\r\\n if isinstance(obj, unicode):\\r\\n return obj.encode('utf-8')\\r\\n elif isinstance(obj, str):\\r\\n return obj\\r\\n else:\\r\\n raise TypeError('Object is not a string.')\",\n \"def tostring(b):\\n if isinstance(b, bytes):\\n return bytes2str(b)\\n else:\\n return b\",\n \"def str_to_bytes(self, data):\\n if isinstance(data, bytes):\\n return data\\n return data.encode(\\\"utf-8\\\")\",\n \"def convert_to_string(value: Any) -> str:\\n if isinstance(value, str):\\n return value\\n\\n if isinstance(value, bytes):\\n return value.decode(\\\"utf-8\\\")\\n\\n return str(value)\",\n \"def bytes2str(data):\\n # pylint: disable=multiple-statements\\n\\n if isinstance(data, bytes): return data.decode('utf-8')\\n if isinstance(data, dict): return dict(map(bytes2str, data.items()))\\n if isinstance(data, tuple): return map(bytes2str, data)\\n return data\",\n \"def test_bytes_to_string():\\n\\n @type_checked\\n def _run_test(something:str):\\n assert something == \\\"yep\\\"\\n\\n _run_test(bytes(\\\"yep\\\", \\\"utf-8\\\"))\",\n \"def fs_str(string):\\n if isinstance(string, str):\\n return string\\n if isinstance(string, bytes):\\n raise AssertionError\\n return string.encode(_fs_encoding)\",\n \"def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n s = str(s)\\n if isinstance(s, str):\\n return s.encode(encoding, errors)\\n return s\",\n \"def bytes_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n s = str(s)\\n if isinstance(s, str):\\n return s.encode(encoding, errors)\\n return s\",\n \"def text_(s, encoding='utf-8', errors='strict'):\\n if isinstance(s, binary_type):\\n return s.decode(encoding, errors)\\n return s # pragma: no cover\",\n \"def clean_value(self, value):\\n if isinstance(value, bytes):\\n return value.decode('utf-8')\\n else:\\n return str(value)\",\n \"def smart_bytes(s):\\n # Handle the common case first for performance reasons.\\n if isinstance(s, bytes) or isinstance(s, _PROTECTED_TYPES):\\n return s\\n if isinstance(s, memoryview):\\n return bytes(s)\\n return s.encode()\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def bytes_to_str(s, encoding='utf-8'):\\n if six.PY3 and isinstance(s, bytes):\\n return s.decode(encoding)\\n return s\",\n \"def asbytes(s):\\n if isinstance(s, bytes):\\n return s\\n else:\\n return s.encode('utf-8')\",\n \"def to_str(value: bytes) -> str:\\n if value is not None:\\n out = value.decode(\\\"utf-8\\\")\\n else:\\n out = \\\"\\\"\\n\\n return out\",\n \"def as_str(self) -> str:\\n if isinstance(self.data, str):\\n return self.data\\n elif isinstance(self.data, bytes):\\n return self.data.decode()\\n else:\\n return bytes(self.data).decode()\",\n \"def from_str(cls, s):\\n raise NotImplementedError\",\n \"def test_str(self):\\n dummy = DummyCryptographicObject()\\n str(dummy)\",\n \"def convert_to_str(input_string):\\n\\n if sys.version < '3':\\n\\n if isinstance(input_string, str) \\\\\\n or isinstance(input_string, unicode): # pragma: no cover py3\\n\\n return input_string # pragma: no cover py3\\n\\n else:\\n\\n if isinstance(input_string, str): # pragma: no cover py3\\n\\n return input_string # pragma: no cover py3\\n\\n return str(input_string)\",\n \"def egest(s):\\n if isinstance(s, rawtype):\\n return s\\n elif isinstance(s, safetype): # On python 2 str is bytes.\\n return str2raw(s)\\n else:\\n raise TypeError(\\\"Can't egest data of type %s\\\" % type(s))\",\n \"def polite_bytes(a_string):\\n if is_py3():\\n try:\\n return bytes(a_string, 'utf-8')\\n except TypeError:\\n return a_string\\n\\n return a_string\",\n \"def as_bytes(string):\\n return same_string_type_as(b\\\"\\\", string)\",\n \"def str_to_python(self, value):\\r\\n return unicode_safe(value)\",\n \"def to_bytes(bytes_or_str):\\r\\n if isinstance(bytes_or_str, str):\\r\\n value = bytes_or_str.encode('utf-8')\\r\\n else:\\r\\n value = bytes_or_str\\r\\n return value\",\n \"def test_native_str(self):\\n if PY2:\\n import __builtin__\\n builtin_str = __builtin__.str\\n else:\\n import builtins\\n builtin_str = builtins.str\\n\\n inputs = [b'blah', u'blah', 'blah']\\n for s in inputs:\\n self.assertEqual(native_str(s), builtin_str(s))\\n self.assertTrue(isinstance(native_str(s), builtin_str))\",\n \"def safeToString():\",\n \"def _to_bytes(value: Union[str, bytes]) -> bytes:\\n return value if isinstance(value, bytes) else value.encode(\\\"utf-8\\\")\",\n \"def test_bytesToString(self):\\n self.assertNativeString(b\\\"hello\\\", \\\"hello\\\")\",\n \"def native_(s, encoding='latin-1', errors='strict'):\\n if isinstance(s, text_type):\\n return s.encode(encoding, errors)\\n return str(s)\",\n \"def ensure_native_str(data, encoding=\\\"utf8\\\"):\\n if isinstance(data, str):\\n return data\\n elif isinstance(data, unicode_type):\\n # Only executes on python 2\\n return data.encode(encoding)\\n elif isinstance(data, bytes):\\n # Only executes on python 3\\n return data.decode(encoding)\\n else:\\n str(data)\",\n \"def asString(obj):\\n if type(obj) in _STR_TYPES:\\n return obj\\n return str(obj)\",\n \"def kafka_bytestring(s):\\n if isinstance(s, bytes):\\n return s\\n if isinstance(s, bytes):\\n return s.encode('utf-8')\\n raise TypeError(s)\",\n \"def test_str(self):\\n self.assertEqual(str(self.bs), str(self.wbs))\\n self.assertEqual(str(self.be), str(self.be))\\n # str(us) fails in Python 2\\n self.assertEqual(str, type(str(self.wus)))\\n # str(ue) fails in Python 2\\n self.assertEqual(str, type(str(self.wue)))\",\n \"def force_unicode(s, encoding=encoding, errors='strict'):\\n if isinstance(s, unicode):\\n return s\\n elif hasattr(s, '__unicode__'):\\n return unicode(s)\\n elif isinstance(s, str):\\n return s.decode(encoding, errors)\\n else:\\n return str(s).decode(encoding, errors)\",\n \"def native_string(input_var):\\n if isinstance(input_var, str):\\n return input_var\\n\\n return input_var.decode('utf-8', 'replace')\",\n \"def test_strmethod(self):\\n b1 = BaseModel()\\n self.assertEqual(type(str(b1)), str)\",\n \"def safe(self, string):\\n if sys.version_info.major >= 3 and isinstance(string, bytes):\\n string = string.decode('utf8')\\n elif sys.version_info.major < 3:\\n if not isinstance(string, unicode):\\n string = unicode(string, encoding='utf8')\\n string = string.replace('\\\\n', '')\\n string = string.replace('\\\\r', '')\\n return string\",\n \"def safestr(obj, encoding='utf-8'):\\n if isinstance(obj, unicode):\\n return obj.encode(encoding)\\n elif isinstance(obj, str):\\n return obj\\n elif hasattr(obj, 'next') and hasattr(obj, '__iter__'): # iterator\\n return itertools.imap(safestr, obj)\\n else:\\n return str(obj)\",\n \"def force_bytes(value):\\n if IS_PY3:\\n if isinstance(value, str):\\n value = value.encode(\\\"utf-8\\\", \\\"backslashreplace\\\")\\n else:\\n if isinstance(value, unicode): # NOQA: F821\\n value = value.encode(\\\"utf-8\\\")\\n\\n return value\",\n \"def convert_to_string(_bytes: bytes)-> str:\\n # print('input bytes: ', _bytes)\\n # print('string: ', binascii.hexlify(_bytes))\\n # print('string2: ', _bytes.hex())\\n # print('string3: ', \\\" \\\".join([\\\"{:02x}\\\".format(x) for x in _bytes]))\\n return \\\" \\\".join([\\\"{:02x}\\\".format(x) for x in _bytes])\",\n \"def _validate_str(val):\\n if not isinstance(val, str):\\n raise ValueError(\\\"Passed value {} is not a string\\\".format(val))\\n return val\",\n \"def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n return str(s)\\n if isinstance(s, bytes):\\n return s.decode(encoding, errors)\\n return s\",\n \"def text_(s: Any, encoding: str = 'utf-8', errors: str = 'strict') -> Any:\\n if isinstance(s, int):\\n return str(s)\\n if isinstance(s, bytes):\\n return s.decode(encoding, errors)\\n return s\",\n \"def simple_str(self):\\n pass\",\n \"def str_to_bytes(data):\\n u_type = type(b''.decode('utf8'))\\n if isinstance(data, u_type):\\n return data.encode('utf8')\\n return data\",\n \"def serialize(self, data):\\n if isinstance(data, str):\\n return data\\n\\n if hasattr(data, \\\"read\\\"):\\n return data.read()\\n\\n raise ValueError(\\\"Unable to handle input format: %s\\\" % type(data))\",\n \"def test_is_str_rep_string(self):\\n self.assertIsInstance(cardutils.Card(10,1).__str__(), str)\",\n \"def force_text(s):\\n if s is None:\\n return \\\"\\\"\\n if not isinstance(s, six.string_types):\\n return six.text_type(s)\\n return s\",\n \"def utfstr(stuff):\\n if isinstance(stuff,basestring):\\n return stuff\\n else:\\n return str(stuff)\",\n \"def ensure_binary(s, encoding='utf-8', errors='strict'):\\n if isinstance(s, six.text_type):\\n return s.encode(encoding, errors)\\n elif isinstance(s, six.binary_type):\\n return s\\n else:\\n raise TypeError(\\\"not expecting type '%s'\\\" % type(s))\",\n \"def _unicodeify(self, value, encoding=\\\"utf8\\\"):\\n if isinstance(value, str):\\n return value\\n return str(value, encoding)\",\n \"def convert_from_bytes(output: ResponseOutput, ty: Optional[Type]) -> Any:\\n if ty == str:\\n return bytearray(output.data).decode(\\\"UTF-8\\\")\\n else:\\n py_str = bytearray(output.data).decode(\\\"UTF-8\\\")\\n from ast import literal_eval\\n\\n return literal_eval(py_str)\",\n \"def from_str(cls, string):\",\n \"def from_bytes(self, ???):\",\n \"def ensure_utf8_bytes(v: Union[str, bytes]) -> bytes:\\n if isinstance(v, str):\\n v = v.encode(\\\"utf-8\\\")\\n return v\",\n \"def convert_str(input_obj):\\n if isinstance(input_obj, str):\\n return(input_obj)\\n elif input_obj is True:\\n return('1')\\n elif (input_obj is None):\\n return('none')\\n elif input_obj is False:\\n return('0')\\n else:\\n return(str(input_obj))\",\n \"def ensure_unicode_string(value):\\n if not isinstance(value, six.string_types):\\n raise TypeError(u'Expected string value, got: {}'.format(value))\\n return six.text_type(value)\",\n \"def is_string(value):\\n return isinstance(value, (str, bytes))\",\n \"def test_str_(self):\\n str(self.standardcode)\\n repr(self.standardcode)\",\n \"def as_text(bytes_or_text, encoding='utf-8'):\\n if isinstance(bytes_or_text, _six.text_type):\\n return bytes_or_text\\n elif isinstance(bytes_or_text, bytes):\\n return bytes_or_text.decode(encoding)\\n else:\\n raise TypeError(\\n 'Expected binary or unicode string, got %r' % bytes_or_text\\n )\",\n \"def encodeString(*args, **kwargs)->AnyStr:\\n pass\",\n \"def to_bytes(data):\\n if isinstance(data, str):\\n return data.encode(encoding='utf-8')\\n else:\\n return data\",\n \"def to_string(data):\\n if isinstance(data, bytes):\\n return data.decode('utf-8')\\n else:\\n return data\",\n \"def test_str_with_no_data(self):\\n data = b''\\n digest_value = DigestValue(data)\\n self._test_str(digest_value, str(data))\",\n \"def byte2str(self, obj):\\n encoding = \\\"utf-8\\\"\\n if isinstance(obj, list):\\n if len(obj)>0 and not isinstance(obj[0], str):\\n self.helper.log_debug(\\n \\\"conversion from list of %s onto list of <class 'str'>\\\" %\\n type(obj[0]))\\n return [ s.decode(encoding) for s in obj ]\\n elif not isinstance(obj, str):\\n self.helper.log_debug(\\n \\\"conversion from %s onto <class 'str'>\\\" %\\n type(obj))\\n return obj.decode(encoding)\\n return obj\",\n \"def force_unicode(s):\\n return (s.decode('utf8')\\n if isinstance(s, str)\\n else unicode(s))\",\n \"def _text(string, encoding='utf8'):\\n if isinstance(string, six.text_type):\\n return string\\n elif isinstance(string, six.binary_type):\\n return string.decode(encoding)\\n else:\\n return six.text_type(string)\",\n \"def safe_str(obj):\\n try:\\n return str(obj)\\n except UnicodeEncodeError:\\n # obj is unicode\\n return unicode(obj).encode('unicode_escape')\",\n \"def safe_str(obj):\\n try:\\n return str(obj)\\n except UnicodeEncodeError:\\n # obj is unicode\\n return unicode(obj).encode('unicode_escape')\",\n \"def safe_str(obj):\\n try:\\n return str(obj)\\n except UnicodeEncodeError:\\n # obj is unicode\\n return unicode(obj).encode('unicode_escape')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6703084","0.6667159","0.665698","0.66231215","0.65923953","0.6549901","0.6501315","0.6458548","0.64560145","0.6408117","0.6405631","0.6373941","0.63643","0.62835956","0.62750614","0.6263772","0.62543184","0.6227834","0.62072873","0.6200505","0.61952037","0.6177074","0.61712384","0.61547846","0.6147122","0.61442393","0.614258","0.6141424","0.6092685","0.60849655","0.6079365","0.60628355","0.60542166","0.6048546","0.60270745","0.599216","0.59891254","0.59557664","0.59557664","0.5947476","0.59417737","0.5927805","0.5924802","0.5924802","0.59186715","0.5906856","0.5896438","0.5892684","0.5888097","0.5874117","0.58550984","0.58547014","0.58413434","0.58402306","0.58377796","0.583298","0.58287156","0.58244616","0.5810802","0.5807804","0.58070374","0.5783393","0.5780152","0.5777429","0.5757897","0.57559127","0.57534313","0.57495564","0.5739079","0.572958","0.57267004","0.5716802","0.57148963","0.57148963","0.5711526","0.5692286","0.5691464","0.5689374","0.56848747","0.5674787","0.56727695","0.56501734","0.5643433","0.56417626","0.56318986","0.5610649","0.5608417","0.55719745","0.55675113","0.5562136","0.5561014","0.55496216","0.5543651","0.5539851","0.55283","0.55241907","0.5513331","0.5510138","0.5501191","0.5501191","0.5501191"],"string":"[\n \"0.6703084\",\n \"0.6667159\",\n \"0.665698\",\n \"0.66231215\",\n \"0.65923953\",\n \"0.6549901\",\n \"0.6501315\",\n \"0.6458548\",\n \"0.64560145\",\n \"0.6408117\",\n \"0.6405631\",\n \"0.6373941\",\n \"0.63643\",\n \"0.62835956\",\n \"0.62750614\",\n \"0.6263772\",\n \"0.62543184\",\n \"0.6227834\",\n \"0.62072873\",\n \"0.6200505\",\n \"0.61952037\",\n \"0.6177074\",\n \"0.61712384\",\n \"0.61547846\",\n \"0.6147122\",\n \"0.61442393\",\n \"0.614258\",\n \"0.6141424\",\n \"0.6092685\",\n \"0.60849655\",\n \"0.6079365\",\n \"0.60628355\",\n \"0.60542166\",\n \"0.6048546\",\n \"0.60270745\",\n \"0.599216\",\n \"0.59891254\",\n \"0.59557664\",\n \"0.59557664\",\n \"0.5947476\",\n \"0.59417737\",\n \"0.5927805\",\n \"0.5924802\",\n \"0.5924802\",\n \"0.59186715\",\n \"0.5906856\",\n \"0.5896438\",\n \"0.5892684\",\n \"0.5888097\",\n \"0.5874117\",\n \"0.58550984\",\n \"0.58547014\",\n \"0.58413434\",\n \"0.58402306\",\n \"0.58377796\",\n \"0.583298\",\n \"0.58287156\",\n \"0.58244616\",\n \"0.5810802\",\n \"0.5807804\",\n \"0.58070374\",\n \"0.5783393\",\n \"0.5780152\",\n \"0.5777429\",\n \"0.5757897\",\n \"0.57559127\",\n \"0.57534313\",\n \"0.57495564\",\n \"0.5739079\",\n \"0.572958\",\n \"0.57267004\",\n \"0.5716802\",\n \"0.57148963\",\n \"0.57148963\",\n \"0.5711526\",\n \"0.5692286\",\n \"0.5691464\",\n \"0.5689374\",\n \"0.56848747\",\n \"0.5674787\",\n \"0.56727695\",\n \"0.56501734\",\n \"0.5643433\",\n \"0.56417626\",\n \"0.56318986\",\n \"0.5610649\",\n \"0.5608417\",\n \"0.55719745\",\n \"0.55675113\",\n \"0.5562136\",\n \"0.5561014\",\n \"0.55496216\",\n \"0.5543651\",\n \"0.5539851\",\n \"0.55283\",\n \"0.55241907\",\n \"0.5513331\",\n \"0.5510138\",\n \"0.5501191\",\n \"0.5501191\",\n \"0.5501191\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88396,"cells":{"query":{"kind":"string","value":"When called with L{None}, L{to_xml} returns a L{Deferred} that fires with C{b\"\"}."},"document":{"kind":"string","value":"def test_none(self):\n self.assertEqual(b\"\", self.successResultOf(to_xml(None)))"},"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 get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()","def xml_string(self):\r\n if self._xml_string is not None:\r\n return self._xml_string\r\n\r\n return etree.tostring(self._xml_node)","def xml_string(self):\n if self._xml_string is not None:\n return self._xml_string\n\n return etree.tostring(self._xml_node)","def test_with_no_encoding(self):\n xml = (\n u'<?xml version=\"1.0\"?>'\n u'<DocRoot>'\n u'<Elem1>默认جذ</Elem1>'\n u'<Elem2/>'\n u'</DocRoot>'\n )\n io_string = six.StringIO()\n self.builder.dom_element.write_doc(io_string, encoding=None)\n # NOTE Exact test, no encoding of comparison XML doc string\n self.assertEqual(xml, io_string.getvalue())","def xstr(s):\n if s is None:\n return u''\n return s","def get_xml(self):\n return etree.tostring(self.get_etree())","def xml_tostring(tree):\n if six.PY2:\n return ET.tostring(tree)\n else:\n return ET.tostring(tree, encoding='unicode')","def _encode_simple(xml, sv):\n # Format according to type.\n if sv in (None, 'None'):\n return ''\n elif isinstance(sv, datetime.datetime):\n sv = sv.isoformat().replace('T', ' ')\n elif isinstance(sv, datetime.date):\n sv = sv.isoformat()\n elif isinstance(sv, datetime.time):\n sv = sv.isoformat()\n else:\n sv = str(sv)\n\n # Assign to xml.\n if sv is not None and len(sv):\n xml.text = unicode(sv.decode(_UNICODE).strip())\n else:\n xml.text = u''","def test_serialize_none(self):\n self.assertEqual(serialize(None), 'null')","def toString(doc):\n return doc.toxml()","def toxml(self) :\n\t\treturn self.doc.toxml()","def none_to_empty(data):\n return data if data is not None else ''","def test_write_defaults(self):\n xml = (\n u'<?xml version=\"1.0\" encoding=\"utf-8\"?>'\n u'<DocRoot>'\n u'<Elem1>默认جذ</Elem1>'\n u'<Elem2/>'\n u'</DocRoot>'\n )\n io_string = six.StringIO()\n self.builder.write_doc(io_string)\n if six.PY2:\n self.assertEqual(xml.encode('utf-8'), io_string.getvalue())\n else:\n self.assertEqual(xml, io_string.getvalue())","def xstr(s):\n if s is None:\n return \"\"\n else:\n return str(s)","def xstr(s):\n if s is None:\n return ''\n else:\n return str(s)","def xstr(s):\n if s is None:\n return ''\n return str(s)","def final(self):\n # except 'final' which is a no-op\n return b''","def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"","def saveToXml(self) -> org.jdom.Element:\n ...","def xml(self):\n raise NotImplementedError('This api does not return xml')","def toXml(prefixes=None, closeElement=1, defaultUri='',\n prefixesInScope=None):","def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()","def saveXml(self, buf: java.lang.StringBuilder) -> None:\n ...","def __init__(self, output, encoding='utf-8', short_empty_elements=True):\n document = XMLGenerator(output, encoding) # Python 3.2 : short_empty_elements\n document.startDocument()\n self._document = document\n self._output = output\n self._encoding = encoding\n self._short_empty_elements = short_empty_elements\n self._open_elements = []\n return","def _default_output(result):\n return str(result) if result is not None else None","def __str__(self):\n result = xml.dom.minidom.parseString(\n xml.etree.ElementTree.tostring(\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\n\n return result","def empty_fn_docstr():","def serialize_result(result: Any) -> Union[str, bytes]:\n if isinstance(result, Node):\n return result.serialize(how='default' if RESULT_FILE_EXTENSION != '.xml' else 'xml')\n else:\n return repr(result)","def test_something(self):\n self.assertEqual(\n b\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n<Foo>bar</Foo>\"\"\",\n self.successResultOf(to_xml(tags.Foo(\"bar\"))),\n )","def _to_serialize(value):\n return value.serialize() if value is not None else None","def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')","def noneType(value):\r\n return ''","def make_request_xml(self):\n #print (self.url)\n try:\n with closing(get(self.url, stream=True)) as resp: #returns b`xml`\n if self.is_good_enough_xml(resp):\n return resp.content\n else:\n return None\n except RequestException as e:\n print('Error during requests to {0} : {1}'.format(url, str(e)))\n return None","def acceptxml(func):\n\n @wraps(func)\n def return_xml(*args, **kwargs):\n if request.headers.get('Accept', '*/*') == 'application/xml':\n return json_toXML(g.payload_json)\n\n return return_xml","def test_incomplete_xml(self):\n self.__opener.contents = '<Report></Report>>'\n self.assertEqual(-1, self.__uft.failed_tests('url'))","def silent_none(value):\n if value is None:\n return ''\n return value","def serialize(self):\n return self.xmlnode.serialize(encoding=\"utf-8\")","def __call__(self, name: str, arg: str) -> XMLContent:\n raise NotImplementedError","def normalize_xml(xml):\n if not xml:\n return u''\n if isinstance(xml, unicode):\n xml = xml.encode('utf-8')\n xml = xml.replace('\\r\\n', '\\n')\n return xml","def emptyresponse():\n return get_response(\"\")","def null() -> SetupVal:\n return NullVal()","def new_xml(self, root_name):\n\n self.tree = ET.ElementTree(ET.fromstring('<?xml version=\"1.0\" encoding=\"UTF-8\"?><%s></%s>'%(\n root_name, root_name)))\n return self.tree.getroot()","def _tree_to_xml(self, tree):\n\n body = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n\n return body + self._element_to_xml(tree)","def _tree_to_xml(self, tree):\n\n body = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n\n return body + self._element_to_xml(tree)","def test_xml_string_roundtrip(self):\n forcefield_1 = ForceField(xml_simple_ff)\n string_1 = forcefield_1.to_string(\"XML\")\n # Ensure that we have spaces instead of tabs\n assert \" \" in string_1\n assert \"\\t\" not in string_1\n forcefield_2 = ForceField(string_1)\n string_2 = forcefield_2.to_string(\"XML\")\n assert string_1 == string_2","def test_none(self):\n self.assertEqual(self.obj.to_json_string(None), '[]')","def xstr(s):\n return str(s) if s else ''","def output_xml(data,code,headers=None):\r\n resp = make_response(dumps({'response': data}), code)\r\n resp.headers.extend(headers or {})\r\n return resp","def tostring(self):\n header, body = None, None\n\n if self._header:\n header = b'<?xml version=\"1.0\" encoding=\"utf-8\"?>'\n\n if self._main() is not None:\n body = ET.tostring(self._main(), 'utf-8')\n\n return (header if header else b'') + (body if body else b'')","def empty_fn_docstr_pass():\n pass","def to_dom_element(self, doc):\n string = \"This should never be printed. - EGCryptoSystem.py\"\n return self.to_stub(string, string).to_dom_element(doc)","def _clean_xml(raw: str) -> str:\n a = raw.encode(\"ascii\", \"ignore\").decode(\"ascii\")\n no_encoding = _strip_encoding(a)\n no_ns = _strip_namespace(no_encoding)\n return no_ns","def to_xml(self, enc='utf-8'):\n return b\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE GIFTI SYSTEM \"http://www.nitrc.org/frs/download.php/115/gifti.dtd\">\n\"\"\" + xml.XmlSerializable.to_xml(self, enc)","def _generate_uuid_str_if_none(given_uuid):\n\t\treturn given_uuid or uuid.uuid4().__str__()","def __noop(self, *args, **kwargs):\n return None","def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml","def prepare(*args, **kwargs):\n LOGGER.warning(\n \"readalongs.api.prepare() is deprecated. Please use make_xml() instead.\"\n )\n return make_xml(*args, **kwargs)","def to_str(x) -> str:\n return str(x) if x else ''","def output_xml(data, code, headers=None):\r\n resp = make_response(dumps({'response' :data}), code)\r\n resp.headers.extend(headers or {})\r\n return resp","def test_export_to_xml_empty_parameters(self):\r\n module_system = DummySystem(load_error_modules=True)\r\n desc = VideoDescriptor(module_system, DictFieldData({}), ScopeIds(None, None, self.location, self.location))\r\n\r\n xml = desc.definition_to_xml(None)\r\n expected = '<video url_name=\"SampleProblem1\"/>\\n'\r\n\r\n self.assertEquals(expected, etree.tostring(xml, pretty_print=True))","def substituteEntitiesDefault(val):\n ret = libxml2mod.xmlSubstituteEntitiesDefault(val)\n return ret","def xml(self):\n return self._xml","def xml(self):\n return self._xml","def _nullify(self, value):\n if not str(value).strip():\n return None\n else:\n return value","def MakeTextXMLReady(text):\n dec_text = DecodeNonASCIIText(text)[0]\n items = []\n for char in dec_text:\n try:\n char = char.encode('ascii')\n except UnicodeEncodeError:\n # We have a non-ASCII character of type unicode. Convert it into an\n # XML-ready format.\n try:\n str(char)\n char.encode('utf-8')\n except UnicodeEncodeError:\n char = '%s;' % hex(ord(char)).replace('0x', '&#x')\n items.append(char)\n return ''.join(items)","def empty_signature():\n return bytes(0)","def test_incomplete_xml_no_timestamp(self):\n self.__opener.contents = '<Report><Doc><Summary/></Doc></Report>'\n self.assertEqual(datetime.datetime.min, self.__uft.datetime('url'))","def get_translated_xml_string(self):\n return etree.tostring(self._translated_xml_tree)","def toXMLString(self):\n return _libsbml.XMLNode_toXMLString(self)","def keepBlanksDefault(val):\n ret = libxml2mod.xmlKeepBlanksDefault(val)\n return ret","def output_xml(data, code, headers=None):\n response = make_response(simplexml.dumps({'response': data}), code)\n response.headers.extend(headers or {})\n return response","def to_xml(self):\r\n\t\ts = \"<event>\\n\"\r\n\t\ts += \"\\t<title>\" + self.title + \"</title>\\n\"\r\n\t\ts += \"\\t<date>\\n\"\r\n\t\ts += \"\\t\\t<year>\" + str(self.dueDate.year) + \"</year>\\n\"\r\n\t\ts += \"\\t\\t<month>\" + str(self.dueDate.month) + \"</month>\\n\"\r\n\t\ts += \"\\t\\t<day>\" + str(self.dueDate.day) + \"</day>\\n\"\r\n\t\ts += \"\\t</date>\\n\"\r\n\t\ts += \"\\t<time>\" + str(self.dueTime) + \"</time>\\n\"\r\n\t\ts += \"</event>\\n\"\r\n\t\treturn s","def test_gbsahandler_sa_model_none(self):\n ForceField(xml_gbsa_ff)","def noop():","def registerDefaultOutputCallbacks():\n libxml2mod.xmlRegisterDefaultOutputCallbacks()","def xml():\n response = make_response(render_template(\"sample.xml\"))\n response.headers[\"Content-Type\"] = \"application/xml\"\n return response","def toXMLNode(self):\n return _libsbml.SBase_toXMLNode(self)","def XMLNode_convertXMLNodeToString(*args):\n return _libsbml.XMLNode_convertXMLNodeToString(*args)","def __call__(self, f):\n tree = f.build_etree(lxml=True)\n return self.xslt(tree)","def _encode_nullable(data_type, obj, alias_validators, old_style, for_msgpack):\n if obj is not None:\n return _json_compat_obj_encode_helper(\n data_type.validator, obj, alias_validators, old_style, for_msgpack)\n else:\n return None","def test_xml_born(xml_parser):\n \n assert xml_parser.get_born() == None","def adaptXmlToXml(self, *args):\n return _SALOMERuntime.RuntimeSALOME_adaptXmlToXml(self, *args)","def create_response_element(self, **kwargs):\r\n return None","def test_generate_xml_node(self):\n with self.assertRaises(cfy_exc.NonRecoverableError):\n utils.generate_xml_node({}, {}, \"sometag\")","def test_dummy5(self):\n xpb = XPathBuilder()\n xp = xpb.dummy()\n xp = xpb.foo & xp\n exp = '/foo'\n self.assertEqual(xp.tostring(), exp)","def bytes(self):\n return Bytes.for_string_or_unicode(\"\")","def empty(self):\n return _libsbml.string_empty(self)","def serialize(self, root):\n def rserialize(root, string):\n \"\"\" a recursive helper function for the serialize() function.\"\"\"\n # check base case\n if root is None:\n string += 'None,'\n else:\n string += str(root.val) + ','\n string = rserialize(root.left, string)\n string = rserialize(root.right, string)\n return string\n \n return rserialize(root, '')","def handle_ajax(self, _dispatch, _data):\r\n return u\"\"","def _encode_supplement(self):","def _encode_supplement(self):","def toXML(self):\n item = \"<item uid=\\\"{uid}\\\" arg=\\\"{arg}\\\" valid=\\\"{valid}\\\"\"\n if(self.autocomplete!=None):\n item += \" autocomplete=\\\"{autocomplete}\\\"\"\n item += \">\"\n item += \"<title><![CDATA[{title}]]></title>\"\n item += \"<subtitle><![CDATA[{subtitle}]]></subtitle>\"\n if (self.icon != None):\n if(self.icontype != None):\n item += \"<icon type=\\\"{icontype}\\\">{icon}</icon>\"\n else:\n item += \"<icon>{icon}</icon>\"\n item += \"</item>\"\n return item.format(uid=self.uid,arg=self.arg,valid=\"yes\" if self.valid else \"no\",icontype=self.icontype,\n title=self.title,subtitle=self.subtitle,icon=self.icon,autocomplete=self.autocomplete)","def to_xml(self):\r\n if self.alias_hosted_zone_id != None and self.alias_dns_name != None:\r\n # Use alias\r\n body = self.AliasBody % (self.alias_hosted_zone_id, self.alias_dns_name)\r\n else:\r\n # Use resource record(s)\r\n records = \"\"\r\n for r in self.resource_records:\r\n records += self.ResourceRecordBody % r\r\n body = self.ResourceRecordsBody % {\r\n \"ttl\": self.ttl,\r\n \"records\": records,\r\n }\r\n params = {\r\n \"name\": self.name,\r\n \"type\": self.type,\r\n \"body\": body,\r\n }\r\n return self.XMLBody % params","def xen_api_success_void():\n return xen_api_success(\"\")","def qe(out):\n return xml.sax.saxutils.escape(str(out))","def get_free_comment_url_xml(content_object, parent=None):\r\n try:\r\n return get_free_comment_url_ajax(content_object, parent, ajax_type=\"xml\")\r\n except template.TemplateSyntaxError:\r\n raise template.TemplateSyntaxError, \"get_free_comment_url_xml requires its parent object to be of type FreeThreadedComment\"\r\n return ''","def string(self, value):\n # respect {None}\n if value is None:\n # by leaving it alone\n return None\n # my value knows\n return str(value)","def get_query_xml(query):\n root = get_query_etree(query)\n\n # can get actual field types by inspecting cursor.description,\n # but these (I think) depend on the database back-end\n # so I decided it was too hard to be smart here,\n # and instead just say that everything is \"CDATA #REQURED\"...\n attlist = '\\n'.join(' {col} CDATA #REQUIRED'.format(col=col) for col in query.cols)\n\n # generating dtd means we can automatically validate output, for testing\n dtd = '<!DOCTYPE {root} [\\n' \\\n ' <!ELEMENT {root} ({row})*>\\n' \\\n ' <!ELEMENT {row} EMPTY>\\n' \\\n ' <!ATTLIST {row}\\n{attlist}\\n' \\\n ' >\\n' \\\n ']>'.format(root=query.root, row=query.row, attlist=attlist)\n\n # DEFAULT_CHARSET is used by HttpResponse, so make etree use it too.\n # Output may become invalid if DEFAULT_CHARSET cannot be used to encode field names!\n # e.g. MySQL columns may include characters from Unicode Basic Multiingual Plane,\n # which could be inexpressible if DEFAULT_CHARSET were ascii, giving invalid xml.\n return etree.tostring(\n root,\n pretty_print = False,\n encoding = settings.DEFAULT_CHARSET,\n xml_declaration = True,\n doctype = dtd,\n )","def make_xml_request(self, xmldata, xml_result=False):\n\n if xml_result:\n return self._xml_command(xmldata)\n else:\n return self._text_command(xmldata)","def to_xml(self):\n return xmltodict.unparse(\n self.to_xml_dict(),\n pretty=True\n ).encode(\"utf-8\")"],"string":"[\n \"def get_xml(self):\\n with io.StringIO() as string:\\n string.write(ET.tostring(self.root, encoding=\\\"unicode\\\"))\\n return string.getvalue()\",\n \"def xml_string(self):\\r\\n if self._xml_string is not None:\\r\\n return self._xml_string\\r\\n\\r\\n return etree.tostring(self._xml_node)\",\n \"def xml_string(self):\\n if self._xml_string is not None:\\n return self._xml_string\\n\\n return etree.tostring(self._xml_node)\",\n \"def test_with_no_encoding(self):\\n xml = (\\n u'<?xml version=\\\"1.0\\\"?>'\\n u'<DocRoot>'\\n u'<Elem1>默认جذ</Elem1>'\\n u'<Elem2/>'\\n u'</DocRoot>'\\n )\\n io_string = six.StringIO()\\n self.builder.dom_element.write_doc(io_string, encoding=None)\\n # NOTE Exact test, no encoding of comparison XML doc string\\n self.assertEqual(xml, io_string.getvalue())\",\n \"def xstr(s):\\n if s is None:\\n return u''\\n return s\",\n \"def get_xml(self):\\n return etree.tostring(self.get_etree())\",\n \"def xml_tostring(tree):\\n if six.PY2:\\n return ET.tostring(tree)\\n else:\\n return ET.tostring(tree, encoding='unicode')\",\n \"def _encode_simple(xml, sv):\\n # Format according to type.\\n if sv in (None, 'None'):\\n return ''\\n elif isinstance(sv, datetime.datetime):\\n sv = sv.isoformat().replace('T', ' ')\\n elif isinstance(sv, datetime.date):\\n sv = sv.isoformat()\\n elif isinstance(sv, datetime.time):\\n sv = sv.isoformat()\\n else:\\n sv = str(sv)\\n\\n # Assign to xml.\\n if sv is not None and len(sv):\\n xml.text = unicode(sv.decode(_UNICODE).strip())\\n else:\\n xml.text = u''\",\n \"def test_serialize_none(self):\\n self.assertEqual(serialize(None), 'null')\",\n \"def toString(doc):\\n return doc.toxml()\",\n \"def toxml(self) :\\n\\t\\treturn self.doc.toxml()\",\n \"def none_to_empty(data):\\n return data if data is not None else ''\",\n \"def test_write_defaults(self):\\n xml = (\\n u'<?xml version=\\\"1.0\\\" encoding=\\\"utf-8\\\"?>'\\n u'<DocRoot>'\\n u'<Elem1>默认جذ</Elem1>'\\n u'<Elem2/>'\\n u'</DocRoot>'\\n )\\n io_string = six.StringIO()\\n self.builder.write_doc(io_string)\\n if six.PY2:\\n self.assertEqual(xml.encode('utf-8'), io_string.getvalue())\\n else:\\n self.assertEqual(xml, io_string.getvalue())\",\n \"def xstr(s):\\n if s is None:\\n return \\\"\\\"\\n else:\\n return str(s)\",\n \"def xstr(s):\\n if s is None:\\n return ''\\n else:\\n return str(s)\",\n \"def xstr(s):\\n if s is None:\\n return ''\\n return str(s)\",\n \"def final(self):\\n # except 'final' which is a no-op\\n return b''\",\n \"def format_xml(self,query_results):\\n results=query_results.data\\n factory=factory_xml()\\n dump=factory.dumps({'data':results})\\n print(dump)\\n # TODO return output for this\\n return \\\"\\\"\",\n \"def saveToXml(self) -> org.jdom.Element:\\n ...\",\n \"def xml(self):\\n raise NotImplementedError('This api does not return xml')\",\n \"def toXml(prefixes=None, closeElement=1, defaultUri='',\\n prefixesInScope=None):\",\n \"def storeAndReturnXML(self):\\n self._storeItems()\\n return self.toXML()\",\n \"def saveXml(self, buf: java.lang.StringBuilder) -> None:\\n ...\",\n \"def __init__(self, output, encoding='utf-8', short_empty_elements=True):\\n document = XMLGenerator(output, encoding) # Python 3.2 : short_empty_elements\\n document.startDocument()\\n self._document = document\\n self._output = output\\n self._encoding = encoding\\n self._short_empty_elements = short_empty_elements\\n self._open_elements = []\\n return\",\n \"def _default_output(result):\\n return str(result) if result is not None else None\",\n \"def __str__(self):\\n result = xml.dom.minidom.parseString(\\n xml.etree.ElementTree.tostring(\\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\\n\\n return result\",\n \"def empty_fn_docstr():\",\n \"def serialize_result(result: Any) -> Union[str, bytes]:\\n if isinstance(result, Node):\\n return result.serialize(how='default' if RESULT_FILE_EXTENSION != '.xml' else 'xml')\\n else:\\n return repr(result)\",\n \"def test_something(self):\\n self.assertEqual(\\n b\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n<Foo>bar</Foo>\\\"\\\"\\\",\\n self.successResultOf(to_xml(tags.Foo(\\\"bar\\\"))),\\n )\",\n \"def _to_serialize(value):\\n return value.serialize() if value is not None else None\",\n \"def xml(self):\\n raise NotImplementedError('must be implemented by all subclasses')\",\n \"def noneType(value):\\r\\n return ''\",\n \"def make_request_xml(self):\\n #print (self.url)\\n try:\\n with closing(get(self.url, stream=True)) as resp: #returns b`xml`\\n if self.is_good_enough_xml(resp):\\n return resp.content\\n else:\\n return None\\n except RequestException as e:\\n print('Error during requests to {0} : {1}'.format(url, str(e)))\\n return None\",\n \"def acceptxml(func):\\n\\n @wraps(func)\\n def return_xml(*args, **kwargs):\\n if request.headers.get('Accept', '*/*') == 'application/xml':\\n return json_toXML(g.payload_json)\\n\\n return return_xml\",\n \"def test_incomplete_xml(self):\\n self.__opener.contents = '<Report></Report>>'\\n self.assertEqual(-1, self.__uft.failed_tests('url'))\",\n \"def silent_none(value):\\n if value is None:\\n return ''\\n return value\",\n \"def serialize(self):\\n return self.xmlnode.serialize(encoding=\\\"utf-8\\\")\",\n \"def __call__(self, name: str, arg: str) -> XMLContent:\\n raise NotImplementedError\",\n \"def normalize_xml(xml):\\n if not xml:\\n return u''\\n if isinstance(xml, unicode):\\n xml = xml.encode('utf-8')\\n xml = xml.replace('\\\\r\\\\n', '\\\\n')\\n return xml\",\n \"def emptyresponse():\\n return get_response(\\\"\\\")\",\n \"def null() -> SetupVal:\\n return NullVal()\",\n \"def new_xml(self, root_name):\\n\\n self.tree = ET.ElementTree(ET.fromstring('<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?><%s></%s>'%(\\n root_name, root_name)))\\n return self.tree.getroot()\",\n \"def _tree_to_xml(self, tree):\\n\\n body = '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n'\\n\\n return body + self._element_to_xml(tree)\",\n \"def _tree_to_xml(self, tree):\\n\\n body = '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n'\\n\\n return body + self._element_to_xml(tree)\",\n \"def test_xml_string_roundtrip(self):\\n forcefield_1 = ForceField(xml_simple_ff)\\n string_1 = forcefield_1.to_string(\\\"XML\\\")\\n # Ensure that we have spaces instead of tabs\\n assert \\\" \\\" in string_1\\n assert \\\"\\\\t\\\" not in string_1\\n forcefield_2 = ForceField(string_1)\\n string_2 = forcefield_2.to_string(\\\"XML\\\")\\n assert string_1 == string_2\",\n \"def test_none(self):\\n self.assertEqual(self.obj.to_json_string(None), '[]')\",\n \"def xstr(s):\\n return str(s) if s else ''\",\n \"def output_xml(data,code,headers=None):\\r\\n resp = make_response(dumps({'response': data}), code)\\r\\n resp.headers.extend(headers or {})\\r\\n return resp\",\n \"def tostring(self):\\n header, body = None, None\\n\\n if self._header:\\n header = b'<?xml version=\\\"1.0\\\" encoding=\\\"utf-8\\\"?>'\\n\\n if self._main() is not None:\\n body = ET.tostring(self._main(), 'utf-8')\\n\\n return (header if header else b'') + (body if body else b'')\",\n \"def empty_fn_docstr_pass():\\n pass\",\n \"def to_dom_element(self, doc):\\n string = \\\"This should never be printed. - EGCryptoSystem.py\\\"\\n return self.to_stub(string, string).to_dom_element(doc)\",\n \"def _clean_xml(raw: str) -> str:\\n a = raw.encode(\\\"ascii\\\", \\\"ignore\\\").decode(\\\"ascii\\\")\\n no_encoding = _strip_encoding(a)\\n no_ns = _strip_namespace(no_encoding)\\n return no_ns\",\n \"def to_xml(self, enc='utf-8'):\\n return b\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n<!DOCTYPE GIFTI SYSTEM \\\"http://www.nitrc.org/frs/download.php/115/gifti.dtd\\\">\\n\\\"\\\"\\\" + xml.XmlSerializable.to_xml(self, enc)\",\n \"def _generate_uuid_str_if_none(given_uuid):\\n\\t\\treturn given_uuid or uuid.uuid4().__str__()\",\n \"def __noop(self, *args, **kwargs):\\n return None\",\n \"def get_xml(self):\\n xml = svgwrite.etree.etree.Element(self.elementname)\\n if self.debug:\\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\\n for attribute, value in self.attribs.items():\\n # filter 'None' values\\n if value is not None:\\n value = self.value_to_string(value)\\n if value: # just add not empty attributes\\n xml.set(attribute, value)\\n \\n for element in self.elements:\\n xml.append(element)\\n return xml\",\n \"def prepare(*args, **kwargs):\\n LOGGER.warning(\\n \\\"readalongs.api.prepare() is deprecated. Please use make_xml() instead.\\\"\\n )\\n return make_xml(*args, **kwargs)\",\n \"def to_str(x) -> str:\\n return str(x) if x else ''\",\n \"def output_xml(data, code, headers=None):\\r\\n resp = make_response(dumps({'response' :data}), code)\\r\\n resp.headers.extend(headers or {})\\r\\n return resp\",\n \"def test_export_to_xml_empty_parameters(self):\\r\\n module_system = DummySystem(load_error_modules=True)\\r\\n desc = VideoDescriptor(module_system, DictFieldData({}), ScopeIds(None, None, self.location, self.location))\\r\\n\\r\\n xml = desc.definition_to_xml(None)\\r\\n expected = '<video url_name=\\\"SampleProblem1\\\"/>\\\\n'\\r\\n\\r\\n self.assertEquals(expected, etree.tostring(xml, pretty_print=True))\",\n \"def substituteEntitiesDefault(val):\\n ret = libxml2mod.xmlSubstituteEntitiesDefault(val)\\n return ret\",\n \"def xml(self):\\n return self._xml\",\n \"def xml(self):\\n return self._xml\",\n \"def _nullify(self, value):\\n if not str(value).strip():\\n return None\\n else:\\n return value\",\n \"def MakeTextXMLReady(text):\\n dec_text = DecodeNonASCIIText(text)[0]\\n items = []\\n for char in dec_text:\\n try:\\n char = char.encode('ascii')\\n except UnicodeEncodeError:\\n # We have a non-ASCII character of type unicode. Convert it into an\\n # XML-ready format.\\n try:\\n str(char)\\n char.encode('utf-8')\\n except UnicodeEncodeError:\\n char = '%s;' % hex(ord(char)).replace('0x', '&#x')\\n items.append(char)\\n return ''.join(items)\",\n \"def empty_signature():\\n return bytes(0)\",\n \"def test_incomplete_xml_no_timestamp(self):\\n self.__opener.contents = '<Report><Doc><Summary/></Doc></Report>'\\n self.assertEqual(datetime.datetime.min, self.__uft.datetime('url'))\",\n \"def get_translated_xml_string(self):\\n return etree.tostring(self._translated_xml_tree)\",\n \"def toXMLString(self):\\n return _libsbml.XMLNode_toXMLString(self)\",\n \"def keepBlanksDefault(val):\\n ret = libxml2mod.xmlKeepBlanksDefault(val)\\n return ret\",\n \"def output_xml(data, code, headers=None):\\n response = make_response(simplexml.dumps({'response': data}), code)\\n response.headers.extend(headers or {})\\n return response\",\n \"def to_xml(self):\\r\\n\\t\\ts = \\\"<event>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t<title>\\\" + self.title + \\\"</title>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t<date>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t\\\\t<year>\\\" + str(self.dueDate.year) + \\\"</year>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t\\\\t<month>\\\" + str(self.dueDate.month) + \\\"</month>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t\\\\t<day>\\\" + str(self.dueDate.day) + \\\"</day>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t</date>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t<time>\\\" + str(self.dueTime) + \\\"</time>\\\\n\\\"\\r\\n\\t\\ts += \\\"</event>\\\\n\\\"\\r\\n\\t\\treturn s\",\n \"def test_gbsahandler_sa_model_none(self):\\n ForceField(xml_gbsa_ff)\",\n \"def noop():\",\n \"def registerDefaultOutputCallbacks():\\n libxml2mod.xmlRegisterDefaultOutputCallbacks()\",\n \"def xml():\\n response = make_response(render_template(\\\"sample.xml\\\"))\\n response.headers[\\\"Content-Type\\\"] = \\\"application/xml\\\"\\n return response\",\n \"def toXMLNode(self):\\n return _libsbml.SBase_toXMLNode(self)\",\n \"def XMLNode_convertXMLNodeToString(*args):\\n return _libsbml.XMLNode_convertXMLNodeToString(*args)\",\n \"def __call__(self, f):\\n tree = f.build_etree(lxml=True)\\n return self.xslt(tree)\",\n \"def _encode_nullable(data_type, obj, alias_validators, old_style, for_msgpack):\\n if obj is not None:\\n return _json_compat_obj_encode_helper(\\n data_type.validator, obj, alias_validators, old_style, for_msgpack)\\n else:\\n return None\",\n \"def test_xml_born(xml_parser):\\n \\n assert xml_parser.get_born() == None\",\n \"def adaptXmlToXml(self, *args):\\n return _SALOMERuntime.RuntimeSALOME_adaptXmlToXml(self, *args)\",\n \"def create_response_element(self, **kwargs):\\r\\n return None\",\n \"def test_generate_xml_node(self):\\n with self.assertRaises(cfy_exc.NonRecoverableError):\\n utils.generate_xml_node({}, {}, \\\"sometag\\\")\",\n \"def test_dummy5(self):\\n xpb = XPathBuilder()\\n xp = xpb.dummy()\\n xp = xpb.foo & xp\\n exp = '/foo'\\n self.assertEqual(xp.tostring(), exp)\",\n \"def bytes(self):\\n return Bytes.for_string_or_unicode(\\\"\\\")\",\n \"def empty(self):\\n return _libsbml.string_empty(self)\",\n \"def serialize(self, root):\\n def rserialize(root, string):\\n \\\"\\\"\\\" a recursive helper function for the serialize() function.\\\"\\\"\\\"\\n # check base case\\n if root is None:\\n string += 'None,'\\n else:\\n string += str(root.val) + ','\\n string = rserialize(root.left, string)\\n string = rserialize(root.right, string)\\n return string\\n \\n return rserialize(root, '')\",\n \"def handle_ajax(self, _dispatch, _data):\\r\\n return u\\\"\\\"\",\n \"def _encode_supplement(self):\",\n \"def _encode_supplement(self):\",\n \"def toXML(self):\\n item = \\\"<item uid=\\\\\\\"{uid}\\\\\\\" arg=\\\\\\\"{arg}\\\\\\\" valid=\\\\\\\"{valid}\\\\\\\"\\\"\\n if(self.autocomplete!=None):\\n item += \\\" autocomplete=\\\\\\\"{autocomplete}\\\\\\\"\\\"\\n item += \\\">\\\"\\n item += \\\"<title><![CDATA[{title}]]></title>\\\"\\n item += \\\"<subtitle><![CDATA[{subtitle}]]></subtitle>\\\"\\n if (self.icon != None):\\n if(self.icontype != None):\\n item += \\\"<icon type=\\\\\\\"{icontype}\\\\\\\">{icon}</icon>\\\"\\n else:\\n item += \\\"<icon>{icon}</icon>\\\"\\n item += \\\"</item>\\\"\\n return item.format(uid=self.uid,arg=self.arg,valid=\\\"yes\\\" if self.valid else \\\"no\\\",icontype=self.icontype,\\n title=self.title,subtitle=self.subtitle,icon=self.icon,autocomplete=self.autocomplete)\",\n \"def to_xml(self):\\r\\n if self.alias_hosted_zone_id != None and self.alias_dns_name != None:\\r\\n # Use alias\\r\\n body = self.AliasBody % (self.alias_hosted_zone_id, self.alias_dns_name)\\r\\n else:\\r\\n # Use resource record(s)\\r\\n records = \\\"\\\"\\r\\n for r in self.resource_records:\\r\\n records += self.ResourceRecordBody % r\\r\\n body = self.ResourceRecordsBody % {\\r\\n \\\"ttl\\\": self.ttl,\\r\\n \\\"records\\\": records,\\r\\n }\\r\\n params = {\\r\\n \\\"name\\\": self.name,\\r\\n \\\"type\\\": self.type,\\r\\n \\\"body\\\": body,\\r\\n }\\r\\n return self.XMLBody % params\",\n \"def xen_api_success_void():\\n return xen_api_success(\\\"\\\")\",\n \"def qe(out):\\n return xml.sax.saxutils.escape(str(out))\",\n \"def get_free_comment_url_xml(content_object, parent=None):\\r\\n try:\\r\\n return get_free_comment_url_ajax(content_object, parent, ajax_type=\\\"xml\\\")\\r\\n except template.TemplateSyntaxError:\\r\\n raise template.TemplateSyntaxError, \\\"get_free_comment_url_xml requires its parent object to be of type FreeThreadedComment\\\"\\r\\n return ''\",\n \"def string(self, value):\\n # respect {None}\\n if value is None:\\n # by leaving it alone\\n return None\\n # my value knows\\n return str(value)\",\n \"def get_query_xml(query):\\n root = get_query_etree(query)\\n\\n # can get actual field types by inspecting cursor.description,\\n # but these (I think) depend on the database back-end\\n # so I decided it was too hard to be smart here,\\n # and instead just say that everything is \\\"CDATA #REQURED\\\"...\\n attlist = '\\\\n'.join(' {col} CDATA #REQUIRED'.format(col=col) for col in query.cols)\\n\\n # generating dtd means we can automatically validate output, for testing\\n dtd = '<!DOCTYPE {root} [\\\\n' \\\\\\n ' <!ELEMENT {root} ({row})*>\\\\n' \\\\\\n ' <!ELEMENT {row} EMPTY>\\\\n' \\\\\\n ' <!ATTLIST {row}\\\\n{attlist}\\\\n' \\\\\\n ' >\\\\n' \\\\\\n ']>'.format(root=query.root, row=query.row, attlist=attlist)\\n\\n # DEFAULT_CHARSET is used by HttpResponse, so make etree use it too.\\n # Output may become invalid if DEFAULT_CHARSET cannot be used to encode field names!\\n # e.g. MySQL columns may include characters from Unicode Basic Multiingual Plane,\\n # which could be inexpressible if DEFAULT_CHARSET were ascii, giving invalid xml.\\n return etree.tostring(\\n root,\\n pretty_print = False,\\n encoding = settings.DEFAULT_CHARSET,\\n xml_declaration = True,\\n doctype = dtd,\\n )\",\n \"def make_xml_request(self, xmldata, xml_result=False):\\n\\n if xml_result:\\n return self._xml_command(xmldata)\\n else:\\n return self._text_command(xmldata)\",\n \"def to_xml(self):\\n return xmltodict.unparse(\\n self.to_xml_dict(),\\n pretty=True\\n ).encode(\\\"utf-8\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6010409","0.5807119","0.5803181","0.57231146","0.5688771","0.5660354","0.54970235","0.5462216","0.54385936","0.538115","0.53393245","0.5326203","0.5314152","0.53080094","0.5306955","0.52890134","0.52495795","0.5163723","0.5145049","0.513027","0.5113245","0.5111564","0.5106003","0.51050794","0.50800604","0.5071062","0.5068015","0.50630337","0.5034253","0.5029626","0.50054157","0.49780747","0.4962529","0.4955753","0.49527055","0.49244946","0.4920663","0.49081257","0.49079865","0.48969468","0.4895389","0.4887941","0.4887307","0.4887307","0.48851964","0.4872163","0.48710975","0.48605624","0.48505697","0.48409525","0.4827359","0.47913098","0.47855982","0.4778841","0.47767478","0.47745335","0.47706768","0.476241","0.47605336","0.4754912","0.47542843","0.4741948","0.4741948","0.47381938","0.4737179","0.47295302","0.4709702","0.47043702","0.4701917","0.4701756","0.46965998","0.46877265","0.4686923","0.46786854","0.4673057","0.4670098","0.46653154","0.4656468","0.46549264","0.46548086","0.46536377","0.46528575","0.46522275","0.46497497","0.464273","0.46317634","0.46299338","0.462001","0.46176142","0.46119416","0.46119416","0.46117374","0.46111512","0.46072555","0.4605655","0.45998654","0.45950922","0.4591884","0.45887864","0.45801717"],"string":"[\n \"0.6010409\",\n \"0.5807119\",\n \"0.5803181\",\n \"0.57231146\",\n \"0.5688771\",\n \"0.5660354\",\n \"0.54970235\",\n \"0.5462216\",\n \"0.54385936\",\n \"0.538115\",\n \"0.53393245\",\n \"0.5326203\",\n \"0.5314152\",\n \"0.53080094\",\n \"0.5306955\",\n \"0.52890134\",\n \"0.52495795\",\n \"0.5163723\",\n \"0.5145049\",\n \"0.513027\",\n \"0.5113245\",\n \"0.5111564\",\n \"0.5106003\",\n \"0.51050794\",\n \"0.50800604\",\n \"0.5071062\",\n \"0.5068015\",\n \"0.50630337\",\n \"0.5034253\",\n \"0.5029626\",\n \"0.50054157\",\n \"0.49780747\",\n \"0.4962529\",\n \"0.4955753\",\n \"0.49527055\",\n \"0.49244946\",\n \"0.4920663\",\n \"0.49081257\",\n \"0.49079865\",\n \"0.48969468\",\n \"0.4895389\",\n \"0.4887941\",\n \"0.4887307\",\n \"0.4887307\",\n \"0.48851964\",\n \"0.4872163\",\n \"0.48710975\",\n \"0.48605624\",\n \"0.48505697\",\n \"0.48409525\",\n \"0.4827359\",\n \"0.47913098\",\n \"0.47855982\",\n \"0.4778841\",\n \"0.47767478\",\n \"0.47745335\",\n \"0.47706768\",\n \"0.476241\",\n \"0.47605336\",\n \"0.4754912\",\n \"0.47542843\",\n \"0.4741948\",\n \"0.4741948\",\n \"0.47381938\",\n \"0.4737179\",\n \"0.47295302\",\n \"0.4709702\",\n \"0.47043702\",\n \"0.4701917\",\n \"0.4701756\",\n \"0.46965998\",\n \"0.46877265\",\n \"0.4686923\",\n \"0.46786854\",\n \"0.4673057\",\n \"0.4670098\",\n \"0.46653154\",\n \"0.4656468\",\n \"0.46549264\",\n \"0.46548086\",\n \"0.46536377\",\n \"0.46528575\",\n \"0.46522275\",\n \"0.46497497\",\n \"0.464273\",\n \"0.46317634\",\n \"0.46299338\",\n \"0.462001\",\n \"0.46176142\",\n \"0.46119416\",\n \"0.46119416\",\n \"0.46117374\",\n \"0.46111512\",\n \"0.46072555\",\n \"0.4605655\",\n \"0.45998654\",\n \"0.45950922\",\n \"0.4591884\",\n \"0.45887864\",\n \"0.45801717\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70309347"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":88397,"cells":{"query":{"kind":"string","value":"When called with an instance of L{txaws.route53._util.Tag}, L{to_xml} returns a L{Defered} giving the result of flattening it as an instance of L{bytes} with an xml doctype prepended."},"document":{"kind":"string","value":"def test_something(self):\n self.assertEqual(\n b\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n<Foo>bar</Foo>\"\"\",\n self.successResultOf(to_xml(tags.Foo(\"bar\"))),\n )"},"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 get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()","def to_xml(self):\r\n if self.alias_hosted_zone_id != None and self.alias_dns_name != None:\r\n # Use alias\r\n body = self.AliasBody % (self.alias_hosted_zone_id, self.alias_dns_name)\r\n else:\r\n # Use resource record(s)\r\n records = \"\"\r\n for r in self.resource_records:\r\n records += self.ResourceRecordBody % r\r\n body = self.ResourceRecordsBody % {\r\n \"ttl\": self.ttl,\r\n \"records\": records,\r\n }\r\n params = {\r\n \"name\": self.name,\r\n \"type\": self.type,\r\n \"body\": body,\r\n }\r\n return self.XMLBody % params","def get_xml(self):\n return etree.tostring(self.get_etree())","def xml(self):\n rough_string = ElementTree.tostring(self.dom, \"utf-8\")\n reparsed = minidom.parseString(rough_string)\n return reparsed.toprettyxml(indent=\" \")","def to_xml(self):\n return xmltodict.unparse(\n self.to_xml_dict(),\n pretty=True\n ).encode(\"utf-8\")","def to_xml(self, enc='utf-8'):\n return b\"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<!DOCTYPE GIFTI SYSTEM \"http://www.nitrc.org/frs/download.php/115/gifti.dtd\">\n\"\"\" + xml.XmlSerializable.to_xml(self, enc)","def toxml(self) :\n\t\treturn self.doc.toxml()","def toXml(prefixes=None, closeElement=1, defaultUri='',\n prefixesInScope=None):","def xmldoc(self, doctype):\n # we hack in the DOCTYPE using the parser\n docstr = \"\"\"<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n <!DOCTYPE %s SYSTEM \"file:///usr/share/emane/dtd/%s.dtd\">\n <%s/>\"\"\" % (doctype, doctype, doctype)\n # normally this would be: doc = Document()\n return parseString(docstr)","def _tree_to_xml(self, tree):\n\n body = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n\n return body + self._element_to_xml(tree)","def _tree_to_xml(self, tree):\n\n body = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>\\n'\n\n return body + self._element_to_xml(tree)","def get_query_xml(query):\n root = get_query_etree(query)\n\n # can get actual field types by inspecting cursor.description,\n # but these (I think) depend on the database back-end\n # so I decided it was too hard to be smart here,\n # and instead just say that everything is \"CDATA #REQURED\"...\n attlist = '\\n'.join(' {col} CDATA #REQUIRED'.format(col=col) for col in query.cols)\n\n # generating dtd means we can automatically validate output, for testing\n dtd = '<!DOCTYPE {root} [\\n' \\\n ' <!ELEMENT {root} ({row})*>\\n' \\\n ' <!ELEMENT {row} EMPTY>\\n' \\\n ' <!ATTLIST {row}\\n{attlist}\\n' \\\n ' >\\n' \\\n ']>'.format(root=query.root, row=query.row, attlist=attlist)\n\n # DEFAULT_CHARSET is used by HttpResponse, so make etree use it too.\n # Output may become invalid if DEFAULT_CHARSET cannot be used to encode field names!\n # e.g. MySQL columns may include characters from Unicode Basic Multiingual Plane,\n # which could be inexpressible if DEFAULT_CHARSET were ascii, giving invalid xml.\n return etree.tostring(\n root,\n pretty_print = False,\n encoding = settings.DEFAULT_CHARSET,\n xml_declaration = True,\n doctype = dtd,\n )","def device_xml() -> Response:\n xml = render_template('device.xml',\n device_model=config.device_model,\n device_version=config.device_version,\n friendly_name=locast_service.city,\n uid=uid,\n host_and_port=host_and_port)\n return Response(xml, mimetype='text/xml')","def xmlify(template, content_type='application/xml', **context):\n content = render_template(template, **context)\n response = make_response(content)\n response.headers['Content-Type'] = content_type\n return response","def xml(self):\n return lxml.etree.fromstring(self.content, _XML_PARSER)","def xml(self):\n raise NotImplementedError('This api does not return xml')","def xml(self):\n return self._xml","def xml(self):\n return self._xml","def toXML(self):\n return self._xmlpre+\"\\n\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost","def to_xml(self, data, options=None):\r\n options = options or {}\r\n\r\n if lxml is None:\r\n raise UnsupportedSerializationFormat(\"Usage of the XML aspects requires lxml.\")\r\n\r\n return tostring(self.to_etree(data, options), xml_declaration=True, encoding='utf-8')","def xml_tostring(tree):\n if six.PY2:\n return ET.tostring(tree)\n else:\n return ET.tostring(tree, encoding='unicode')","def tostring(self):\n header, body = None, None\n\n if self._header:\n header = b'<?xml version=\"1.0\" encoding=\"utf-8\"?>'\n\n if self._main() is not None:\n body = ET.tostring(self._main(), 'utf-8')\n\n return (header if header else b'') + (body if body else b'')","def to_xml(self):\n \n root = ET.Element(\"Document\")\n root.set('xmlns',\"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.02\")\n root_fito = ET.SubElement(root, \"FIToFICstmrCdtTrf\")\n \n self.xml_header(root_fito)\n self.xml_transaction(root_fito)\n\n ET.ElementTree(root)\n \n return ET.tostring(root,encoding='utf-8',xml_declaration=True).decode('utf-8')","def format_xml(self,query_results):\n results=query_results.data\n factory=factory_xml()\n dump=factory.dumps({'data':results})\n print(dump)\n # TODO return output for this\n return \"\"","def get_xml(self):\n xml = svgwrite.etree.etree.Element(self.elementname)\n if self.debug:\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\n for attribute, value in self.attribs.items():\n # filter 'None' values\n if value is not None:\n value = self.value_to_string(value)\n if value: # just add not empty attributes\n xml.set(attribute, value)\n \n for element in self.elements:\n xml.append(element)\n return xml","def xml_to_string(xml_tag):\n return parseString(ET.tostring(xml_tag)).toprettyxml(indent=\" \")","def xml():\n response = make_response(render_template(\"sample.xml\"))\n response.headers[\"Content-Type\"] = \"application/xml\"\n return response","def acceptxml(func):\n\n @wraps(func)\n def return_xml(*args, **kwargs):\n if request.headers.get('Accept', '*/*') == 'application/xml':\n return json_toXML(g.payload_json)\n\n return return_xml","def encode(self):\n\n return lxml.etree.tostring(self.get_content(),\n pretty_print = True,\n encoding = self.encoding,\n xml_declaration = True)","def xml_string(self):\n if self._xml_string is not None:\n return self._xml_string\n\n return etree.tostring(self._xml_node)","def generateXML(self):\n return self.formatEval(\n self.TEMPLATES[self.attrs['name']]['XML'],\n self.attrs\n )","def toString(doc):\n return doc.toxml()","def definition_to_xml(self, resource_fs):\r\n raise NotImplementedError(\r\n \"%s does not implement definition_to_xml\" % self.__class__.__name__)","def ConvertToXML (given_dict) :\r\n stream_thing = cStringIO.StringIO()\r\n WriteToXMLStream(given_dict, stream_thing, 'top')\r\n return stream_thing.getvalue()","def xml_string(self):\r\n if self._xml_string is not None:\r\n return self._xml_string\r\n\r\n return etree.tostring(self._xml_node)","def write(doc: Document, encoding='utf8', xml_declaration=True, pretty_print=False) -> bytes:\n tree = Parser.to_element_tree(doc)\n return etree.tostring(tree, encoding=encoding, xml_declaration=xml_declaration, pretty_print=pretty_print)","def prepare(*args, **kwargs):\n LOGGER.warning(\n \"readalongs.api.prepare() is deprecated. Please use make_xml() instead.\"\n )\n return make_xml(*args, **kwargs)","def generate(self):\n xml = self.template()\n fp = BytesIO()\n gzip = GzipFile(self.filename, \"wb\", 9, fp)\n if isinstance(xml, str):\n xml = xml.encode(\"utf8\")\n gzip.write(xml)\n gzip.close()\n data = fp.getvalue()\n fp.close()\n return data","def getXML(self):\n\n def _getElementForMappingEntry(entry, mappingStyle):\n xmlDocTmp = Document()\n element = xmlDocTmp.createElement(mappingStyle)\n for k, v in viewitems(entry):\n # ignore empty, None or compiled regexp items into output\n if not v or (k == \"path-match-expr\"):\n continue\n element.setAttribute(k, str(v))\n return element\n\n xmlDoc = Document()\n root = xmlDoc.createElement(\"storage-mapping\") # root element name\n for mappingStyle, mappings in viewitems(self):\n for mapping in mappings:\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\n root.appendChild(mapElem)\n return root.toprettyxml()","def XMLWriter(\n fd,\n encoding=\"utf-8\",\n pretty=True,\n compactempty=True,\n indentation=_DEFAULT_INDENTATION\n):\n return _document(fd, encoding, pretty, compactempty, indentation)","def emit_tag(self):\n root = etree.Element('CdtTrfTxInf')\n pmtid = etree.SubElement(root, 'PmtId')\n # etree.SubElement(pmtid, 'InstrId').text = self.tx_id\n # etree.SubElement(pmtid, 'EndToEndId').text = self.eeid\n etree.SubElement(pmtid, 'EndToEndId').text = self.creditor.name\n # info = etree.SubElement(root, 'PmtTpInf')\n # purp = etree.SubElement(info, 'CtgyPurp')\n # etree.SubElement(purp, 'Cd').text = self.category\n amt = etree.SubElement(root, 'Amt')\n etree.SubElement(\n amt, 'InstdAmt', attrib={'Ccy': 'EUR'}).text = str(self.amount)\n if hasattr(self, 'ultimate_debtor'):\n root.append(self.ultimate_debtor.__tag__('UltmtDbtr'))\n if self.account.is_foreign() or self.bic:\n agt = etree.SubElement(root, 'CdtrAgt')\n agt.append(Bank(bic=self.bic).__tag__())\n root.append(self.creditor.__tag__('Cdtr'))\n root.append(self.account.__tag__('CdtrAcct'))\n if hasattr(self, 'ultimate_creditor'):\n root.append(self.ultimate_creditor.__tag__('UltmtCdtr'))\n rmtinf = etree.SubElement(root, 'RmtInf')\n if hasattr(self, 'rmtinfo'):\n etree.SubElement(rmtinf, 'Ustrd').text = self.rmtinfo\n else:\n etree.SubElement(rmtinf, 'Ustrd').text = ''.join(\n [str(doc) for doc in self.docs])\n return root","def _ds(elem):\n _indent(elem)\n return ElementTree.tostring(elem)","def __att_to_xml(self, doc, parent, att_name, att):\r\n \r\n if att == None:\r\n e=doc.createElementNS(None, att_name)\r\n parent.appendChild(e)\r\n e.appendChild(doc.createTextNode(''))\r\n elif type(att) == str or type(att) == unicode or type(att) == int:\r\n e=doc.createElementNS(None, att_name)\r\n parent.appendChild(e)\r\n e.appendChild(doc.createTextNode('%s' % att))\r\n #e.setAttributeNS(None, \"class\", \"sample\")\r\n elif hasattr(att, 'to_xml'):\r\n # Looks like an entity object, so call it's to_xml and append it\r\n child_frag = att.to_xml(doc)\r\n parent.appendChild(child_frag)\r\n elif type(att) == list or type(att) == tuple:\r\n # Looks like an ordered collection\r\n col = doc.createElementNS(None, att_name)\r\n parent.appendChild(col)\r\n for item in att:\r\n self.__att_to_xml(doc, col, att_name, item)\r\n elif isinstance(att, dict):\r\n # Looks like a dictionary\r\n col = doc.createElementNS(None, att_name)\r\n parent.appendChild(col)\r\n att_keys = att.keys()\r\n att_keys.sort()\r\n for item in att_keys:\r\n self.__att_to_xml(doc, col, item, att[item])\r\n else:\r\n # Not sure, so treat it like a string\r\n e=doc.createElementNS(None, att_name)\r\n parent.appendChild(e)\r\n e.appendChild(doc.createTextNode('%s' % att))","def export(xsd_object, make_pretty=True):\n buff = StringIO.StringIO()\n xsd_object.export(\n buff,\n 1,\n namespacedef_='xmlns=\"http://zigbee.org/sep\" xmlns:xsi=\"http://www.w3.org/2001/XMLSchema-instance\"',\n pretty_print=make_pretty\n )\n return buff.getvalue()","def toXml(self, prefixes=None, closeElement=1, defaultUri='',\n prefixesInScope=None):\n s = SerializerClass(prefixes=prefixes, prefixesInScope=prefixesInScope)\n s.serialize(self, closeElement=closeElement, defaultUri=defaultUri)\n return s.getValue()","def render_to_xml(self, context_dict):\r\n # add dummy STATIC_URL to template context\r\n context_dict.setdefault(\"STATIC_URL\", \"/dummy-static/\")\r\n try:\r\n xml_str = self.template.render_unicode(**context_dict)\r\n except:\r\n raise TemplateError(exceptions.text_error_template().render())\r\n\r\n # Attempt to construct an XML tree from the template\r\n # This makes it easy to use XPath to make assertions, rather\r\n # than dealing with a string.\r\n # We modify the string slightly by wrapping it in <test>\r\n # tags, to ensure it has one root element.\r\n try:\r\n xml = etree.fromstring(\"<test>\" + xml_str + \"</test>\")\r\n except Exception as exc:\r\n raise TemplateError(\"Could not parse XML from '{0}': {1}\".format(\r\n xml_str, str(exc)))\r\n else:\r\n return xml","def convert_dict_to_xml(data_dict):\n from dicttoxml import dicttoxml\n\n return dicttoxml(data_dict, attr_type=False)","def xml(self):\n return parse_xml(self, tab=\"\\t\", id=self.id or \"\")","def CreateXMLTransformer() -> TransformerFunc:\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())","def toxml(self) -> ET.Element:\n # Dummy element that ElementTree extend() will strip\n root = ET.Element('root')\n\n connection = ET.SubElement(root, 'Connection')\n\n origin = ET.SubElement(connection, 'Origin')\n origin.set('ToolID', self.origin_tool.tool_id)\n origin.set('Connection', self.origin_output)\n\n destination = ET.SubElement(connection, 'Destination')\n destination.set('ToolID', self.destination_tool.tool_id)\n destination.set('Connection', self.destination_input)\n\n return root","def serialize(self):\n res = '<?xml version=\"1.0\" encoding=\"UTF-8\"?>'\n self.grammar_elem.attr[\"xmlns\"] = \\\n \"http://relaxng.org/ns/structure/1.0\"\n self.grammar_elem.attr[\"datatypeLibrary\"] = \\\n \"http://www.w3.org/2001/XMLSchema-datatypes\"\n for ns in self.namespaces:\n self.grammar_elem.attr[\"xmlns:\" + self.namespaces[ns]] = ns\n res += self.grammar_elem.start_tag()\n for ch in self.grammar_elem.children:\n res += ch.serialize()\n if not self.no_data:\n res += \"<start>\" + self.root.serialize() + \"</start>\"\n for d in self.defs:\n res += self.defs[d].serialize()\n if self.has_anyxml:\n res += self.anyxml_def\n return res + self.grammar_elem.end_tag()","def adaptXmlToXml(self, *args):\n return _SALOMERuntime.RuntimeSALOME_adaptXmlToXml(self, *args)","def serialize(self):\n return self.xmlnode.serialize(encoding=\"utf-8\")","def toXML(self):\n return _libsbml.Layout_toXML(self)","def render(self, data, accepted_media_type=None, renderer_context=None):\n if data is None:\n return ''\n\n stream = StringIO()\n\n xml = SimplerXMLGenerator(stream, self.charset)\n xml.startDocument()\n #xml.startElement(\"root\", {})\n\n self._to_xml(xml, data)\n\n #xml.endElement(\"root\")\n xml.endDocument()\n return stream.getvalue()","def saveXml(self, buf: java.lang.StringBuilder) -> None:\n ...","def to_xml(self):\r\n element = ET.Element(\"node\")\r\n\r\n element.attrib['name'] = self.name\r\n element.attrib['description'] = self.description\r\n\r\n return element","def output_xml(data, code, headers=None):\n response = make_response(simplexml.dumps({'response': data}), code)\n response.headers.extend(headers or {})\n return response","def datatoxml(data):\n return dicttoxml.dicttoxml(data,\n custom_root='records',\n attr_type=False,\n item_func=record_to_xml)","def to_xml(self, doc = None, output = None, indent = False):\r\n \r\n # Determine what format to return the values as\r\n if output != None and output.lower() != 'str' and output.lower() != 'dom':\r\n # Check to see if it's a filepath\r\n if output.lower().split('.')[-1] == 'xml':\r\n output = os.path.abspath(output)\r\n else:\r\n raise ValueError('Unrecognized format: %s' % output)\r\n \r\n # If doc is None, create a document\r\n if doc != None:\r\n is_root = False\r\n else:\r\n is_root = True\r\n doc = domlette.implementation.createDocument(None, None, None)\r\n #doc.publicId = \"-//W3C//DTD XHTML 1.0 Strict//EN\"\r\n #doc.systemId = \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\"\r\n \r\n # Prepare an XML fragment to hold this entity's data\r\n frag = doc.createDocumentFragment()\r\n frag_root=doc.createElementNS(None, self.__class__.entity_name.lower())\r\n frag.appendChild(frag_root)\r\n\r\n # Append all of the key value pairs \r\n for att_name in self.__class__.entity_atts:\r\n att = getattr(self, att_name)\r\n self.__att_to_xml(doc, frag_root, att_name, att)\r\n\r\n # Return the result\r\n if not is_root:\r\n return frag\r\n else:\r\n # Determine how to return\r\n doc.appendChild(frag) \r\n if output == None:\r\n # Default returns XML as an objectified gnosis object\r\n return gnosis.xml.objectify.XML_Objectify(doc, parser='DOM').make_instance()\r\n elif output == 'str':\r\n # Return as string\r\n buf = StringIO()\r\n if indent:\r\n domlette.PrettyPrint(doc, stream=buf, encoding='us-ascii')\r\n else:\r\n domlette.Print(doc, stream=buf)\r\n xml_string = buf.getvalue()\r\n buf.close() \r\n return xml_string\r\n elif output == 'dom':\r\n # Return as a XML Document (Raw DOM)\r\n return doc\r\n else:\r\n f = open(output, 'w')\r\n if indent:\r\n domlette.PrettyPrint(doc, stream=f)\r\n else:\r\n domlette.Print(doc, stream=f)\r\n f.close()\r\n return True","def tostring(self, indent: str = '', max_lines: Optional[int] = None,\n spaces_for_tab: int = 4) -> Union[str, bytes]:\n return etree_tostring(self.schema_elem, self.namespaces, indent, max_lines, spaces_for_tab)","def dumps(records, xslt_filename=None, **kwargs):\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\n return etree.tostring(\n root,\n pretty_print=True,\n xml_declaration=True,\n encoding='UTF-8',\n **kwargs\n )","def writeXMLDecl(self):\n return _libsbml.XMLOutputStream_writeXMLDecl(self)","def storeAndReturnXML(self):\n self._storeItems()\n return self.toXML()","def xml(self):\n raise NotImplementedError('must be implemented by all subclasses')","def output_xml(data, code, headers=None):\r\n resp = make_response(dumps({'response' :data}), code)\r\n resp.headers.extend(headers or {})\r\n return resp","def file_to_xml(cls, file_object):\r\n return etree.parse(file_object, parser=edx_xml_parser).getroot()","def format_xml(elem):\n rough_string = ET.tostring(elem, 'utf-8')\n reparsed = minidom.parseString(rough_string)\n return reparsed.toprettyxml(indent=\"\\t\")","def prettify(self):\n reparsed = minidom.parseString(self.tostring())\n return reparsed.toprettyxml(indent=' ', encoding='utf-8')","def start_serialization(self):\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\"encoding\", settings.DEFAULT_CHARSET))\n self.xml.startDocument()\n self.xml.startElement(\"xliff\", {\n \"version\": \"1.2\",\n \"xmlns\": \"urn:oasis:names:tc:xliff:document:1.2\",\n \"xmlns:d\": \"https://docs.djangoproject.com/\"\n })","def pprint_xml(et):\n \n return tostring(et, pretty_print=True)","def to_xml(self):\n xml_strings = ['<code_object name=\"%s\">' % self.name]\n xml_strings.append(' <type value=\"%s\" />' % self.object_type)\n xml_strings.append(' <source>')\n for source_line in self.source:\n xml_strings.append(source_line[1])\n xml_strings.append(' </source>')\n xml_strings.append('</code_object>')\n return \"\".join(xml_strings)","def output_xml(data,code,headers=None):\r\n resp = make_response(dumps({'response': data}), code)\r\n resp.headers.extend(headers or {})\r\n return resp","def xml(self):\n xml_string = '<VendorMap>\\n'\n for vendorid, name in self.data.items():\n xml_string += \"<Vendor>\\n<Id>{}</Id>\\n<Name>{}</Name>\\n</Vendor>\\n\".format(vendorid, name)\n xml_string += '</VendorMap>\\n'\n return xml_string","def xml(self):\n xml = []\n xml.append('<?xml version=\"1.0\" encoding=\"%s\"?>' % XML_ENCODING.get(self.encoding, self.encoding))\n xml.append(\"<%s>\" % XML_TEXT)\n xml.extend([sentence.xml for sentence in self])\n xml.append(\"</%s>\" % XML_TEXT)\n return \"\\n\".join(xml)","def to_xml(self, resource):\n stream = StringIO.StringIO()\n stream.write(\"<?xml version='1.0' encoding='UTF-8'?>\")\n stream.write('<%s>' % \"GpsRO\")\n\n for item in resource.items():\n key, value = item\n if isinstance(value, str) or isinstance(value, unicode):\n stream.write('\\n<%s>%s</%s>' % (key, value, key))\n else:\n stream.write('\\n<%s>%d</%s>' % (key, value, key))\n\n stream.write('\\n</%s>' % \"GpsRO\")\n stream.seek(0)\n return stream.read()","def get_xml(self):\n\t\treturn cziso.fill_template(self.libvirt, vm_name = self.name,\n\t\t disks=\"\\n\".join(self.disk_xmls), interface=self.iface_xml)","def toXML( self, indent = '', **kwargs ) :\n\n return( '\\n'.join( self.toXMLList( **kwargs ) ) )","def to_xml(self, tag='next'):\n if self.name is not None:\n elem = cElementTree.Element(tag)\n name = self.name if self.name else ''\n elem.set('step', name)\n for flag in self.flags:\n elem.append(flag.to_xml())\n return elem","def _generate_xml(self, body, destn_dir, nodes=True):\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\n fn += '.xml'\n\n _dir = os.path.dirname(os.path.abspath(__file__))\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\n _env = Environment(autoescape=False,\n loader=FileSystemLoader(_dir),\n trim_blocks=False)\n\n with open(fn, 'w+') as f:\n o = _env.get_template(_tmpl).render(body)\n f.write(o)\n\n _d = destn_dir + '/' + fn\n self._remote_copy(fn, _d)\n # Remove the XML file created locally\n os.remove(fn)\n\n return _d","def toXML(self):\n item = \"<item uid=\\\"{uid}\\\" arg=\\\"{arg}\\\" valid=\\\"{valid}\\\"\"\n if(self.autocomplete!=None):\n item += \" autocomplete=\\\"{autocomplete}\\\"\"\n item += \">\"\n item += \"<title><![CDATA[{title}]]></title>\"\n item += \"<subtitle><![CDATA[{subtitle}]]></subtitle>\"\n if (self.icon != None):\n if(self.icontype != None):\n item += \"<icon type=\\\"{icontype}\\\">{icon}</icon>\"\n else:\n item += \"<icon>{icon}</icon>\"\n item += \"</item>\"\n return item.format(uid=self.uid,arg=self.arg,valid=\"yes\" if self.valid else \"no\",icontype=self.icontype,\n title=self.title,subtitle=self.subtitle,icon=self.icon,autocomplete=self.autocomplete)","def toXML(obj: dict, xsi_namespace=\"i\") -> str:\n ATTRIBUTESKEY = \"$attributes\"\n NAMESPACEKEY = \"$namespace\"\n\n def tag(\n name: str, value: str, *, attributes: dict = {}, namespace: str = None\n ) -> str:\n \"\"\"Surrounds a string in xml tags\n\n Args:\n name (str): Name of tag\n value (str): Value of tag\n attributes (dict, optional): Dict of attributes for xml element. Defaults to {}.\n namespace (str, optional): Namespace prefix for the tag. Defaults to None.\n\n Returns:\n str: xml string\n \"\"\"\n attributes_str = \" \".join(f'{k}=\"{v}\"' for k, v in attributes.items())\n ns = f\"{namespace}:\" if namespace else \"\"\n if attributes_str:\n attributes_str = \" \" + attributes_str\n if value:\n return f\"<{ns}{name}{attributes_str}>{value}</{ns}{name}>\"\n return f\"<{ns}{name}{attributes_str} />\"\n\n def serialize_dict(val: dict, namespace: str = None) -> str:\n ns = val.pop(NAMESPACEKEY, namespace)\n return \"\".join(serialize(k, v, ns) for k, v in val.items())\n\n def serialize(name: str, val: Any, namespace: str = None) -> str:\n \"\"\"Serializes a key value pair into an XML element\n\n Args:\n name (str): Tag name for element\n val (Any): Value to serialize\n namespace (str, optional): Namespace to prepend to child tags\n of value. Defaults to None.\n\n Returns:\n str: XML string\n \"\"\"\n t = lambda v, a={}: tag(name, v, attributes=a, namespace=namespace)\n if isinstance(val, dict):\n attrs = val.pop(ATTRIBUTESKEY, {})\n return t(serialize_dict(val, namespace), attrs)\n if isinstance(val, list):\n return t(\"\".join(serialize_dict(v, namespace=namespace) for v in val))\n elif isinstance(val, bool):\n return t(str(val).lower())\n elif val is None:\n return t(None, {f\"{xsi_namespace}:nil\": \"true\"})\n else:\n return t(str(val))\n\n return serialize_dict(obj)","def output_xml(data, code, headers=None):\n resp = make_response(simplexml_dumps({\"response\": data}), code)\n resp.headers.extend(headers or {})\n return resp","def to_xml(self, f=None):\r\n if not f:\r\n from tempfile import TemporaryFile\r\n f = TemporaryFile()\r\n print >> f, '<?xml version=\"1.0\" encoding=\"UTF-8\"?>'\r\n print >> f, '<Domain id=\"%s\">' % self.name\r\n for item in self:\r\n print >> f, '\\t<Item id=\"%s\">' % item.name\r\n for k in item:\r\n print >> f, '\\t\\t<attribute id=\"%s\">' % k\r\n values = item[k]\r\n if not isinstance(values, list):\r\n values = [values]\r\n for value in values:\r\n print >> f, '\\t\\t\\t<value><![CDATA[',\r\n if isinstance(value, unicode):\r\n value = value.encode('utf-8', 'replace')\r\n else:\r\n value = unicode(value, errors='replace').encode('utf-8', 'replace')\r\n f.write(value)\r\n print >> f, ']]></value>'\r\n print >> f, '\\t\\t</attribute>'\r\n print >> f, '\\t</Item>'\r\n print >> f, '</Domain>'\r\n f.flush()\r\n f.seek(0)\r\n return f","def xml2obj(self, src):\n\n\t\tclass DataNode(object):\n\t\t\tdef __init__(self):\n\t\t\t\tself._attrs = {} # XML attributes and child elements\n\t\t\t\tself.data = None # child text data\n\n\t\t\tdef __len__(self):\n\t\t\t\t# treat single element as a list of 1\n\t\t\t\treturn 1\n\n\t\t\tdef __getitem__(self, key):\n\t\t\t\tif isinstance(key, basestring):\n\t\t\t\t\treturn self._attrs.get(key,None)\n\t\t\t\telse:\n\t\t\t\t\treturn [self][key]\n\n\t\t\tdef __contains__(self, name):\n\t\t\t\treturn self._attrs.has_key(name)\n\n\t\t\tdef __nonzero__(self):\n\t\t\t\treturn bool(self._attrs or self.data)\n\n\t\t\tdef __getattr__(self, name):\n\t\t\t\tif name.startswith('__'):\n\t\t\t\t\t# need to do this for Python special methods???\n\t\t\t\t\traise AttributeError(name)\n\t\t\t\treturn self._attrs.get(name,None)\n\n\t\t\tdef _add_xml_attr(self, name, value):\n\t\t\t\tif name in self._attrs:\n\t\t\t\t\t\t# multiple attribute of the same name are represented by a list\n\t\t\t\t\t\tchildren = self._attrs[name]\n\t\t\t\t\t\tif not isinstance(children, list):\n\t\t\t\t\t\t\tchildren = [children]\n\t\t\t\t\t\t\tself._attrs[name] = children\n\t\t\t\t\t\tchildren.append(value)\n\t\t\t\telse:\n\t\t\t\t\tself._attrs[name] = value\n\n\t\t\tdef __str__(self):\n\t\t\t\treturn self.data or ''\n\n\t\t\tdef __repr__(self):\n\t\t\t\titems = sorted(self._attrs.items())\n\t\t\t\tif self.data:\n\t\t\t\t\titems.append(('data', self.data))\n\t\t\t\treturn u'{%s}' % ', '.join([u'%s:%s' % (k,repr(v)) for k,v in items])\n\n\t\tclass TreeBuilder(xml.sax.handler.ContentHandler):\n\t\t\tdef __init__(self):\n\t\t\t\tself.stack = []\n\t\t\t\tself.root = DataNode()\n\t\t\t\tself.current = self.root\n\t\t\t\tself.text_parts = []\n\t\t\t\tself.publicObjects = {}\n\n\t\t\tdef startElement(self, name, attrs):\n\t\t\t\tself.stack.append((self.current, self.text_parts))\n\t\t\t\tself.current = DataNode()\n\t\t\t\tself.text_parts = []\n\t\t\t\t# xml attributes --> python attributes\n\t\t\t\tfor k, v in attrs.items():\n\t\t\t\t\t# Register PublicObject in lookup map\n\t\t\t\t\tif k == \"publicID\":\n\t\t\t\t\t\tself.publicObjects[v] = self.current\n\t\t\t\t\tself.current._add_xml_attr(k, v)\n\n\t\t\tdef endElement(self, name):\n\t\t\t\ttext = ''.join(self.text_parts).strip()\n\t\t\t\tif text:\n\t\t\t\t\tself.current.data = text\n\t\t\t\tif self.current._attrs:\n\t\t\t\t\tobj = self.current\n\t\t\t\telse:\n\t\t\t\t\t# a text only node is simply represented by the string\n\t\t\t\t\tobj = text or ''\n\t\t\t\t\t# try to store the object as float if possible\n\t\t\t\t\ttry: obj = float(obj)\n\t\t\t\t\texcept: pass\n\t\t\t\tself.current, self.text_parts = self.stack.pop()\n\t\t\t\tself.current._add_xml_attr(name, obj)\n\n\t\t\tdef characters(self, content):\n\t\t\t\tself.text_parts.append(content)\n\n\t\tbuilder = TreeBuilder()\n\t\tif isinstance(src,basestring):\n\t\t\txml.sax.parseString(src, builder)\n\t\telse:\n\t\t\txml.sax.parse(src, builder)\n\t\treturn builder","def saveToXml(self) -> org.jdom.Element:\n ...","def to_xml(self):\n\n xml = '<activity at=\"' + self.get_at_as_string() + '\" '\n xml += 'action=\"' + self.action + '\" '\n xml += 'actor=\"' + self.actor + '\" '\n xml += 'regarding=\"' + self.regarding + '\" '\n xml += 'source=\"' + self.source + '\" ' \n xml += 'tags=\"' + \",\".join(self.tags) + '\" '\n xml += 'to=\"' + self.to + '\" '\n xml += 'url=\"' + self.url + '\"'\n\n if self.body is None:\n xml += '/>'\n else:\n xml += '>'\n xml += '<payload><body>'\n xml += self.body\n xml += '</body>'\n if self.raw is not None:\n xml += '<raw>'\n xml += self.raw\n xml += '</raw>'\n xml += '</payload></activity>'\n return xml","def rec_dumps(obj, spaces):\n\n nonlocal res\n\n if isinstance(obj, str):\n res.append('{}{}\\n'.format(spaces, obj))\n return\n\n # begining tag\n res.append('{}<{}'.format(spaces, obj['tag']))\n\n # attribs\n for key, value in obj['attribs'].items():\n res.append(' {}:\"{}\"'.format(key, value))\n\n res.append('>\\n')\n\n # elements\n for element in obj['elements']:\n rec_dumps(element, spaces + delta_indent)\n\n # ending tag\n res.append('{}</{}>\\n'.format(spaces, obj['tag']))","def to_xml(self):\r\n\t\ts = \"<event>\\n\"\r\n\t\ts += \"\\t<title>\" + self.title + \"</title>\\n\"\r\n\t\ts += \"\\t<date>\\n\"\r\n\t\ts += \"\\t\\t<year>\" + str(self.dueDate.year) + \"</year>\\n\"\r\n\t\ts += \"\\t\\t<month>\" + str(self.dueDate.month) + \"</month>\\n\"\r\n\t\ts += \"\\t\\t<day>\" + str(self.dueDate.day) + \"</day>\\n\"\r\n\t\ts += \"\\t</date>\\n\"\r\n\t\ts += \"\\t<time>\" + str(self.dueTime) + \"</time>\\n\"\r\n\t\ts += \"</event>\\n\"\r\n\t\treturn s","def dumps_etree(pid, record, **kwargs):\n from dojson.contrib.to_marc21 import to_marc21\n from dojson.contrib.to_marc21.utils import dumps_etree\n\n return dumps_etree(to_marc21.do(record[\"_source\"]), **kwargs)","def new_xml(self, root_name):\n\n self.tree = ET.ElementTree(ET.fromstring('<?xml version=\"1.0\" encoding=\"UTF-8\"?><%s></%s>'%(\n root_name, root_name)))\n return self.tree.getroot()","def xml_prettify(elem):\n\n\tfrom xml.etree import ElementTree\n\tfrom xml.dom import minidom\n\n\trough_string = ElementTree.tostring(elem, 'utf-8')\n\treparsed = minidom.parseString(rough_string)\n\treturn reparsed.toprettyxml(indent=\" \")","def example_xml(example_xml_file):\n return etree.fromstring(example_xml_file.encode('utf-8'))","def pretty_print_content(self):\n\n return lxml.etree.tostring(self.get_content(),\n pretty_print = True,\n encoding = self.encoding,\n xml_declaration = True)","def maybe_xml_to_string(message, logger=None):\n if isinstance(message, six.binary_type):\n # message is returned as binary from pysaml2 in python3\n message = message.decode('utf-8')\n message = str(message)\n try:\n from defusedxml import ElementTree as DefusedElementTree\n\n parser = DefusedElementTree.DefusedXMLParser()\n xml = DefusedElementTree.XML(message, parser)\n return DefusedElementTree.tostring(xml)\n except Exception as exc:\n if logger is not None:\n logger.debug(\"Could not parse message of type {!r} as XML: {!r}\".format(type(message), exc))\n return message","def test_with_no_encoding(self):\n xml = (\n u'<?xml version=\"1.0\"?>'\n u'<DocRoot>'\n u'<Elem1>默认جذ</Elem1>'\n u'<Elem2/>'\n u'</DocRoot>'\n )\n io_string = six.StringIO()\n self.builder.dom_element.write_doc(io_string, encoding=None)\n # NOTE Exact test, no encoding of comparison XML doc string\n self.assertEqual(xml, io_string.getvalue())","def __str__(self):\n result = xml.dom.minidom.parseString(\n xml.etree.ElementTree.tostring(\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\n\n return result","def pprintXml(et):\n \n return tostring(et, pretty_print=True)","def adm_to_xml(adm: ADM) -> lxml.etree._Element:\n audioStreamFormats = AudioStreamFormatWrapper.wrapped_audioStreamFormats(adm)\n\n element_types = [\n (programme_handler.to_xml, adm.audioProgrammes),\n (content_handler.to_xml, adm.audioContents),\n (object_handler.to_xml, adm.audioObjects),\n (channel_format_handler.to_xml, adm.audioChannelFormats),\n (pack_format_handler.to_xml, adm.audioPackFormats),\n (stream_format_handler.to_xml, audioStreamFormats),\n (track_format_handler.to_xml, adm.audioTrackFormats),\n (track_uid_handler.to_xml, adm.audioTrackUIDs),\n ]\n\n E = ElementMaker(namespace=default_ns, nsmap=default_nsmap)\n afx = E.audioFormatExtended()\n\n for to_xml, elements in element_types:\n for element in elements:\n if not element.is_common_definition:\n to_xml(afx, element)\n\n return E.ebuCoreMain(\n E.coreMetadata(\n E.format(\n afx)))","def beautify_xml(XML):\n # convert XML file to modifiable string to beautify it\n text_string = ET.tostring(XML, encoding='UTF-8', method='xml')\n \n # insert line breaks before end of file tag\n file_string = text_string.replace('</aardvark>', '\\n\\n</aardvark>')\n \n # insert double new line before comments to create\n # blocks for each command\n file_string = file_string.replace('<!', '\\n\\n<!')\n \n # insert new line between each set of XML tags\n file_string = file_string.replace('><', '>\\n\\t<')\n \n # remove header\n # file_string = file_string.replace('<?xml version=\\'1.0\\' encoding=\\'utf8\\'?>\\n', '') \n \n return file_string","def print_xml(self, filename):\n\n # TODO: check what happens when input is not an xml file\n # TODO: add xmldec, processing instructions and comments\n\n xml_string = u'' # TODO: use a string buffer\n offset = 0\n stack = []\n\n for char in self.text:\n\n # any tags on the stack that can be closed?\n (stack, matching) = self._matching_closing_tags(offset, stack, [])\n for t in matching:\n xml_string += \"</%s>\" % t.name\n\n # any new opening tags?\n for t in self.source_tags.opening_tags.get(offset,[]):\n stack.append(t)\n xml_string += \"<%s%s>\" % (t.name, t.attributes_as_string())\n\n # any of those need to be closed immediately (non-consuming tags)?\n (stack, matching) = self._matching_closing_tags(offset, stack, [])\n for t in matching:\n xml_string += \"</%s>\" % t.name\n\n xml_string += escape(char)\n offset += 1\n\n fh = open(filename, 'w')\n fh.write(xml_string.encode('utf-8'))"],"string":"[\n \"def get_xml(self):\\n with io.StringIO() as string:\\n string.write(ET.tostring(self.root, encoding=\\\"unicode\\\"))\\n return string.getvalue()\",\n \"def to_xml(self):\\r\\n if self.alias_hosted_zone_id != None and self.alias_dns_name != None:\\r\\n # Use alias\\r\\n body = self.AliasBody % (self.alias_hosted_zone_id, self.alias_dns_name)\\r\\n else:\\r\\n # Use resource record(s)\\r\\n records = \\\"\\\"\\r\\n for r in self.resource_records:\\r\\n records += self.ResourceRecordBody % r\\r\\n body = self.ResourceRecordsBody % {\\r\\n \\\"ttl\\\": self.ttl,\\r\\n \\\"records\\\": records,\\r\\n }\\r\\n params = {\\r\\n \\\"name\\\": self.name,\\r\\n \\\"type\\\": self.type,\\r\\n \\\"body\\\": body,\\r\\n }\\r\\n return self.XMLBody % params\",\n \"def get_xml(self):\\n return etree.tostring(self.get_etree())\",\n \"def xml(self):\\n rough_string = ElementTree.tostring(self.dom, \\\"utf-8\\\")\\n reparsed = minidom.parseString(rough_string)\\n return reparsed.toprettyxml(indent=\\\" \\\")\",\n \"def to_xml(self):\\n return xmltodict.unparse(\\n self.to_xml_dict(),\\n pretty=True\\n ).encode(\\\"utf-8\\\")\",\n \"def to_xml(self, enc='utf-8'):\\n return b\\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n<!DOCTYPE GIFTI SYSTEM \\\"http://www.nitrc.org/frs/download.php/115/gifti.dtd\\\">\\n\\\"\\\"\\\" + xml.XmlSerializable.to_xml(self, enc)\",\n \"def toxml(self) :\\n\\t\\treturn self.doc.toxml()\",\n \"def toXml(prefixes=None, closeElement=1, defaultUri='',\\n prefixesInScope=None):\",\n \"def xmldoc(self, doctype):\\n # we hack in the DOCTYPE using the parser\\n docstr = \\\"\\\"\\\"<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\n <!DOCTYPE %s SYSTEM \\\"file:///usr/share/emane/dtd/%s.dtd\\\">\\n <%s/>\\\"\\\"\\\" % (doctype, doctype, doctype)\\n # normally this would be: doc = Document()\\n return parseString(docstr)\",\n \"def _tree_to_xml(self, tree):\\n\\n body = '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n'\\n\\n return body + self._element_to_xml(tree)\",\n \"def _tree_to_xml(self, tree):\\n\\n body = '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>\\\\n'\\n\\n return body + self._element_to_xml(tree)\",\n \"def get_query_xml(query):\\n root = get_query_etree(query)\\n\\n # can get actual field types by inspecting cursor.description,\\n # but these (I think) depend on the database back-end\\n # so I decided it was too hard to be smart here,\\n # and instead just say that everything is \\\"CDATA #REQURED\\\"...\\n attlist = '\\\\n'.join(' {col} CDATA #REQUIRED'.format(col=col) for col in query.cols)\\n\\n # generating dtd means we can automatically validate output, for testing\\n dtd = '<!DOCTYPE {root} [\\\\n' \\\\\\n ' <!ELEMENT {root} ({row})*>\\\\n' \\\\\\n ' <!ELEMENT {row} EMPTY>\\\\n' \\\\\\n ' <!ATTLIST {row}\\\\n{attlist}\\\\n' \\\\\\n ' >\\\\n' \\\\\\n ']>'.format(root=query.root, row=query.row, attlist=attlist)\\n\\n # DEFAULT_CHARSET is used by HttpResponse, so make etree use it too.\\n # Output may become invalid if DEFAULT_CHARSET cannot be used to encode field names!\\n # e.g. MySQL columns may include characters from Unicode Basic Multiingual Plane,\\n # which could be inexpressible if DEFAULT_CHARSET were ascii, giving invalid xml.\\n return etree.tostring(\\n root,\\n pretty_print = False,\\n encoding = settings.DEFAULT_CHARSET,\\n xml_declaration = True,\\n doctype = dtd,\\n )\",\n \"def device_xml() -> Response:\\n xml = render_template('device.xml',\\n device_model=config.device_model,\\n device_version=config.device_version,\\n friendly_name=locast_service.city,\\n uid=uid,\\n host_and_port=host_and_port)\\n return Response(xml, mimetype='text/xml')\",\n \"def xmlify(template, content_type='application/xml', **context):\\n content = render_template(template, **context)\\n response = make_response(content)\\n response.headers['Content-Type'] = content_type\\n return response\",\n \"def xml(self):\\n return lxml.etree.fromstring(self.content, _XML_PARSER)\",\n \"def xml(self):\\n raise NotImplementedError('This api does not return xml')\",\n \"def xml(self):\\n return self._xml\",\n \"def xml(self):\\n return self._xml\",\n \"def toXML(self):\\n return self._xmlpre+\\\"\\\\n\\\".join(map(lambda f:f.toXML(),self._items))+self._xmlpost\",\n \"def to_xml(self, data, options=None):\\r\\n options = options or {}\\r\\n\\r\\n if lxml is None:\\r\\n raise UnsupportedSerializationFormat(\\\"Usage of the XML aspects requires lxml.\\\")\\r\\n\\r\\n return tostring(self.to_etree(data, options), xml_declaration=True, encoding='utf-8')\",\n \"def xml_tostring(tree):\\n if six.PY2:\\n return ET.tostring(tree)\\n else:\\n return ET.tostring(tree, encoding='unicode')\",\n \"def tostring(self):\\n header, body = None, None\\n\\n if self._header:\\n header = b'<?xml version=\\\"1.0\\\" encoding=\\\"utf-8\\\"?>'\\n\\n if self._main() is not None:\\n body = ET.tostring(self._main(), 'utf-8')\\n\\n return (header if header else b'') + (body if body else b'')\",\n \"def to_xml(self):\\n \\n root = ET.Element(\\\"Document\\\")\\n root.set('xmlns',\\\"urn:iso:std:iso:20022:tech:xsd:pacs.008.001.02\\\")\\n root_fito = ET.SubElement(root, \\\"FIToFICstmrCdtTrf\\\")\\n \\n self.xml_header(root_fito)\\n self.xml_transaction(root_fito)\\n\\n ET.ElementTree(root)\\n \\n return ET.tostring(root,encoding='utf-8',xml_declaration=True).decode('utf-8')\",\n \"def format_xml(self,query_results):\\n results=query_results.data\\n factory=factory_xml()\\n dump=factory.dumps({'data':results})\\n print(dump)\\n # TODO return output for this\\n return \\\"\\\"\",\n \"def get_xml(self):\\n xml = svgwrite.etree.etree.Element(self.elementname)\\n if self.debug:\\n self.validator.check_all_svg_attribute_values(self.elementname, self.attribs)\\n for attribute, value in self.attribs.items():\\n # filter 'None' values\\n if value is not None:\\n value = self.value_to_string(value)\\n if value: # just add not empty attributes\\n xml.set(attribute, value)\\n \\n for element in self.elements:\\n xml.append(element)\\n return xml\",\n \"def xml_to_string(xml_tag):\\n return parseString(ET.tostring(xml_tag)).toprettyxml(indent=\\\" \\\")\",\n \"def xml():\\n response = make_response(render_template(\\\"sample.xml\\\"))\\n response.headers[\\\"Content-Type\\\"] = \\\"application/xml\\\"\\n return response\",\n \"def acceptxml(func):\\n\\n @wraps(func)\\n def return_xml(*args, **kwargs):\\n if request.headers.get('Accept', '*/*') == 'application/xml':\\n return json_toXML(g.payload_json)\\n\\n return return_xml\",\n \"def encode(self):\\n\\n return lxml.etree.tostring(self.get_content(),\\n pretty_print = True,\\n encoding = self.encoding,\\n xml_declaration = True)\",\n \"def xml_string(self):\\n if self._xml_string is not None:\\n return self._xml_string\\n\\n return etree.tostring(self._xml_node)\",\n \"def generateXML(self):\\n return self.formatEval(\\n self.TEMPLATES[self.attrs['name']]['XML'],\\n self.attrs\\n )\",\n \"def toString(doc):\\n return doc.toxml()\",\n \"def definition_to_xml(self, resource_fs):\\r\\n raise NotImplementedError(\\r\\n \\\"%s does not implement definition_to_xml\\\" % self.__class__.__name__)\",\n \"def ConvertToXML (given_dict) :\\r\\n stream_thing = cStringIO.StringIO()\\r\\n WriteToXMLStream(given_dict, stream_thing, 'top')\\r\\n return stream_thing.getvalue()\",\n \"def xml_string(self):\\r\\n if self._xml_string is not None:\\r\\n return self._xml_string\\r\\n\\r\\n return etree.tostring(self._xml_node)\",\n \"def write(doc: Document, encoding='utf8', xml_declaration=True, pretty_print=False) -> bytes:\\n tree = Parser.to_element_tree(doc)\\n return etree.tostring(tree, encoding=encoding, xml_declaration=xml_declaration, pretty_print=pretty_print)\",\n \"def prepare(*args, **kwargs):\\n LOGGER.warning(\\n \\\"readalongs.api.prepare() is deprecated. Please use make_xml() instead.\\\"\\n )\\n return make_xml(*args, **kwargs)\",\n \"def generate(self):\\n xml = self.template()\\n fp = BytesIO()\\n gzip = GzipFile(self.filename, \\\"wb\\\", 9, fp)\\n if isinstance(xml, str):\\n xml = xml.encode(\\\"utf8\\\")\\n gzip.write(xml)\\n gzip.close()\\n data = fp.getvalue()\\n fp.close()\\n return data\",\n \"def getXML(self):\\n\\n def _getElementForMappingEntry(entry, mappingStyle):\\n xmlDocTmp = Document()\\n element = xmlDocTmp.createElement(mappingStyle)\\n for k, v in viewitems(entry):\\n # ignore empty, None or compiled regexp items into output\\n if not v or (k == \\\"path-match-expr\\\"):\\n continue\\n element.setAttribute(k, str(v))\\n return element\\n\\n xmlDoc = Document()\\n root = xmlDoc.createElement(\\\"storage-mapping\\\") # root element name\\n for mappingStyle, mappings in viewitems(self):\\n for mapping in mappings:\\n mapElem = _getElementForMappingEntry(mapping, mappingStyle)\\n root.appendChild(mapElem)\\n return root.toprettyxml()\",\n \"def XMLWriter(\\n fd,\\n encoding=\\\"utf-8\\\",\\n pretty=True,\\n compactempty=True,\\n indentation=_DEFAULT_INDENTATION\\n):\\n return _document(fd, encoding, pretty, compactempty, indentation)\",\n \"def emit_tag(self):\\n root = etree.Element('CdtTrfTxInf')\\n pmtid = etree.SubElement(root, 'PmtId')\\n # etree.SubElement(pmtid, 'InstrId').text = self.tx_id\\n # etree.SubElement(pmtid, 'EndToEndId').text = self.eeid\\n etree.SubElement(pmtid, 'EndToEndId').text = self.creditor.name\\n # info = etree.SubElement(root, 'PmtTpInf')\\n # purp = etree.SubElement(info, 'CtgyPurp')\\n # etree.SubElement(purp, 'Cd').text = self.category\\n amt = etree.SubElement(root, 'Amt')\\n etree.SubElement(\\n amt, 'InstdAmt', attrib={'Ccy': 'EUR'}).text = str(self.amount)\\n if hasattr(self, 'ultimate_debtor'):\\n root.append(self.ultimate_debtor.__tag__('UltmtDbtr'))\\n if self.account.is_foreign() or self.bic:\\n agt = etree.SubElement(root, 'CdtrAgt')\\n agt.append(Bank(bic=self.bic).__tag__())\\n root.append(self.creditor.__tag__('Cdtr'))\\n root.append(self.account.__tag__('CdtrAcct'))\\n if hasattr(self, 'ultimate_creditor'):\\n root.append(self.ultimate_creditor.__tag__('UltmtCdtr'))\\n rmtinf = etree.SubElement(root, 'RmtInf')\\n if hasattr(self, 'rmtinfo'):\\n etree.SubElement(rmtinf, 'Ustrd').text = self.rmtinfo\\n else:\\n etree.SubElement(rmtinf, 'Ustrd').text = ''.join(\\n [str(doc) for doc in self.docs])\\n return root\",\n \"def _ds(elem):\\n _indent(elem)\\n return ElementTree.tostring(elem)\",\n \"def __att_to_xml(self, doc, parent, att_name, att):\\r\\n \\r\\n if att == None:\\r\\n e=doc.createElementNS(None, att_name)\\r\\n parent.appendChild(e)\\r\\n e.appendChild(doc.createTextNode(''))\\r\\n elif type(att) == str or type(att) == unicode or type(att) == int:\\r\\n e=doc.createElementNS(None, att_name)\\r\\n parent.appendChild(e)\\r\\n e.appendChild(doc.createTextNode('%s' % att))\\r\\n #e.setAttributeNS(None, \\\"class\\\", \\\"sample\\\")\\r\\n elif hasattr(att, 'to_xml'):\\r\\n # Looks like an entity object, so call it's to_xml and append it\\r\\n child_frag = att.to_xml(doc)\\r\\n parent.appendChild(child_frag)\\r\\n elif type(att) == list or type(att) == tuple:\\r\\n # Looks like an ordered collection\\r\\n col = doc.createElementNS(None, att_name)\\r\\n parent.appendChild(col)\\r\\n for item in att:\\r\\n self.__att_to_xml(doc, col, att_name, item)\\r\\n elif isinstance(att, dict):\\r\\n # Looks like a dictionary\\r\\n col = doc.createElementNS(None, att_name)\\r\\n parent.appendChild(col)\\r\\n att_keys = att.keys()\\r\\n att_keys.sort()\\r\\n for item in att_keys:\\r\\n self.__att_to_xml(doc, col, item, att[item])\\r\\n else:\\r\\n # Not sure, so treat it like a string\\r\\n e=doc.createElementNS(None, att_name)\\r\\n parent.appendChild(e)\\r\\n e.appendChild(doc.createTextNode('%s' % att))\",\n \"def export(xsd_object, make_pretty=True):\\n buff = StringIO.StringIO()\\n xsd_object.export(\\n buff,\\n 1,\\n namespacedef_='xmlns=\\\"http://zigbee.org/sep\\\" xmlns:xsi=\\\"http://www.w3.org/2001/XMLSchema-instance\\\"',\\n pretty_print=make_pretty\\n )\\n return buff.getvalue()\",\n \"def toXml(self, prefixes=None, closeElement=1, defaultUri='',\\n prefixesInScope=None):\\n s = SerializerClass(prefixes=prefixes, prefixesInScope=prefixesInScope)\\n s.serialize(self, closeElement=closeElement, defaultUri=defaultUri)\\n return s.getValue()\",\n \"def render_to_xml(self, context_dict):\\r\\n # add dummy STATIC_URL to template context\\r\\n context_dict.setdefault(\\\"STATIC_URL\\\", \\\"/dummy-static/\\\")\\r\\n try:\\r\\n xml_str = self.template.render_unicode(**context_dict)\\r\\n except:\\r\\n raise TemplateError(exceptions.text_error_template().render())\\r\\n\\r\\n # Attempt to construct an XML tree from the template\\r\\n # This makes it easy to use XPath to make assertions, rather\\r\\n # than dealing with a string.\\r\\n # We modify the string slightly by wrapping it in <test>\\r\\n # tags, to ensure it has one root element.\\r\\n try:\\r\\n xml = etree.fromstring(\\\"<test>\\\" + xml_str + \\\"</test>\\\")\\r\\n except Exception as exc:\\r\\n raise TemplateError(\\\"Could not parse XML from '{0}': {1}\\\".format(\\r\\n xml_str, str(exc)))\\r\\n else:\\r\\n return xml\",\n \"def convert_dict_to_xml(data_dict):\\n from dicttoxml import dicttoxml\\n\\n return dicttoxml(data_dict, attr_type=False)\",\n \"def xml(self):\\n return parse_xml(self, tab=\\\"\\\\t\\\", id=self.id or \\\"\\\")\",\n \"def CreateXMLTransformer() -> TransformerFunc:\\n return partial(traverse, transformation_table=XML_AST_transformation_table.copy())\",\n \"def toxml(self) -> ET.Element:\\n # Dummy element that ElementTree extend() will strip\\n root = ET.Element('root')\\n\\n connection = ET.SubElement(root, 'Connection')\\n\\n origin = ET.SubElement(connection, 'Origin')\\n origin.set('ToolID', self.origin_tool.tool_id)\\n origin.set('Connection', self.origin_output)\\n\\n destination = ET.SubElement(connection, 'Destination')\\n destination.set('ToolID', self.destination_tool.tool_id)\\n destination.set('Connection', self.destination_input)\\n\\n return root\",\n \"def serialize(self):\\n res = '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>'\\n self.grammar_elem.attr[\\\"xmlns\\\"] = \\\\\\n \\\"http://relaxng.org/ns/structure/1.0\\\"\\n self.grammar_elem.attr[\\\"datatypeLibrary\\\"] = \\\\\\n \\\"http://www.w3.org/2001/XMLSchema-datatypes\\\"\\n for ns in self.namespaces:\\n self.grammar_elem.attr[\\\"xmlns:\\\" + self.namespaces[ns]] = ns\\n res += self.grammar_elem.start_tag()\\n for ch in self.grammar_elem.children:\\n res += ch.serialize()\\n if not self.no_data:\\n res += \\\"<start>\\\" + self.root.serialize() + \\\"</start>\\\"\\n for d in self.defs:\\n res += self.defs[d].serialize()\\n if self.has_anyxml:\\n res += self.anyxml_def\\n return res + self.grammar_elem.end_tag()\",\n \"def adaptXmlToXml(self, *args):\\n return _SALOMERuntime.RuntimeSALOME_adaptXmlToXml(self, *args)\",\n \"def serialize(self):\\n return self.xmlnode.serialize(encoding=\\\"utf-8\\\")\",\n \"def toXML(self):\\n return _libsbml.Layout_toXML(self)\",\n \"def render(self, data, accepted_media_type=None, renderer_context=None):\\n if data is None:\\n return ''\\n\\n stream = StringIO()\\n\\n xml = SimplerXMLGenerator(stream, self.charset)\\n xml.startDocument()\\n #xml.startElement(\\\"root\\\", {})\\n\\n self._to_xml(xml, data)\\n\\n #xml.endElement(\\\"root\\\")\\n xml.endDocument()\\n return stream.getvalue()\",\n \"def saveXml(self, buf: java.lang.StringBuilder) -> None:\\n ...\",\n \"def to_xml(self):\\r\\n element = ET.Element(\\\"node\\\")\\r\\n\\r\\n element.attrib['name'] = self.name\\r\\n element.attrib['description'] = self.description\\r\\n\\r\\n return element\",\n \"def output_xml(data, code, headers=None):\\n response = make_response(simplexml.dumps({'response': data}), code)\\n response.headers.extend(headers or {})\\n return response\",\n \"def datatoxml(data):\\n return dicttoxml.dicttoxml(data,\\n custom_root='records',\\n attr_type=False,\\n item_func=record_to_xml)\",\n \"def to_xml(self, doc = None, output = None, indent = False):\\r\\n \\r\\n # Determine what format to return the values as\\r\\n if output != None and output.lower() != 'str' and output.lower() != 'dom':\\r\\n # Check to see if it's a filepath\\r\\n if output.lower().split('.')[-1] == 'xml':\\r\\n output = os.path.abspath(output)\\r\\n else:\\r\\n raise ValueError('Unrecognized format: %s' % output)\\r\\n \\r\\n # If doc is None, create a document\\r\\n if doc != None:\\r\\n is_root = False\\r\\n else:\\r\\n is_root = True\\r\\n doc = domlette.implementation.createDocument(None, None, None)\\r\\n #doc.publicId = \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\"\\r\\n #doc.systemId = \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\"\\r\\n \\r\\n # Prepare an XML fragment to hold this entity's data\\r\\n frag = doc.createDocumentFragment()\\r\\n frag_root=doc.createElementNS(None, self.__class__.entity_name.lower())\\r\\n frag.appendChild(frag_root)\\r\\n\\r\\n # Append all of the key value pairs \\r\\n for att_name in self.__class__.entity_atts:\\r\\n att = getattr(self, att_name)\\r\\n self.__att_to_xml(doc, frag_root, att_name, att)\\r\\n\\r\\n # Return the result\\r\\n if not is_root:\\r\\n return frag\\r\\n else:\\r\\n # Determine how to return\\r\\n doc.appendChild(frag) \\r\\n if output == None:\\r\\n # Default returns XML as an objectified gnosis object\\r\\n return gnosis.xml.objectify.XML_Objectify(doc, parser='DOM').make_instance()\\r\\n elif output == 'str':\\r\\n # Return as string\\r\\n buf = StringIO()\\r\\n if indent:\\r\\n domlette.PrettyPrint(doc, stream=buf, encoding='us-ascii')\\r\\n else:\\r\\n domlette.Print(doc, stream=buf)\\r\\n xml_string = buf.getvalue()\\r\\n buf.close() \\r\\n return xml_string\\r\\n elif output == 'dom':\\r\\n # Return as a XML Document (Raw DOM)\\r\\n return doc\\r\\n else:\\r\\n f = open(output, 'w')\\r\\n if indent:\\r\\n domlette.PrettyPrint(doc, stream=f)\\r\\n else:\\r\\n domlette.Print(doc, stream=f)\\r\\n f.close()\\r\\n return True\",\n \"def tostring(self, indent: str = '', max_lines: Optional[int] = None,\\n spaces_for_tab: int = 4) -> Union[str, bytes]:\\n return etree_tostring(self.schema_elem, self.namespaces, indent, max_lines, spaces_for_tab)\",\n \"def dumps(records, xslt_filename=None, **kwargs):\\n root = dumps_etree(records=records, xslt_filename=xslt_filename)\\n return etree.tostring(\\n root,\\n pretty_print=True,\\n xml_declaration=True,\\n encoding='UTF-8',\\n **kwargs\\n )\",\n \"def writeXMLDecl(self):\\n return _libsbml.XMLOutputStream_writeXMLDecl(self)\",\n \"def storeAndReturnXML(self):\\n self._storeItems()\\n return self.toXML()\",\n \"def xml(self):\\n raise NotImplementedError('must be implemented by all subclasses')\",\n \"def output_xml(data, code, headers=None):\\r\\n resp = make_response(dumps({'response' :data}), code)\\r\\n resp.headers.extend(headers or {})\\r\\n return resp\",\n \"def file_to_xml(cls, file_object):\\r\\n return etree.parse(file_object, parser=edx_xml_parser).getroot()\",\n \"def format_xml(elem):\\n rough_string = ET.tostring(elem, 'utf-8')\\n reparsed = minidom.parseString(rough_string)\\n return reparsed.toprettyxml(indent=\\\"\\\\t\\\")\",\n \"def prettify(self):\\n reparsed = minidom.parseString(self.tostring())\\n return reparsed.toprettyxml(indent=' ', encoding='utf-8')\",\n \"def start_serialization(self):\\n self.xml = SimplerXMLGenerator(self.stream, self.options.get(\\\"encoding\\\", settings.DEFAULT_CHARSET))\\n self.xml.startDocument()\\n self.xml.startElement(\\\"xliff\\\", {\\n \\\"version\\\": \\\"1.2\\\",\\n \\\"xmlns\\\": \\\"urn:oasis:names:tc:xliff:document:1.2\\\",\\n \\\"xmlns:d\\\": \\\"https://docs.djangoproject.com/\\\"\\n })\",\n \"def pprint_xml(et):\\n \\n return tostring(et, pretty_print=True)\",\n \"def to_xml(self):\\n xml_strings = ['<code_object name=\\\"%s\\\">' % self.name]\\n xml_strings.append(' <type value=\\\"%s\\\" />' % self.object_type)\\n xml_strings.append(' <source>')\\n for source_line in self.source:\\n xml_strings.append(source_line[1])\\n xml_strings.append(' </source>')\\n xml_strings.append('</code_object>')\\n return \\\"\\\".join(xml_strings)\",\n \"def output_xml(data,code,headers=None):\\r\\n resp = make_response(dumps({'response': data}), code)\\r\\n resp.headers.extend(headers or {})\\r\\n return resp\",\n \"def xml(self):\\n xml_string = '<VendorMap>\\\\n'\\n for vendorid, name in self.data.items():\\n xml_string += \\\"<Vendor>\\\\n<Id>{}</Id>\\\\n<Name>{}</Name>\\\\n</Vendor>\\\\n\\\".format(vendorid, name)\\n xml_string += '</VendorMap>\\\\n'\\n return xml_string\",\n \"def xml(self):\\n xml = []\\n xml.append('<?xml version=\\\"1.0\\\" encoding=\\\"%s\\\"?>' % XML_ENCODING.get(self.encoding, self.encoding))\\n xml.append(\\\"<%s>\\\" % XML_TEXT)\\n xml.extend([sentence.xml for sentence in self])\\n xml.append(\\\"</%s>\\\" % XML_TEXT)\\n return \\\"\\\\n\\\".join(xml)\",\n \"def to_xml(self, resource):\\n stream = StringIO.StringIO()\\n stream.write(\\\"<?xml version='1.0' encoding='UTF-8'?>\\\")\\n stream.write('<%s>' % \\\"GpsRO\\\")\\n\\n for item in resource.items():\\n key, value = item\\n if isinstance(value, str) or isinstance(value, unicode):\\n stream.write('\\\\n<%s>%s</%s>' % (key, value, key))\\n else:\\n stream.write('\\\\n<%s>%d</%s>' % (key, value, key))\\n\\n stream.write('\\\\n</%s>' % \\\"GpsRO\\\")\\n stream.seek(0)\\n return stream.read()\",\n \"def get_xml(self):\\n\\t\\treturn cziso.fill_template(self.libvirt, vm_name = self.name,\\n\\t\\t disks=\\\"\\\\n\\\".join(self.disk_xmls), interface=self.iface_xml)\",\n \"def toXML( self, indent = '', **kwargs ) :\\n\\n return( '\\\\n'.join( self.toXMLList( **kwargs ) ) )\",\n \"def to_xml(self, tag='next'):\\n if self.name is not None:\\n elem = cElementTree.Element(tag)\\n name = self.name if self.name else ''\\n elem.set('step', name)\\n for flag in self.flags:\\n elem.append(flag.to_xml())\\n return elem\",\n \"def _generate_xml(self, body, destn_dir, nodes=True):\\n fn = ''.join([random.choice(string.ascii_letters) for _ in range(12)])\\n fn += '.xml'\\n\\n _dir = os.path.dirname(os.path.abspath(__file__))\\n _tmpl = 'multi_node.template' if nodes else 'single_node.template'\\n _env = Environment(autoescape=False,\\n loader=FileSystemLoader(_dir),\\n trim_blocks=False)\\n\\n with open(fn, 'w+') as f:\\n o = _env.get_template(_tmpl).render(body)\\n f.write(o)\\n\\n _d = destn_dir + '/' + fn\\n self._remote_copy(fn, _d)\\n # Remove the XML file created locally\\n os.remove(fn)\\n\\n return _d\",\n \"def toXML(self):\\n item = \\\"<item uid=\\\\\\\"{uid}\\\\\\\" arg=\\\\\\\"{arg}\\\\\\\" valid=\\\\\\\"{valid}\\\\\\\"\\\"\\n if(self.autocomplete!=None):\\n item += \\\" autocomplete=\\\\\\\"{autocomplete}\\\\\\\"\\\"\\n item += \\\">\\\"\\n item += \\\"<title><![CDATA[{title}]]></title>\\\"\\n item += \\\"<subtitle><![CDATA[{subtitle}]]></subtitle>\\\"\\n if (self.icon != None):\\n if(self.icontype != None):\\n item += \\\"<icon type=\\\\\\\"{icontype}\\\\\\\">{icon}</icon>\\\"\\n else:\\n item += \\\"<icon>{icon}</icon>\\\"\\n item += \\\"</item>\\\"\\n return item.format(uid=self.uid,arg=self.arg,valid=\\\"yes\\\" if self.valid else \\\"no\\\",icontype=self.icontype,\\n title=self.title,subtitle=self.subtitle,icon=self.icon,autocomplete=self.autocomplete)\",\n \"def toXML(obj: dict, xsi_namespace=\\\"i\\\") -> str:\\n ATTRIBUTESKEY = \\\"$attributes\\\"\\n NAMESPACEKEY = \\\"$namespace\\\"\\n\\n def tag(\\n name: str, value: str, *, attributes: dict = {}, namespace: str = None\\n ) -> str:\\n \\\"\\\"\\\"Surrounds a string in xml tags\\n\\n Args:\\n name (str): Name of tag\\n value (str): Value of tag\\n attributes (dict, optional): Dict of attributes for xml element. Defaults to {}.\\n namespace (str, optional): Namespace prefix for the tag. Defaults to None.\\n\\n Returns:\\n str: xml string\\n \\\"\\\"\\\"\\n attributes_str = \\\" \\\".join(f'{k}=\\\"{v}\\\"' for k, v in attributes.items())\\n ns = f\\\"{namespace}:\\\" if namespace else \\\"\\\"\\n if attributes_str:\\n attributes_str = \\\" \\\" + attributes_str\\n if value:\\n return f\\\"<{ns}{name}{attributes_str}>{value}</{ns}{name}>\\\"\\n return f\\\"<{ns}{name}{attributes_str} />\\\"\\n\\n def serialize_dict(val: dict, namespace: str = None) -> str:\\n ns = val.pop(NAMESPACEKEY, namespace)\\n return \\\"\\\".join(serialize(k, v, ns) for k, v in val.items())\\n\\n def serialize(name: str, val: Any, namespace: str = None) -> str:\\n \\\"\\\"\\\"Serializes a key value pair into an XML element\\n\\n Args:\\n name (str): Tag name for element\\n val (Any): Value to serialize\\n namespace (str, optional): Namespace to prepend to child tags\\n of value. Defaults to None.\\n\\n Returns:\\n str: XML string\\n \\\"\\\"\\\"\\n t = lambda v, a={}: tag(name, v, attributes=a, namespace=namespace)\\n if isinstance(val, dict):\\n attrs = val.pop(ATTRIBUTESKEY, {})\\n return t(serialize_dict(val, namespace), attrs)\\n if isinstance(val, list):\\n return t(\\\"\\\".join(serialize_dict(v, namespace=namespace) for v in val))\\n elif isinstance(val, bool):\\n return t(str(val).lower())\\n elif val is None:\\n return t(None, {f\\\"{xsi_namespace}:nil\\\": \\\"true\\\"})\\n else:\\n return t(str(val))\\n\\n return serialize_dict(obj)\",\n \"def output_xml(data, code, headers=None):\\n resp = make_response(simplexml_dumps({\\\"response\\\": data}), code)\\n resp.headers.extend(headers or {})\\n return resp\",\n \"def to_xml(self, f=None):\\r\\n if not f:\\r\\n from tempfile import TemporaryFile\\r\\n f = TemporaryFile()\\r\\n print >> f, '<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?>'\\r\\n print >> f, '<Domain id=\\\"%s\\\">' % self.name\\r\\n for item in self:\\r\\n print >> f, '\\\\t<Item id=\\\"%s\\\">' % item.name\\r\\n for k in item:\\r\\n print >> f, '\\\\t\\\\t<attribute id=\\\"%s\\\">' % k\\r\\n values = item[k]\\r\\n if not isinstance(values, list):\\r\\n values = [values]\\r\\n for value in values:\\r\\n print >> f, '\\\\t\\\\t\\\\t<value><![CDATA[',\\r\\n if isinstance(value, unicode):\\r\\n value = value.encode('utf-8', 'replace')\\r\\n else:\\r\\n value = unicode(value, errors='replace').encode('utf-8', 'replace')\\r\\n f.write(value)\\r\\n print >> f, ']]></value>'\\r\\n print >> f, '\\\\t\\\\t</attribute>'\\r\\n print >> f, '\\\\t</Item>'\\r\\n print >> f, '</Domain>'\\r\\n f.flush()\\r\\n f.seek(0)\\r\\n return f\",\n \"def xml2obj(self, src):\\n\\n\\t\\tclass DataNode(object):\\n\\t\\t\\tdef __init__(self):\\n\\t\\t\\t\\tself._attrs = {} # XML attributes and child elements\\n\\t\\t\\t\\tself.data = None # child text data\\n\\n\\t\\t\\tdef __len__(self):\\n\\t\\t\\t\\t# treat single element as a list of 1\\n\\t\\t\\t\\treturn 1\\n\\n\\t\\t\\tdef __getitem__(self, key):\\n\\t\\t\\t\\tif isinstance(key, basestring):\\n\\t\\t\\t\\t\\treturn self._attrs.get(key,None)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\treturn [self][key]\\n\\n\\t\\t\\tdef __contains__(self, name):\\n\\t\\t\\t\\treturn self._attrs.has_key(name)\\n\\n\\t\\t\\tdef __nonzero__(self):\\n\\t\\t\\t\\treturn bool(self._attrs or self.data)\\n\\n\\t\\t\\tdef __getattr__(self, name):\\n\\t\\t\\t\\tif name.startswith('__'):\\n\\t\\t\\t\\t\\t# need to do this for Python special methods???\\n\\t\\t\\t\\t\\traise AttributeError(name)\\n\\t\\t\\t\\treturn self._attrs.get(name,None)\\n\\n\\t\\t\\tdef _add_xml_attr(self, name, value):\\n\\t\\t\\t\\tif name in self._attrs:\\n\\t\\t\\t\\t\\t\\t# multiple attribute of the same name are represented by a list\\n\\t\\t\\t\\t\\t\\tchildren = self._attrs[name]\\n\\t\\t\\t\\t\\t\\tif not isinstance(children, list):\\n\\t\\t\\t\\t\\t\\t\\tchildren = [children]\\n\\t\\t\\t\\t\\t\\t\\tself._attrs[name] = children\\n\\t\\t\\t\\t\\t\\tchildren.append(value)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself._attrs[name] = value\\n\\n\\t\\t\\tdef __str__(self):\\n\\t\\t\\t\\treturn self.data or ''\\n\\n\\t\\t\\tdef __repr__(self):\\n\\t\\t\\t\\titems = sorted(self._attrs.items())\\n\\t\\t\\t\\tif self.data:\\n\\t\\t\\t\\t\\titems.append(('data', self.data))\\n\\t\\t\\t\\treturn u'{%s}' % ', '.join([u'%s:%s' % (k,repr(v)) for k,v in items])\\n\\n\\t\\tclass TreeBuilder(xml.sax.handler.ContentHandler):\\n\\t\\t\\tdef __init__(self):\\n\\t\\t\\t\\tself.stack = []\\n\\t\\t\\t\\tself.root = DataNode()\\n\\t\\t\\t\\tself.current = self.root\\n\\t\\t\\t\\tself.text_parts = []\\n\\t\\t\\t\\tself.publicObjects = {}\\n\\n\\t\\t\\tdef startElement(self, name, attrs):\\n\\t\\t\\t\\tself.stack.append((self.current, self.text_parts))\\n\\t\\t\\t\\tself.current = DataNode()\\n\\t\\t\\t\\tself.text_parts = []\\n\\t\\t\\t\\t# xml attributes --> python attributes\\n\\t\\t\\t\\tfor k, v in attrs.items():\\n\\t\\t\\t\\t\\t# Register PublicObject in lookup map\\n\\t\\t\\t\\t\\tif k == \\\"publicID\\\":\\n\\t\\t\\t\\t\\t\\tself.publicObjects[v] = self.current\\n\\t\\t\\t\\t\\tself.current._add_xml_attr(k, v)\\n\\n\\t\\t\\tdef endElement(self, name):\\n\\t\\t\\t\\ttext = ''.join(self.text_parts).strip()\\n\\t\\t\\t\\tif text:\\n\\t\\t\\t\\t\\tself.current.data = text\\n\\t\\t\\t\\tif self.current._attrs:\\n\\t\\t\\t\\t\\tobj = self.current\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# a text only node is simply represented by the string\\n\\t\\t\\t\\t\\tobj = text or ''\\n\\t\\t\\t\\t\\t# try to store the object as float if possible\\n\\t\\t\\t\\t\\ttry: obj = float(obj)\\n\\t\\t\\t\\t\\texcept: pass\\n\\t\\t\\t\\tself.current, self.text_parts = self.stack.pop()\\n\\t\\t\\t\\tself.current._add_xml_attr(name, obj)\\n\\n\\t\\t\\tdef characters(self, content):\\n\\t\\t\\t\\tself.text_parts.append(content)\\n\\n\\t\\tbuilder = TreeBuilder()\\n\\t\\tif isinstance(src,basestring):\\n\\t\\t\\txml.sax.parseString(src, builder)\\n\\t\\telse:\\n\\t\\t\\txml.sax.parse(src, builder)\\n\\t\\treturn builder\",\n \"def saveToXml(self) -> org.jdom.Element:\\n ...\",\n \"def to_xml(self):\\n\\n xml = '<activity at=\\\"' + self.get_at_as_string() + '\\\" '\\n xml += 'action=\\\"' + self.action + '\\\" '\\n xml += 'actor=\\\"' + self.actor + '\\\" '\\n xml += 'regarding=\\\"' + self.regarding + '\\\" '\\n xml += 'source=\\\"' + self.source + '\\\" ' \\n xml += 'tags=\\\"' + \\\",\\\".join(self.tags) + '\\\" '\\n xml += 'to=\\\"' + self.to + '\\\" '\\n xml += 'url=\\\"' + self.url + '\\\"'\\n\\n if self.body is None:\\n xml += '/>'\\n else:\\n xml += '>'\\n xml += '<payload><body>'\\n xml += self.body\\n xml += '</body>'\\n if self.raw is not None:\\n xml += '<raw>'\\n xml += self.raw\\n xml += '</raw>'\\n xml += '</payload></activity>'\\n return xml\",\n \"def rec_dumps(obj, spaces):\\n\\n nonlocal res\\n\\n if isinstance(obj, str):\\n res.append('{}{}\\\\n'.format(spaces, obj))\\n return\\n\\n # begining tag\\n res.append('{}<{}'.format(spaces, obj['tag']))\\n\\n # attribs\\n for key, value in obj['attribs'].items():\\n res.append(' {}:\\\"{}\\\"'.format(key, value))\\n\\n res.append('>\\\\n')\\n\\n # elements\\n for element in obj['elements']:\\n rec_dumps(element, spaces + delta_indent)\\n\\n # ending tag\\n res.append('{}</{}>\\\\n'.format(spaces, obj['tag']))\",\n \"def to_xml(self):\\r\\n\\t\\ts = \\\"<event>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t<title>\\\" + self.title + \\\"</title>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t<date>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t\\\\t<year>\\\" + str(self.dueDate.year) + \\\"</year>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t\\\\t<month>\\\" + str(self.dueDate.month) + \\\"</month>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t\\\\t<day>\\\" + str(self.dueDate.day) + \\\"</day>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t</date>\\\\n\\\"\\r\\n\\t\\ts += \\\"\\\\t<time>\\\" + str(self.dueTime) + \\\"</time>\\\\n\\\"\\r\\n\\t\\ts += \\\"</event>\\\\n\\\"\\r\\n\\t\\treturn s\",\n \"def dumps_etree(pid, record, **kwargs):\\n from dojson.contrib.to_marc21 import to_marc21\\n from dojson.contrib.to_marc21.utils import dumps_etree\\n\\n return dumps_etree(to_marc21.do(record[\\\"_source\\\"]), **kwargs)\",\n \"def new_xml(self, root_name):\\n\\n self.tree = ET.ElementTree(ET.fromstring('<?xml version=\\\"1.0\\\" encoding=\\\"UTF-8\\\"?><%s></%s>'%(\\n root_name, root_name)))\\n return self.tree.getroot()\",\n \"def xml_prettify(elem):\\n\\n\\tfrom xml.etree import ElementTree\\n\\tfrom xml.dom import minidom\\n\\n\\trough_string = ElementTree.tostring(elem, 'utf-8')\\n\\treparsed = minidom.parseString(rough_string)\\n\\treturn reparsed.toprettyxml(indent=\\\" \\\")\",\n \"def example_xml(example_xml_file):\\n return etree.fromstring(example_xml_file.encode('utf-8'))\",\n \"def pretty_print_content(self):\\n\\n return lxml.etree.tostring(self.get_content(),\\n pretty_print = True,\\n encoding = self.encoding,\\n xml_declaration = True)\",\n \"def maybe_xml_to_string(message, logger=None):\\n if isinstance(message, six.binary_type):\\n # message is returned as binary from pysaml2 in python3\\n message = message.decode('utf-8')\\n message = str(message)\\n try:\\n from defusedxml import ElementTree as DefusedElementTree\\n\\n parser = DefusedElementTree.DefusedXMLParser()\\n xml = DefusedElementTree.XML(message, parser)\\n return DefusedElementTree.tostring(xml)\\n except Exception as exc:\\n if logger is not None:\\n logger.debug(\\\"Could not parse message of type {!r} as XML: {!r}\\\".format(type(message), exc))\\n return message\",\n \"def test_with_no_encoding(self):\\n xml = (\\n u'<?xml version=\\\"1.0\\\"?>'\\n u'<DocRoot>'\\n u'<Elem1>默认جذ</Elem1>'\\n u'<Elem2/>'\\n u'</DocRoot>'\\n )\\n io_string = six.StringIO()\\n self.builder.dom_element.write_doc(io_string, encoding=None)\\n # NOTE Exact test, no encoding of comparison XML doc string\\n self.assertEqual(xml, io_string.getvalue())\",\n \"def __str__(self):\\n result = xml.dom.minidom.parseString(\\n xml.etree.ElementTree.tostring(\\n self.ToXMLElement(), encoding='utf-8')).toprettyxml(indent=' ')\\n\\n return result\",\n \"def pprintXml(et):\\n \\n return tostring(et, pretty_print=True)\",\n \"def adm_to_xml(adm: ADM) -> lxml.etree._Element:\\n audioStreamFormats = AudioStreamFormatWrapper.wrapped_audioStreamFormats(adm)\\n\\n element_types = [\\n (programme_handler.to_xml, adm.audioProgrammes),\\n (content_handler.to_xml, adm.audioContents),\\n (object_handler.to_xml, adm.audioObjects),\\n (channel_format_handler.to_xml, adm.audioChannelFormats),\\n (pack_format_handler.to_xml, adm.audioPackFormats),\\n (stream_format_handler.to_xml, audioStreamFormats),\\n (track_format_handler.to_xml, adm.audioTrackFormats),\\n (track_uid_handler.to_xml, adm.audioTrackUIDs),\\n ]\\n\\n E = ElementMaker(namespace=default_ns, nsmap=default_nsmap)\\n afx = E.audioFormatExtended()\\n\\n for to_xml, elements in element_types:\\n for element in elements:\\n if not element.is_common_definition:\\n to_xml(afx, element)\\n\\n return E.ebuCoreMain(\\n E.coreMetadata(\\n E.format(\\n afx)))\",\n \"def beautify_xml(XML):\\n # convert XML file to modifiable string to beautify it\\n text_string = ET.tostring(XML, encoding='UTF-8', method='xml')\\n \\n # insert line breaks before end of file tag\\n file_string = text_string.replace('</aardvark>', '\\\\n\\\\n</aardvark>')\\n \\n # insert double new line before comments to create\\n # blocks for each command\\n file_string = file_string.replace('<!', '\\\\n\\\\n<!')\\n \\n # insert new line between each set of XML tags\\n file_string = file_string.replace('><', '>\\\\n\\\\t<')\\n \\n # remove header\\n # file_string = file_string.replace('<?xml version=\\\\'1.0\\\\' encoding=\\\\'utf8\\\\'?>\\\\n', '') \\n \\n return file_string\",\n \"def print_xml(self, filename):\\n\\n # TODO: check what happens when input is not an xml file\\n # TODO: add xmldec, processing instructions and comments\\n\\n xml_string = u'' # TODO: use a string buffer\\n offset = 0\\n stack = []\\n\\n for char in self.text:\\n\\n # any tags on the stack that can be closed?\\n (stack, matching) = self._matching_closing_tags(offset, stack, [])\\n for t in matching:\\n xml_string += \\\"</%s>\\\" % t.name\\n\\n # any new opening tags?\\n for t in self.source_tags.opening_tags.get(offset,[]):\\n stack.append(t)\\n xml_string += \\\"<%s%s>\\\" % (t.name, t.attributes_as_string())\\n\\n # any of those need to be closed immediately (non-consuming tags)?\\n (stack, matching) = self._matching_closing_tags(offset, stack, [])\\n for t in matching:\\n xml_string += \\\"</%s>\\\" % t.name\\n\\n xml_string += escape(char)\\n offset += 1\\n\\n fh = open(filename, 'w')\\n fh.write(xml_string.encode('utf-8'))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6391548","0.61091745","0.6022592","0.58278495","0.56610465","0.5652941","0.56497854","0.5648577","0.5553133","0.55280334","0.55280334","0.5448845","0.5372592","0.5368684","0.53555965","0.53358155","0.5322113","0.5322113","0.5310961","0.530388","0.5302422","0.5251348","0.523114","0.51925206","0.51861703","0.5181769","0.5177761","0.51703775","0.5169898","0.5148436","0.5139417","0.5124164","0.5103655","0.50721836","0.5071795","0.50705904","0.5046064","0.50406414","0.50210786","0.5011947","0.5009305","0.50062096","0.5003221","0.49983367","0.49833888","0.4980139","0.49775752","0.49704164","0.4944752","0.49154538","0.49020827","0.4901987","0.49015397","0.4898647","0.48825017","0.48765156","0.48698664","0.48590106","0.48554233","0.48401183","0.48393562","0.48378286","0.48367372","0.48362952","0.4828618","0.48149863","0.4812506","0.48075798","0.48060465","0.48013586","0.4791029","0.478785","0.47862518","0.47842425","0.47771606","0.4774042","0.4773263","0.47644135","0.47576427","0.4751223","0.47486565","0.47455347","0.47447821","0.47418126","0.4736863","0.47353318","0.47333282","0.47324714","0.4729627","0.471935","0.47105318","0.46927708","0.46874583","0.4679797","0.4678767","0.46735477","0.46572578","0.46572173","0.4654464","0.46544558","0.46475446"],"string":"[\n \"0.6391548\",\n \"0.61091745\",\n \"0.6022592\",\n \"0.58278495\",\n \"0.56610465\",\n \"0.5652941\",\n \"0.56497854\",\n \"0.5648577\",\n \"0.5553133\",\n \"0.55280334\",\n \"0.55280334\",\n \"0.5448845\",\n \"0.5372592\",\n \"0.5368684\",\n \"0.53555965\",\n \"0.53358155\",\n \"0.5322113\",\n \"0.5322113\",\n \"0.5310961\",\n \"0.530388\",\n \"0.5302422\",\n \"0.5251348\",\n \"0.523114\",\n \"0.51925206\",\n \"0.51861703\",\n \"0.5181769\",\n \"0.5177761\",\n \"0.51703775\",\n \"0.5169898\",\n \"0.5148436\",\n \"0.5139417\",\n \"0.5124164\",\n \"0.5103655\",\n \"0.50721836\",\n \"0.5071795\",\n \"0.50705904\",\n \"0.5046064\",\n \"0.50406414\",\n \"0.50210786\",\n \"0.5011947\",\n \"0.5009305\",\n \"0.50062096\",\n \"0.5003221\",\n \"0.49983367\",\n \"0.49833888\",\n \"0.4980139\",\n \"0.49775752\",\n \"0.49704164\",\n \"0.4944752\",\n \"0.49154538\",\n \"0.49020827\",\n \"0.4901987\",\n \"0.49015397\",\n \"0.4898647\",\n \"0.48825017\",\n \"0.48765156\",\n \"0.48698664\",\n \"0.48590106\",\n \"0.48554233\",\n \"0.48401183\",\n \"0.48393562\",\n \"0.48378286\",\n \"0.48367372\",\n \"0.48362952\",\n \"0.4828618\",\n \"0.48149863\",\n \"0.4812506\",\n \"0.48075798\",\n \"0.48060465\",\n \"0.48013586\",\n \"0.4791029\",\n \"0.478785\",\n \"0.47862518\",\n \"0.47842425\",\n \"0.47771606\",\n \"0.4774042\",\n \"0.4773263\",\n \"0.47644135\",\n \"0.47576427\",\n \"0.4751223\",\n \"0.47486565\",\n \"0.47455347\",\n \"0.47447821\",\n \"0.47418126\",\n \"0.4736863\",\n \"0.47353318\",\n \"0.47333282\",\n \"0.47324714\",\n \"0.4729627\",\n \"0.471935\",\n \"0.47105318\",\n \"0.46927708\",\n \"0.46874583\",\n \"0.4679797\",\n \"0.4678767\",\n \"0.46735477\",\n \"0.46572578\",\n \"0.46572173\",\n \"0.4654464\",\n \"0.46544558\",\n \"0.46475446\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":88398,"cells":{"query":{"kind":"string","value":"in this page teacher can see all of the forum posts"},"document":{"kind":"string","value":"def teacher_forum_landing_page(request, page):\n # Deleting admin-typed user session\n # Deleting programmer-typed-user session\n\n # Get the current users\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\n\n current_basic_user_profile = get_current_user_profile(\n request,\n User,\n BasicUserProfile,\n ObjectDoesNotExist\n )\n\n # Getting the teacher profile\n current_teacher_profile = get_current_teacher_user_profile(\n request,\n User,\n TeacherUserProfile,\n ObjectDoesNotExist\n )\n\n # getting the page posts\n # At every page there will be 45 entries so always multiply it by that and\n # then reduce your objects\n current_page = page\n previous_page = page-1\n next_page = page+1\n\n post_records_starting_point = current_page * 46\n post_records_ending_point = post_records_starting_point + 46\n\n try:\n current_page_posts = TeacherForumPost.objects.all().order_by(\"-id\")[post_records_starting_point:post_records_ending_point]\n except ObjectDoesNotExist:\n current_page_posts = None\n\n # getting posts comment count\n page_comments = {}\n for post in current_page_posts:\n comments = TeacherForumComment.objects.filter(post=post)\n comment_count = 0\n for comment in comments:\n comment_count += 1\n page_comments[post.id] = comment_count\n\n # post upvote form processing\n if request.POST.get(\"teacher_forum_landing_upvote_submit\"):\n hidden_post_id = request.POST.get(\"hidden_post_id\")\n post = TeacherForumPost.objects.get(id=hidden_post_id)\n # upvote the post\n post.karma += 1\n post.save()\n return HttpResponseRedirect(\"/teacher/forum/read/\"+str(post.id)+\"/\")\n\n data = {\n \"current_basic_user\": current_basic_user,\n \"current_basic_user_profile\": current_basic_user_profile,\n \"current_teacher_profile\": current_teacher_profile,\n \"current_page_posts\": current_page_posts,\n \"current_page\": current_page,\n \"previous_page\": previous_page,\n \"next_page\": next_page,\n \"current_page_posts\": current_page_posts,\n \"page_comments\": page_comments,\n }\n\n if \"teacher_user_logged_in\" in request.session:\n return render(request, \"teacher_forum/landing_page.html\", data)\n else:\n return HttpResponseRedirect(\"/\")"},"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 post_list(request):\n\timage_post_list = list(ImagePost.objects.all())\n\tvideo_post_list = list(VideoPost.objects.all())\n\tall_post = image_post_list + video_post_list\n\treturn render(request,'devblog/post_list.html', {'posts':all_post})","def view_blog(self):","def forum(request, forum_id):\n topics = Topic.objects.filter(forum=forum_id).order_by(\"-created\")\n topics = mk_paginator(request, topics, DJANGO_SIMPLE_FORUM_TOPICS_PER_PAGE)\n\n forum = get_object_or_404(Forum, pk=forum_id)\n\n return render_to_response(\"forum/forum.html\", add_csrf(request, topics=topics, pk=forum_id, forum=forum),\n context_instance=RequestContext(request))","def my_posttopic_list(request, show_user=False):\n\tif not show_user:\n\t\tshow_user = str(request.user)\n\ttry:\n\t\ttopics = Post.objects.order_by('-post_date').filter(post_author=show_user).values('post_topic').distinct()[:50]\n\t\tposts = []\n\t\tfor i in topics:\n\t\t\tposts.append(int(i['post_topic']))\n\t\ttopics = Topic.objects.order_by('-topic_modification_date').filter(id__in=posts)\n\t\tfor i in topics:\n\t\t\tpmax = i.post_set.all().count()/10\n\t\t\tpmaxten = i.post_set.all().count()%10\n\t\t\tif pmaxten != 0:\n\t\t\t\ti.pagination_max = pmax+1\n\t\t\telse:\n\t\t\t\ti.pagination_max = pmax\n\t\tforum_name = _('User Posts in Latest Topics')\n\texcept:\n\t\treturn render_to_response('myghtyboard/mytopics_list.html', {'perms': list_perms(request)}, context_instance=RequestContext(request))\n\treturn render_to_response(\n\t\t'myghtyboard/mytopics_list.html',\n\t\t{'topics': topics, 'forum_name': forum_name, 'perms': list_perms(request)},\n\t\tcontext_instance=RequestContext(request))","def __getThreadPage( self ):\r\n threads = [x.findParent('tr') for x in self.soup.findAll('td','tbl_forum_thread')]\r\n if len(threads )==0:\r\n log.info(self.log_msg('No threads are found'))\r\n return False\r\n for thread in threads:\r\n self.total_posts_count = self.total_posts_count + 1\r\n try:\r\n thread_info = thread.find('td','tbl_forum_thread').findAll('a')\r\n date_str = stripHtml(thread_info[-1].next.next.__str__())\r\n thread_time = datetime.strptime(date_str,'on %B %d, %Y')\r\n except:\r\n log.exception(self.log_msg('Date cannot found, continue with other posts'))\r\n continue\r\n if self.total_posts_count > self.max_posts_count:\r\n log.info(self.log_msg('Reaching maximum post,Return false'))\r\n return False\r\n try:\r\n if checkSessionInfo('Search',self.session_info_out, thread_time,\\\r\n self.task.instance_data.get('update')):\r\n continue\r\n self.last_timestamp = max(thread_time , self.last_timestamp )\r\n temp_task=self.task.clone()\r\n try:\r\n title_tag = thread.find('h2')\r\n temp_task.pagedata['title']= stripHtml(title_tag.renderContents())\r\n temp_task.instance_data[ 'uri' ] = 'http://silverlight.net' + title_tag.find('a')['href']\r\n temp_task.pagedata['et_author_name'] = stripHtml(thread.find('p').find('a').renderContents())\r\n temp_task.pagedata['et_thread_last_post_author'] = stripHtml(thread_info[-1].renderContents())\r\n view_reply = {'ei_thread_num_replies':'tbl_forum_views','ei_thread_num_views':'tbl_forum_replies'}\r\n for each in view_reply.keys():\r\n temp_task.pagedata[each] = int(re.sub('[^\\d]','',stripHtml(thread.find('td',view_reply[each]).renderContents())))\r\n temp_task.pagedata['edate_last_post_date']= datetime.strftime(thread_time,\"%Y-%m-%dT%H:%M:%SZ\")\r\n except:\r\n log.exception(self.log_msg('Cannot find the uri'))\r\n continue\r\n try:\r\n temp_task.pagedata['ef_thread_rating']= float(re.search('\\[([^ ]+)',thread.find('span','ForumThreadRateControl star_ratings')['title']).group(1))\r\n except:\r\n log.info(self.log_msg('Thread rating not found'))\r\n self.linksOut.append( temp_task )\r\n log.info(self.log_msg('Task added'))\r\n except:\r\n log.info(self.log_msg('Cannot add the Task'))\r\n return True","def post_list(request, topic_id, pagination_id):\n\ttry:\n\t\ttopic = Topic.objects.get(id=topic_id)\n\texcept Topic.DoesNotExist:\n\t\treturn HttpResponseRedirect('/forum/')\n\tif topic.is_locked:\n\t\topened = False\n\telse:\n\t\topened = True\n\treturn object_list(\n\t\trequest,\n\t\ttopic.post_set.all().order_by('post_date'),\n\t\tpaginate_by = 10,\n\t\tpage = pagination_id,\n\t\textra_context = {\n\t\t\t'topic_id':topic_id,\n\t\t\t'opened': opened,\n\t\t\t'topic': topic.topic_name,\n\t\t\t'forum_id': topic.topic_forum.id,\n\t\t\t'forum_name': topic.topic_forum,\n\t\t\t'perms': list_perms(request),\n\t\t\t'current_user': str(request.user)},\n\t\ttemplate_name = 'myghtyboard/post_list.html')","def teacher_forum_read(request, post_id):\n # Deleting admin-typed user session\n # Deleting programmer-typed-user session\n\n # Get the current users\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\n\n current_basic_user_profile = get_current_user_profile(\n request,\n User,\n BasicUserProfile,\n ObjectDoesNotExist\n )\n\n # Getting the teacher profile\n current_teacher_profile = get_current_teacher_user_profile(\n request,\n User,\n TeacherUserProfile,\n ObjectDoesNotExist\n )\n\n # Get the current post\n try:\n current_post = TeacherForumPost.objects.get(id=post_id)\n except ObjectDoesNotExist:\n current_post = None\n\n # if the post id is not existing redirect to 404\n if current_post == None:\n return HttpResponseRedirect(\"/404/\")\n\n # check if the post is owned by the current user if it is pass it on to\n # the template logic\n current_user_is_teacher = False\n if current_post.teacher == current_teacher_profile:\n current_user_is_teacher = True\n\n # current post upvote form processing\n if request.POST.get(\"teacher_forum_read_post_upvote_btn\"):\n current_post.karma += 1\n current_post.save()\n\n # current post downvote form processing\n if request.POST.get(\"teacher_forum_read_post_downvote_btn\"):\n current_post.karma -= 1\n current_post.save()\n\n # get all the coments\n try:\n all_post_comments = TeacherForumComment.objects.filter(\n post=current_post\n ).order_by(\"-id\")\n except ObjectDoesNotExist:\n all_post_comments = None\n\n # comment upote form processing\n if request.POST.get(\"teacher_forum_comment_upvote_submit\"):\n hidden_comment_id = request.POST.get(\"hidden_comment_id\")\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\n current_comment.karma += 1\n current_comment.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n # comment downvote form processing\n if request.POST.get(\"teacher_forum_comment_downvote_submit\"):\n hidden_comment_id = request.POST.get(\"hidden_comment_id\")\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\n current_comment.karma -= 1\n current_comment.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n # comment create form processing\n if request.POST.get(\"teacher_forum_comment_subtmit_btn\"):\n comment_content = request.POST.get(\"comment_content\")\n # check if it is empty\n if bool(comment_content) == False or comment_content == \"\":\n pass\n else:\n new_comment = TeacherForumComment(\n teacher=current_teacher_profile,\n post=current_post,\n content=comment_content\n )\n new_comment.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n # Delete the post and its comments form processing\n if request.POST.get(\"teacher_forum_delete_post_submit\"):\n # check if the current user is the owner\n if current_post.teacher == current_teacher_profile:\n # delete the ppost\n current_post.delete()\n # delete all the comments\n all_post_comments.delete()\n # redirect to landing page\n return HttpResponseRedirect(\"/teacher/forum/0/\")\n else:\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n data = {\n \"current_basic_user\": current_basic_user,\n \"current_basic_user_profile\": current_basic_user_profile,\n \"current_teacher_profile\": current_teacher_profile,\n \"current_post\": current_post,\n \"current_user_is_teacher\": current_user_is_teacher,\n \"all_post_comments\": all_post_comments,\n }\n\n if \"teacher_user_logged_in\" in request.session:\n return render(request, \"teacher_forum/read.html\", data)\n else:\n return HttpResponseRedirect(\"/\")","def show_all_posts():\n post = Post.query.all()\n\n return render_template('all-posts.html', post=post)","def topic_recent(request):\n posts = Post.objects.all().order_by(\"-created\")[:3]\n posts = mk_paginator(request, posts, DJANGO_SIMPLE_FORUM_REPLIES_PER_PAGE)\n # topic = Topic.objects.get(pk=topic_id)\n return render_to_response(\"forum/topic_recent.html\", add_csrf(request, posts=posts), context_instance=RequestContext(request))","def education_post_list(request):\n posts = EducationBlogPost.objects.filter(published_date__lte=timezone.now()\n ).order_by('-published_date')\n return render(request, \"education_center/education_blogposts.html\", {'posts': posts})","def get(self):\n\n self.render_posts()","def __addThreadAndPosts(self):\n try:\n self.genre = \"Review\"\n self.__hierarchy = []\n self.__baseuri = 'http://broncosfreaks.com/forums/'\n self.__task_elements_dict = {\n 'priority':self.task.priority,\n 'level': self.task.level,\n 'last_updated_time':datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\"),\n 'pickup_date':datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\"),\n 'connector_instance_log_id': self.task.connector_instance_log_id,\n 'connector_instance_id':self.task.connector_instance_id,\n 'workspace_id':self.task.workspace_id,\n 'client_id':self.task.client_id,\n 'client_name':self.task.client_name,\n 'versioned':False,\n 'category':self.task.instance_data.get('category',''),\n 'task_log_id':self.task.id }\n self.__setSoupForCurrentUri()\n self.__setParentPage()\n question_post = self.soup.find('div', id=re.compile('^edit.*?'))\n self.__addPost(question_post, True)\n self.__goToLastPage() \n while self.__iteratePosts():\n try:\n next_page_uri = self.soup.find('a', text='<',rel='prev').parent['href']\n data_dict = dict(parse_qsl(next_page_uri.split('?')[-1]))\n if 's' in data_dict.keys():\n data_dict.pop('s')\n self.currenturi = self.__baseuri + 'showthread.php?'+ urlencode(data_dict) \n self.__setSoupForCurrentUri()\n except:\n log.exception(self.log_msg('Next Page link not found for url \\\n %s'%self.currenturi))\n break\n return True\n \n\n \"\"\"#try: \n # question_post = self.soup.find('div', id=re.compile ('^edit\\d+'))\n #except:\n # log.info(self.log_msg('Question post cannot be added'))\n #main_page_soup = copy.copy(self.soup)\n # self.__addPost(question_post, True)\n except:\n log.info(self.log_msg('page not added'))\n self.__goToLastPage(main_page_soup)\n while True:\n main_page_soup = copy.copy(self.soup)\n #log.info(self.log_msg('Question post cannot be added'))\n if not self.__iteratePosts():\n break\n try:\n self.currenturi = main_page_soup.find('a',text='<').parent['href']\n log.info(self.log_msg('uri %s'%self.currenturi)) \n except:\n \n log.info(self.log_msg('No Previous URL found for url \\\n %s'%self.currenturi))\n break\n return True\n \"\"\" \n \n \n except:\n log.exception(self.log_msg('Exception while add the theread posts \\\n for the url %s'%self.currenturi))\n return False","def posts_list(request):\n\n # recupera posts\n posts = Post.objects.select_related(\"owner\").filter(Q(publish_at__lte=now())).all()\n categorias = Categoria.objects.all()\n\n # prepara el contexto de la plantilla\n context = {\n 'post_objects': posts,\n 'categoria_objects': categorias\n }\n\n # renderiza y devuelve la plantilla\n return render(request, 'blogs/inicio.html', context)","def forums(self):\r\n return forums.Forums(self)","def home(request):\n context_dict = {}\n categories = []\n general_category = Category.objects.get_or_create(name=\"General Discussion\")[0]\n if general_category:\n categories_qs = Category.objects.exclude(slug=\"general-discussion\").annotate(num_threads=Count('thread')).order_by('-num_threads')\n top_threads = {}\n for category in chain([general_category], categories_qs):\n categories.append(category)\n top_threads[str(category.pk)] = [[thread, str(thread.post_set.count() - 1)] for thread in Thread.objects.filter(category=category, visible=True).order_by('-last_modified')[:2]]\n context_dict['categories'] = categories\n context_dict['top_threads'] = top_threads\n if request.user.is_authenticated():\n member = Member.objects.get(user=request.user)\n if member:\n context_dict['member'] = member\n return render(request, 'home.html', context_dict)\n else:\n return server_error(request)","def get_threads(self):\n page = self.course.moodle.fetch(\n self._view_url % self.id,\n None\n )\n bs = bs4.BeautifulSoup(page.text, 'lxml')\n\n table = bs.find('table', class_='forumheaderlist')\n posts = table.find_all('tr', class_='discussion')\n\n data = []\n for p in posts:\n topiccell = p.find('td', class_='topic starter')\n topic = topiccell.find('a').text\n url = topiccell.find('a')['href']\n groupcell = p.find('td', class_=\"picture group\")\n if groupcell.text:\n groupname = groupcell.find('a').text\n else:\n groupname = None\n\n data.append((topic, url, groupname))\n\n return data","def get(self):\n\n page = self.request.get('page')\n if page:\n page = int(page)\n else:\n page = 1\n limit = 10\n offset = limit * (page - 1)\n\n my_posts = Post.all().order('-created').filter('user =', self.user)\n\n number_posts = my_posts.count()\n total_pages = number_posts / limit\n if number_posts % limit:\n total_pages += 1\n\n posts = my_posts.fetch(limit=limit, offset=offset)\n self.render('mypost.html', posts=posts, page=page,\n total_pages=total_pages, user=self.user)","def get(self, request, *args, **kwargs):\n my_normal_post_lists = NormalPosts.objects.filter(uploded_by=request.user.normalprofile).order_by(\"-id\")\n return render(request, self.template_name, {\n 'my_normal_post_lists': my_normal_post_lists,\n })","def get(self, request):\n #all_posts = Post.objects.all()\n #self.context['posts'] = all_posts\n return render(request, self.template, self.context)","def get(self):\n # posts = db.GqlQuery(\"select * from Post order by created desc limit 10\")\n posts = greetings = Post.all().order('-created')\n self.render('front.html', posts = posts)","def post(self):\n subject = self.request.get('subject')\n content = self.request.get('post_content')\n post_id = self.request.get('post_id')\n post = Posts.get_by_id(int(post_id))\n user = self.get_active_user()\n user_id = int(user.key().id())\n\n if post and user and subject and content:\n if post.submitter_id == user_id:\n self.render_editpage(user, post_id, subject, content)\n else:\n self.render_improper_access()\n else:\n self.error(500)","def comunicado(request):\n forums = Forum.objects.all()\n count = forums.count()\n discussions = []\n for i in forums:\n discussions.append(i.discussion_set.all())\n\n context = {\n 'forums': forums,\n 'count': count,\n 'discussions': discussions\n }\n\n return render(request, 'comunicado/comunicado.html', context)","def __getThreads(self):\n threads = self.soup.find('div', 'fp_left').findAll('div', attrs={'class':re.compile('fp_topic_')}, recursive=False)\n if not threads:\n log.info(self.log_msg('No threads are found for url %s'%\\\n self.currenturi))\n return False\n for thread in threads[1:]:\n self.__current_thread_count += 1\n if self.__current_thread_count > self.__max_threads_count:\n log.info(self.log_msg('Reaching maximum post,Return false \\\n from the url %s'%self.currenturi))\n return False\n \n try:\n date_str = stripHtml(thread.find('span', 'fp_last_post_time').renderContents())\n thread_time = datetime.strptime(date_str, 'Last post: %m-%d-%Y %H:%M%p')\n except:\n log.exception(self.log_msg('Cannot fetch the date for the url\\\n %s'%self.currenturi))\n continue\n if checkSessionInfo('Search', self.session_info_out, thread_time,\\\n self.task.instance_data.get('update')):\n log.info(self.log_msg('Session info Returns True for url %s'%self.currenturi))\n return False\n self.__last_timestamp = max(thread_time , self.__last_timestamp )\n temp_task = self.task.clone() \n try:\n temp_task.instance_data['uri'] = thread.find('a', 'topictitle')['href']\n except:\n log.exception(self.log_msg('Cannot find the thread url \\\n in the uri %s'%self.currenturi))\n continue\n temp_task.pagedata['edate_last_post_date']= datetime.\\\n strftime(thread_time,\"%Y-%m-%dT%H:%M:%SZ\")\n last_post_author = thread.find('div', 'fp_topic_last_post_author', title=True)\n if last_post_author:\n temp_task.pagedata['et_thread_last_post_author'] = last_post_author['title']\n try:\n author_tag = thread.find('span', 'fp_topic_author')\n author_name_tag = author_tag.span.extract()\n temp_task.pagedata['et_author_name'] = stripHtml(author_name_tag.renderContents())\n except:\n log.info(self.log_msg('Author name not found in url %s'%self.currenturi))\n try:\n temp_task.pagedata['ei_thread_views_count'] = int(stripHtml(author_tag.renderContents()).replace(',', '').replace('views',''))\n except:\n log.info(self.log_msg('Views count not found in the url\\\n %s'%self.currenturi))\n try:\n replies_str = stripHtml(thread.find('div', 'fp_topic_content_replies').renderContents()).replace(',', '')\n if re.match('\\d+', replies_str):\n temp_task.pagedata['ei_thread_replies_count'] = int(replies_str)\n except:\n log.exception(self.log_msg('Replies count not found in the url\\\n %s'%self.currenturi))\n self.linksOut.append(temp_task)\n return True","def __addThreadAndPosts(self):\n self.__genre = \"Review\"\n self.__hierarchy = []\n self.__baseuri = 'http://forums.seagate.com'\n self.__task_elements_dict = {\n 'priority':self.task.priority,\n 'level': self.task.level,\n 'last_updated_time':datetime.strftime(datetime.utcnow()\n , \"%Y-%m-%dT%H:%M:%SZ\"), \n 'pickup_date':datetime.strftime(datetime.utcnow(), \n \"%Y-%m-%dT%H:%M:%SZ\"), \n 'connector_instance_log_id': \\\n self.task.connector_instance_log_id, \n 'connector_instance_id':\n self.task.connector_instance_id, \n 'workspace_id':self.task.workspace_id, \n 'client_id':self.task.client_id, \n 'client_name':self.task.client_name, \n 'versioned':False, \n 'category':self.task.instance_data.get('category',''), \n 'task_log_id':self.task.id }\n self.__setParentPage()\n question_post = self.soup.find('div', 'lia-message-view')\n self.__addPost(question_post, True)\n self.__goToLastPage()\n while self.__iteratePosts():\n try:\n self.currenturi = self.__baseuri + self.soup.find('span', \\\n 'lia-paging-page-link', text='Previous').findParent('a')\\\n ['href'].split(';')[0]\n self.__setSoupForCurrentUri()\n except:\n log.info(self.log_msg('No Previous URL found for url \\\n %s'%self.currenturi))\n break\n return True","def index(request, archive=False):\n context = {'archive':archive}\n posts = Post.objects.all()\n if not archive:\n posts = posts[:10]\n context['posts'] = posts\n if request.user.is_authenticated():\n #These are the new news items the logged in user has\n context['new_posts'] = NewBlog.objects.filter(user=request.user)\n return render(request, 'blog/index.html', context)","def topic_list(request, forum_id, pagination_id=1):\n\ttry:\n\t\ttopics = Topic.objects.order_by('-is_global', '-is_sticky', '-topic_modification_date').filter(Q(topic_forum=forum_id) | Q(is_global='1'))\n\t\tforum_name = Forum.objects.get(id=forum_id)\n\t\tforum_name = forum_name.forum_name\n\texcept:\n\t\treturn HttpResponseRedirect('/forum/')\n\treturn object_list(\n\t\trequest,\n\t\tTopic.objects.order_by('-is_global', '-is_sticky', '-topic_modification_date').filter(Q(topic_forum=forum_id) | Q(is_global='1')),\n\t\tpaginate_by = 10,\n\t\tallow_empty = True,\n\t\tpage = pagination_id,\n\t\textra_context = {'forum': forum_id, 'perms': list_perms(request), 'forum_name': forum_name},\n\t\ttemplate_name = 'myghtyboard/topics_list.html')","def latest_blog_posts(self, request, *args, **kwargs):\n context = self.get_context(request, *args, **kwargs)\n context[\"latest_posts\"] = MyblogDetailPage.objects.live().public()[:1] \n return render(request, \"myblog/latest_posts.html\", context)","def get_posts(self): #return list of posts that are associated with this blog_id\n return Post.find_posts_for_blog_id(self.blog_id) #this will return a list of posts objects","def list(self, request):\n # Get all Post records from the database\n posts = Post.objects.all()\n \n \n\n # Support filtering Posts by type\n # http://localhost:8000/Posts?type=1\n #\n # That URL will retrieve all tabletop Posts\n \n\n category = self.request.query_params.get('category', None)\n if category is not None:\n posts = posts.filter(category__id=category)\n \n user = RareUser.objects.get(user=request.auth.user)\n active = self.request.query_params.get('active', None)\n my_subscriptions=Subscription.objects.filter(follower_id=user.id)\n # print(my_subscriptions)\n \n if active is not None:\n print(\"my post navbar is being clicked\")\n # 1)get the posts where the user on the post equals the id on the user\n\n # 2)get the subscriptions where the follower on the subscription equals the id on the user\n # 3)get the posts where the user on the post equals the author in the subscription\n\n home_page_posts=[]\n\n followed_users=RareUser.objects.filter(rareusers_author__follower=user)\n for author in followed_users:\n subscribed_post=list(posts.filter(user=author))\n home_page_posts=home_page_posts+subscribed_post\n\n only_my_posts = list(posts.filter(user__id=user.id))\n home_page_posts=home_page_posts+only_my_posts\n\n # for subscription in my_subscriptions:\n \n # subscribed_post=posts.filter(user__id=subscription.author_id)\n # # my_list.append(subscribed_post)\n # # print(subscribed_post)\n # # my_list.append(only_my_posts)\n \n posts=home_page_posts\n \n \n users = self.request.query_params.get('user', None)\n if users is not None:\n \n posts = posts.filter(user__id=user)\n \n\n title = self.request.query_params.get('title', None)\n if title is not None:\n posts = posts.filter(title__contains=title)\n\n # subscribers=Subscription.objects.filter(follower=user.id)\n # for subscriber in subscribers:\n # subscriptionPosts=posts.filter(user=subscriber.author)\n # posts.append(subscriptionPosts)\n\n for post in posts:\n if post.user == user:\n post.my_post =True\n else:\n post.my_post =False\n\n \n\n serializer = PostSerializer(\n posts, many=True, context={'request': request})\n\n return Response(serializer.data)","def test_discussion_filter_forum(self):\n forum1 = ForumFactory(name=u'Forum 1')\n thread1 = ThreadFactory(forum=forum1, title=u'audio 1')\n PostFactory(thread=thread1)\n\n forum2 = ForumFactory(name=u'Forum 2')\n thread2 = ThreadFactory(forum=forum2, title=u'audio 2')\n PostFactory(thread=thread2)\n\n self.refresh()\n\n qs = {'a': 1, 'w': 4, 'format': 'json'}\n\n for forum_id in (forum1.id, forum2.id):\n qs['forum'] = int(forum_id)\n response = self.client.get(reverse('search.advanced'), qs)\n eq_(json.loads(response.content)['total'], 1)","def posts_per_topic_all(request, pk):\n #update is_expired in all posts\n update_posts_expiration()\n #get all posts with a certain topic\n posts = Post.objects.filter(topic=pk)\n serializer = ViewPostSerializer(posts, many=True)\n return Response(serializer.data)","def topic(request, topic_id):\n posts = Post.objects.filter(topic=topic_id).order_by(\"created\")\n posts = mk_paginator(request, posts, DJANGO_SIMPLE_FORUM_REPLIES_PER_PAGE)\n topic = Topic.objects.get(pk=topic_id)\n return render_to_response(\"forum/topic.html\", add_csrf(request, posts=posts, pk=topic_id,\n topic=topic), context_instance=RequestContext(request))","def list_posts(request):\n if request.method == 'POST':\n category = request.POST.get('category', False)\n posts = Post.objects.select_related('author')\\\n .filter(category=category)\\\n .order_by('-modified')\n # import pdb; pdb.set_trace()\n return render(request, 'posts/index.html',\n {'posts': posts})\n\n posts = Post.objects.select_related('author').order_by('-modified')\n likes = Likes.objects.select_related('post')\n\n return render(request, 'posts/index.html',\n {'posts': posts})","def feed(request):\n followers = request.user.profile.followers.values_list('pk', flat=True)\n posts = Post.objects.filter(author_id__in=followers)\n\n return render(request,\n 'posts/feed.html',\n {'posts': posts})","def profile(request):\n bugs = Bug.objects.filter(author=request.user)\n features = Feature.objects.filter(author=request.user)\n posts = ForumPost.objects.filter(author=request.user)\n return render(request, 'profile.html', {'bugs': bugs,\n 'features': features,\n 'posts': posts})","def find_posts_by_targetuser(self):\n\n if not self.threads:\n raise Exception('No threads present in class. ' +\n 'Run find_threads_on_board first.')\n\n title_strip_text = ' - Current Events Message Board - GameFAQs'\n post_bodies = []\n page_counter = 0\n total_pages = len(self.threads)\n for thread in self.threads:\n thread_url = thread[0]\n resp = self.session.get(thread_url)\n thread_pages = self.find_num_pages(resp.text)\n total_pages += thread_pages - 1\n soup = bs(resp.text, 'html.parser')\n postbody = ''\n\n for page in range(thread_pages):\n page_counter += 1\n logging.debug('Loading page {} of {}'\n .format(page_counter, total_pages))\n if page > 0:\n thread_url = thread[0] + '?page={}'.format(page)\n resp = self.session.get(thread_url)\n soup = bs(resp.text, 'html.parser')\n # If target user exists anywhere in page.\n if soup.find_all(string=self.targetuser):\n # Find all posts created by target user.\n for post in soup.find_all(string=self.targetuser):\n for parent in post.parents:\n if parent.name == \"td\" and parent['class'][0] == 'msg':\n # Find post time, replace &nsbp with\n # a normal space.\n post_time_str = parent.find('span', class_='post_time')['title']\\\n .replace(u'\\xa0', ' ')\n # Convert string time to datetime.\n post_time_dt = datetime.strptime(post_time_str, '%m/%d/%Y %I:%M:%S %p')\n # If post is newer than last time checked.\n # if True: # <-- Used for debugging.\n if self.last_time_checked < post_time_dt:\n logging.info('Post Found! Time - ' + post_time_str)\n title = soup.title.string\\\n .replace(title_strip_text, '')\n\n # Remove user_subnav from parent.parent\n parent.parent.find('ul').decompose()\n post_body = str(parent.parent)\n post_bodies.append([post_body,\n thread_url,\n title,\n post_time_str])\n break\n else:\n logging.debug(\"Post not more recent than last_time_checked.\")\n else:\n logging.debug(\"Username not found.\")\n\n logging.info('{} pages checked, {} found containing {}.'\n .format(page_counter, len(post_bodies), self.targetuser))\n self.targetuser_posts = post_bodies","def posts(request):\n id_user = request.session.get('id_user')\n if id_user is None:\n request.session['res'] = 'Warn'\n messages.add_message(request, messages.WARNING,\n \"The session has expired\")\n return HttpResponseRedirect(reverse('home'))\n form = PostForm()\n if request.session['user_type'] == 1:\n return render(request, \"posts.html\",\n {\"posts\": Post.objects.filter(\n author_id=id_user).order_by('date_pub'),\n \"messages\": messages.get_messages(request),\n \"form\": form,\n },\n )\n else:\n return render(request, \"posts.html\",\n {\"posts\": Post.objects.all().order_by('date_pub'),\n \"messages\": messages.get_messages(request),\n \"users\": User.objects.all().order_by('real_name'),\n \"form\": form,\n },\n )","async def getposts(ctx, theme):\n q = Query(limit=100, tag=\"travelfeed\")\n for post in Discussions_by_created(q):\n continent_code = get_location(post['body'], \"continentcode\")\n link = \"https://steemit.com/\"+construct_authorperm(post['author'], post['permlink'])\n if post['author'] in curatorlist or post['author'] in whitelist:\n continue\n elif (continent_code == \"AF\" or continent_code == \"OC\" or continent_code == \"AN\") and (theme == \"Africa\" or theme == \"Oceania\" or theme ==\"Australia\" or theme == \"australiaoceaniaafrica\"):\n await bot.say(link)\n elif continent_code == \"AS\" and theme == \"Asia\":\n await bot.say(link)\n elif continent_code == \"EU\" and theme == \"Europe\":\n await bot.say(link)\n elif (continent_code == \"SA\" or continent_code == \"NA\") and theme == \"America\":\n await bot.say(link)\n elif (\"food\" in post['body'] or \"eat\" in post['body'] or \"restaurant\" in post['body']) and (theme == \"Food\" or theme ==\"foodoftheworld\"):\n await bot.say(link)\n elif (\"advice\" in post['body'] or \"budget\" in post['body'] or \"learn\" in post['body']) and (theme == \"Advice\" or theme == \"Travel Advice\" or theme == \"traveladvice\"):\n await bot.say(link)","def index():\r\n db = get_db()\r\n cur = db.cursor()\r\n cur.execute(\r\n 'SELECT p.id, title, body, created, author_id, username'\r\n ' FROM novel.post p JOIN novel.user u ON p.author_id = u.id'\r\n ' ORDER BY created DESC'\r\n )\r\n posts = cur.fetchall()\r\n return render_template('novel/index.html', posts=posts)","def get(self):\n\n page = self.request.get('page')\n if page:\n page = int(page)\n else:\n page = 1\n limit = 10\n offset = limit * (page - 1)\n posts = Post.all().order('-created').fetch(limit=limit, offset=offset)\n number_posts = Post.all().count()\n total_pages = number_posts / limit\n if number_posts % limit:\n total_pages += 1\n\n self.render('home.html', posts=posts, page=page,\n total_pages=total_pages, user=self.user)","def show_blog(request, primkey = None):\n dajax = Dajax()\n \n dajax.add_css_class('#showcase', 'hide')\n dajax.add_css_class('#sponsors', 'hide')\n \n html_content = \"\"\n \n if primkey:\n pass\n show_alert(dajax, \"info\", \"This part has not yet been completed\")\n else:\n bloglist = Thread.objects.all()\n #print bloglist\n for i in bloglist:\n i.description = (i.description[:100] + \" ....\") if len(i.description) > 100 else i.description\n html_content = render_to_string('blog/show.html', {'bloglist': bloglist}, RequestContext(request))\n \n if html_content:\n dajax.assign('#features', 'innerHTML', html_content);\n \n return dajax.json()","def all_blogs(request):\n\n posts = Post.objects.all()\n\n context = {\n 'posts': posts\n }\n\n return render(request, 'blog/blog.html', context)","def full_listing(request, urlname):\n\tif request.user.is_authenticated():\n\t\tblog = Blog.qa_objects.get(urlname=urlname)\n\t\tposts = BlogEntry.qa_objects.filter(blog=blog, posting_time__lte=datetime.now()).order_by('-posting_time')\n\telse:\n\t\tblog = Blog.objects.get(urlname=urlname)\n\t\tposts = BlogEntry.objects.filter(blog=blog).order_by('-posting_time')\n\treturn render_to_response('blogs/full.html', {'blog': blog, 'posts': posts}, context_instance=RequestContext(request))","def render_posts(self, **params):\n\n if \"user_posts\" in params:\n posts = params['user_posts']\n else:\n posts = Post.get_all()\n\n rendered_posts = \"\"\n for post in posts:\n rendered_posts += self.render_post(post, **params)\n\n self.render(\"blog/blog.html\", rendered_posts=rendered_posts)","def show_pages():\n page_id=request.args['page_id']\n\n if str(request.args['r_type'])==\"Create\":\n return render_template(\"write.html\",page_id=page_id)\n\n if request.args['referrer']==\"home\":\n graph = facebook.GraphAPI(page_id)\n pages = graph.get_object('me')\n is_published = request.args['r_type'] == \"Show_Published\"\n print_me(is_published)\n res = graph.get_connections(pages['id'], 'promotable_posts', is_published=is_published, limit=8)\n else:\n res = requests.request(\"GET\",request.args['next']).json()\n posts,next_page = get_posts_from_graph_object(res)\n views_dict={}\n thread_list = []\n message_dict={} \n id_list=[]\n for post in posts:\n if \"message\" in post:\n post_id = post['id']\n message_dict[post_id] = post['message']\n id_list.append(post_id)\n thread=Thread(target=get_views,args=(page_id, post_id, views_dict) )\n thread.start()\n thread_list.append(thread)\n\n for thread in thread_list:\n thread.join()\n posts_info=[]\n for i in id_list:\n posts_info.append( (message_dict[i], views_dict[i] ) )\n return render_template('show_posts.html', posts_info=(posts_info,next_page,page_id))","def parse_thread(self, response):\n item = DataakForumItem()\n\n # xpath selectors\n thread = '//span[@class=\"active\"]/text()'\n navpath = '//div[@class=\"navigation\"]/a/text()'\n posts = '//div[@class=\"post \"]'\n # author_not_admin = '//div[@class=\"author_information\"]//a/text()'\n author = './/div[@class=\"author_information\"]//a/text() | .//div[@class=\"author_information\"]//em/text()'\n body = './/div[@class=\"post_body scaleimages\"]/text() | .//div[@class=\"post_body scaleimages\"]//*/text()'\n\n posts_selector = response.xpath(posts)\n for post in posts_selector:\n item['url'] = response.url\n # self.log(response.url)\n\n item['thread'] = response.xpath(thread).extract_first()\n # self.log(\"thread: %s\" % response.xpath(thread).extract())\n\n # get the last item which is the forum name\n item['forum'] = response.xpath(navpath).extract()[-1]\n # self.log(\"nav path: %s\" % response.xpath(navpath).extract())\n\n item['author'] = post.xpath(author).extract_first()\n # self.log(\"author: %s\" % post.xpath(author).extract())\n\n item['body'] = post.xpath(body).extract()\n # self.log(\"body: %s\" % post.xpath(body).extract())\n\n yield item","def getMyPosts():\n \n cur, user_id = initialise(3)\n cur.execute(\"SELECT username FROM users WHERE id = ?\", [user_id])\n name = cur.fetchall()[0][0]\n cur.execute(\"SELECT * FROM posts WHERE name = ?\", [name])\n posts = cur.fetchall()\n return posts","def get_posts(self):\n return self.blog_posts.all()","def find_posts(self):\n\n posts = self.soup.find_all(\"div\", class_=\"_401d\")\n print(f'[Scraper] Found {len(posts)} posts.')\n\n for post in posts:\n try: \n text = post.find(\"div\", class_=\"_6-cp\").div.get_text()\n a_tag = post.find('span', class_=\"_6-cm\").find('a')\n link = \"https://www.facebook.com\" + a_tag['href'] \n print(f\"[Scraper] {link}\")\n print(f\"[Scraper] {text}\")\n except:\n print(\"Error occured. Skipped a result.\")","def index(request):\n # most of the heavy lifting is handled by Angular, on the front end\n return render(request, 'forum/index.html')","def test_list_posts_on_topic(self):\n url = reverse('post-list', args=[self.topic1.url_name])\n response = self.client.get(url)\n\n self.assertEqual(response.status_code, status.HTTP_200_OK)\n self.assertEqual(response.data['count'], 2)","def get(self, request, user_mail, post_id):\n\n all_posts = Evento.objects.all()\n self.context['user_mail'] = user_mail\n self.context['post_id'] = post_id\n #self.context['posts'] = all_posts\n\n xy = \"\"\n for i in all_posts:\n xy = xy + \" \" + i.etiquetas\n\n xy = xy.split()\n\n self.context['posts'] = xy\n\n\n #all_posts = Post.objects.all()\n #self.context['posts'] = all_posts\n return render(request, self.template, self.context)","def get_queryset(self):\n return Post.objects.order_by('-posted')[:5]","def forums(self):\n return forums.Forums(self)","def index(request):\n from ..models.post import Post\n collection = Post.objects.all()\n # import pdb;pdb.set_trace()\n return render(request,'index.html',{\"collection\":collection})","def last_topic_list(request):\n\ttopics = Topic.objects.order_by('-topic_modification_date')[:50]\n\tfor i in topics:\n\t\tpmax = i.post_set.all().count()/10\n\t\tpmaxten = i.post_set.all().count()%10\n\t\tif pmaxten != 0:\n\t\t\ti.pagination_max = pmax+1\n\t\telse:\n\t\t\ti.pagination_max = pmax\n\tforum_name = _('Last Active Topics')\n\treturn render_to_response(\n\t\t'myghtyboard/mytopics_list.html',\n\t\t{'topics': topics, 'forum_name': forum_name, 'perms': list_perms(request)},\n\t\tcontext_instance=RequestContext(request))","def index(self):\n \n return self.view.render('index.html', {\"posts\"=posts})","def get_queryset(self, request):\n qs = super(ExamAdmin, self).get_queryset(request)\n if request.user.is_superuser:\n return qs.filter(content_type__lt=3)\n return qs.filter(topic_id__in=request.user.profile.topics.all(), content_type__lt=3)","def post_list(request):\n # Only show the posts that have been published\n posts = Post.objects.filter(date_published__isnull=False)\n return render(request,\n 'blog/post_list.html',\n {'posts': posts}\n )","def posts_index():\n posts = Post.query.all()\n return render_template('posts.html', posts=posts, post=None)","def community_post_detail_view(request, slug):\n post = CommunityPostModel.objects.get(slug=slug) # Get the post\n posts = CommunityPostModel.objects.all()[:3] # Get the latest 3 posts\n author = UserModel.objects.get(id=post.author.id) # Get the author\n\n my_article = False # Set the flag to false\n if request.user == post.author: # If the user is the author, set the flag to true\n my_article = True # Set the flag to true\n\n context = { # Pass the variables to the template\n 'post': post,\n 'latest_posts': posts,\n 'author': author,\n 'my_article': my_article,\n }\n return render(request,\n 'pages/patient-community/community-post-details.html',\n context) # render the patient community detail page","def all(request):\n\n posts = Post.objects.filter()\n\n print(\"made a query\")\n return render(request, 'posts/all.html', {'posts':posts})","def display_blogcontent(request):\n\n blogposts = BlogPost.objects.all()\n template = 'blog/blog.html'\n context = {\n 'blogposts': blogposts,\n }\n\n return render(request, template, context)","def iter_all_posts(self, limit=None): # new\n feed = self.get_feed(limit=999999)\n posts = feed[\"threads\"]\n if limit:\n posts = posts[:limit]\n for post in posts:\n yield post","def get_queryset(self):\r\n\r\n user = get_object_or_404(User, username=self.kwargs.get('username'))\r\n return Post.objects.filter(author=user).order_by('-date_posted')","def get(self, request, user_mail, post_id):\n #all_posts = Post.objects.all()\n #self.context['posts'] = all_posts\n all_posts = Evento.objects.all()\n self.context['posts'] = all_posts\n all_events = RegEvento.objects.all()\n self.context['eventos'] = all_events\n \n self.context['usuario'] = user_mail\n\n self.context['evento'] = post_id\n\n all_staff = AsigStaff.objects.all()\n self.context['staffs'] = all_staff\n all_user = User.objects.get(username = user_mail)\n self.context['user'] = all_user\n\n return render(request, self.template, self.context)","def show_home():\r\n posts = Post.query.order_by(Post.created_at.desc()).limit(5).all()\r\n\r\n return render_template('home.html', posts=posts)","def topic_less(request, topic_id):\n posts = Post.objects.filter(topic=topic_id).order_by(\"-created\")[:3]\n posts = mk_paginator(request, posts, DJANGO_SIMPLE_FORUM_REPLIES_PER_PAGE)\n topic = Topic.objects.get(pk=topic_id)\n return render_to_response(\"forum/topic_less.html\", add_csrf(request, posts=posts, pk=topic_id,\n topic=topic), context_instance=RequestContext(request))","def homepage(request):\n limit = 7\n featured_marketer_list = (\n PimpUser.objects\n .filter(featured=True)\n .filter(usertype=PimpUser.MARKETER)\n .order_by('-date_joined')[:limit]\n )\n featured_cause_list = (\n PimpUser.objects\n .filter(featured=True)\n .filter(usertype=PimpUser.CAUSE)\n .order_by('-date_joined')[:limit]\n )\n news_post_list = (\n NewsPost.objects\n .order_by('-created_at')[:3]\n )\n\n context = {\n 'featured_marketer_list': featured_marketer_list,\n 'featured_cause_list': featured_cause_list,\n 'news_post_list': news_post_list,\n }\n\n return render(\n request,\n 'index.html',\n context\n )","def get_posts():\n db = psycopg2.connect(\"dbname=forum\")\n c = db.cursor()\n query = \"SELECT content, time FROM posts ORDER BY time DESC\"\n c.execute(query)\n rows = c.fetchall()\n POSTS = rows\n db.close()\n return POSTS","def community_home_view(request):\n posts = CommunityPostModel.objects.all() # Get all posts\n\n is_patient = False # Set the flag to false\n if request.user.is_authenticated and request.user.is_patient: # If user is authenticated and is a patient, set the flag to true\n is_patient = True # Set the flag to true\n\n paginator = Paginator(posts, 5) # Show 5 posts per page\n page = request.GET.get('page', 1) # Get the page number\n try:\n posts = paginator.page(page) # Get the page\n except PageNotAnInteger: # If page is not an integer, deliver first page.\n posts = paginator.page(1)\n except EmptyPage: # If page is out of range, deliver last page of results.\n posts = paginator.page(paginator.num_pages)\n\n context = { # Pass the variables to the template\n 'posts': posts,\n 'latest_posts': posts[:3], # Get the latest 3 posts\n 'is_patient': is_patient,\n }\n return render(request, \"pages/patient-community/community-home.html\", context)","def view_post(id):\n # all_category = postCategory.get_categories()\n posts = Post.query.get(id)\n\n if posts is None:\n\n abort(404)\n \n comment = Comments.get_comments(id)\n print(comment)\n count_likes = Votes.query.filter_by(posts_id=id, vote=1).all()\n count_dislikes = Votes.query.filter_by(posts_id=id, vote=2).all()\n return render_template('view-post.html', posts = posts, comment = comment, count_likes=len(count_likes), count_dislikes=len(count_dislikes))","def messages_view(request):\n if request.user.is_authenticated:\n user_info = models.UserInfo.objects.get(user=request.user)\n friends=user_info.friends.all()\n\n # TODO Objective 9: query for posts (HINT only return posts needed to be displayed)\n posts = []\n posts = models.Post.objects.all()\n posts=posts[::-1]\n\n post_visits = request.session.get('post_visits', 0)\n allPosts=[]\n for post in posts:\n allPosts.append(post)\n\n\n\n listUpperBound = post_visits + 2\n postSize = len(allPosts)\n\n new_list = []\n if listUpperBound < postSize - 1:\n for i in range(listUpperBound):\n new_list.append(allPosts[i])\n else:\n new_list = allPosts\n\n # TODO Objective 10: check if user has like post, attach as a new attribute to each post\n\n context = { 'user_info':user_info,\n 'posts' : posts,\n 'friends':friends,\n 'new_list':new_list}\n\n return render(request,'messages.djhtml',context)\n\n request.session['failed'] = True\n return redirect('login:login_view')","def articles():\n \n # Parse through RSS feed of Get Rich Slowly\n feed = feedparser.parse(\"http://www.getrichslowly.org/blog/feed/\")\n \n # Get current username\n username = get_user()\n \n return render_template(\"articles.html\", username=username, feed=feed)","def index(request):\n # Generate counts of some of the main objects\n num_posts=Post.objects.all()\n num_authors=Author.objects.count() # The 'all()' is implied by default.\n # Render the HTML template index.html with the data in the context variable\n return render(\n request,\n 'index.html',\n context={'num_posts':num_posts,'num_authors':num_authors},\n )","def show():\n context = {\n \"posts\": get_posts()[::-1]\n }\n return render_template(\"show.html\", **context)","def posts_for_feed():\n user_id = session.get('user_id')\n friend_posts = Post.query.join(Friend, db.and_(Post.user_id == Friend.user_2,\n Friend.active == True)).outerjoin(Comment, db.and_(Comment.post_id == Post.post_id,\n Comment.active == True)).filter(Friend.user_1 == user_id,\n Post.active == True).order_by(Post.post_id.desc()).all()\n\n post_list = []\n for post in friend_posts:\n post_list.append(post.to_dict_for_json())\n\n resp = make_response(jsonify(post_list), 200)\n return resp","def get_posts(request):\n posts = Post.objects.order_by(\"created_date\")\n return render(request, \"blogposts.html\", {\"posts\": posts})","def GET_side_posts(self, *a, **kw):\r\n # Server side cache is also invalidated when new article is posted\r\n return self.render_cached('side-posts', RecentArticles, g.side_posts_max_age)","def entries_index(request):\n blog_entries = Entry.objects.filter(status=2).order_by('-pub_date')\n paginator = Paginator(blog_entries, 4)#4 posts/page\n try:\n page = int(request.GET.get('page','1'))\n except ValueError:\n page = 1\n try:\n entries = paginator.page(page)\n except (EmptyPage, InvalidPage):\n entries = paginator.page(paginator.num_pages)\n return render_to_response('blog/blog.html', {'entries':entries}, RequestContext(request))","def show_posts(page):\n if not session.get('logged_in'):\n posts = Post.query.filter_by(visible=True)\n else:\n posts = Post.query\n pagination = posts.order_by(Post.datetime.desc()).paginate(page=page, \n per_page=current_app.config['POSTS_PER_PAGE'])\n if not pagination.total: flash(\"No posts so far\")\n return render_template('posts.html', pagination=pagination,\n endpoint_func=lambda x: url_for('main.show_posts', page=x))","def post(request):\n home_user = request.user.profile\n\n num_activities = Activity.objects.count()\n AllActivites = Activity.objects.all()\n\n\n # Generate counts of some of the main objects\n\n\n\n\n\n\n\n\n context = {\n 'huser': home_user,\n 'Lname' : home_user.user.last_name,\n 'Fname': home_user.user.first_name,\n 'allactivites': AllActivites,\n }\n\n # Render the HTML template index.html with the data in the context variable\n return render(request, 'post.html', context=context)","def get(self, request):\n\n all_posts = Evento.objects.all()\n #self.context['posts'] = all_posts\n\n xy = \"\"\n for i in all_posts:\n xy = xy + \" \" + i.etiquetas\n\n xy = xy.split()\n\n self.context['posts'] = xy\n\n\n #all_posts = Post.objects.all()\n #self.context['posts'] = all_posts\n return render(request, self.template, self.context)","def __processForumUrl(self):\n threads = [each.findParent('tr') for each in self.soup.find('table',\\\n id='threadslist').findAll('td', id=re.compile('td_threadtitle_'))]\n for thread in threads:\n try:\n if thread.find('img', src=re.compile('sticky.gif$')):\n log.info(self.log_msg('Its a Sticky Thread, Ignore it in the \\\n url %s'%self.currenturi)) \n continue\n self.__total_threads_count += 1\n if self.__total_threads_count > self.__max_threads_count:\n log.info(self.log_msg('Reaching maximum post,Return false \\\n from the url %s'%self.currenturi))\n return False \n \n try:\n th=thread.findAll('td',recursive=False)\n date_tag = stripHtml(th[3].renderContents()).splitlines()\\\n [0] .strip() \n if date_tag.startswith('Today'):\n date_tag = date_tag.replace('Today', datetime.strftime\\\n (datetime.utcnow(),'%m-%d-%Y')) \n elif date_tag.startswith('Yesterday'):\n date_tag = date_tag.replace('Yesterday', datetime.\\\n strftime((datetime.utcnow()-timedelta\\\n (days=1)),'%m-%d-%Y')) \n thread_time = datetime.strptime(date_tag,'%m-%d-%Y %I:%M %p')\n except:\n log.exception(self.log_msg('last post not found in the url\\\n %s'%self.currenturi)) \n if checkSessionInfo('Search', self.session_info_out, thread_time, \\\n self.task.instance_data.get('update')):\n log.info(self.log_msg('Session info Returns True for %s'%\\\n self.currenturi))\n log.info(thread_time)\n return False\n self.__last_timestamp = max(thread_time , self.__last_timestamp )\n temp_task=self.task.clone() \n try:\n \n s=th[2].find('a', id=re.compile('thread_title_\\d+'))['href'] \n temp_task.instance_data[ 'uri' ] = self.__baseuri + re.sub\\\n ('\\?s=.*?&','?',s)\n except:\n log.exception(self.log_msg('uri not found in the url\\\n %s'%self.currenturi)) \n continue \n try:\n temp_task.pagedata['edate_last_post_date'] = datetime.strftime\\\n (thread_time, \"%Y-%m-%dT%H:%M:%SZ\") \n except: \n log.info(self.log_msg('last post date not found in the url\\\n %s'%self.currenturi)) \n try: \n temp_task.pagedata['et_author_name'] = stripHtml(th[2].\\\n find('div','smallfont').renderContents()) \n except:\n log.info(self.log_msg('author name not found in the url\\\n %s'%self.currenturi)) \n try: \n temp_task.pagedata['et_last_post_author'] = \\\n stripHtml(th[3].renderContents()).\\\n splitlines()[-1].strip().replace('by','') \n except:\n log.info(self.log_msg('last post author not found in the url\\\n %s'%self.currenturi)) \n try: \n temp_task.pagedata['ei_thread_views_count'] = int(stripHtml\\\n (th[5].renderContents()))\n except:\n log.info(self.log_msg('views not found in the url\\\n %s'%self.currenturi)) \n try: \n temp_task.pagedata['ei_thread_replies_count'] = int(stripHtml\\\n (th[4].renderContents()))\n except:\n log.info(self.log_msg('reply not found in the url\\\n %s'%self.currenturi)) \n self.linksOut.append(temp_task)\n except:\n log.exception(self.log_msg('links not found')) \n return True","def print_posts(posts):\n\n click.echo()\n for post in posts:\n click.secho('%d. ' % post['rank'], nl=False)\n click.secho('%s\\t' % post['title'], bold=True, fg=\"red\", nl=False)\n click.secho('%s' % post['tagline'], fg=\"yellow\")\n click.echo()","def get(self, request):\n\n # recupera posts\n posts = Post.objects.filter(owner__in=request.user.owned_blogs.all())\n\n # prepara el contexto de la plantilla\n context = {\n 'post_objects': posts\n }\n\n # renderiza y devuelve la plantilla\n return render(request, 'blogs/inicio.html', context)","def faq(request):\n \n \n question = Question.objects.all()\n categories = Category.objects.all()\n webdev = Question.objects.filter(category='1')\n context = {\n 'question': question,\n }\n return render(request, 'faq/faq.html', context)","def index(request):\n\tif request.user.is_authenticated():\n\t\tblogs = Blog.qa_objects.order_by('name')\n\telse:\n\t\tblogs = Blog.objects.order_by('name')\n\treturn render_to_response('blogs/blogs.html', {'blogs': blogs}, context_instance=RequestContext(request))","def fetch(self):\r\n self.genre=\"Review\"\r\n try:\r\n self.parent_uri = self.currenturi\r\n self.total_posts_count = 0\r\n self.last_timestamp = datetime( 1980,1,1 )\r\n self.max_posts_count = int(tg.config.get(path='Connector',key='silverlight_numresults'))\r\n self.hrefs_info = self.currenturi.split('/')\r\n if '/forums/t/' in self.currenturi:\r\n if not self.__setSoup():\r\n log.info(self.log_msg('Soup not set , Returning False from Fetch'))\r\n return False\r\n self.__getParentPage()\r\n self.__addPosts()\r\n return True\r\n else:\r\n if not self.__setSoup():\r\n log.info(self.log_msg('Soup not set , Returning False from Fetch'))\r\n return False\r\n while True:\r\n if not self.__getThreadPage():\r\n break\r\n try:\r\n self.currenturi = self.soup.find('a',text='Next >').parent['href']\r\n if not self.__setSoup():\r\n break\r\n except:\r\n log.info(self.log_msg('Next Page link not found'))\r\n break\r\n if self.linksOut:\r\n updateSessionInfo('Search', self.session_info_out,self.last_timestamp , None,'ForumThreadsPage', self.task.instance_data.get('update'))\r\n\r\n return True\r\n except:\r\n log.exception(self.log_msg('Exception in fetch'))\r\n return False","def index(request):\n # Generate counts of some of the main objects\n ##num_books=Book.objects.all().count()\n ##num_instances=BookInstance.objects.all().count()\n # Available books (status = 'a')\n ##num_instances_available=BookInstance.objects.filter(status__exact='a').count()\n num_authors=Post.objects.count() # The 'all()' is implied by default.\n model = Post\n # Render the HTML template index.html with the data in the context variable\n return render(\n request,\n 'index.html',\n context={'num_authors':num_authors},\n )","def get(self):\n return get_all_posts()","def get_queryset(self):\n\t\treturn Post.objects.order_by('-pub_date')[:5]","def index():\n\n posts = models.Post.select()\n return render_template('index.html', posts=posts)","def postList(posts):\n post_list = list()\n for post in posts:\n visible_to = list()\n visible = post.visibleTo.all()\n if visible:\n for author in visible:\n auth = \"{}/api/author/{}\".format(DOMAIN, author.id)\n visible_to.append(auth)\n\n comments = commentList(post)\n comment_url = \"{}/api/posts/{}/comments\".format(DOMAIN, post.id)\n post_dict = {'author': addAuthor(post.author), 'title': post.title, 'description': post.description,\n 'contentType': post.contentType, 'content': post.content, 'published': post.published,\n 'visibility': post.visibility, 'visibleTo': visible_to, 'unlisted': post.unlisted, 'id': post.id,\n 'comments': comments[:5], 'next': comment_url, 'count': len(comments),\n 'origin': \"{}/api/posts/{}\".format(DOMAIN, post.id),\n 'source': \"{}/api/posts/{}\".format(DOMAIN, post.id)}\n post_list.append(post_dict)\n return post_list","def my_topic_list(request, show_user=False):\n\tif not show_user:\n\t\tshow_user = str(request.user)\n\tif request.user.is_authenticated():\n\t\ttopics = Topic.objects.order_by('-topic_modification_date').filter(topic_author=show_user)[:50]\n\t\tforum_name = _('User Topics')\n\t\treturn render_to_response(\n\t\t\t'myghtyboard/mytopics_list.html',\n\t\t\t{'topics': topics, 'forum_name': forum_name, 'perms': list_perms(request)},\n\t\t\tcontext_instance=RequestContext(request))\n\telse:\n\t\treturn render_to_response('pages/bug.html', {'bug': _('You aren\\'t logged in')}, context_instance=RequestContext(request))","def index(request):\n\n num_posts = BlogPost.objects.all().count()\n num_bloggers = Blogger.objects.all().count()\n latest_blog = BlogPost.objects.latest('post_date')\n\n context = {\n 'num_posts': num_posts,\n 'num_bloggers': num_bloggers,\n 'latest_blog': latest_blog,\n }\n\n return render(request, 'index.html', context=context)","def get_teacher_topic_all():\n topic_data = query_db(\n \"SELECT topics.id, topics.name, classes.name FROM topics JOIN classes \"\n \"ON topics.class_id=classes.id WHERE teacher_id=?;\",\n [flask.session[\"id\"]],\n )\n topics = []\n for topic in topic_data:\n topic_dict_teacher = {}\n topic_dict_teacher[\"id\"] = topic[0]\n topic_dict_teacher[\"name\"] = flask.escape(str(topic[1]))\n topic_dict_teacher[\"class\"] = flask.escape(str(topic[2]))\n topics.append(topic_dict_teacher)\n return topics","def get_posts(self):\n return Post.select().where (Post.user == self)","def __getData(self, post,is_question=False):\n page = {'entity':'question' if is_question else 'answer', 'uri':self.currenturi}\n css_class_name = 'span' if is_question else 'div'\n if post.find('div', text='Post temporarily unavailable'):\n log.info(self.log_msg('Message Temporarily not available in url %s'%self.currenturi))\n return False\n if post.find('form', id='frm_quick_reply_submit'):\n log.info(self.log_msg('It is not a post'))\n return False\n try:\n page['et_author_name'] = stripHtml(post.find(css_class_name, 'vt_asked_by_user').renderContents())\n except:\n log.info(self.log_msg('Author name not found in %s'% self.currenturi))\n try:\n date_str = stripHtml(post.find(css_class_name,attrs={'class':re.compile('vt_.+?_timestamp')}).renderContents()).replace('replied ','').strip()\n date_str = re.sub(\"(\\d+)(st|nd|rd|th)\",r\"\\1\", date_str)\n page['posted_date'] = datetime.strftime(datetime.strptime(date_str\n , 'on %B %d, %Y'),\"%Y-%m-%dT%H:%M:%SZ\")\n except:\n page['posted_date'] = datetime.strftime(datetime.utcnow(), \"%Y-%m-%dT%H:%M:%SZ\")\n log.info(self.log_msg('Date not be found in %s'% self.currenturi))\n try:\n page['et_author_category'] = stripHtml(post.find('span', 'vt_user_rank').renderContents())\n except:\n log.info(self.log_msg('Author name not found in %s'% self.currenturi))\n try:\n data_tag = post.find('div', 'vt_post_body')\n ads_tag = post.findAll('div',attrs={'class':re.compile('vt_post_body_ad_[l/r]')})\n [each.extract() for each in ads_tag]\n page['data'] = stripHtml(data_tag.renderContents())\n except:\n log.info(post)\n log.info(self.log_msg('Cannot find the Data for this Post %s'%self.currenturi))\n page['data'] = ''\n try:\n if is_question:\n page['title'] = stripHtml(str(post.find('div', 'vt_post_subject').span.next.next))\n else:\n page['title'] = 'Re: ' + self.__hierarchy[-1]\n except:\n log.info(self.log_msg('Cannot find the Data thread details for this Post %s'%self.currenturi))\n page['title'] = ''\n if not (page['data'] and page['title']):\n log.info(self.log_msg('No data found in url %s'%self.currenturi))\n return \n if len(self.__hierarchy) >= 3:\n page['et_thread_topic'] = self.__hierarchy[-1]\n page['et_thread_forum'] = self.__hierarchy[-3]\n page['et_thread_subforum'] = self.__hierarchy[-2]\n return page","def teacher_forum_create(request):\n # Deleting admin-typed user session\n # Deleting programmer-typed-user session\n\n # Get the current users\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\n\n current_basic_user_profile = get_current_user_profile(\n request,\n User,\n BasicUserProfile,\n ObjectDoesNotExist\n )\n\n # Getting the teacher profile\n current_teacher_profile = get_current_teacher_user_profile(\n request,\n User,\n TeacherUserProfile,\n ObjectDoesNotExist\n )\n\n # forum create post form processing\n empty_input = False\n\n if request.POST.get(\"teacher_forum_create_post_btn\"):\n post_title = request.POST.get(\"post_title\")\n post_content = request.POST.get(\"post_content\")\n\n # check if any of the inputs are empty\n if bool(post_title) == False or post_title == \"\" \\\n or bool(post_content) == False or post_content == \"\":\n empty_input = True\n else:\n new_post = TeacherForumPost(\n teacher=current_teacher_profile,\n course=current_teacher_profile.teacher_course,\n post_title=post_title,\n content=post_content\n )\n new_post.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(new_post.id)+\"/\"\n )\n\n data = {\n \"current_basic_user\": current_basic_user,\n \"current_basic_user_profile\": current_basic_user_profile,\n \"current_teacher_profile\": current_teacher_profile,\n \"empty_input\": empty_input,\n }\n\n if \"teacher_user_logged_in\" in request.session:\n return render(request, \"teacher_forum/create.html\", data)\n else:\n return HttpResponseRedirect(\"/\")"],"string":"[\n \"def post_list(request):\\n\\timage_post_list = list(ImagePost.objects.all())\\n\\tvideo_post_list = list(VideoPost.objects.all())\\n\\tall_post = image_post_list + video_post_list\\n\\treturn render(request,'devblog/post_list.html', {'posts':all_post})\",\n \"def view_blog(self):\",\n \"def forum(request, forum_id):\\n topics = Topic.objects.filter(forum=forum_id).order_by(\\\"-created\\\")\\n topics = mk_paginator(request, topics, DJANGO_SIMPLE_FORUM_TOPICS_PER_PAGE)\\n\\n forum = get_object_or_404(Forum, pk=forum_id)\\n\\n return render_to_response(\\\"forum/forum.html\\\", add_csrf(request, topics=topics, pk=forum_id, forum=forum),\\n context_instance=RequestContext(request))\",\n \"def my_posttopic_list(request, show_user=False):\\n\\tif not show_user:\\n\\t\\tshow_user = str(request.user)\\n\\ttry:\\n\\t\\ttopics = Post.objects.order_by('-post_date').filter(post_author=show_user).values('post_topic').distinct()[:50]\\n\\t\\tposts = []\\n\\t\\tfor i in topics:\\n\\t\\t\\tposts.append(int(i['post_topic']))\\n\\t\\ttopics = Topic.objects.order_by('-topic_modification_date').filter(id__in=posts)\\n\\t\\tfor i in topics:\\n\\t\\t\\tpmax = i.post_set.all().count()/10\\n\\t\\t\\tpmaxten = i.post_set.all().count()%10\\n\\t\\t\\tif pmaxten != 0:\\n\\t\\t\\t\\ti.pagination_max = pmax+1\\n\\t\\t\\telse:\\n\\t\\t\\t\\ti.pagination_max = pmax\\n\\t\\tforum_name = _('User Posts in Latest Topics')\\n\\texcept:\\n\\t\\treturn render_to_response('myghtyboard/mytopics_list.html', {'perms': list_perms(request)}, context_instance=RequestContext(request))\\n\\treturn render_to_response(\\n\\t\\t'myghtyboard/mytopics_list.html',\\n\\t\\t{'topics': topics, 'forum_name': forum_name, 'perms': list_perms(request)},\\n\\t\\tcontext_instance=RequestContext(request))\",\n \"def __getThreadPage( self ):\\r\\n threads = [x.findParent('tr') for x in self.soup.findAll('td','tbl_forum_thread')]\\r\\n if len(threads )==0:\\r\\n log.info(self.log_msg('No threads are found'))\\r\\n return False\\r\\n for thread in threads:\\r\\n self.total_posts_count = self.total_posts_count + 1\\r\\n try:\\r\\n thread_info = thread.find('td','tbl_forum_thread').findAll('a')\\r\\n date_str = stripHtml(thread_info[-1].next.next.__str__())\\r\\n thread_time = datetime.strptime(date_str,'on %B %d, %Y')\\r\\n except:\\r\\n log.exception(self.log_msg('Date cannot found, continue with other posts'))\\r\\n continue\\r\\n if self.total_posts_count > self.max_posts_count:\\r\\n log.info(self.log_msg('Reaching maximum post,Return false'))\\r\\n return False\\r\\n try:\\r\\n if checkSessionInfo('Search',self.session_info_out, thread_time,\\\\\\r\\n self.task.instance_data.get('update')):\\r\\n continue\\r\\n self.last_timestamp = max(thread_time , self.last_timestamp )\\r\\n temp_task=self.task.clone()\\r\\n try:\\r\\n title_tag = thread.find('h2')\\r\\n temp_task.pagedata['title']= stripHtml(title_tag.renderContents())\\r\\n temp_task.instance_data[ 'uri' ] = 'http://silverlight.net' + title_tag.find('a')['href']\\r\\n temp_task.pagedata['et_author_name'] = stripHtml(thread.find('p').find('a').renderContents())\\r\\n temp_task.pagedata['et_thread_last_post_author'] = stripHtml(thread_info[-1].renderContents())\\r\\n view_reply = {'ei_thread_num_replies':'tbl_forum_views','ei_thread_num_views':'tbl_forum_replies'}\\r\\n for each in view_reply.keys():\\r\\n temp_task.pagedata[each] = int(re.sub('[^\\\\d]','',stripHtml(thread.find('td',view_reply[each]).renderContents())))\\r\\n temp_task.pagedata['edate_last_post_date']= datetime.strftime(thread_time,\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\r\\n except:\\r\\n log.exception(self.log_msg('Cannot find the uri'))\\r\\n continue\\r\\n try:\\r\\n temp_task.pagedata['ef_thread_rating']= float(re.search('\\\\[([^ ]+)',thread.find('span','ForumThreadRateControl star_ratings')['title']).group(1))\\r\\n except:\\r\\n log.info(self.log_msg('Thread rating not found'))\\r\\n self.linksOut.append( temp_task )\\r\\n log.info(self.log_msg('Task added'))\\r\\n except:\\r\\n log.info(self.log_msg('Cannot add the Task'))\\r\\n return True\",\n \"def post_list(request, topic_id, pagination_id):\\n\\ttry:\\n\\t\\ttopic = Topic.objects.get(id=topic_id)\\n\\texcept Topic.DoesNotExist:\\n\\t\\treturn HttpResponseRedirect('/forum/')\\n\\tif topic.is_locked:\\n\\t\\topened = False\\n\\telse:\\n\\t\\topened = True\\n\\treturn object_list(\\n\\t\\trequest,\\n\\t\\ttopic.post_set.all().order_by('post_date'),\\n\\t\\tpaginate_by = 10,\\n\\t\\tpage = pagination_id,\\n\\t\\textra_context = {\\n\\t\\t\\t'topic_id':topic_id,\\n\\t\\t\\t'opened': opened,\\n\\t\\t\\t'topic': topic.topic_name,\\n\\t\\t\\t'forum_id': topic.topic_forum.id,\\n\\t\\t\\t'forum_name': topic.topic_forum,\\n\\t\\t\\t'perms': list_perms(request),\\n\\t\\t\\t'current_user': str(request.user)},\\n\\t\\ttemplate_name = 'myghtyboard/post_list.html')\",\n \"def teacher_forum_read(request, post_id):\\n # Deleting admin-typed user session\\n # Deleting programmer-typed-user session\\n\\n # Get the current users\\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\\n\\n current_basic_user_profile = get_current_user_profile(\\n request,\\n User,\\n BasicUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Getting the teacher profile\\n current_teacher_profile = get_current_teacher_user_profile(\\n request,\\n User,\\n TeacherUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Get the current post\\n try:\\n current_post = TeacherForumPost.objects.get(id=post_id)\\n except ObjectDoesNotExist:\\n current_post = None\\n\\n # if the post id is not existing redirect to 404\\n if current_post == None:\\n return HttpResponseRedirect(\\\"/404/\\\")\\n\\n # check if the post is owned by the current user if it is pass it on to\\n # the template logic\\n current_user_is_teacher = False\\n if current_post.teacher == current_teacher_profile:\\n current_user_is_teacher = True\\n\\n # current post upvote form processing\\n if request.POST.get(\\\"teacher_forum_read_post_upvote_btn\\\"):\\n current_post.karma += 1\\n current_post.save()\\n\\n # current post downvote form processing\\n if request.POST.get(\\\"teacher_forum_read_post_downvote_btn\\\"):\\n current_post.karma -= 1\\n current_post.save()\\n\\n # get all the coments\\n try:\\n all_post_comments = TeacherForumComment.objects.filter(\\n post=current_post\\n ).order_by(\\\"-id\\\")\\n except ObjectDoesNotExist:\\n all_post_comments = None\\n\\n # comment upote form processing\\n if request.POST.get(\\\"teacher_forum_comment_upvote_submit\\\"):\\n hidden_comment_id = request.POST.get(\\\"hidden_comment_id\\\")\\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\\n current_comment.karma += 1\\n current_comment.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n # comment downvote form processing\\n if request.POST.get(\\\"teacher_forum_comment_downvote_submit\\\"):\\n hidden_comment_id = request.POST.get(\\\"hidden_comment_id\\\")\\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\\n current_comment.karma -= 1\\n current_comment.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n # comment create form processing\\n if request.POST.get(\\\"teacher_forum_comment_subtmit_btn\\\"):\\n comment_content = request.POST.get(\\\"comment_content\\\")\\n # check if it is empty\\n if bool(comment_content) == False or comment_content == \\\"\\\":\\n pass\\n else:\\n new_comment = TeacherForumComment(\\n teacher=current_teacher_profile,\\n post=current_post,\\n content=comment_content\\n )\\n new_comment.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n # Delete the post and its comments form processing\\n if request.POST.get(\\\"teacher_forum_delete_post_submit\\\"):\\n # check if the current user is the owner\\n if current_post.teacher == current_teacher_profile:\\n # delete the ppost\\n current_post.delete()\\n # delete all the comments\\n all_post_comments.delete()\\n # redirect to landing page\\n return HttpResponseRedirect(\\\"/teacher/forum/0/\\\")\\n else:\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n data = {\\n \\\"current_basic_user\\\": current_basic_user,\\n \\\"current_basic_user_profile\\\": current_basic_user_profile,\\n \\\"current_teacher_profile\\\": current_teacher_profile,\\n \\\"current_post\\\": current_post,\\n \\\"current_user_is_teacher\\\": current_user_is_teacher,\\n \\\"all_post_comments\\\": all_post_comments,\\n }\\n\\n if \\\"teacher_user_logged_in\\\" in request.session:\\n return render(request, \\\"teacher_forum/read.html\\\", data)\\n else:\\n return HttpResponseRedirect(\\\"/\\\")\",\n \"def show_all_posts():\\n post = Post.query.all()\\n\\n return render_template('all-posts.html', post=post)\",\n \"def topic_recent(request):\\n posts = Post.objects.all().order_by(\\\"-created\\\")[:3]\\n posts = mk_paginator(request, posts, DJANGO_SIMPLE_FORUM_REPLIES_PER_PAGE)\\n # topic = Topic.objects.get(pk=topic_id)\\n return render_to_response(\\\"forum/topic_recent.html\\\", add_csrf(request, posts=posts), context_instance=RequestContext(request))\",\n \"def education_post_list(request):\\n posts = EducationBlogPost.objects.filter(published_date__lte=timezone.now()\\n ).order_by('-published_date')\\n return render(request, \\\"education_center/education_blogposts.html\\\", {'posts': posts})\",\n \"def get(self):\\n\\n self.render_posts()\",\n \"def __addThreadAndPosts(self):\\n try:\\n self.genre = \\\"Review\\\"\\n self.__hierarchy = []\\n self.__baseuri = 'http://broncosfreaks.com/forums/'\\n self.__task_elements_dict = {\\n 'priority':self.task.priority,\\n 'level': self.task.level,\\n 'last_updated_time':datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\"),\\n 'pickup_date':datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\"),\\n 'connector_instance_log_id': self.task.connector_instance_log_id,\\n 'connector_instance_id':self.task.connector_instance_id,\\n 'workspace_id':self.task.workspace_id,\\n 'client_id':self.task.client_id,\\n 'client_name':self.task.client_name,\\n 'versioned':False,\\n 'category':self.task.instance_data.get('category',''),\\n 'task_log_id':self.task.id }\\n self.__setSoupForCurrentUri()\\n self.__setParentPage()\\n question_post = self.soup.find('div', id=re.compile('^edit.*?'))\\n self.__addPost(question_post, True)\\n self.__goToLastPage() \\n while self.__iteratePosts():\\n try:\\n next_page_uri = self.soup.find('a', text='<',rel='prev').parent['href']\\n data_dict = dict(parse_qsl(next_page_uri.split('?')[-1]))\\n if 's' in data_dict.keys():\\n data_dict.pop('s')\\n self.currenturi = self.__baseuri + 'showthread.php?'+ urlencode(data_dict) \\n self.__setSoupForCurrentUri()\\n except:\\n log.exception(self.log_msg('Next Page link not found for url \\\\\\n %s'%self.currenturi))\\n break\\n return True\\n \\n\\n \\\"\\\"\\\"#try: \\n # question_post = self.soup.find('div', id=re.compile ('^edit\\\\d+'))\\n #except:\\n # log.info(self.log_msg('Question post cannot be added'))\\n #main_page_soup = copy.copy(self.soup)\\n # self.__addPost(question_post, True)\\n except:\\n log.info(self.log_msg('page not added'))\\n self.__goToLastPage(main_page_soup)\\n while True:\\n main_page_soup = copy.copy(self.soup)\\n #log.info(self.log_msg('Question post cannot be added'))\\n if not self.__iteratePosts():\\n break\\n try:\\n self.currenturi = main_page_soup.find('a',text='<').parent['href']\\n log.info(self.log_msg('uri %s'%self.currenturi)) \\n except:\\n \\n log.info(self.log_msg('No Previous URL found for url \\\\\\n %s'%self.currenturi))\\n break\\n return True\\n \\\"\\\"\\\" \\n \\n \\n except:\\n log.exception(self.log_msg('Exception while add the theread posts \\\\\\n for the url %s'%self.currenturi))\\n return False\",\n \"def posts_list(request):\\n\\n # recupera posts\\n posts = Post.objects.select_related(\\\"owner\\\").filter(Q(publish_at__lte=now())).all()\\n categorias = Categoria.objects.all()\\n\\n # prepara el contexto de la plantilla\\n context = {\\n 'post_objects': posts,\\n 'categoria_objects': categorias\\n }\\n\\n # renderiza y devuelve la plantilla\\n return render(request, 'blogs/inicio.html', context)\",\n \"def forums(self):\\r\\n return forums.Forums(self)\",\n \"def home(request):\\n context_dict = {}\\n categories = []\\n general_category = Category.objects.get_or_create(name=\\\"General Discussion\\\")[0]\\n if general_category:\\n categories_qs = Category.objects.exclude(slug=\\\"general-discussion\\\").annotate(num_threads=Count('thread')).order_by('-num_threads')\\n top_threads = {}\\n for category in chain([general_category], categories_qs):\\n categories.append(category)\\n top_threads[str(category.pk)] = [[thread, str(thread.post_set.count() - 1)] for thread in Thread.objects.filter(category=category, visible=True).order_by('-last_modified')[:2]]\\n context_dict['categories'] = categories\\n context_dict['top_threads'] = top_threads\\n if request.user.is_authenticated():\\n member = Member.objects.get(user=request.user)\\n if member:\\n context_dict['member'] = member\\n return render(request, 'home.html', context_dict)\\n else:\\n return server_error(request)\",\n \"def get_threads(self):\\n page = self.course.moodle.fetch(\\n self._view_url % self.id,\\n None\\n )\\n bs = bs4.BeautifulSoup(page.text, 'lxml')\\n\\n table = bs.find('table', class_='forumheaderlist')\\n posts = table.find_all('tr', class_='discussion')\\n\\n data = []\\n for p in posts:\\n topiccell = p.find('td', class_='topic starter')\\n topic = topiccell.find('a').text\\n url = topiccell.find('a')['href']\\n groupcell = p.find('td', class_=\\\"picture group\\\")\\n if groupcell.text:\\n groupname = groupcell.find('a').text\\n else:\\n groupname = None\\n\\n data.append((topic, url, groupname))\\n\\n return data\",\n \"def get(self):\\n\\n page = self.request.get('page')\\n if page:\\n page = int(page)\\n else:\\n page = 1\\n limit = 10\\n offset = limit * (page - 1)\\n\\n my_posts = Post.all().order('-created').filter('user =', self.user)\\n\\n number_posts = my_posts.count()\\n total_pages = number_posts / limit\\n if number_posts % limit:\\n total_pages += 1\\n\\n posts = my_posts.fetch(limit=limit, offset=offset)\\n self.render('mypost.html', posts=posts, page=page,\\n total_pages=total_pages, user=self.user)\",\n \"def get(self, request, *args, **kwargs):\\n my_normal_post_lists = NormalPosts.objects.filter(uploded_by=request.user.normalprofile).order_by(\\\"-id\\\")\\n return render(request, self.template_name, {\\n 'my_normal_post_lists': my_normal_post_lists,\\n })\",\n \"def get(self, request):\\n #all_posts = Post.objects.all()\\n #self.context['posts'] = all_posts\\n return render(request, self.template, self.context)\",\n \"def get(self):\\n # posts = db.GqlQuery(\\\"select * from Post order by created desc limit 10\\\")\\n posts = greetings = Post.all().order('-created')\\n self.render('front.html', posts = posts)\",\n \"def post(self):\\n subject = self.request.get('subject')\\n content = self.request.get('post_content')\\n post_id = self.request.get('post_id')\\n post = Posts.get_by_id(int(post_id))\\n user = self.get_active_user()\\n user_id = int(user.key().id())\\n\\n if post and user and subject and content:\\n if post.submitter_id == user_id:\\n self.render_editpage(user, post_id, subject, content)\\n else:\\n self.render_improper_access()\\n else:\\n self.error(500)\",\n \"def comunicado(request):\\n forums = Forum.objects.all()\\n count = forums.count()\\n discussions = []\\n for i in forums:\\n discussions.append(i.discussion_set.all())\\n\\n context = {\\n 'forums': forums,\\n 'count': count,\\n 'discussions': discussions\\n }\\n\\n return render(request, 'comunicado/comunicado.html', context)\",\n \"def __getThreads(self):\\n threads = self.soup.find('div', 'fp_left').findAll('div', attrs={'class':re.compile('fp_topic_')}, recursive=False)\\n if not threads:\\n log.info(self.log_msg('No threads are found for url %s'%\\\\\\n self.currenturi))\\n return False\\n for thread in threads[1:]:\\n self.__current_thread_count += 1\\n if self.__current_thread_count > self.__max_threads_count:\\n log.info(self.log_msg('Reaching maximum post,Return false \\\\\\n from the url %s'%self.currenturi))\\n return False\\n \\n try:\\n date_str = stripHtml(thread.find('span', 'fp_last_post_time').renderContents())\\n thread_time = datetime.strptime(date_str, 'Last post: %m-%d-%Y %H:%M%p')\\n except:\\n log.exception(self.log_msg('Cannot fetch the date for the url\\\\\\n %s'%self.currenturi))\\n continue\\n if checkSessionInfo('Search', self.session_info_out, thread_time,\\\\\\n self.task.instance_data.get('update')):\\n log.info(self.log_msg('Session info Returns True for url %s'%self.currenturi))\\n return False\\n self.__last_timestamp = max(thread_time , self.__last_timestamp )\\n temp_task = self.task.clone() \\n try:\\n temp_task.instance_data['uri'] = thread.find('a', 'topictitle')['href']\\n except:\\n log.exception(self.log_msg('Cannot find the thread url \\\\\\n in the uri %s'%self.currenturi))\\n continue\\n temp_task.pagedata['edate_last_post_date']= datetime.\\\\\\n strftime(thread_time,\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n last_post_author = thread.find('div', 'fp_topic_last_post_author', title=True)\\n if last_post_author:\\n temp_task.pagedata['et_thread_last_post_author'] = last_post_author['title']\\n try:\\n author_tag = thread.find('span', 'fp_topic_author')\\n author_name_tag = author_tag.span.extract()\\n temp_task.pagedata['et_author_name'] = stripHtml(author_name_tag.renderContents())\\n except:\\n log.info(self.log_msg('Author name not found in url %s'%self.currenturi))\\n try:\\n temp_task.pagedata['ei_thread_views_count'] = int(stripHtml(author_tag.renderContents()).replace(',', '').replace('views',''))\\n except:\\n log.info(self.log_msg('Views count not found in the url\\\\\\n %s'%self.currenturi))\\n try:\\n replies_str = stripHtml(thread.find('div', 'fp_topic_content_replies').renderContents()).replace(',', '')\\n if re.match('\\\\d+', replies_str):\\n temp_task.pagedata['ei_thread_replies_count'] = int(replies_str)\\n except:\\n log.exception(self.log_msg('Replies count not found in the url\\\\\\n %s'%self.currenturi))\\n self.linksOut.append(temp_task)\\n return True\",\n \"def __addThreadAndPosts(self):\\n self.__genre = \\\"Review\\\"\\n self.__hierarchy = []\\n self.__baseuri = 'http://forums.seagate.com'\\n self.__task_elements_dict = {\\n 'priority':self.task.priority,\\n 'level': self.task.level,\\n 'last_updated_time':datetime.strftime(datetime.utcnow()\\n , \\\"%Y-%m-%dT%H:%M:%SZ\\\"), \\n 'pickup_date':datetime.strftime(datetime.utcnow(), \\n \\\"%Y-%m-%dT%H:%M:%SZ\\\"), \\n 'connector_instance_log_id': \\\\\\n self.task.connector_instance_log_id, \\n 'connector_instance_id':\\n self.task.connector_instance_id, \\n 'workspace_id':self.task.workspace_id, \\n 'client_id':self.task.client_id, \\n 'client_name':self.task.client_name, \\n 'versioned':False, \\n 'category':self.task.instance_data.get('category',''), \\n 'task_log_id':self.task.id }\\n self.__setParentPage()\\n question_post = self.soup.find('div', 'lia-message-view')\\n self.__addPost(question_post, True)\\n self.__goToLastPage()\\n while self.__iteratePosts():\\n try:\\n self.currenturi = self.__baseuri + self.soup.find('span', \\\\\\n 'lia-paging-page-link', text='Previous').findParent('a')\\\\\\n ['href'].split(';')[0]\\n self.__setSoupForCurrentUri()\\n except:\\n log.info(self.log_msg('No Previous URL found for url \\\\\\n %s'%self.currenturi))\\n break\\n return True\",\n \"def index(request, archive=False):\\n context = {'archive':archive}\\n posts = Post.objects.all()\\n if not archive:\\n posts = posts[:10]\\n context['posts'] = posts\\n if request.user.is_authenticated():\\n #These are the new news items the logged in user has\\n context['new_posts'] = NewBlog.objects.filter(user=request.user)\\n return render(request, 'blog/index.html', context)\",\n \"def topic_list(request, forum_id, pagination_id=1):\\n\\ttry:\\n\\t\\ttopics = Topic.objects.order_by('-is_global', '-is_sticky', '-topic_modification_date').filter(Q(topic_forum=forum_id) | Q(is_global='1'))\\n\\t\\tforum_name = Forum.objects.get(id=forum_id)\\n\\t\\tforum_name = forum_name.forum_name\\n\\texcept:\\n\\t\\treturn HttpResponseRedirect('/forum/')\\n\\treturn object_list(\\n\\t\\trequest,\\n\\t\\tTopic.objects.order_by('-is_global', '-is_sticky', '-topic_modification_date').filter(Q(topic_forum=forum_id) | Q(is_global='1')),\\n\\t\\tpaginate_by = 10,\\n\\t\\tallow_empty = True,\\n\\t\\tpage = pagination_id,\\n\\t\\textra_context = {'forum': forum_id, 'perms': list_perms(request), 'forum_name': forum_name},\\n\\t\\ttemplate_name = 'myghtyboard/topics_list.html')\",\n \"def latest_blog_posts(self, request, *args, **kwargs):\\n context = self.get_context(request, *args, **kwargs)\\n context[\\\"latest_posts\\\"] = MyblogDetailPage.objects.live().public()[:1] \\n return render(request, \\\"myblog/latest_posts.html\\\", context)\",\n \"def get_posts(self): #return list of posts that are associated with this blog_id\\n return Post.find_posts_for_blog_id(self.blog_id) #this will return a list of posts objects\",\n \"def list(self, request):\\n # Get all Post records from the database\\n posts = Post.objects.all()\\n \\n \\n\\n # Support filtering Posts by type\\n # http://localhost:8000/Posts?type=1\\n #\\n # That URL will retrieve all tabletop Posts\\n \\n\\n category = self.request.query_params.get('category', None)\\n if category is not None:\\n posts = posts.filter(category__id=category)\\n \\n user = RareUser.objects.get(user=request.auth.user)\\n active = self.request.query_params.get('active', None)\\n my_subscriptions=Subscription.objects.filter(follower_id=user.id)\\n # print(my_subscriptions)\\n \\n if active is not None:\\n print(\\\"my post navbar is being clicked\\\")\\n # 1)get the posts where the user on the post equals the id on the user\\n\\n # 2)get the subscriptions where the follower on the subscription equals the id on the user\\n # 3)get the posts where the user on the post equals the author in the subscription\\n\\n home_page_posts=[]\\n\\n followed_users=RareUser.objects.filter(rareusers_author__follower=user)\\n for author in followed_users:\\n subscribed_post=list(posts.filter(user=author))\\n home_page_posts=home_page_posts+subscribed_post\\n\\n only_my_posts = list(posts.filter(user__id=user.id))\\n home_page_posts=home_page_posts+only_my_posts\\n\\n # for subscription in my_subscriptions:\\n \\n # subscribed_post=posts.filter(user__id=subscription.author_id)\\n # # my_list.append(subscribed_post)\\n # # print(subscribed_post)\\n # # my_list.append(only_my_posts)\\n \\n posts=home_page_posts\\n \\n \\n users = self.request.query_params.get('user', None)\\n if users is not None:\\n \\n posts = posts.filter(user__id=user)\\n \\n\\n title = self.request.query_params.get('title', None)\\n if title is not None:\\n posts = posts.filter(title__contains=title)\\n\\n # subscribers=Subscription.objects.filter(follower=user.id)\\n # for subscriber in subscribers:\\n # subscriptionPosts=posts.filter(user=subscriber.author)\\n # posts.append(subscriptionPosts)\\n\\n for post in posts:\\n if post.user == user:\\n post.my_post =True\\n else:\\n post.my_post =False\\n\\n \\n\\n serializer = PostSerializer(\\n posts, many=True, context={'request': request})\\n\\n return Response(serializer.data)\",\n \"def test_discussion_filter_forum(self):\\n forum1 = ForumFactory(name=u'Forum 1')\\n thread1 = ThreadFactory(forum=forum1, title=u'audio 1')\\n PostFactory(thread=thread1)\\n\\n forum2 = ForumFactory(name=u'Forum 2')\\n thread2 = ThreadFactory(forum=forum2, title=u'audio 2')\\n PostFactory(thread=thread2)\\n\\n self.refresh()\\n\\n qs = {'a': 1, 'w': 4, 'format': 'json'}\\n\\n for forum_id in (forum1.id, forum2.id):\\n qs['forum'] = int(forum_id)\\n response = self.client.get(reverse('search.advanced'), qs)\\n eq_(json.loads(response.content)['total'], 1)\",\n \"def posts_per_topic_all(request, pk):\\n #update is_expired in all posts\\n update_posts_expiration()\\n #get all posts with a certain topic\\n posts = Post.objects.filter(topic=pk)\\n serializer = ViewPostSerializer(posts, many=True)\\n return Response(serializer.data)\",\n \"def topic(request, topic_id):\\n posts = Post.objects.filter(topic=topic_id).order_by(\\\"created\\\")\\n posts = mk_paginator(request, posts, DJANGO_SIMPLE_FORUM_REPLIES_PER_PAGE)\\n topic = Topic.objects.get(pk=topic_id)\\n return render_to_response(\\\"forum/topic.html\\\", add_csrf(request, posts=posts, pk=topic_id,\\n topic=topic), context_instance=RequestContext(request))\",\n \"def list_posts(request):\\n if request.method == 'POST':\\n category = request.POST.get('category', False)\\n posts = Post.objects.select_related('author')\\\\\\n .filter(category=category)\\\\\\n .order_by('-modified')\\n # import pdb; pdb.set_trace()\\n return render(request, 'posts/index.html',\\n {'posts': posts})\\n\\n posts = Post.objects.select_related('author').order_by('-modified')\\n likes = Likes.objects.select_related('post')\\n\\n return render(request, 'posts/index.html',\\n {'posts': posts})\",\n \"def feed(request):\\n followers = request.user.profile.followers.values_list('pk', flat=True)\\n posts = Post.objects.filter(author_id__in=followers)\\n\\n return render(request,\\n 'posts/feed.html',\\n {'posts': posts})\",\n \"def profile(request):\\n bugs = Bug.objects.filter(author=request.user)\\n features = Feature.objects.filter(author=request.user)\\n posts = ForumPost.objects.filter(author=request.user)\\n return render(request, 'profile.html', {'bugs': bugs,\\n 'features': features,\\n 'posts': posts})\",\n \"def find_posts_by_targetuser(self):\\n\\n if not self.threads:\\n raise Exception('No threads present in class. ' +\\n 'Run find_threads_on_board first.')\\n\\n title_strip_text = ' - Current Events Message Board - GameFAQs'\\n post_bodies = []\\n page_counter = 0\\n total_pages = len(self.threads)\\n for thread in self.threads:\\n thread_url = thread[0]\\n resp = self.session.get(thread_url)\\n thread_pages = self.find_num_pages(resp.text)\\n total_pages += thread_pages - 1\\n soup = bs(resp.text, 'html.parser')\\n postbody = ''\\n\\n for page in range(thread_pages):\\n page_counter += 1\\n logging.debug('Loading page {} of {}'\\n .format(page_counter, total_pages))\\n if page > 0:\\n thread_url = thread[0] + '?page={}'.format(page)\\n resp = self.session.get(thread_url)\\n soup = bs(resp.text, 'html.parser')\\n # If target user exists anywhere in page.\\n if soup.find_all(string=self.targetuser):\\n # Find all posts created by target user.\\n for post in soup.find_all(string=self.targetuser):\\n for parent in post.parents:\\n if parent.name == \\\"td\\\" and parent['class'][0] == 'msg':\\n # Find post time, replace &nsbp with\\n # a normal space.\\n post_time_str = parent.find('span', class_='post_time')['title']\\\\\\n .replace(u'\\\\xa0', ' ')\\n # Convert string time to datetime.\\n post_time_dt = datetime.strptime(post_time_str, '%m/%d/%Y %I:%M:%S %p')\\n # If post is newer than last time checked.\\n # if True: # <-- Used for debugging.\\n if self.last_time_checked < post_time_dt:\\n logging.info('Post Found! Time - ' + post_time_str)\\n title = soup.title.string\\\\\\n .replace(title_strip_text, '')\\n\\n # Remove user_subnav from parent.parent\\n parent.parent.find('ul').decompose()\\n post_body = str(parent.parent)\\n post_bodies.append([post_body,\\n thread_url,\\n title,\\n post_time_str])\\n break\\n else:\\n logging.debug(\\\"Post not more recent than last_time_checked.\\\")\\n else:\\n logging.debug(\\\"Username not found.\\\")\\n\\n logging.info('{} pages checked, {} found containing {}.'\\n .format(page_counter, len(post_bodies), self.targetuser))\\n self.targetuser_posts = post_bodies\",\n \"def posts(request):\\n id_user = request.session.get('id_user')\\n if id_user is None:\\n request.session['res'] = 'Warn'\\n messages.add_message(request, messages.WARNING,\\n \\\"The session has expired\\\")\\n return HttpResponseRedirect(reverse('home'))\\n form = PostForm()\\n if request.session['user_type'] == 1:\\n return render(request, \\\"posts.html\\\",\\n {\\\"posts\\\": Post.objects.filter(\\n author_id=id_user).order_by('date_pub'),\\n \\\"messages\\\": messages.get_messages(request),\\n \\\"form\\\": form,\\n },\\n )\\n else:\\n return render(request, \\\"posts.html\\\",\\n {\\\"posts\\\": Post.objects.all().order_by('date_pub'),\\n \\\"messages\\\": messages.get_messages(request),\\n \\\"users\\\": User.objects.all().order_by('real_name'),\\n \\\"form\\\": form,\\n },\\n )\",\n \"async def getposts(ctx, theme):\\n q = Query(limit=100, tag=\\\"travelfeed\\\")\\n for post in Discussions_by_created(q):\\n continent_code = get_location(post['body'], \\\"continentcode\\\")\\n link = \\\"https://steemit.com/\\\"+construct_authorperm(post['author'], post['permlink'])\\n if post['author'] in curatorlist or post['author'] in whitelist:\\n continue\\n elif (continent_code == \\\"AF\\\" or continent_code == \\\"OC\\\" or continent_code == \\\"AN\\\") and (theme == \\\"Africa\\\" or theme == \\\"Oceania\\\" or theme ==\\\"Australia\\\" or theme == \\\"australiaoceaniaafrica\\\"):\\n await bot.say(link)\\n elif continent_code == \\\"AS\\\" and theme == \\\"Asia\\\":\\n await bot.say(link)\\n elif continent_code == \\\"EU\\\" and theme == \\\"Europe\\\":\\n await bot.say(link)\\n elif (continent_code == \\\"SA\\\" or continent_code == \\\"NA\\\") and theme == \\\"America\\\":\\n await bot.say(link)\\n elif (\\\"food\\\" in post['body'] or \\\"eat\\\" in post['body'] or \\\"restaurant\\\" in post['body']) and (theme == \\\"Food\\\" or theme ==\\\"foodoftheworld\\\"):\\n await bot.say(link)\\n elif (\\\"advice\\\" in post['body'] or \\\"budget\\\" in post['body'] or \\\"learn\\\" in post['body']) and (theme == \\\"Advice\\\" or theme == \\\"Travel Advice\\\" or theme == \\\"traveladvice\\\"):\\n await bot.say(link)\",\n \"def index():\\r\\n db = get_db()\\r\\n cur = db.cursor()\\r\\n cur.execute(\\r\\n 'SELECT p.id, title, body, created, author_id, username'\\r\\n ' FROM novel.post p JOIN novel.user u ON p.author_id = u.id'\\r\\n ' ORDER BY created DESC'\\r\\n )\\r\\n posts = cur.fetchall()\\r\\n return render_template('novel/index.html', posts=posts)\",\n \"def get(self):\\n\\n page = self.request.get('page')\\n if page:\\n page = int(page)\\n else:\\n page = 1\\n limit = 10\\n offset = limit * (page - 1)\\n posts = Post.all().order('-created').fetch(limit=limit, offset=offset)\\n number_posts = Post.all().count()\\n total_pages = number_posts / limit\\n if number_posts % limit:\\n total_pages += 1\\n\\n self.render('home.html', posts=posts, page=page,\\n total_pages=total_pages, user=self.user)\",\n \"def show_blog(request, primkey = None):\\n dajax = Dajax()\\n \\n dajax.add_css_class('#showcase', 'hide')\\n dajax.add_css_class('#sponsors', 'hide')\\n \\n html_content = \\\"\\\"\\n \\n if primkey:\\n pass\\n show_alert(dajax, \\\"info\\\", \\\"This part has not yet been completed\\\")\\n else:\\n bloglist = Thread.objects.all()\\n #print bloglist\\n for i in bloglist:\\n i.description = (i.description[:100] + \\\" ....\\\") if len(i.description) > 100 else i.description\\n html_content = render_to_string('blog/show.html', {'bloglist': bloglist}, RequestContext(request))\\n \\n if html_content:\\n dajax.assign('#features', 'innerHTML', html_content);\\n \\n return dajax.json()\",\n \"def all_blogs(request):\\n\\n posts = Post.objects.all()\\n\\n context = {\\n 'posts': posts\\n }\\n\\n return render(request, 'blog/blog.html', context)\",\n \"def full_listing(request, urlname):\\n\\tif request.user.is_authenticated():\\n\\t\\tblog = Blog.qa_objects.get(urlname=urlname)\\n\\t\\tposts = BlogEntry.qa_objects.filter(blog=blog, posting_time__lte=datetime.now()).order_by('-posting_time')\\n\\telse:\\n\\t\\tblog = Blog.objects.get(urlname=urlname)\\n\\t\\tposts = BlogEntry.objects.filter(blog=blog).order_by('-posting_time')\\n\\treturn render_to_response('blogs/full.html', {'blog': blog, 'posts': posts}, context_instance=RequestContext(request))\",\n \"def render_posts(self, **params):\\n\\n if \\\"user_posts\\\" in params:\\n posts = params['user_posts']\\n else:\\n posts = Post.get_all()\\n\\n rendered_posts = \\\"\\\"\\n for post in posts:\\n rendered_posts += self.render_post(post, **params)\\n\\n self.render(\\\"blog/blog.html\\\", rendered_posts=rendered_posts)\",\n \"def show_pages():\\n page_id=request.args['page_id']\\n\\n if str(request.args['r_type'])==\\\"Create\\\":\\n return render_template(\\\"write.html\\\",page_id=page_id)\\n\\n if request.args['referrer']==\\\"home\\\":\\n graph = facebook.GraphAPI(page_id)\\n pages = graph.get_object('me')\\n is_published = request.args['r_type'] == \\\"Show_Published\\\"\\n print_me(is_published)\\n res = graph.get_connections(pages['id'], 'promotable_posts', is_published=is_published, limit=8)\\n else:\\n res = requests.request(\\\"GET\\\",request.args['next']).json()\\n posts,next_page = get_posts_from_graph_object(res)\\n views_dict={}\\n thread_list = []\\n message_dict={} \\n id_list=[]\\n for post in posts:\\n if \\\"message\\\" in post:\\n post_id = post['id']\\n message_dict[post_id] = post['message']\\n id_list.append(post_id)\\n thread=Thread(target=get_views,args=(page_id, post_id, views_dict) )\\n thread.start()\\n thread_list.append(thread)\\n\\n for thread in thread_list:\\n thread.join()\\n posts_info=[]\\n for i in id_list:\\n posts_info.append( (message_dict[i], views_dict[i] ) )\\n return render_template('show_posts.html', posts_info=(posts_info,next_page,page_id))\",\n \"def parse_thread(self, response):\\n item = DataakForumItem()\\n\\n # xpath selectors\\n thread = '//span[@class=\\\"active\\\"]/text()'\\n navpath = '//div[@class=\\\"navigation\\\"]/a/text()'\\n posts = '//div[@class=\\\"post \\\"]'\\n # author_not_admin = '//div[@class=\\\"author_information\\\"]//a/text()'\\n author = './/div[@class=\\\"author_information\\\"]//a/text() | .//div[@class=\\\"author_information\\\"]//em/text()'\\n body = './/div[@class=\\\"post_body scaleimages\\\"]/text() | .//div[@class=\\\"post_body scaleimages\\\"]//*/text()'\\n\\n posts_selector = response.xpath(posts)\\n for post in posts_selector:\\n item['url'] = response.url\\n # self.log(response.url)\\n\\n item['thread'] = response.xpath(thread).extract_first()\\n # self.log(\\\"thread: %s\\\" % response.xpath(thread).extract())\\n\\n # get the last item which is the forum name\\n item['forum'] = response.xpath(navpath).extract()[-1]\\n # self.log(\\\"nav path: %s\\\" % response.xpath(navpath).extract())\\n\\n item['author'] = post.xpath(author).extract_first()\\n # self.log(\\\"author: %s\\\" % post.xpath(author).extract())\\n\\n item['body'] = post.xpath(body).extract()\\n # self.log(\\\"body: %s\\\" % post.xpath(body).extract())\\n\\n yield item\",\n \"def getMyPosts():\\n \\n cur, user_id = initialise(3)\\n cur.execute(\\\"SELECT username FROM users WHERE id = ?\\\", [user_id])\\n name = cur.fetchall()[0][0]\\n cur.execute(\\\"SELECT * FROM posts WHERE name = ?\\\", [name])\\n posts = cur.fetchall()\\n return posts\",\n \"def get_posts(self):\\n return self.blog_posts.all()\",\n \"def find_posts(self):\\n\\n posts = self.soup.find_all(\\\"div\\\", class_=\\\"_401d\\\")\\n print(f'[Scraper] Found {len(posts)} posts.')\\n\\n for post in posts:\\n try: \\n text = post.find(\\\"div\\\", class_=\\\"_6-cp\\\").div.get_text()\\n a_tag = post.find('span', class_=\\\"_6-cm\\\").find('a')\\n link = \\\"https://www.facebook.com\\\" + a_tag['href'] \\n print(f\\\"[Scraper] {link}\\\")\\n print(f\\\"[Scraper] {text}\\\")\\n except:\\n print(\\\"Error occured. Skipped a result.\\\")\",\n \"def index(request):\\n # most of the heavy lifting is handled by Angular, on the front end\\n return render(request, 'forum/index.html')\",\n \"def test_list_posts_on_topic(self):\\n url = reverse('post-list', args=[self.topic1.url_name])\\n response = self.client.get(url)\\n\\n self.assertEqual(response.status_code, status.HTTP_200_OK)\\n self.assertEqual(response.data['count'], 2)\",\n \"def get(self, request, user_mail, post_id):\\n\\n all_posts = Evento.objects.all()\\n self.context['user_mail'] = user_mail\\n self.context['post_id'] = post_id\\n #self.context['posts'] = all_posts\\n\\n xy = \\\"\\\"\\n for i in all_posts:\\n xy = xy + \\\" \\\" + i.etiquetas\\n\\n xy = xy.split()\\n\\n self.context['posts'] = xy\\n\\n\\n #all_posts = Post.objects.all()\\n #self.context['posts'] = all_posts\\n return render(request, self.template, self.context)\",\n \"def get_queryset(self):\\n return Post.objects.order_by('-posted')[:5]\",\n \"def forums(self):\\n return forums.Forums(self)\",\n \"def index(request):\\n from ..models.post import Post\\n collection = Post.objects.all()\\n # import pdb;pdb.set_trace()\\n return render(request,'index.html',{\\\"collection\\\":collection})\",\n \"def last_topic_list(request):\\n\\ttopics = Topic.objects.order_by('-topic_modification_date')[:50]\\n\\tfor i in topics:\\n\\t\\tpmax = i.post_set.all().count()/10\\n\\t\\tpmaxten = i.post_set.all().count()%10\\n\\t\\tif pmaxten != 0:\\n\\t\\t\\ti.pagination_max = pmax+1\\n\\t\\telse:\\n\\t\\t\\ti.pagination_max = pmax\\n\\tforum_name = _('Last Active Topics')\\n\\treturn render_to_response(\\n\\t\\t'myghtyboard/mytopics_list.html',\\n\\t\\t{'topics': topics, 'forum_name': forum_name, 'perms': list_perms(request)},\\n\\t\\tcontext_instance=RequestContext(request))\",\n \"def index(self):\\n \\n return self.view.render('index.html', {\\\"posts\\\"=posts})\",\n \"def get_queryset(self, request):\\n qs = super(ExamAdmin, self).get_queryset(request)\\n if request.user.is_superuser:\\n return qs.filter(content_type__lt=3)\\n return qs.filter(topic_id__in=request.user.profile.topics.all(), content_type__lt=3)\",\n \"def post_list(request):\\n # Only show the posts that have been published\\n posts = Post.objects.filter(date_published__isnull=False)\\n return render(request,\\n 'blog/post_list.html',\\n {'posts': posts}\\n )\",\n \"def posts_index():\\n posts = Post.query.all()\\n return render_template('posts.html', posts=posts, post=None)\",\n \"def community_post_detail_view(request, slug):\\n post = CommunityPostModel.objects.get(slug=slug) # Get the post\\n posts = CommunityPostModel.objects.all()[:3] # Get the latest 3 posts\\n author = UserModel.objects.get(id=post.author.id) # Get the author\\n\\n my_article = False # Set the flag to false\\n if request.user == post.author: # If the user is the author, set the flag to true\\n my_article = True # Set the flag to true\\n\\n context = { # Pass the variables to the template\\n 'post': post,\\n 'latest_posts': posts,\\n 'author': author,\\n 'my_article': my_article,\\n }\\n return render(request,\\n 'pages/patient-community/community-post-details.html',\\n context) # render the patient community detail page\",\n \"def all(request):\\n\\n posts = Post.objects.filter()\\n\\n print(\\\"made a query\\\")\\n return render(request, 'posts/all.html', {'posts':posts})\",\n \"def display_blogcontent(request):\\n\\n blogposts = BlogPost.objects.all()\\n template = 'blog/blog.html'\\n context = {\\n 'blogposts': blogposts,\\n }\\n\\n return render(request, template, context)\",\n \"def iter_all_posts(self, limit=None): # new\\n feed = self.get_feed(limit=999999)\\n posts = feed[\\\"threads\\\"]\\n if limit:\\n posts = posts[:limit]\\n for post in posts:\\n yield post\",\n \"def get_queryset(self):\\r\\n\\r\\n user = get_object_or_404(User, username=self.kwargs.get('username'))\\r\\n return Post.objects.filter(author=user).order_by('-date_posted')\",\n \"def get(self, request, user_mail, post_id):\\n #all_posts = Post.objects.all()\\n #self.context['posts'] = all_posts\\n all_posts = Evento.objects.all()\\n self.context['posts'] = all_posts\\n all_events = RegEvento.objects.all()\\n self.context['eventos'] = all_events\\n \\n self.context['usuario'] = user_mail\\n\\n self.context['evento'] = post_id\\n\\n all_staff = AsigStaff.objects.all()\\n self.context['staffs'] = all_staff\\n all_user = User.objects.get(username = user_mail)\\n self.context['user'] = all_user\\n\\n return render(request, self.template, self.context)\",\n \"def show_home():\\r\\n posts = Post.query.order_by(Post.created_at.desc()).limit(5).all()\\r\\n\\r\\n return render_template('home.html', posts=posts)\",\n \"def topic_less(request, topic_id):\\n posts = Post.objects.filter(topic=topic_id).order_by(\\\"-created\\\")[:3]\\n posts = mk_paginator(request, posts, DJANGO_SIMPLE_FORUM_REPLIES_PER_PAGE)\\n topic = Topic.objects.get(pk=topic_id)\\n return render_to_response(\\\"forum/topic_less.html\\\", add_csrf(request, posts=posts, pk=topic_id,\\n topic=topic), context_instance=RequestContext(request))\",\n \"def homepage(request):\\n limit = 7\\n featured_marketer_list = (\\n PimpUser.objects\\n .filter(featured=True)\\n .filter(usertype=PimpUser.MARKETER)\\n .order_by('-date_joined')[:limit]\\n )\\n featured_cause_list = (\\n PimpUser.objects\\n .filter(featured=True)\\n .filter(usertype=PimpUser.CAUSE)\\n .order_by('-date_joined')[:limit]\\n )\\n news_post_list = (\\n NewsPost.objects\\n .order_by('-created_at')[:3]\\n )\\n\\n context = {\\n 'featured_marketer_list': featured_marketer_list,\\n 'featured_cause_list': featured_cause_list,\\n 'news_post_list': news_post_list,\\n }\\n\\n return render(\\n request,\\n 'index.html',\\n context\\n )\",\n \"def get_posts():\\n db = psycopg2.connect(\\\"dbname=forum\\\")\\n c = db.cursor()\\n query = \\\"SELECT content, time FROM posts ORDER BY time DESC\\\"\\n c.execute(query)\\n rows = c.fetchall()\\n POSTS = rows\\n db.close()\\n return POSTS\",\n \"def community_home_view(request):\\n posts = CommunityPostModel.objects.all() # Get all posts\\n\\n is_patient = False # Set the flag to false\\n if request.user.is_authenticated and request.user.is_patient: # If user is authenticated and is a patient, set the flag to true\\n is_patient = True # Set the flag to true\\n\\n paginator = Paginator(posts, 5) # Show 5 posts per page\\n page = request.GET.get('page', 1) # Get the page number\\n try:\\n posts = paginator.page(page) # Get the page\\n except PageNotAnInteger: # If page is not an integer, deliver first page.\\n posts = paginator.page(1)\\n except EmptyPage: # If page is out of range, deliver last page of results.\\n posts = paginator.page(paginator.num_pages)\\n\\n context = { # Pass the variables to the template\\n 'posts': posts,\\n 'latest_posts': posts[:3], # Get the latest 3 posts\\n 'is_patient': is_patient,\\n }\\n return render(request, \\\"pages/patient-community/community-home.html\\\", context)\",\n \"def view_post(id):\\n # all_category = postCategory.get_categories()\\n posts = Post.query.get(id)\\n\\n if posts is None:\\n\\n abort(404)\\n \\n comment = Comments.get_comments(id)\\n print(comment)\\n count_likes = Votes.query.filter_by(posts_id=id, vote=1).all()\\n count_dislikes = Votes.query.filter_by(posts_id=id, vote=2).all()\\n return render_template('view-post.html', posts = posts, comment = comment, count_likes=len(count_likes), count_dislikes=len(count_dislikes))\",\n \"def messages_view(request):\\n if request.user.is_authenticated:\\n user_info = models.UserInfo.objects.get(user=request.user)\\n friends=user_info.friends.all()\\n\\n # TODO Objective 9: query for posts (HINT only return posts needed to be displayed)\\n posts = []\\n posts = models.Post.objects.all()\\n posts=posts[::-1]\\n\\n post_visits = request.session.get('post_visits', 0)\\n allPosts=[]\\n for post in posts:\\n allPosts.append(post)\\n\\n\\n\\n listUpperBound = post_visits + 2\\n postSize = len(allPosts)\\n\\n new_list = []\\n if listUpperBound < postSize - 1:\\n for i in range(listUpperBound):\\n new_list.append(allPosts[i])\\n else:\\n new_list = allPosts\\n\\n # TODO Objective 10: check if user has like post, attach as a new attribute to each post\\n\\n context = { 'user_info':user_info,\\n 'posts' : posts,\\n 'friends':friends,\\n 'new_list':new_list}\\n\\n return render(request,'messages.djhtml',context)\\n\\n request.session['failed'] = True\\n return redirect('login:login_view')\",\n \"def articles():\\n \\n # Parse through RSS feed of Get Rich Slowly\\n feed = feedparser.parse(\\\"http://www.getrichslowly.org/blog/feed/\\\")\\n \\n # Get current username\\n username = get_user()\\n \\n return render_template(\\\"articles.html\\\", username=username, feed=feed)\",\n \"def index(request):\\n # Generate counts of some of the main objects\\n num_posts=Post.objects.all()\\n num_authors=Author.objects.count() # The 'all()' is implied by default.\\n # Render the HTML template index.html with the data in the context variable\\n return render(\\n request,\\n 'index.html',\\n context={'num_posts':num_posts,'num_authors':num_authors},\\n )\",\n \"def show():\\n context = {\\n \\\"posts\\\": get_posts()[::-1]\\n }\\n return render_template(\\\"show.html\\\", **context)\",\n \"def posts_for_feed():\\n user_id = session.get('user_id')\\n friend_posts = Post.query.join(Friend, db.and_(Post.user_id == Friend.user_2,\\n Friend.active == True)).outerjoin(Comment, db.and_(Comment.post_id == Post.post_id,\\n Comment.active == True)).filter(Friend.user_1 == user_id,\\n Post.active == True).order_by(Post.post_id.desc()).all()\\n\\n post_list = []\\n for post in friend_posts:\\n post_list.append(post.to_dict_for_json())\\n\\n resp = make_response(jsonify(post_list), 200)\\n return resp\",\n \"def get_posts(request):\\n posts = Post.objects.order_by(\\\"created_date\\\")\\n return render(request, \\\"blogposts.html\\\", {\\\"posts\\\": posts})\",\n \"def GET_side_posts(self, *a, **kw):\\r\\n # Server side cache is also invalidated when new article is posted\\r\\n return self.render_cached('side-posts', RecentArticles, g.side_posts_max_age)\",\n \"def entries_index(request):\\n blog_entries = Entry.objects.filter(status=2).order_by('-pub_date')\\n paginator = Paginator(blog_entries, 4)#4 posts/page\\n try:\\n page = int(request.GET.get('page','1'))\\n except ValueError:\\n page = 1\\n try:\\n entries = paginator.page(page)\\n except (EmptyPage, InvalidPage):\\n entries = paginator.page(paginator.num_pages)\\n return render_to_response('blog/blog.html', {'entries':entries}, RequestContext(request))\",\n \"def show_posts(page):\\n if not session.get('logged_in'):\\n posts = Post.query.filter_by(visible=True)\\n else:\\n posts = Post.query\\n pagination = posts.order_by(Post.datetime.desc()).paginate(page=page, \\n per_page=current_app.config['POSTS_PER_PAGE'])\\n if not pagination.total: flash(\\\"No posts so far\\\")\\n return render_template('posts.html', pagination=pagination,\\n endpoint_func=lambda x: url_for('main.show_posts', page=x))\",\n \"def post(request):\\n home_user = request.user.profile\\n\\n num_activities = Activity.objects.count()\\n AllActivites = Activity.objects.all()\\n\\n\\n # Generate counts of some of the main objects\\n\\n\\n\\n\\n\\n\\n\\n\\n context = {\\n 'huser': home_user,\\n 'Lname' : home_user.user.last_name,\\n 'Fname': home_user.user.first_name,\\n 'allactivites': AllActivites,\\n }\\n\\n # Render the HTML template index.html with the data in the context variable\\n return render(request, 'post.html', context=context)\",\n \"def get(self, request):\\n\\n all_posts = Evento.objects.all()\\n #self.context['posts'] = all_posts\\n\\n xy = \\\"\\\"\\n for i in all_posts:\\n xy = xy + \\\" \\\" + i.etiquetas\\n\\n xy = xy.split()\\n\\n self.context['posts'] = xy\\n\\n\\n #all_posts = Post.objects.all()\\n #self.context['posts'] = all_posts\\n return render(request, self.template, self.context)\",\n \"def __processForumUrl(self):\\n threads = [each.findParent('tr') for each in self.soup.find('table',\\\\\\n id='threadslist').findAll('td', id=re.compile('td_threadtitle_'))]\\n for thread in threads:\\n try:\\n if thread.find('img', src=re.compile('sticky.gif$')):\\n log.info(self.log_msg('Its a Sticky Thread, Ignore it in the \\\\\\n url %s'%self.currenturi)) \\n continue\\n self.__total_threads_count += 1\\n if self.__total_threads_count > self.__max_threads_count:\\n log.info(self.log_msg('Reaching maximum post,Return false \\\\\\n from the url %s'%self.currenturi))\\n return False \\n \\n try:\\n th=thread.findAll('td',recursive=False)\\n date_tag = stripHtml(th[3].renderContents()).splitlines()\\\\\\n [0] .strip() \\n if date_tag.startswith('Today'):\\n date_tag = date_tag.replace('Today', datetime.strftime\\\\\\n (datetime.utcnow(),'%m-%d-%Y')) \\n elif date_tag.startswith('Yesterday'):\\n date_tag = date_tag.replace('Yesterday', datetime.\\\\\\n strftime((datetime.utcnow()-timedelta\\\\\\n (days=1)),'%m-%d-%Y')) \\n thread_time = datetime.strptime(date_tag,'%m-%d-%Y %I:%M %p')\\n except:\\n log.exception(self.log_msg('last post not found in the url\\\\\\n %s'%self.currenturi)) \\n if checkSessionInfo('Search', self.session_info_out, thread_time, \\\\\\n self.task.instance_data.get('update')):\\n log.info(self.log_msg('Session info Returns True for %s'%\\\\\\n self.currenturi))\\n log.info(thread_time)\\n return False\\n self.__last_timestamp = max(thread_time , self.__last_timestamp )\\n temp_task=self.task.clone() \\n try:\\n \\n s=th[2].find('a', id=re.compile('thread_title_\\\\d+'))['href'] \\n temp_task.instance_data[ 'uri' ] = self.__baseuri + re.sub\\\\\\n ('\\\\?s=.*?&','?',s)\\n except:\\n log.exception(self.log_msg('uri not found in the url\\\\\\n %s'%self.currenturi)) \\n continue \\n try:\\n temp_task.pagedata['edate_last_post_date'] = datetime.strftime\\\\\\n (thread_time, \\\"%Y-%m-%dT%H:%M:%SZ\\\") \\n except: \\n log.info(self.log_msg('last post date not found in the url\\\\\\n %s'%self.currenturi)) \\n try: \\n temp_task.pagedata['et_author_name'] = stripHtml(th[2].\\\\\\n find('div','smallfont').renderContents()) \\n except:\\n log.info(self.log_msg('author name not found in the url\\\\\\n %s'%self.currenturi)) \\n try: \\n temp_task.pagedata['et_last_post_author'] = \\\\\\n stripHtml(th[3].renderContents()).\\\\\\n splitlines()[-1].strip().replace('by','') \\n except:\\n log.info(self.log_msg('last post author not found in the url\\\\\\n %s'%self.currenturi)) \\n try: \\n temp_task.pagedata['ei_thread_views_count'] = int(stripHtml\\\\\\n (th[5].renderContents()))\\n except:\\n log.info(self.log_msg('views not found in the url\\\\\\n %s'%self.currenturi)) \\n try: \\n temp_task.pagedata['ei_thread_replies_count'] = int(stripHtml\\\\\\n (th[4].renderContents()))\\n except:\\n log.info(self.log_msg('reply not found in the url\\\\\\n %s'%self.currenturi)) \\n self.linksOut.append(temp_task)\\n except:\\n log.exception(self.log_msg('links not found')) \\n return True\",\n \"def print_posts(posts):\\n\\n click.echo()\\n for post in posts:\\n click.secho('%d. ' % post['rank'], nl=False)\\n click.secho('%s\\\\t' % post['title'], bold=True, fg=\\\"red\\\", nl=False)\\n click.secho('%s' % post['tagline'], fg=\\\"yellow\\\")\\n click.echo()\",\n \"def get(self, request):\\n\\n # recupera posts\\n posts = Post.objects.filter(owner__in=request.user.owned_blogs.all())\\n\\n # prepara el contexto de la plantilla\\n context = {\\n 'post_objects': posts\\n }\\n\\n # renderiza y devuelve la plantilla\\n return render(request, 'blogs/inicio.html', context)\",\n \"def faq(request):\\n \\n \\n question = Question.objects.all()\\n categories = Category.objects.all()\\n webdev = Question.objects.filter(category='1')\\n context = {\\n 'question': question,\\n }\\n return render(request, 'faq/faq.html', context)\",\n \"def index(request):\\n\\tif request.user.is_authenticated():\\n\\t\\tblogs = Blog.qa_objects.order_by('name')\\n\\telse:\\n\\t\\tblogs = Blog.objects.order_by('name')\\n\\treturn render_to_response('blogs/blogs.html', {'blogs': blogs}, context_instance=RequestContext(request))\",\n \"def fetch(self):\\r\\n self.genre=\\\"Review\\\"\\r\\n try:\\r\\n self.parent_uri = self.currenturi\\r\\n self.total_posts_count = 0\\r\\n self.last_timestamp = datetime( 1980,1,1 )\\r\\n self.max_posts_count = int(tg.config.get(path='Connector',key='silverlight_numresults'))\\r\\n self.hrefs_info = self.currenturi.split('/')\\r\\n if '/forums/t/' in self.currenturi:\\r\\n if not self.__setSoup():\\r\\n log.info(self.log_msg('Soup not set , Returning False from Fetch'))\\r\\n return False\\r\\n self.__getParentPage()\\r\\n self.__addPosts()\\r\\n return True\\r\\n else:\\r\\n if not self.__setSoup():\\r\\n log.info(self.log_msg('Soup not set , Returning False from Fetch'))\\r\\n return False\\r\\n while True:\\r\\n if not self.__getThreadPage():\\r\\n break\\r\\n try:\\r\\n self.currenturi = self.soup.find('a',text='Next >').parent['href']\\r\\n if not self.__setSoup():\\r\\n break\\r\\n except:\\r\\n log.info(self.log_msg('Next Page link not found'))\\r\\n break\\r\\n if self.linksOut:\\r\\n updateSessionInfo('Search', self.session_info_out,self.last_timestamp , None,'ForumThreadsPage', self.task.instance_data.get('update'))\\r\\n\\r\\n return True\\r\\n except:\\r\\n log.exception(self.log_msg('Exception in fetch'))\\r\\n return False\",\n \"def index(request):\\n # Generate counts of some of the main objects\\n ##num_books=Book.objects.all().count()\\n ##num_instances=BookInstance.objects.all().count()\\n # Available books (status = 'a')\\n ##num_instances_available=BookInstance.objects.filter(status__exact='a').count()\\n num_authors=Post.objects.count() # The 'all()' is implied by default.\\n model = Post\\n # Render the HTML template index.html with the data in the context variable\\n return render(\\n request,\\n 'index.html',\\n context={'num_authors':num_authors},\\n )\",\n \"def get(self):\\n return get_all_posts()\",\n \"def get_queryset(self):\\n\\t\\treturn Post.objects.order_by('-pub_date')[:5]\",\n \"def index():\\n\\n posts = models.Post.select()\\n return render_template('index.html', posts=posts)\",\n \"def postList(posts):\\n post_list = list()\\n for post in posts:\\n visible_to = list()\\n visible = post.visibleTo.all()\\n if visible:\\n for author in visible:\\n auth = \\\"{}/api/author/{}\\\".format(DOMAIN, author.id)\\n visible_to.append(auth)\\n\\n comments = commentList(post)\\n comment_url = \\\"{}/api/posts/{}/comments\\\".format(DOMAIN, post.id)\\n post_dict = {'author': addAuthor(post.author), 'title': post.title, 'description': post.description,\\n 'contentType': post.contentType, 'content': post.content, 'published': post.published,\\n 'visibility': post.visibility, 'visibleTo': visible_to, 'unlisted': post.unlisted, 'id': post.id,\\n 'comments': comments[:5], 'next': comment_url, 'count': len(comments),\\n 'origin': \\\"{}/api/posts/{}\\\".format(DOMAIN, post.id),\\n 'source': \\\"{}/api/posts/{}\\\".format(DOMAIN, post.id)}\\n post_list.append(post_dict)\\n return post_list\",\n \"def my_topic_list(request, show_user=False):\\n\\tif not show_user:\\n\\t\\tshow_user = str(request.user)\\n\\tif request.user.is_authenticated():\\n\\t\\ttopics = Topic.objects.order_by('-topic_modification_date').filter(topic_author=show_user)[:50]\\n\\t\\tforum_name = _('User Topics')\\n\\t\\treturn render_to_response(\\n\\t\\t\\t'myghtyboard/mytopics_list.html',\\n\\t\\t\\t{'topics': topics, 'forum_name': forum_name, 'perms': list_perms(request)},\\n\\t\\t\\tcontext_instance=RequestContext(request))\\n\\telse:\\n\\t\\treturn render_to_response('pages/bug.html', {'bug': _('You aren\\\\'t logged in')}, context_instance=RequestContext(request))\",\n \"def index(request):\\n\\n num_posts = BlogPost.objects.all().count()\\n num_bloggers = Blogger.objects.all().count()\\n latest_blog = BlogPost.objects.latest('post_date')\\n\\n context = {\\n 'num_posts': num_posts,\\n 'num_bloggers': num_bloggers,\\n 'latest_blog': latest_blog,\\n }\\n\\n return render(request, 'index.html', context=context)\",\n \"def get_teacher_topic_all():\\n topic_data = query_db(\\n \\\"SELECT topics.id, topics.name, classes.name FROM topics JOIN classes \\\"\\n \\\"ON topics.class_id=classes.id WHERE teacher_id=?;\\\",\\n [flask.session[\\\"id\\\"]],\\n )\\n topics = []\\n for topic in topic_data:\\n topic_dict_teacher = {}\\n topic_dict_teacher[\\\"id\\\"] = topic[0]\\n topic_dict_teacher[\\\"name\\\"] = flask.escape(str(topic[1]))\\n topic_dict_teacher[\\\"class\\\"] = flask.escape(str(topic[2]))\\n topics.append(topic_dict_teacher)\\n return topics\",\n \"def get_posts(self):\\n return Post.select().where (Post.user == self)\",\n \"def __getData(self, post,is_question=False):\\n page = {'entity':'question' if is_question else 'answer', 'uri':self.currenturi}\\n css_class_name = 'span' if is_question else 'div'\\n if post.find('div', text='Post temporarily unavailable'):\\n log.info(self.log_msg('Message Temporarily not available in url %s'%self.currenturi))\\n return False\\n if post.find('form', id='frm_quick_reply_submit'):\\n log.info(self.log_msg('It is not a post'))\\n return False\\n try:\\n page['et_author_name'] = stripHtml(post.find(css_class_name, 'vt_asked_by_user').renderContents())\\n except:\\n log.info(self.log_msg('Author name not found in %s'% self.currenturi))\\n try:\\n date_str = stripHtml(post.find(css_class_name,attrs={'class':re.compile('vt_.+?_timestamp')}).renderContents()).replace('replied ','').strip()\\n date_str = re.sub(\\\"(\\\\d+)(st|nd|rd|th)\\\",r\\\"\\\\1\\\", date_str)\\n page['posted_date'] = datetime.strftime(datetime.strptime(date_str\\n , 'on %B %d, %Y'),\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n except:\\n page['posted_date'] = datetime.strftime(datetime.utcnow(), \\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n log.info(self.log_msg('Date not be found in %s'% self.currenturi))\\n try:\\n page['et_author_category'] = stripHtml(post.find('span', 'vt_user_rank').renderContents())\\n except:\\n log.info(self.log_msg('Author name not found in %s'% self.currenturi))\\n try:\\n data_tag = post.find('div', 'vt_post_body')\\n ads_tag = post.findAll('div',attrs={'class':re.compile('vt_post_body_ad_[l/r]')})\\n [each.extract() for each in ads_tag]\\n page['data'] = stripHtml(data_tag.renderContents())\\n except:\\n log.info(post)\\n log.info(self.log_msg('Cannot find the Data for this Post %s'%self.currenturi))\\n page['data'] = ''\\n try:\\n if is_question:\\n page['title'] = stripHtml(str(post.find('div', 'vt_post_subject').span.next.next))\\n else:\\n page['title'] = 'Re: ' + self.__hierarchy[-1]\\n except:\\n log.info(self.log_msg('Cannot find the Data thread details for this Post %s'%self.currenturi))\\n page['title'] = ''\\n if not (page['data'] and page['title']):\\n log.info(self.log_msg('No data found in url %s'%self.currenturi))\\n return \\n if len(self.__hierarchy) >= 3:\\n page['et_thread_topic'] = self.__hierarchy[-1]\\n page['et_thread_forum'] = self.__hierarchy[-3]\\n page['et_thread_subforum'] = self.__hierarchy[-2]\\n return page\",\n \"def teacher_forum_create(request):\\n # Deleting admin-typed user session\\n # Deleting programmer-typed-user session\\n\\n # Get the current users\\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\\n\\n current_basic_user_profile = get_current_user_profile(\\n request,\\n User,\\n BasicUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Getting the teacher profile\\n current_teacher_profile = get_current_teacher_user_profile(\\n request,\\n User,\\n TeacherUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # forum create post form processing\\n empty_input = False\\n\\n if request.POST.get(\\\"teacher_forum_create_post_btn\\\"):\\n post_title = request.POST.get(\\\"post_title\\\")\\n post_content = request.POST.get(\\\"post_content\\\")\\n\\n # check if any of the inputs are empty\\n if bool(post_title) == False or post_title == \\\"\\\" \\\\\\n or bool(post_content) == False or post_content == \\\"\\\":\\n empty_input = True\\n else:\\n new_post = TeacherForumPost(\\n teacher=current_teacher_profile,\\n course=current_teacher_profile.teacher_course,\\n post_title=post_title,\\n content=post_content\\n )\\n new_post.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(new_post.id)+\\\"/\\\"\\n )\\n\\n data = {\\n \\\"current_basic_user\\\": current_basic_user,\\n \\\"current_basic_user_profile\\\": current_basic_user_profile,\\n \\\"current_teacher_profile\\\": current_teacher_profile,\\n \\\"empty_input\\\": empty_input,\\n }\\n\\n if \\\"teacher_user_logged_in\\\" in request.session:\\n return render(request, \\\"teacher_forum/create.html\\\", data)\\n else:\\n return HttpResponseRedirect(\\\"/\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.65342","0.6510963","0.6504755","0.6503333","0.6503325","0.65012","0.6413255","0.636724","0.6361781","0.63528556","0.634705","0.6344606","0.62456393","0.6225456","0.62220657","0.62189585","0.61770386","0.6170098","0.61636835","0.61625767","0.6136682","0.6131323","0.61308384","0.61240125","0.6123401","0.6112048","0.60892403","0.6085086","0.6084391","0.608316","0.6080312","0.60645676","0.6051773","0.605004","0.6047574","0.60151994","0.60007334","0.599696","0.59847134","0.59825295","0.5978072","0.59650415","0.5949776","0.5947536","0.593808","0.5936075","0.59344476","0.5923387","0.5916222","0.5912224","0.5905489","0.5897248","0.58959526","0.5890709","0.5884988","0.587953","0.58631563","0.5858017","0.58290136","0.58203983","0.581697","0.58071387","0.58012986","0.57950425","0.5794542","0.57907283","0.57730687","0.57706493","0.57604957","0.57603985","0.5755811","0.5755172","0.57419056","0.57396024","0.57364327","0.5732734","0.57319653","0.57317454","0.5725758","0.5723651","0.5723484","0.5718365","0.5716472","0.57137734","0.56926185","0.5686694","0.5676521","0.5675177","0.5674804","0.56672835","0.5667162","0.56610155","0.56580454","0.56480855","0.5647287","0.56463313","0.56326795","0.56228805","0.56197876","0.5619016"],"string":"[\n \"0.65342\",\n \"0.6510963\",\n \"0.6504755\",\n \"0.6503333\",\n \"0.6503325\",\n \"0.65012\",\n \"0.6413255\",\n \"0.636724\",\n \"0.6361781\",\n \"0.63528556\",\n \"0.634705\",\n \"0.6344606\",\n \"0.62456393\",\n \"0.6225456\",\n \"0.62220657\",\n \"0.62189585\",\n \"0.61770386\",\n \"0.6170098\",\n \"0.61636835\",\n \"0.61625767\",\n \"0.6136682\",\n \"0.6131323\",\n \"0.61308384\",\n \"0.61240125\",\n \"0.6123401\",\n \"0.6112048\",\n \"0.60892403\",\n \"0.6085086\",\n \"0.6084391\",\n \"0.608316\",\n \"0.6080312\",\n \"0.60645676\",\n \"0.6051773\",\n \"0.605004\",\n \"0.6047574\",\n \"0.60151994\",\n \"0.60007334\",\n \"0.599696\",\n \"0.59847134\",\n \"0.59825295\",\n \"0.5978072\",\n \"0.59650415\",\n \"0.5949776\",\n \"0.5947536\",\n \"0.593808\",\n \"0.5936075\",\n \"0.59344476\",\n \"0.5923387\",\n \"0.5916222\",\n \"0.5912224\",\n \"0.5905489\",\n \"0.5897248\",\n \"0.58959526\",\n \"0.5890709\",\n \"0.5884988\",\n \"0.587953\",\n \"0.58631563\",\n \"0.5858017\",\n \"0.58290136\",\n \"0.58203983\",\n \"0.581697\",\n \"0.58071387\",\n \"0.58012986\",\n \"0.57950425\",\n \"0.5794542\",\n \"0.57907283\",\n \"0.57730687\",\n \"0.57706493\",\n \"0.57604957\",\n \"0.57603985\",\n \"0.5755811\",\n \"0.5755172\",\n \"0.57419056\",\n \"0.57396024\",\n \"0.57364327\",\n \"0.5732734\",\n \"0.57319653\",\n \"0.57317454\",\n \"0.5725758\",\n \"0.5723651\",\n \"0.5723484\",\n \"0.5718365\",\n \"0.5716472\",\n \"0.57137734\",\n \"0.56926185\",\n \"0.5686694\",\n \"0.5676521\",\n \"0.5675177\",\n \"0.5674804\",\n \"0.56672835\",\n \"0.5667162\",\n \"0.56610155\",\n \"0.56580454\",\n \"0.56480855\",\n \"0.5647287\",\n \"0.56463313\",\n \"0.56326795\",\n \"0.56228805\",\n \"0.56197876\",\n \"0.5619016\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6446999"},"document_rank":{"kind":"string","value":"6"}}},{"rowIdx":88399,"cells":{"query":{"kind":"string","value":"in this view the teacher can create a forum post"},"document":{"kind":"string","value":"def teacher_forum_create(request):\n # Deleting admin-typed user session\n # Deleting programmer-typed-user session\n\n # Get the current users\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\n\n current_basic_user_profile = get_current_user_profile(\n request,\n User,\n BasicUserProfile,\n ObjectDoesNotExist\n )\n\n # Getting the teacher profile\n current_teacher_profile = get_current_teacher_user_profile(\n request,\n User,\n TeacherUserProfile,\n ObjectDoesNotExist\n )\n\n # forum create post form processing\n empty_input = False\n\n if request.POST.get(\"teacher_forum_create_post_btn\"):\n post_title = request.POST.get(\"post_title\")\n post_content = request.POST.get(\"post_content\")\n\n # check if any of the inputs are empty\n if bool(post_title) == False or post_title == \"\" \\\n or bool(post_content) == False or post_content == \"\":\n empty_input = True\n else:\n new_post = TeacherForumPost(\n teacher=current_teacher_profile,\n course=current_teacher_profile.teacher_course,\n post_title=post_title,\n content=post_content\n )\n new_post.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(new_post.id)+\"/\"\n )\n\n data = {\n \"current_basic_user\": current_basic_user,\n \"current_basic_user_profile\": current_basic_user_profile,\n \"current_teacher_profile\": current_teacher_profile,\n \"empty_input\": empty_input,\n }\n\n if \"teacher_user_logged_in\" in request.session:\n return render(request, \"teacher_forum/create.html\", data)\n else:\n return HttpResponseRedirect(\"/\")"},"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 post(self):\n teacher = self.request.get(\"teacher\")\n student = self.request.get(\"student\")\n lessondate = self.request.get(\"lessondate\")\n reason = self.request.get(\"reason\")\n comment = self.request.get(\"comment\")\n\n if teacher and student and lessondate and reason:\n\n # create a new Post object and store it in the database !!!!!!!!!!!!!!!\n loglesson = Teacher(\n teacher=teacher,\n student=student,\n lessondate=lessondate,\n reason = reason,\n comment = comment)\n loglesson.put()\n\n # get the id of the new post, so we can render the post's page (via the permalink)\n id = loglesson.key().id()\n self.redirect(\"/loglesson/%s\" % id)\n else:\n error = \"Please include a teacher, student, lesson date, reason and comment!\"\n self.render_form(teacher, student, lessondate,reason, comment, error)","def make_post(request):\n if request.user.is_authenticated() and request.POST:\n member = Member.objects.get(user=request.user)\n thread_id = request.POST.get('thread_id', -1)\n content = request.POST.get('content', -1)\n if thread_id != -1 and content != -1 and member:\n post = Post()\n post.author = member\n post.thread = Thread.objects.get(pk=thread_id)\n post.content = content\n post.save()\n return HttpResponse(200)\n else:\n return server_error(request)\n else:\n return server_error(request)","def post(self):\n subject = self.request.get('subject')\n content = self.request.get('content')\n\n # if user enter good subject and content, redirect them to new post page\n if subject and content:\n p = Post(parent = blog_key(), subject = subject, content = content)\n p.put() # store the post element into database\n self.redirect('/blog/%s' % str(p.key().id()))\n # otherwise, render an error page \n else:\n error = \"subject and content, please!\"\n self.render(\"newpost.html\", subject=subject, content=content, error=error)","def post(self):\n subject = self.request.get('subject')\n content = self.request.get('post_content')\n post_id = self.request.get('post_id')\n post = Posts.get_by_id(int(post_id))\n user = self.get_active_user()\n user_id = int(user.key().id())\n\n if post and user and subject and content:\n if post.submitter_id == user_id:\n self.render_editpage(user, post_id, subject, content)\n else:\n self.render_improper_access()\n else:\n self.error(500)","def post(self):\n\n subject = self.request.get('subject')\n content = self.request.get('content')\n\n have_errors = False\n\n if not subject:\n error_subject = \"Please write down the subject\"\n have_errors = True\n if not content:\n error_content = \"Content is required\"\n have_errors = True\n\n if have_errors:\n self.render(\"newpost.html\",\n subject=subject,\n content=content,\n error_subject=error_subject,\n error_content=error_content,\n user=self.user)\n else:\n post = Post(parent=blog_key(),\n subject=subject,\n content=content,\n user=self.user)\n post.put()\n self.redirect('/blog/%s' % str(post.key().id()))","def post(self):\n subject = self.request.get('subject')\n post_content = self.request.get('post_content')\n submit = self.request.get('submit')\n cancel = self.request.get('cancel')\n user = self.get_active_user()\n created_by = int(user.key().id())\n post_id = self.request.get('post_id')\n\n if not user:\n self.redirect('/login')\n if post_id:\n post = Posts.get_by_id(int(post_id))\n else:\n post = None\n\n if cancel == \"cancel\":\n self.redirect('/%s' % str(post.key().id()))\n return\n if (post and post.submitter_id == user.key().id()) or not post:\n if submit == \"submit\" and subject and post_content:\n if post:\n post.subject = subject\n post.content = post_content\n post.put()\n else:\n post = Posts(subject=subject,\n content=post_content,\n submitter_id=created_by)\n post.put()\n self.redirect('/%s' % str(post.key().id()))\n else:\n self.render_newpage(user=user,\n subject=subject,\n post_content=post_content,\n error=\"\"\"Please provide both a subject and a\n post!\"\"\")\n else:\n self.redirect('/login')","def add_topic(request, forum_id):\n\t\n\t\n\tif request.POST:\n\t\tpage_data = request.POST.copy()\n\t\tpage_data['topic_author'] = str(request.user)\n\t\ttags = findall( r'(?xs)\\[code\\](.*?)\\[/code\\]''', page_data['text'])\n\t\tfor i in tags:\n\t\t\tpage_data['text'] = page_data['text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.encodestring(i)+u'[/code]')\n\t\tpage_data['text'] = html2safehtml(page_data['text'] ,valid_tags=settings.VALID_TAGS)\n\t\ttags = findall( r'(?xs)\\[code\\](.*?)\\[/code\\]''', page_data['text'])\n\t\tfor i in tags:\n\t\t\tpage_data['text'] = page_data['text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.decodestring(i)+u'[/code]')\n\t\ttext = page_data['text']\n\t\tdel page_data['text']\n\t\tpage_data['topic_name'] = html2safehtml(page_data['topic_name'] ,valid_tags=())\n\t\tpage_data['topic_forum'] = forum_id\n\t\tpage_data['topic_posts'] = 1\n\t\tpage_data['topic_lastpost'] = str(request.user)+'<br />' + str(datetime.today())[:-10]\n\t\tpage_data['topic_last_pagination_page'] = 1\n\t\tpage_data['topic_modification_date'] = datetime.now()\n\t\tform = AddTopicForm(page_data)\n\t\tif form.is_valid():\n\t\t\tnew_place = form.save()\n\t\t\tpost = Post(post_topic = new_place, post_text = text, post_author = str(request.user), post_ip = request.META['REMOTE_ADDR'])\n\t\t\tpost.save()\n\t\t\tforum = Forum.objects.get(id=forum_id)\n\t\t\tforum.forum_topics = forum.forum_topics +1\n\t\t\tforum.forum_posts = forum.forum_posts +1\n\t\t\tforum.forum_lastpost = str(request.user)+' (' + str(datetime.today())[:-10] + ')<br /><a href=\"/forum/topic/1/' + str(new_place.id) + '/\">' + new_place.topic_name + '</a>'\n\t\t\tforum.save()\n\t\t\t\n\t\t\tmail_admins('Temat Dodany', \"Dodano Temat: http://www.\" + settings.SITE_KEY + \"/forum/forum/\" + forum_id +\"/\", fail_silently=True)\n\t\t\t\n\t\t\treturn HttpResponseRedirect(\"/forum/forum/\" + forum_id +\"/\")\n\t\telse:\n\t\t\treturn render_to_response(\n\t\t\t\t'myghtyboard/add_topic.html',\n\t\t\t\t{'form': form, 'perms': list_perms(request)},\n\t\t\t\tcontext_instance=RequestContext(request))\n\t\n\tform = AddTopicForm()\n\treturn render_to_response(\n\t\t'myghtyboard/add_topic.html',\n\t\t{'form': form, 'perms': list_perms(request)},\n\t\tcontext_instance=RequestContext(request))","def create_post(request):\n if request.method == 'POST':\n title = request.POST['title']\n content = request.POST['content']\n user_id = request.POST['author_id']\n category = request.POST['category']\n\n slug = \"-\".join(list(map(lambda word: word.lower(), title.split())))\n author = User.objects.get(id=int(user_id))\n\n # save info in models\n post = Post()\n post.author = author\n post.category = category\n post.title = title\n post.content = content\n post.slug = slug\n post.save()\n return redirect('post')\n\n return render(request, 'posts/create_post.html')","def post(self, request):\n\n # crear el formulario con los datos del post\n form = PostForm(request.POST)\n\n if form.is_valid():\n #crea el post\n post = form.save()\n\n #generar mensaje de exito\n msg = \"Post creado con éxito\"\n form = PostForm()\n else:\n msg = \"Ha ocurrido un error al guardar el post\" \\\n\n\n # renderiza la plantilla con el formulario\n context = {\n \"form\": form,\n \"msg\": msg\n }\n\n # renderiza y devuelve la plantilla\n return render(request, 'blogs/new-post.html', context)","def community_post_create_view(request):\n task = \"Create New\"\n form = AddEditPostForm() # An unbound form\n\n if request.method == 'POST': # If the form has been submitted...\n form = AddEditPostForm(request.POST, request.FILES) # A form bound to the POST data\n if form.is_valid(): # All validation rules pass\n post = form.save(commit=False) # Create a new object from the form, but don't save it to the database\n post.author = request.user # Set the author to the current user\n post.save() # Save the object to the database\n slug_str = \"%s %s\" % (post.title, post.date_posted) # Create a slug from the title and date\n post.slug = slugify(slug_str) # Create the slug\n post.save() # Save the object to the database\n return redirect('community-home') # Redirect to the home page\n\n context = { # Pass the variables to the template\n 'task': task,\n 'form': form,\n }\n return render(request,\n 'pages/patient-community/community-create-update-post.html',\n context) # render the patient community create post page","def post(self):\n current_user = self.authenticate_user()\n\n if not current_user:\n self.redirect(\"/login\")\n else:\n content = self.request.get(\"content\")\n title = self.request.get(\"subject\")\n\n if not content or not title:\n self.render_front(title, content, \"We need both a title and content\")\n else:\n post = Post(title=title, content=content, user=current_user.key)\n post.put()\n\n current_user.posts.append(post.key)\n current_user.put()\n\n self.redirect(\"/post/\" + str(post.key.id()))","def post(self):\n teacher = self.request.get(\"teacher\")\n temail = self.request.get(\"temail\")\n tphone = self.request.get(\"tphone\")\n specialty = self.request.get(\"specialty\")\n\n if teacher and temail and tphone and specialty:\n\n #create a new teacher object and store it in the database\n teacher = Teacher(\n teacher=teacher,\n temail=temail,\n tphone=tphone, \n specialty=specialty)\n teacher.put()\n\n id = teacher.key().id()\n self.redirect(\"/teacher/%s\" % id)\n else:\n error = \"Please include a teacher, an email, a phone number, and a specialty.\"\n self.render_form(teacher, temail, tphone, specialty, error)","def post(self):\n title = self.request.get(\"title\")\n body = self.request.get(\"body\")\n\n if title and body:\n\n # create a new Post object and store it in the database\n post = Post(\n title=title,\n body=body\n )\n post.put()\n\n # get the id of the new post, so we can render the post's page (via the permalink)\n id = post.key().id()\n self.redirect(\"/blog/%s\" % id)\n else:\n error = \"we need both a title and a body!\"\n #self.render_form(title, body, error)\n self.render(\"newpost.html\", title, body, error)","def new_post(mkp_form, request):\n newpost = Posts()\n newpost.init()\n newpost.authorid = int(request.user.id)\n newpost.title = mkp_form.cleaned_data['title']\n newpost.name = mkp_form.cleaned_data['short_title'] # 缩略名\n newpost.cover = mkp_form.cleaned_data['cover_url']\n newpost.introduction = mkp_form.cleaned_data['introduction']\n newpost.content = js_resize_img(mkp_form.cleaned_data['content'])\n newpost.status = Status.objects.get(id=2) # id为2是已发布的文章，默认为已发布，后面再改\n tagids = mkp_form.cleaned_data['tags']\n if len(tagids) != 0:\n for tagid in tagids:\n tagid = int(tagid)\n tag = Tags.objects.get(id=tagid)\n newpost.tags.add(tag)\n threadtypeid = mkp_form.cleaned_data['threadtypeid']\n newpost.threadtypeid = ThreadTypes.objects.get(id=threadtypeid)\n if mkp_form.cleaned_data['commentnotshow'] != '':\n newpost.comment_status = False\n else:\n newpost.comment_status = True\n return newpost","def post(self, user):\n subject = self.request.get(\"subject\")\n content = self.request.get(\"content\")\n\n if subject and content:\n post = Post(subject=subject,\n content=content,\n author=self.user)\n post.put()\n return self.redirect(\"/%s\" % post.key().id())\n else:\n\n error = \"subject and content, please!\"\n return self.render(\"newpost.html\",\n subject=subject,\n content=content,\n error=error)","def post(self):\n\n title = self.request.get(\"title\")\n blogPost = self.request.get(\"blogPost\")\n author = self.request.cookies.get('name')\n\n if title and blogPost:\n\n bp = Blogposts(parent=blog_key(), title=title,\n blogPost=blogPost, author=check_secure_val(author))\n\n bp.put()\n\n self.redirect('/%s' % str(bp.key.integer_id()))\n else:\n error = \"Please submit both a title and a blogpost!\"\n self.render(\"newpost.html\", title=title,\n blogPost=blogPost, error=error)","def posts_create(request):\n if request.method == 'POST':\n form = PostForm(request.POST, request.FILES)\n if form.is_valid():\n form.save()\n return redirect('feed')\n\n else:\n form = PostForm()\n\n return render(\n request=request,\n template_name='posts/new.html',\n context={\n 'form': form,\n 'user': request.user,\n 'perfil': request.user.perfil\n }\n )","def create_post():\r\n\r\n # Check for and reject empty username or whinge\r\n if not request.values.get(\"username\") or not request.values.get(\"whinge\"):\r\n print(\"Ignoring request to with empty username or whinge\")\r\n else:\r\n # Form data ok; add to DB\r\n con = get_db()\r\n con.execute(\"INSERT INTO posts (submitter,content,ts) VALUES (?,?,?);\",\r\n (\r\n request.values.get(\"username\"), # form field username -> DB column submitter\r\n request.values.get(\"whinge\"), # form field whinge -> DB column content\r\n time.time()\r\n )\r\n )\r\n con.commit()\r\n con.close()\r\n \r\n # TODO: Handle possibility of failed INSERT\r\n\r\n # Send them back to the main page\r\n return redirect(url_for(\"display_top\"))","def post(request):\n if request.method == \"POST\":\n post = Post()\n post.content = request.POST['content']\n post.author = request.user\n post.save()\n return HttpResponseRedirect(reverse(\"index\"))","def create_post():\n\n #Get prompt id\n prompt_id = request.form.get('prompt_id')\n\n # Get post text\n post_text = request.form.get('user_post')\n\n # Create post timestamp\n created_at = datetime.now()\n user_facing_date = created_at.strftime(\"%B %d, %Y\")\n\n # Save post and related data to database\n post = crud.create_post(session['user_id'], prompt_id, post_text, session['lat'], session['lng'], session['user_facing_location'], created_at)\n\n return render_template('post_data.html', post=post, user_facing_date=user_facing_date)","def post(self, request):\n\n # crear el formulario con los datos del POST\n blog_with_user = Blog(owner=request.user)\n form = BlogForm(request.POST, instance=blog_with_user)\n\n if form.is_valid():\n #crea el post\n blog = form.save()\n\n #generar mensaje de exito\n msg = \"Blog creado con éxito\"\n\n # limpiamos el formulario creando uno vacío para pasar a la plantilla\n form = BlogForm()\n else:\n msg = \"Ha ocurrido un error al guardar el blog\" \\\n\n\n # renderiza la plantilla con el formulario\n context = {\n \"form\": form,\n \"msg\": msg\n }\n\n # renderiza y devuelve la plantilla\n return render(request, 'blogs/new-blog.html', context)","def post(self, req):\n error_messages = []\n success_message = ''\n\n # Creamos owner y se lo pasamos al form con un objeto pre-establecido\n post_with_owner = Post()\n post_with_owner.owner = req.user\n post_with_owner.blog = Blog.objects.filter(owner=req.user)[0]\n\n form = PostCreateForm(req.POST, instance=post_with_owner)\n if form.is_valid():\n\n new_post = form.save()\n form = PostCreateForm()\n success_message = u'Post guardado con éxito! '\n success_message += u'<a href=\"{0}\">'.format(reverse('post_detail', args=[req.user.username, new_post.pk]))\n success_message += u'(ver post)</a>'\n else:\n error_messages.append(u'Formulario incompleto.')\n\n context = {\n 'form': form,\n 'success_message': success_message\n }\n return render(req, 'posts/new_post.html', context)","def test_new_thread(self):\n self.helper('create_user', 'testuser', 'password')\n self.login('testuser', 'password', 'auth_login','id_login')\n self.url(settings.LOGIN_REDIRECT_URL)\n self.go200('forum_new_thread', [forum.slug])\n self.showforms()\n self.formclear('id_newthread')\n self.fv('id_newthread', 'id_title', 'Some cool new thread')\n self.fv('id_newthread', 'id_body', 'Hello world!')\n self.submit200()\n self.go200('forum_thread_list', [forum.slug])\n self.find('Some cool new thread')\n self.go200('forum_view_thread', [2])\n self.find('Hello world!')","def test_forum_new_post(self):\n sel = self.selenium\n login_page_obj = login_page.LoginPage(sel)\n forums_page_obj = forums_page.ForumsPage(sel)\n \n user_info = sumo_test_data.SUMOtestData().getUserInfo(0)\n uname = user_info['username']\n pwd = user_info['password']\n timestamp = sel.get_eval(\"new Date().getTime()\")\n thread_title = \"Litmus 7829 test\" + timestamp\n thread_text = \"Litmus QA 7829 Testcase Test Msg\"\n \n ''' Login '''\n login_page_obj.log_in(uname, pwd) \n \n \n ''' Post a new thread '''\n forums_page_obj.open(forums_page_obj.kb_articles_forum_url)\n forums_page_obj.post_new_thread_first_cat(thread_title, thread_text)\n\n time.sleep(5)\n self.failUnless(sel.is_text_present(thread_text))\n # Verify post title\n forums_page_obj.open(forums_page_obj.kb_articles_forum_url)\n self.failUnless(sel.is_text_present(thread_title))\n \n ''' Logout '''\n forums_page_obj.log_out()","def create_welcome_forum():\n if User.query.count() < 1:\n return False\n\n user = User.query.filter_by(id=1).first()\n\n category = Category(title=\"My Category\", position=1)\n category.save()\n\n forum = Forum(title=\"Welcome\", description=\"Your first forum\",\n category_id=category.id)\n forum.save()\n\n topic = Topic(title=\"Welcome!\")\n post = Post(content=\"Have fun with your new FlaskBB Forum!\")\n\n topic.save(user=user, forum=forum, post=post)\n return True","def newreply(request, post_id):\n if not request.user.is_authenticated():\n return redirect('/login/?next=%s' % request.path)\n else:\n\n reply = Reply.objects.create(\n creator = request.user,\n created = datetime.datetime.now(),\n body = request.POST.get('mensaje'),)\n post = Post.objects.get(id = post_id)\n post.reply.add(reply) \n return redirect('/home/')","def get(self):\n\n self.render(\"newpost.html\", user=self.user)","def create_post(user_id):\n if CURRENT_USER_KEY not in session or session[CURRENT_USER_KEY] != user_id:\n raise Unauthorized\n\n user = User.query.get_or_404(user_id)\n\n form = PostForm()\n form.muscles.choices = [(m.id, m.name) for m in Muscle.query.all()]\n form.equipment.choices = [(e.id, e.name) for e in Equipment.query.all()]\n # import pdb\n # pdb.set_trace()\n if form.validate_on_submit():\n title = form.title.data\n details = form.details.data\n is_private = form.is_private.data\n muscles = form.muscles.data\n equipment = form.equipment.data\n post = Post(title=title, details=form.details.data,\n is_private=form.is_private.data, user_id=user_id)\n db.session.add(post)\n db.session.commit()\n\n # create join table additions\n muscles_to_add = []\n equipment_to_add = []\n for muscle in muscles:\n muscle_post = PostMuscle(post_id=post.id, muscle_id=muscle)\n muscles_to_add.append(muscle_post)\n for choice in equipment:\n equipment_post = PostEquipment(\n post_id=post.id, equipment_id=choice)\n equipment_to_add.append(equipment_post)\n db.session.add_all(muscles_to_add + equipment_to_add)\n db.session.commit()\n flash('New post created!', 'success')\n return redirect(url_for('show_user_profile', user_id=user_id))\n return render_template('add_post.html', form=form, user=user)","def add_post(request, topic_id, post_id = False):\n\t\n\ttopic = Topic.objects.values('is_locked').get(id=topic_id)\n\tif topic['is_locked']:\n\t\treturn render_to_response('pages/bug.html', {'bug': _('Topic is closed')}, context_instance=RequestContext(request))\n\n\t# check who made the last post.\n\tlastpost = Post.objects.order_by('-post_date').filter(post_topic=topic_id)[:1]\n\tis_staff = request.user.is_staff\n\t# if the last poster is the current one (login) and he isn't staff then we don't let him post after his post\n\tif str(lastpost[0].post_author) == str(request.user) and not is_staff:\n\t\treturn render_to_response('pages/bug.html', {'bug': _('You can\\'t post after your post')}, context_instance=RequestContext(request))\n\t\n\tlastpost = Post.objects.filter(post_topic=topic_id).order_by('-id')[:10]\n\tif request.POST:\n\t\tpage_data = request.POST.copy()\n\t\tpage_data['post_author'] = str(request.user)\n\t\ttags = findall( r'(?xs)\\[code\\](.*?)\\[/code\\]''', page_data['post_text'])\n\t\tfor i in tags:\n\t\t\tpage_data['post_text'] = page_data['post_text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.encodestring(i)+u'[/code]')\n\t\tpage_data['post_text'] = html2safehtml(page_data['post_text'] ,valid_tags=settings.VALID_TAGS)\n\t\ttags = findall( r'(?xs)\\[code\\](.*?)\\[/code\\]''', page_data['post_text'])\n\t\tfor i in tags:\n\t\t\tpage_data['post_text'] = page_data['post_text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.decodestring(i)+u'[/code]')\n\t\t\n\t\tpage_data['post_ip'] = request.META['REMOTE_ADDR']\n\t\tpage_data['post_topic'] = topic_id\n\t\tpage_data['post_date'] = datetime.now()\n\t\tform = AddPostForm(page_data)\n\t\tif form.is_valid():\n\t\t\tform.save()\n\t\t\n\t\t\ttopic = Topic.objects.get(id=topic_id)\n\t\t\tposts = Post.objects.filter(post_topic=topic_id).count()\n\t\t\t\n\t\t\tpmax = posts/10\n\t\t\tpmaxten = posts%10\n\t\t\tif pmaxten != 0:\n\t\t\t\tpmax = pmax+1\n\t\t\t\ttopic.topic_last_pagination_page = pmax\n\t\t\telif pmax > 0:\n\t\t\t\ttopic.topic_last_pagination_page = pmax\n\t\t\telse:\n\t\t\t\tpmax = 1\n\t\t\t\ttopic.topic_last_pagination_page = 1\n\t\t\ttopic.topic_posts = posts\n\t\t\ttopic.topic_lastpost = str(request.user)+'<br />' + str(datetime.today())[:-10]\n\t\t\ttopic.save()\n\t\t\t\n\t\t\tforum = Forum.objects.get(id=topic.topic_forum.id)\n\t\t\tforum.forum_posts = forum.forum_posts +1\n\t\t\t\n\t\t\tforum.forum_lastpost = str(request.user)+' (' + str(datetime.today())[:-10] + ')<br /><a href=\"/forum/topic/' + str(pmax) + '/' + str(topic.id) + '/\">' + topic.topic_name + '</a>'\n\t\t\tforum.save()\n\t\t\t\n\t\t\tmail_admins('Post Dodany', \"Dodano Post: http://www.\" + settings.SITE_KEY + \"/forum/topic/\" + str(pmax) + \"/\" + topic_id +\"/\", fail_silently=True)\n\t\t\treturn HttpResponseRedirect(\"/forum/topic/\" + str(pmax) + \"/\" + topic_id +\"/\")\n\t\telse:\n\t\t\treturn render_to_response(\n\t\t\t\t'myghtyboard/add_post.html',\n\t\t\t\t{'lastpost': lastpost, 'perms': list_perms(request), 'form':form},\n\t\t\t\tcontext_instance=RequestContext(request))\n\telse:\n\t\tif post_id:\n\t\t\tquote = Post.objects.get(id=post_id)\n\t\t\tquote_text = '<blockquote><b>' + quote.post_author + _(' wrote') + ':</b><br /><cite>' + quote.post_text + '</cite></blockquote>\\n\\n'\n\t\telse:\n\t\t\tquote_text = ''\n\treturn render_to_response(\n\t\t'myghtyboard/add_post.html',\n\t\t{'quote_text': quote_text, 'lastpost': lastpost, 'perms': list_perms(request)},\n\t\tcontext_instance=RequestContext(request))","def post(self, request, *args, **kwargs):\n self.object = self.get_object()\n\n # # check permissions before serving view\n # has_permission = request.user.is_admin or (self.object and self.object.created_by == self.request.user)\n #\n # if not has_permission:\n # raise PermissionDenied\n\n form_class = self.get_form_class()\n form = self.get_form(form_class)\n Topic_formset = inlineTopicFormset(self.request.POST, instance=self.object)\n if form.is_valid() and Topic_formset.is_valid():\n return self.form_valid(form, Topic_formset)\n else:\n return self.form_invalid(form, Topic_formset)","def post_create(request):\n\tform = PostForm(request.POST or None, request.FILES or None)\n\tif request.POST:\n\t\tif form.is_valid():\n\t\t\tinstance = form.save(commit=False)\n\t\t\tinstance.user = request.user\n\t\t\tinstance.save()\n\t\t\tmessages.success(request, \"Post created!\")\n\t\t\treturn HttpResponseRedirect(instance.get_absolute_url())\n\t\telse:\n\t\t\tmessages.error(request, \"Sorry! Something went wrong.\", extra_tags=\"\")\n\tcontext = {\n\t\t'title': \"Create Post\",\n\t\t'form' : form,\n\t}\n\treturn render(request, 'post/create.html', context)","def new(request):\n\n form = PostForm(request.POST or None)\n\n if request.method == \"POST\":\n if form.is_valid():\n instance = form.save(commit=False)\n instance.user = request.user\n instance.save()\n return HttpResponseRedirect(reverse('posts:toggle_publish', args=(instance.id,)))\n\n context = {'form':form}\n\n return render(request, 'posts/new.html', context)","def create_post(bid):\n form = PostForm(request.form)\n if request.method == 'POST':\n if form.validate():\n DB.session.add(\n Post(\n bid,\n current_user.uid,\n form.name.data,\n form.desc.data))\n DB.session.commit()\n flash('Post ({}) successfully created!'.format(form.name.data))\n else:\n flash(constants.DEFAULT_SUBMISSION_ERR)\n return redirect(request.referrer)","def post(self):\n post_title = self.request.get(\"post_title\")\n post_content = self.request.get(\"post_content\")\n param_list = dict(post_title=post_title, post_content=post_content)\n any_error = False\n\n if not post_title:\n param_list['title_error'] = \"Title is missing!\"\n any_error = True\n if not post_content:\n param_list['content_error'] = \"Content is missing!\"\n any_error = True\n\n if any_error:\n self.render(\"blog/addpost.html\", **param_list)\n else:\n p = Post.add_post(post_title, post_content, self.user)\n self.redirect('/blog/%s' % str(p.key().id()))","def post():\n\n form = forms.PostForm()\n if form.validate_on_submit():\n models.Post.create(title=form.title.data,\n date=form.date.data,\n time_spent=form.time_spent.data,\n details=form.details.data,\n remember=form.remember.data)\n return redirect(url_for('index'))\n return render_template('new.html', form=form)","def create():\n if request.method == 'POST':\n title = request.form['title']\n body = request.form['body']\n error = None\n\n if not title:\n error = 'Title is required.'\n\n if error is not None:\n flash(error)\n else:\n db = get_db()\n db.execute(\n 'INSERT INTO post (title, body, author_id)'\n ' VALUES (?, ?, ?)',\n (title, body, g.user['id'])\n )\n db.commit()\n return redirect(url_for('blog.index'))\n\n return render_template('blog/create.html')","def add_post(request, id):\n template = loader.get_template('topic.html')\n if request.method == \"POST\":\n data = JSONParser().parse(request)\n try:\n user = User.objects.get(username=request.user)\n except ObjectDoesNotExist:\n return HttpResponse(\"You should login to post!\")\n requested_topic = Topic.objects.get(id=data[\"topic_id\"])\n postObject = Post.objects.create(user_id=user.id, topic_id=requested_topic.id,content=data[\"content\"])\n for tag in data[\"tags\"]:\n if len(tag)>0:\n if tag['label'] == '':\n continue\n try:\n tagObject = Tag.objects.get(wikidataID=tag['id'])\n except ObjectDoesNotExist:\n tagObject = Tag.objects.create(wikidataID=tag['id'], name=tag['label'])\n except MultipleObjectsReturned:\n return HttpResponse(\"Multiple tags exist for.\" + tag + \" Invalid State.\")\n\n unique_hidden_tags = list(set(tag['hidden_tags']))\n if unique_hidden_tags:\n tagObject.hidden_tags = unique_hidden_tags\n\n tagObject.save()\n postObject.tags.add(tagObject)\n try:\n topic = Topic.objects.get(id=id)\n serialized_topic = TopicNestedSerializer(topic)\n topic_json = JSONRenderer().render(serialized_topic.data)\n except ObjectDoesNotExist:\n return HttpResponse(\"This topic doesn't exists!\")\n\n hot_topics = Topic.objects.order_by('-updated_at')[:5]\n serialized_hot_topics = HotTopicsSerializer(hot_topics, many=True)\n hot_topics_json = JSONRenderer().render(serialized_hot_topics.data)\n context = {\n 'topic': topic_json,\n 'hot_topics': hot_topics_json\n }\n return HttpResponse(template.render(context, request))","def new_post_form(user_id):\n user = User.query.get_or_404(user_id)\n tags = Tag.query.all()\n return render_template('posts/new.html', user=user, tags=tags)","def create_post(request):\n\n # modified from: http://django-angular.readthedocs.org/en/latest/angular-model-form.html\n\n # get data\n in_data = getRequestData(request)\n\n try:\n # save in database\n # note that in_data.mytitle throws an error while in_data.get('mytitle') works smoothly\n post = Thread(pub_date = datetime.datetime.now(pytz.timezone('US/Eastern')), username = in_data.get('myusername'), title = in_data.get('mytitle'), description = in_data.get('mydescription'))\n post.save()\n except:\n return HttpResponseBadRequest('Error saving to database!')\n\n return JsonResponse(in_data)","def create_a_post():\n subj = create_subject()\n post = Post.create(subject=subj, title=\"A great title\", body=\"Just a great day!\")\n post.save()\n return post","def add_new_post(request):\n\n token = request.data.get('token')\n if Token.objects.filter(key=request.data[\"token\"]).exists():\n text = request.data.get('text', '')\n image = request.data.get('image')\n video = request.data.get('video')\n\n if len(request.data[\"text\"]) < 1:\n return Response({\"error\": 21})\n elif len(request.data[\"text\"]) > 10000:\n return Response({\"error\": 22})\n\n token = get_object_or_404(Token, key=token)\n post = Post.objects.create(permission=request.data[\"permission\"],\n author_id=token.user_id,\n text=request.data[\"text\"])\n if image:\n image_data = b64decode(image)\n post.image = ContentFile(image_data, \"post.png\")\n\n if video:\n video_data = b64decode(request.data[\"video\"])\n post.video = ContentFile(video_data, \"post.mov\")\n post.save()\n\n if \"hashtags\" in request.data and len(request.data[\"hashtags\"]) > 0:\n for hashtag in request.data[\"hashtags\"]:\n PostHashtag.objects.create(post=post,\n hashtag=hashtag)\n\n serializer = PostSerializer(post, context={'user_id': token.user_id})\n return Response({\"success\": 23,\n \"post\": serializer.data})\n else:\n return Response({\"error\": 17})","def create_post(user_id):\n\n user = User.query.get_or_404(user_id)\n title = request.form['title']\n content = request.form['content']\n tag_ids = [int(num) for num in request.form.getlist(\"tags\")]\n tags = Tag.query.filter(Tag.id.in_(tag_ids)).all()\n \n new_post = Post(title=title, content=content, user=user, tags=tags)\n db.session.add(new_post)\n db.session.commit()\n\n return redirect(f\"/users/{user_id}\")","def add_post(request):\n if 'form.submitted' in request.params:\n title = request.params['title']\n name = title_to_name(title)\n\n if not name or DBSession.query(Post).filter(Post.name==name).count():\n # this should be a popup ajaxy box\n return Response(\"Name %s is in use, choose a different title\" % name, content_type='text/plain', status_int=500)\n\n body = request.params['body']\n post = Post(title, body, name)\n DBSession.add(post)\n return HTTPFound(location = request.route_url('view_post', postname=name))\n\n save_url = request.route_url('new_post')\n post = Post('')\n return environment_factory(post=post, save_url=save_url)","def get(self, request):\n form = PostForm()\n context = {\n 'form': form,\n }\n return render(request, 'blogs/new_post.html', context)","def change_post(mfp_form, request):\n article_id = int(mfp_form.cleaned_data['id'])\n newpost = APost(article_id)\n if newpost.exist:\n newpost.article.title = mfp_form.cleaned_data['title']\n # 缩略名\n newpost.article.short_title = mfp_form.cleaned_data['short_title']\n newpost.article.cover = mfp_form.cleaned_data['cover_url']\n newpost.article.introduction = mfp_form.cleaned_data['introduction']\n newpost.article.content = mfp_form.cleaned_data['content']\n # id为2是已发布的文章，默认为已发布，后面再改\n newpost.article.status = Status.objects.get(id=2)\n tagids = mfp_form.cleaned_data['tags']\n if len(tagids) != 0:\n for tagid in tagids:\n tagid = int(tagid)\n tag = Tags.objects.get(id=tagid)\n newpost.article.tags.add(tag)\n threadtypeid = int(mfp_form.cleaned_data['threadtypeid'])\n newpost.article.threadtypeid = ThreadTypes.objects.get(id=threadtypeid)\n if mfp_form.cleaned_data['commentnotshow'] != '':\n newpost.article.comment_status = False\n else:\n newpost.article.comment_status = True\n return newpost.article\n else:\n return False","def get(self, request):\n\n # crear el formulario\n form = PostForm()\n form.fields['owner'].queryset = Blog.objects.filter(owner=request.user)\n # renderiza la plantilla con el formulario\n context = {\n \"form\": form\n }\n\n # renderiza y devuelve la plantilla\n return render(request, 'blogs/new-post.html', context)","def add_post(request):\n if request.session.get('id_user') is None:\n request.session['res'] = 'Warn'\n messages.add_message(request, messages.WARNING,\n \"The session has expired\")\n return HttpResponseRedirect(reverse('home'))\n form = PostForm(request.POST or None)\n if request.method == 'POST':\n if form.is_valid():\n data = form.save(commit=False)\n data.author = User.objects.filter(id=request.session.get(\n 'id_user'))[0]\n data.save()\n messages.add_message(request, messages.SUCCESS,\n \"The post has been saved!\")\n return HttpResponseRedirect(\"/posts/list/\")\n return render(request, 'form.html', {'form': form})","def admincreate(object):\n if request.method == \"POST\":\n\n db = get_db()\n execute_string = 'INSERT INTO ' + object.title()\n\n if object == 'post':\n execute_string += '(title, content, authorId, categoryId) VALUES (\"' + request.form['title'] + '\", \"' + request.form[\"content\"] + '\", \"' + request.form[\"authorid\"] + '\", \"' + request.form[\"categoryid\"] + '\")'\n elif object == 'author':\n execute_string += '(name) VALUES (\"' + request.form['name'] + '\")'\n elif object == 'category':\n execute_string += '(name, description) VALUES (\"' + request.form['name'] + '\", \"' + request.form[\"description\"] + '\")'\n\n db.execute(execute_string)\n db.commit()\n return redirect(url_for(\"adminview\", object=object))\n\n return render_template(\"new.html\", object=object, item={})","def create_post(request):\n user = User.objects.get(email=request.user.email)\n if request.method == \"POST\":\n form = BlogPostForm(request.POST)\n if form.is_valid():\n post = form.save(commit=False)\n post.author = user\n post.avatar = user.userprofile.avatar.url\n post.save()\n messages.success(request, \"You have posted successfully\")\n return redirect(\"get_posts\")\n else:\n messages.error(request, \"Unable to post at this time\")\n else:\n form = BlogPostForm()\n return render(request, \"blogpostform.html\", {\"form\": form})","def new_post(request):\n if request.method != 'POST':\n # No data submitted; create a blank form.\n form = PostForm()\n else:\n # POST data submitted; process data.\n form = PostForm(data=request.POST)\n if form.is_valid():\n new_post = form.save(commit=False)\n new_post.owner = request.user\n new_post.save()\n return redirect('blogs:posts')\n\n # Display a blank or invalid form.\n context = {'form': form}\n return render(request, 'blogs/new_post.html', context)","def get(self, request):\n form = PostForm()\n context = {\n 'form': form,\n 'success_message': ''\n }\n return render(request, 'posts/new-post.html', context)","def new_topic(request):\n form = Form(request, schema=TopicSchema)\n if form.validate():\n topic = form.data[\"title\"]\n author = form.data[\"author\"]\n desc = form.data[\"description\"]\n date = datetime.datetime.now()\n url = slugfy(topic)\n topic_tuple = {\n \"title\": topic,\n \"url\": url,\n \"author\": author,\n \"description\": desc,\n \"topic_date\": date.strftime(\"%d/%m/%Y\"),\n }\n request.db[\"topic\"].insert(topic_tuple)\n return HTTPFound(location=\"/\")\n\n return render_to_response(\n \"templates/new_topic.html\",\n {\"form\": FormRenderer(form), \"count\": count(request)},\n request=request,\n )","def show_post_form(user_id):\n\n user = User.query.get_or_404(user_id)\n tags = Tag.query.all()\n\n return render_template(\"posts/create_post.html\", user=user, tags=tags)","def test_createPost(self):\n\t\tself.client.force_authenticate(user=User.objects.get(id=1))\n\t\turl = \"/posts/\"\n\t\tdata = {\n\t\t\t'text' : 'Vivaldi',\n\t\t\t'group': 3\n\n\t\t}\n\t\tresponse = self.client.post(url, data, format='json')\n\t\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\n\t\tself.assertEqual(response.data[\"id\"], 4)\n\t\tself.assertEqual(response.data[\"text\"], 'Vivaldi')\n\t\tself.assertEqual(Post.objects.count(), 4)","def save(self, user):\n if self.is_valid():\n\n topic = self.cleaned_data['topic']\n\n thread = models.Thread.objects.create(\n topic=topic,\n title=self.cleaned_data['title'])\n\n models.Message.objects.create(\n user=user,\n thread=thread,\n body=self.cleaned_data['body'])\n\n return thread","def get(self):\n if self.user:\n self.render(\"blog/addpost.html\")\n else:\n self.redirect(\"/login\")","def create(thing):\n fields = {}\n errors = []\n\n for col in thing.cols:\n new[col.field_name] = request.form.get(col.field_name)\n if col.required and not new[col.field_name]:\n errors.append('%s cannot be empty' % col.human_name)\n\n if errors:\n for e in errors:\n flash(e)\n add_template_variable('thing', thing)\n add_template_variable('fields', fields)\n return my_render_template('generic/create_post.html')\n\n # insert into database\n\n db = get_db()\n cursor = db.cursor()\n\n # create the two strings we use in the query\n field_names = \"'\" + \"', '\".join(thing.field_names) + \"'\"\n question_marks = \", \".join(map(lambda x: '?', thing.field_names.count() ))\n\n cursor.execute(\"insert into posts (%s) values (%s)\" % (field_names, question_marks), (title, body))\n db.commit()\n new_id = cursor.lastrowid\n\n # show new post to the user\n flash(\"You made a new %s\" % thing.human_name)\n return redirect(url_for('show_one', id_=new_id))","def __addThreadAndPosts(self):\n try:\n self.genre = \"Review\"\n self.__hierarchy = []\n self.__baseuri = 'http://broncosfreaks.com/forums/'\n self.__task_elements_dict = {\n 'priority':self.task.priority,\n 'level': self.task.level,\n 'last_updated_time':datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\"),\n 'pickup_date':datetime.strftime(datetime.utcnow(),\"%Y-%m-%dT%H:%M:%SZ\"),\n 'connector_instance_log_id': self.task.connector_instance_log_id,\n 'connector_instance_id':self.task.connector_instance_id,\n 'workspace_id':self.task.workspace_id,\n 'client_id':self.task.client_id,\n 'client_name':self.task.client_name,\n 'versioned':False,\n 'category':self.task.instance_data.get('category',''),\n 'task_log_id':self.task.id }\n self.__setSoupForCurrentUri()\n self.__setParentPage()\n question_post = self.soup.find('div', id=re.compile('^edit.*?'))\n self.__addPost(question_post, True)\n self.__goToLastPage() \n while self.__iteratePosts():\n try:\n next_page_uri = self.soup.find('a', text='<',rel='prev').parent['href']\n data_dict = dict(parse_qsl(next_page_uri.split('?')[-1]))\n if 's' in data_dict.keys():\n data_dict.pop('s')\n self.currenturi = self.__baseuri + 'showthread.php?'+ urlencode(data_dict) \n self.__setSoupForCurrentUri()\n except:\n log.exception(self.log_msg('Next Page link not found for url \\\n %s'%self.currenturi))\n break\n return True\n \n\n \"\"\"#try: \n # question_post = self.soup.find('div', id=re.compile ('^edit\\d+'))\n #except:\n # log.info(self.log_msg('Question post cannot be added'))\n #main_page_soup = copy.copy(self.soup)\n # self.__addPost(question_post, True)\n except:\n log.info(self.log_msg('page not added'))\n self.__goToLastPage(main_page_soup)\n while True:\n main_page_soup = copy.copy(self.soup)\n #log.info(self.log_msg('Question post cannot be added'))\n if not self.__iteratePosts():\n break\n try:\n self.currenturi = main_page_soup.find('a',text='<').parent['href']\n log.info(self.log_msg('uri %s'%self.currenturi)) \n except:\n \n log.info(self.log_msg('No Previous URL found for url \\\n %s'%self.currenturi))\n break\n return True\n \"\"\" \n \n \n except:\n log.exception(self.log_msg('Exception while add the theread posts \\\n for the url %s'%self.currenturi))\n return False","def make_new_post(user_id):\n user = User.query.get_or_404(user_id)\n tags = Tag.query.all()\n return render_template('posts/new_post.html', user=user, tags=tags)","def __addThreadAndPosts(self):\n self.__genre = \"Review\"\n self.__hierarchy = []\n self.__baseuri = 'http://forums.seagate.com'\n self.__task_elements_dict = {\n 'priority':self.task.priority,\n 'level': self.task.level,\n 'last_updated_time':datetime.strftime(datetime.utcnow()\n , \"%Y-%m-%dT%H:%M:%SZ\"), \n 'pickup_date':datetime.strftime(datetime.utcnow(), \n \"%Y-%m-%dT%H:%M:%SZ\"), \n 'connector_instance_log_id': \\\n self.task.connector_instance_log_id, \n 'connector_instance_id':\n self.task.connector_instance_id, \n 'workspace_id':self.task.workspace_id, \n 'client_id':self.task.client_id, \n 'client_name':self.task.client_name, \n 'versioned':False, \n 'category':self.task.instance_data.get('category',''), \n 'task_log_id':self.task.id }\n self.__setParentPage()\n question_post = self.soup.find('div', 'lia-message-view')\n self.__addPost(question_post, True)\n self.__goToLastPage()\n while self.__iteratePosts():\n try:\n self.currenturi = self.__baseuri + self.soup.find('span', \\\n 'lia-paging-page-link', text='Previous').findParent('a')\\\n ['href'].split(';')[0]\n self.__setSoupForCurrentUri()\n except:\n log.info(self.log_msg('No Previous URL found for url \\\n %s'%self.currenturi))\n break\n return True","def create_topic():\n nodes = Node.query.all()\n form = TopicForm(nodes)\n if request.method == 'POST':\n topic = Topic(title=request.form.get('title'),\n content=request.form.get('content'),\n node_id=request.form.get('node_id'),\n user=current_user._get_current_object())\n db.session.add(topic)\n db.session.commit()\n return jsonify({\"result\": 'ok'})\n\n return render_template('main/create_topic.html', nodes=nodes, form=form)","def post(self, request, pk):\n\n post = Blog.objects.get(pk=int(pk))\n user_id = self.request.session.get('USER_ID')\n\n try:\n user = User.objects.get(pk=user_id)\n except:\n pass\n body = self.request.POST.get('body')\n\n if user_id is None:\n messages.add_message(request, messages.ERROR, \"Please login to add comments.\")\n return HttpResponseRedirect(self)\n\n comments = Comment.objects.create(post=post, author=user, body=body)\n\n d = model_to_dict(post)\n messages.add_message(request, messages.SUCCESS, \"Comment added successfully.\")\n return self.render_to_response(d)","def new_post_form(user_id):\r\n\r\n user = User.query.get_or_404(user_id)\r\n tags = Tag.query.all()\r\n\r\n return render_template('post-form.html', user=user, tags=tags)","def test_post_creation_success(self):\n url = reverse('post-list', args=[self.topic1.url_name])\n payload = {\n 'author': self.user1.id,\n 'title': 'Creating a post',\n 'content': 'Rich content 4',\n }\n self.client.credentials(\n HTTP_AUTHORIZATION = 'Token ' + self.user1.auth_token.key\n )\n response = self.client.post(url, payload)\n\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\n new_post = Post.objects.filter(\n author=self.user1,\n title=payload.get('title'),\n content=payload.get('content'),\n topic=self.topic1\n )\n self.assertTrue(new_post.exists())","def new_answer(request):\n if request.method == \"POST\":\n author = request.POST.get(\"author\")\n content = request.POST.get(\"content\")\n date = datetime.datetime.now()\n answer_tuple = {\n \"author\": author,\n \"content\": content,\n \"votes\": 0,\n \"topic_index\": request.matchdict[\"url\"],\n \"answer_date\": date.strftime(\"%d/%m/%Y\"),\n }\n request.db[\"answer\"].insert(answer_tuple)\n return HTTPFound(location=\"/topic/\" + request.matchdict[\"url\"])\n return HTTPFound(location=\"/\")","def make_post_view(request):\n # get方法，显示表单页面\n data = request.extra_data\n if request.method == 'GET':\n mkp_form = MakePostForm()\n return (\n render_to_response(\n 'manage/make_post.html',\n locals(),\n context_instance=RequestContext(request))\n )\n # post方法提交表单并跳转\n if request.method == 'POST':\n mkp_form = MakePostForm(request.POST)\n # Posts.objects.get(id='1')\n if mkp_form.is_valid():\n newpost = new_post(mkp_form, request)\n newpost.save()\n return (\n HttpResponseRedirect(\n data['basic_info'].blog_edit_url + '/' + str(newpost.id) + '/')\n )\n else:\n return (\n render_to_response(\n 'manage/make_post.html',\n locals(),\n context_instance=RequestContext(request))\n )","def post(self):\n post_id = int(self.request.get('post_id'))\n post = Posts.get_by_id(post_id)\n comment = self.request.get('comment')\n submitter_id = self.get_active_user().key().id()\n\n if submitter_id:\n comment = Comments(post_id=post_id, content=comment,\n submitter_id=submitter_id)\n comment.put()\n self.redirect('/%s' % str(post.key().id()))\n else:\n self.error(403)","def teacher_forum_update(request, post_id):\n # Deleting admin-typed user session\n # Deleting programmer-typed-user session\n\n # Get the current users\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\n\n current_basic_user_profile = get_current_user_profile(\n request,\n User,\n BasicUserProfile,\n ObjectDoesNotExist\n )\n\n # Getting the teacher profile\n current_teacher_profile = get_current_teacher_user_profile(\n request,\n User,\n TeacherUserProfile,\n ObjectDoesNotExist\n )\n\n # Get the current post\n try:\n current_post = TeacherForumPost.objects.get(id=post_id)\n except ObjectDoesNotExist:\n current_post = None\n\n # if the post id is not existing redirect to 404\n if current_post == None:\n return HttpResponseRedirect(\"/404/\")\n\n # update form processing\n empty_input = False\n current_teacher_is_owner = True\n\n if request.POST.get(\"teacher_forum_update_submit_btn\"):\n post_update_title = request.POST.get(\"post_update_title\")\n post_update_content = request.POST.get(\"post_update_content\")\n\n # check if any of the inputs are empty\n if bool(post_update_title) == False or post_update_title == \"\" \\\n or bool(post_update_content) == False or post_update_content == \"\":\n empty_input = True\n else:\n # check if the post is owned by current teacher\n if current_post.teacher == current_teacher_profile:\n current_post.post_title = post_update_title\n current_post.content = post_update_content\n current_post.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n else:\n current_teacher_is_owner = False\n\n data = {\n \"current_basic_user\": current_basic_user,\n \"current_basic_user_profile\": current_basic_user_profile,\n \"current_teacher_profile\": current_teacher_profile,\n \"current_post\": current_post,\n \"empty_input\": empty_input,\n \"current_teacher_is_owner\": current_teacher_is_owner,\n }\n\n if \"teacher_user_logged_in\" in request.session:\n return render(request, \"teacher_forum/update.html\", data)\n else:\n return HttpResponseRedirect(\"/\")","def new_post():\n form = PostForm()\n if form.validate_on_submit():\n post = Post(pub_date=datetime.date.today())\n post.title = form.title.data\n post.content = form.content.data\n post.slug = slugify(post.title)\n db.session.add(post)\n db.session.commit()\n return flask.redirect(flask.url_for(\n 'view_post',\n year=post.pub_date.year,\n month=post.pub_date.month,\n day=post.pub_date.day,\n slug=post.slug\n ))\n return flask.render_template('new.html', form=form)","def create():\r\n if request.method == 'POST':\r\n title = request.form['title']\r\n body = request.form['body']\r\n error = None\r\n db = get_db()\r\n cur = db.cursor()\r\n\r\n cur.execute('SELECT title FROM novel.post WHERE title = %s', title)\r\n newTitle = cur.fetchone()\r\n\r\n if not title:\r\n error = 'Title is required.'\r\n\r\n if newTitle and newTitle['title'] == title:\r\n error = 'Title is repeated.'\r\n\r\n if error is not None:\r\n flash(error)\r\n else:\r\n db = get_db()\r\n db.cursor().execute(\r\n 'INSERT INTO novel.post (title, body, author_id) VALUES (\"{0}\", \"{1}\", \"{2}\")'\r\n .format(title, body, g.user['id'])\r\n )\r\n db.commit()\r\n return redirect(url_for('novel.index'))\r\n\r\n return render_template('novel/create.html')","def test_create_post(self):\n self.test_category = Category.objects.create(name='django')\n self.testuser1 = User.objects.create_superuser(\n username='test_user1', password='123456789')\n # self.testuser1.is_staff = True\n\n self.client.login(username=self.testuser1.username,\n password='123456789')\n\n data = {\"title\": \"new\", \"author\": 1,\n \"excerpt\": \"new\", \"content\": \"new\"}\n url = reverse('blog_api:listcreate')\n response = self.client.post(url, data, format='json')\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)","def testAddForum(self):\n board = self.board\n forum_id = 'forum'\n board.addForum(forum_id, 'title', 'description')\n self.failUnless(forum_id in board.objectIds())\n forum = getattr(board, forum_id)\n self.failUnless(IForum.providedBy(forum))","def teacher_forum_read(request, post_id):\n # Deleting admin-typed user session\n # Deleting programmer-typed-user session\n\n # Get the current users\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\n\n current_basic_user_profile = get_current_user_profile(\n request,\n User,\n BasicUserProfile,\n ObjectDoesNotExist\n )\n\n # Getting the teacher profile\n current_teacher_profile = get_current_teacher_user_profile(\n request,\n User,\n TeacherUserProfile,\n ObjectDoesNotExist\n )\n\n # Get the current post\n try:\n current_post = TeacherForumPost.objects.get(id=post_id)\n except ObjectDoesNotExist:\n current_post = None\n\n # if the post id is not existing redirect to 404\n if current_post == None:\n return HttpResponseRedirect(\"/404/\")\n\n # check if the post is owned by the current user if it is pass it on to\n # the template logic\n current_user_is_teacher = False\n if current_post.teacher == current_teacher_profile:\n current_user_is_teacher = True\n\n # current post upvote form processing\n if request.POST.get(\"teacher_forum_read_post_upvote_btn\"):\n current_post.karma += 1\n current_post.save()\n\n # current post downvote form processing\n if request.POST.get(\"teacher_forum_read_post_downvote_btn\"):\n current_post.karma -= 1\n current_post.save()\n\n # get all the coments\n try:\n all_post_comments = TeacherForumComment.objects.filter(\n post=current_post\n ).order_by(\"-id\")\n except ObjectDoesNotExist:\n all_post_comments = None\n\n # comment upote form processing\n if request.POST.get(\"teacher_forum_comment_upvote_submit\"):\n hidden_comment_id = request.POST.get(\"hidden_comment_id\")\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\n current_comment.karma += 1\n current_comment.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n # comment downvote form processing\n if request.POST.get(\"teacher_forum_comment_downvote_submit\"):\n hidden_comment_id = request.POST.get(\"hidden_comment_id\")\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\n current_comment.karma -= 1\n current_comment.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n # comment create form processing\n if request.POST.get(\"teacher_forum_comment_subtmit_btn\"):\n comment_content = request.POST.get(\"comment_content\")\n # check if it is empty\n if bool(comment_content) == False or comment_content == \"\":\n pass\n else:\n new_comment = TeacherForumComment(\n teacher=current_teacher_profile,\n post=current_post,\n content=comment_content\n )\n new_comment.save()\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n # Delete the post and its comments form processing\n if request.POST.get(\"teacher_forum_delete_post_submit\"):\n # check if the current user is the owner\n if current_post.teacher == current_teacher_profile:\n # delete the ppost\n current_post.delete()\n # delete all the comments\n all_post_comments.delete()\n # redirect to landing page\n return HttpResponseRedirect(\"/teacher/forum/0/\")\n else:\n return HttpResponseRedirect(\n \"/teacher/forum/read/\"+str(current_post.id)+\"/\"\n )\n\n data = {\n \"current_basic_user\": current_basic_user,\n \"current_basic_user_profile\": current_basic_user_profile,\n \"current_teacher_profile\": current_teacher_profile,\n \"current_post\": current_post,\n \"current_user_is_teacher\": current_user_is_teacher,\n \"all_post_comments\": all_post_comments,\n }\n\n if \"teacher_user_logged_in\" in request.session:\n return render(request, \"teacher_forum/read.html\", data)\n else:\n return HttpResponseRedirect(\"/\")","def render_form(self, title=\"\", body=\"\", error=\"\"):\n self.render(\"newpost.html\", title=title, body=body, error=error)","def new_post(user_id):\n user = User.query.get_or_404(user_id)\n\n tags = Tag.query.all()\n return render_template('posts/new_page.html', user=user, tags=tags)","def post(self, post_id):\n post = Post.get_by_id(int(post_id), parent=blog_key())\n\n if post and self.user.key().id() == post.user.key().id():\n post.subject = self.request.get('subject')\n post.content = self.request.get('content')\n\n # initialize error to false\n have_errors = False\n\n # if there is no subject or content, it will throw errors\n if not post.subject:\n error_subject = \"Please write down the subject\"\n have_errors = True\n if not post.content:\n error_content = \"Content is required\"\n have_errors = True\n\n if have_errors:\n self.render(\"edit.html\",\n subject=post.subject,\n content=post.content,\n error_subject=error_subject,\n error_content=error_content,\n user=self.user)\n else:\n post.put()\n self.redirect('/blog/%s' % str(post.key().id()))","def new_blog(request, form = None):\n dajax = Dajax()\n \n html_content = \"\"\n dajax.add_css_class('#showcase', 'hide')\n dajax.add_css_class('#sponsors', 'hide')\n \n if request.method == 'POST':\n form = ThreadForm(deserialize_form(form))\n print form\n if form.is_valid(): # check validity\n form.save()\n show_alert(dajax, \"success\", \"Your post has been saved !\")\n else: # form was not valid, show errors\n dajax.remove_css_class('#form_new_blog_post input', 'error')\n for error in form.errors: # tell which parts had errors\n dajax.add_css_class('#id_%s' % error, 'error')\n print [error for error in form.errors]\n show_alert(dajax, 'error', \"There were some errors : please rectify them\") # show alert\n else: # GET - display empty form\n form = ThreadForm()\n html_content = render_to_string('blog/new.html', {'form': form}, RequestContext(request))\n \n if html_content:\n dajax.assign(\"#features\", \"innerHTML\", html_content)\n \n return dajax.json()","def __addPost(self, post, is_question=False):\n try:\n unique_key = post.find('a')['name']\n if checkSessionInfo(self.__genre, self.session_info_out, unique_key, \\\n self.task.instance_data.get('update'),parent_list\\\n = [self.task.instance_data['uri']]):\n log.info(self.log_msg('Session info returns True for uri %s'%unique_key))\n return False\n page = self.__getData(post, is_question)\n if not page:\n log.info(self.log_msg('page contains empty data, getdata \\\n returns False for uri %s'%self.currenturi))\n return True\n result = updateSessionInfo(self.__genre, self.session_info_out, unique_key, \\\n get_hash( page ),'forum', self.task.instance_data.get('update'),\\\n parent_list=[self.task.instance_data['uri']])\n if result['updated']:\n page['parent_path'] = [self.task.instance_data['uri']]\n page['path'] = [ self.task.instance_data['uri'], unique_key]\n page['uri'] = self.currenturi + '#' + unique_key\n page['uri_domain'] = urlparse.urlparse(page['uri'])[1]\n page.update(self.__task_elements_dict)\n self.pages.append(page)\n else:\n log.info(self.log_msg('Update session info returns False for \\\n url %s'%self.currenturi))\n except:\n log.exception(self.log_msg('Cannot add the post for the uri %s'%self.currenturi))\n return True","def test_create_post(self):\n with self.client:\n result = self.client.post('/users/spike-test/posts', data={\n \"post-title\": \"autotest title\",\n \"post-content\": \"autotest content for blog post testing\"\n }, follow_redirects=True)\n self.assertEqual(result.status_code, 200)\n self.assertIn(b'autotest title', result.data)","def createPost(request):\n\n #save the organization's post\n if request.method == 'POST':\n form = PostForm(request.user, request.POST, request.FILES)\n if form.is_valid():\n filterList = ['everyone', 'black', 'hispanic', 'female', 'lgbt', 'immigrants', 'disabled', 'poor'] \n newpost = form.save()\n\n #Add tags to the object only if in the filterlist\n tags = form.cleaned_data.get('tags')\n tags = [tag.lower() for tag in tags if tag.lower() in filterList]\n\n newpost.tags.add(*tags)\n messages.success(request, 'You have successful created the post')\n form = PostForm(request.user)\n context = {'form':form} \n return render(request, 'create_post.html', context=context)\n \n #form to fill out for the post\n form = PostForm(request.user)\n context = {'form':form} \n return render(request, 'create_post.html', context=context)","def get(self, user):\n return self.render(\"post-new.html\", user=user)","def dashboard_post(request):\n template = \"pages/dashboard.html\"\n form = CreateLeaderboardForm(request.POST)\n if form.is_valid():\n data = form.cleaned_data\n add_owner = data[\"add_owner\"]\n del data[\"add_owner\"] # Drop the fields not needed by leaderboard model\n ldb = Leaderboard.objects.create(**data, owner=request.user)\n if add_owner:\n ldb.participants.add(request.user) # Add the creator as participant\n return render(request, template, context=dashboard_context(request))\n else:\n ctx = dashboard_context(request)\n ctx[\"creation_form\"] = form # Send it back with error messages\n return render(request, template, context=ctx)","def new(request):\n assert isinstance(request, HttpRequest)\n if request.method == 'POST': # フォームが提出された\n form = EntryForm(request.POST) # POST データの束縛フォーム\n if form.is_valid(): # バリデーションを通った\n entry = form.save(commit=False)\n entry.member = request.user\n entry.save()\n return HttpResponseRedirect(reverse('entry_list')) # POST 後のリダイレクト\n else:\n form = EntryForm() # 非束縛フォーム\n article_list = Article.objects.order_by('-released_at')[:5]\n auth_form = AuthenticationForm(None, request.POST or None)\n return render(request, 'app/entry_edit.html', { \n 'form': form,\n 'title':'ブログ記事の新規登録',\n 'year':datetime.now().year,\n 'articles':article_list,\n 'blogs':EntryView.get_entry_list('-posted_at',-1, request.user.pk )[:5],\n 'submit_title':'登録する',\n 'auth_form':auth_form,\n 'current_user':request.user,\n })","def show_form_to_add_new_post(user_id):\n user = User.query.get_or_404(user_id)\n tags = Tag.query.all()\n\n return render_template('posts/new.html', user=user, tags=tags)","def add_post(user_id):\n\n title = request.form['title']\n content = request.form['content']\n tags = request.form.getlist('tag')\n user = User.query.get_or_404(user_id)\n\n if not title or not content:\n flash(\"Please enter title and content.\")\n return redirect(f\"/users/{user.id}/posts/new\")\n\n post = Post(title=title, content=content, user=user)\n\n if tags:\n for tag in tags:\n post.tags.append(Tag.query.filter(Tag.name==tag).one())\n\n db.session.add(post)\n db.session.commit()\n\n user = User.query.get_or_404(user_id)\n\n return redirect(f\"/users/{user_id}\")","def new_from_post():\n # If you make a post request with a question_id we will assume you want a new question editor\n # we will prepopulate the question new page with data from that question (if it is a valid question id)\n question_id = request.form['question_id'] if request.form['question_id'] else ''\n\n return render_template('questionNew.html', question_id=question_id)","def new_post(self, content):\n return self.proxy.wp.newPost(self.blog_id, self.username, self.password,\n content)","def post(self):\n\n token = self.request.get('token')\n user = users.get_current_user()\n if not user:\n self.redirect('/')\n user_obj = utils.get_user(user)\n if token: # Adding a token for a user\n if utils.verify_token(token):\n user_obj.auth_token = token\n user_obj.put()\n self.redirect('/privatefeeds')\n else:\n args = constants.TOKEN_ARGS\n auth_url = \"https://trello.com/1/authorize?%s\" % urlencode(args)\n self.render('private.html',\n actions=constants.ACTIONS,\n incorrect_token=True,\n auth_url=auth_url,\n signout=constants.SIGNOUT)\n else: # Adding a board for a user\n board_id = self.request.get('board')\n title = self.request.get('title')\n link = self.request.get('link')\n description = self.request.get('description')\n actions = [x for x in constants.ACTIONS if self.request.get(x)]\n\n if actions:\n get_all = False\n if board_id == 'all':\n get_all = True\n board_id = None\n feed_url = utils.create_feed(\n user,board_id,\n title,link,\n description,actions,\n public_board=False,\n get_all=get_all,\n token=user_obj.auth_token)\n self.render('congrats.html',feed_url=feed_url,signout=constants.SIGNOUT)\n else: # They missed some required info\n user_boards = utils.find_boards(user_obj)\n self.render('private.html',\n actions=constants.ACTIONS,\n check_error=True,\n user_boards=user_boards,\n link=link,\n description=description,\n title=title,\n signout=constants.SIGNOUT)","def crear_userstory(request, id_proyecto):\n band=False\n context = RequestContext(request)\n\n\n rol_en_proyecto=Equipo.objects.get(usuario_id=request.user.pk, proyecto_id=id_proyecto)\n rol = Group.objects.get(id=rol_en_proyecto.rol.pk)\n user_permissions_groups = list(rol.permissions.all())\n\n for p in user_permissions_groups:\n if (p.codename == 'add_userstory'):\n band = True\n\n if (band == True):\n\n #valor booleano para llamar al template cuando el registro fue correcto\n registered = False\n\n if request.method == 'POST':\n userstory_form = UserstoryForm(data=request.POST, id_proyecto=id_proyecto)\n\n # If the two forms are valid...\n if userstory_form.is_valid():\n\n # Guarda el Usuarios en la bd\n #us = userstory_form\n userstory_form.clean()\n nombre = userstory_form.cleaned_data['nombre']\n descripcion =userstory_form.cleaned_data['descripcion']\n tiempoestimado =userstory_form.cleaned_data['tiempoestimado']\n usuarioasignado= userstory_form.cleaned_data['usuarioasignado']\n prioridad =userstory_form.cleaned_data['prioridad']\n porcentajerealizado= userstory_form.cleaned_data['porcentajerealizado']\n sprint=userstory_form.cleaned_data['sprint']\n\n us = Userstory()\n\n if usuarioasignado and sprint:\n us.estado = 'InPlanning'\n\n if userstory_form.cleaned_data['prioridad'] == 'Alta':\n cambioDePrioridades(usuarioasignado, sprint)\n\n us.nombre = nombre\n us.descripcion =descripcion\n us.tiempoestimado =tiempoestimado\n us.usuarioasignado =usuarioasignado\n us.prioridad=prioridad\n us.porcentajerealizado=porcentajerealizado\n us.sprint = sprint\n\n us.save()\n #Actualiza la variable para llamar al template cuando el registro fue correcto\n registered = True\n\n # Invalid form or forms - mistakes or something else?\n # Print problems to the terminal.\n # They'll also be shown to the user.\n else:\n print userstory_form.errors\n\n pass\n\n # Not a HTTP POST, so we render our form using two ModelForm instances.\n # These forms will be blank, ready for user input.\n else:\n userstory_form = UserstoryForm(id_proyecto=id_proyecto)\n\n\n # Render the template depending on the context.\n return render_to_response('./Userstories/crearUserstory.html', {'user_form': userstory_form, 'registered': registered, 'id_proyecto': id_proyecto}, context)\n else:\n raise Http404(\"No cuenta con los permisos necesarios\")","def postCreate(post):\n post_list = list()\n comments = commentList(post)\n comment_url = \"{}/api/posts/{}/comments\".format(DOMAIN, post.id)\n visible_to = list()\n visible = post.visibleTo.all()\n if visible:\n for author in visible:\n auth = \"{}/api/author/{}\".format(DOMAIN, author.id)\n visible_to.append(auth)\n\n # visible_to = list(post.visibleTo)\n post_dict = {'author': addAuthor(post.author), 'title': post.title, 'description': post.description,\n 'contentType': post.contentType, 'content': post.content, 'published': post.published,\n 'visibility': post.visibility, 'visibleTo': visible_to, 'unlisted': post.unlisted, 'id': post.id,\n 'comments': comments[:5], 'next': comment_url, 'count': len(comments),\n 'source': \"{}/api/posts/{}\".format(DOMAIN, post.id),\n 'origin': \"{}/api/posts/{}\".format(DOMAIN, post.id)}\n post_list.append(post_dict)\n return post_list","def test_has_perm_post_edit(self):\n self.context['request'].user = User.objects.get(pk=47963)\n allowed = has_perm(self.context, 'forums_forum.post_edit_forum',\n self.forum_1)\n eq_(allowed, True)\n allowed = has_perm(self.context, 'forums_forum.post_edit_forum',\n self.forum_2)\n eq_(allowed, False)","def test_new_thread_anonymous(self):\n self.go200('forum_thread_list', [forum.slug])\n self.find('Для створення нових тем — будь-ласка авторизуйтесь.')\n self.go200('forum_new_thread', [forum.slug])\n self.url(settings.LOGIN_REDIRECT_URL+'.*')","def new(request):\n if request.method == 'POST': # フォームが提出された\n form = ArticleForm(request.POST) # POST データの束縛フォーム\n if form.is_valid(): # バリデーションを通った\n article = form.save(commit=False)\n if form.cleaned_data['no_expired_at'] is True:\n article.expired_at = None\n article.save()\n return HttpResponseRedirect(reverse('article_list')) # POST 後のリダイレクト\n else:\n form = ArticleForm() # 非束縛フォーム\n article_list = Article.objects.order_by('-released_at')[:5]\n auth_form = AuthenticationForm(None, request.POST or None)\n return render(request, 'app/article_edit.html', { \n 'form': form,\n 'title':'ニュース記事の新規登録',\n 'year':datetime.now().year,\n 'articles':article_list,\n 'blogs':EntryView.get_entry_list('-posted_at',-1, request.user.pk )[:5],\n 'submit_title':'登録する',\n 'auth_form':auth_form,\n 'current_user':request.user,\n })","def add(self, project_id, forum):\n url = base_url + 'portal/' + str(self.portal_id) + '/projects/' + str(project_id) + '/forums/' \n data = parser.to_json(forum)\n if forum.get_upload_file():\n file_list = []\n for value in forum.get_upload_file():\n attachment = {\n 'uploadfile': {\n 'filename': basename(value), \n 'content':open(value).read()\n } \n }\n file_list.append(attachment)\n else:\n file_list = []\n response = zoho_http_client.post(url, self.details, data, None, file_list)\n return parser.get_forums(response)[0]","def create_task(request):\n all_task_list = Todo.objects.all()\n form = TaskForm()\n if request.method == 'POST':\n form = TaskForm(request.POST)\n if form.is_valid():\n # create default todolist\n user = request.user if request.user.is_authenticated else None\n task = Todo(\n description=request.POST['description'],\n content= request.POST['content'],\n tesk_medium= request.POST['tesk_medium'],\n creator=user\n )\n task.save()\n return redirect('lists:alllist')\n else:\n return render(request, 'lists/index.html', {'form': form})\n\n context = {\n 'form': form, \n 'taskli':all_task_list\n }\n return render(request, 'lists/create_task.html',context )","def get(self):\n username = self.request.cookies.get('name')\n self.render(\"newpost.html\", title=\"\",\n blogPost=\"\", error=\"\",\n username=check_secure_val(username))","def post():\n pass","def post_permissions(request, post):\n user = request.user\n is_editable = has_ownership = False\n\n if user.is_authenticated():\n\n if user == post.author :\n has_ownership = is_editable = True\n elif user.is_moderator or user.is_staff:\n is_editable = True\n\n post.is_editable = is_editable\n post.has_ownership = has_ownership\n\n return post","def post(self):\n post_id = int(self.request.get('post_id'))\n post = Posts.get_by_id(post_id)\n if post.submitter_id == self.get_active_user().key().id():\n post.delete()\n else:\n self.error(403)\n self.redirect('/')","def post(self):\n user_id = request.args.get('user_id')\n firstname = request.args.get('firstname')\n return post_new_etunimi(user_id, firstname=firstname)"],"string":"[\n \"def post(self):\\n teacher = self.request.get(\\\"teacher\\\")\\n student = self.request.get(\\\"student\\\")\\n lessondate = self.request.get(\\\"lessondate\\\")\\n reason = self.request.get(\\\"reason\\\")\\n comment = self.request.get(\\\"comment\\\")\\n\\n if teacher and student and lessondate and reason:\\n\\n # create a new Post object and store it in the database !!!!!!!!!!!!!!!\\n loglesson = Teacher(\\n teacher=teacher,\\n student=student,\\n lessondate=lessondate,\\n reason = reason,\\n comment = comment)\\n loglesson.put()\\n\\n # get the id of the new post, so we can render the post's page (via the permalink)\\n id = loglesson.key().id()\\n self.redirect(\\\"/loglesson/%s\\\" % id)\\n else:\\n error = \\\"Please include a teacher, student, lesson date, reason and comment!\\\"\\n self.render_form(teacher, student, lessondate,reason, comment, error)\",\n \"def make_post(request):\\n if request.user.is_authenticated() and request.POST:\\n member = Member.objects.get(user=request.user)\\n thread_id = request.POST.get('thread_id', -1)\\n content = request.POST.get('content', -1)\\n if thread_id != -1 and content != -1 and member:\\n post = Post()\\n post.author = member\\n post.thread = Thread.objects.get(pk=thread_id)\\n post.content = content\\n post.save()\\n return HttpResponse(200)\\n else:\\n return server_error(request)\\n else:\\n return server_error(request)\",\n \"def post(self):\\n subject = self.request.get('subject')\\n content = self.request.get('content')\\n\\n # if user enter good subject and content, redirect them to new post page\\n if subject and content:\\n p = Post(parent = blog_key(), subject = subject, content = content)\\n p.put() # store the post element into database\\n self.redirect('/blog/%s' % str(p.key().id()))\\n # otherwise, render an error page \\n else:\\n error = \\\"subject and content, please!\\\"\\n self.render(\\\"newpost.html\\\", subject=subject, content=content, error=error)\",\n \"def post(self):\\n subject = self.request.get('subject')\\n content = self.request.get('post_content')\\n post_id = self.request.get('post_id')\\n post = Posts.get_by_id(int(post_id))\\n user = self.get_active_user()\\n user_id = int(user.key().id())\\n\\n if post and user and subject and content:\\n if post.submitter_id == user_id:\\n self.render_editpage(user, post_id, subject, content)\\n else:\\n self.render_improper_access()\\n else:\\n self.error(500)\",\n \"def post(self):\\n\\n subject = self.request.get('subject')\\n content = self.request.get('content')\\n\\n have_errors = False\\n\\n if not subject:\\n error_subject = \\\"Please write down the subject\\\"\\n have_errors = True\\n if not content:\\n error_content = \\\"Content is required\\\"\\n have_errors = True\\n\\n if have_errors:\\n self.render(\\\"newpost.html\\\",\\n subject=subject,\\n content=content,\\n error_subject=error_subject,\\n error_content=error_content,\\n user=self.user)\\n else:\\n post = Post(parent=blog_key(),\\n subject=subject,\\n content=content,\\n user=self.user)\\n post.put()\\n self.redirect('/blog/%s' % str(post.key().id()))\",\n \"def post(self):\\n subject = self.request.get('subject')\\n post_content = self.request.get('post_content')\\n submit = self.request.get('submit')\\n cancel = self.request.get('cancel')\\n user = self.get_active_user()\\n created_by = int(user.key().id())\\n post_id = self.request.get('post_id')\\n\\n if not user:\\n self.redirect('/login')\\n if post_id:\\n post = Posts.get_by_id(int(post_id))\\n else:\\n post = None\\n\\n if cancel == \\\"cancel\\\":\\n self.redirect('/%s' % str(post.key().id()))\\n return\\n if (post and post.submitter_id == user.key().id()) or not post:\\n if submit == \\\"submit\\\" and subject and post_content:\\n if post:\\n post.subject = subject\\n post.content = post_content\\n post.put()\\n else:\\n post = Posts(subject=subject,\\n content=post_content,\\n submitter_id=created_by)\\n post.put()\\n self.redirect('/%s' % str(post.key().id()))\\n else:\\n self.render_newpage(user=user,\\n subject=subject,\\n post_content=post_content,\\n error=\\\"\\\"\\\"Please provide both a subject and a\\n post!\\\"\\\"\\\")\\n else:\\n self.redirect('/login')\",\n \"def add_topic(request, forum_id):\\n\\t\\n\\t\\n\\tif request.POST:\\n\\t\\tpage_data = request.POST.copy()\\n\\t\\tpage_data['topic_author'] = str(request.user)\\n\\t\\ttags = findall( r'(?xs)\\\\[code\\\\](.*?)\\\\[/code\\\\]''', page_data['text'])\\n\\t\\tfor i in tags:\\n\\t\\t\\tpage_data['text'] = page_data['text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.encodestring(i)+u'[/code]')\\n\\t\\tpage_data['text'] = html2safehtml(page_data['text'] ,valid_tags=settings.VALID_TAGS)\\n\\t\\ttags = findall( r'(?xs)\\\\[code\\\\](.*?)\\\\[/code\\\\]''', page_data['text'])\\n\\t\\tfor i in tags:\\n\\t\\t\\tpage_data['text'] = page_data['text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.decodestring(i)+u'[/code]')\\n\\t\\ttext = page_data['text']\\n\\t\\tdel page_data['text']\\n\\t\\tpage_data['topic_name'] = html2safehtml(page_data['topic_name'] ,valid_tags=())\\n\\t\\tpage_data['topic_forum'] = forum_id\\n\\t\\tpage_data['topic_posts'] = 1\\n\\t\\tpage_data['topic_lastpost'] = str(request.user)+'<br />' + str(datetime.today())[:-10]\\n\\t\\tpage_data['topic_last_pagination_page'] = 1\\n\\t\\tpage_data['topic_modification_date'] = datetime.now()\\n\\t\\tform = AddTopicForm(page_data)\\n\\t\\tif form.is_valid():\\n\\t\\t\\tnew_place = form.save()\\n\\t\\t\\tpost = Post(post_topic = new_place, post_text = text, post_author = str(request.user), post_ip = request.META['REMOTE_ADDR'])\\n\\t\\t\\tpost.save()\\n\\t\\t\\tforum = Forum.objects.get(id=forum_id)\\n\\t\\t\\tforum.forum_topics = forum.forum_topics +1\\n\\t\\t\\tforum.forum_posts = forum.forum_posts +1\\n\\t\\t\\tforum.forum_lastpost = str(request.user)+' (' + str(datetime.today())[:-10] + ')<br /><a href=\\\"/forum/topic/1/' + str(new_place.id) + '/\\\">' + new_place.topic_name + '</a>'\\n\\t\\t\\tforum.save()\\n\\t\\t\\t\\n\\t\\t\\tmail_admins('Temat Dodany', \\\"Dodano Temat: http://www.\\\" + settings.SITE_KEY + \\\"/forum/forum/\\\" + forum_id +\\\"/\\\", fail_silently=True)\\n\\t\\t\\t\\n\\t\\t\\treturn HttpResponseRedirect(\\\"/forum/forum/\\\" + forum_id +\\\"/\\\")\\n\\t\\telse:\\n\\t\\t\\treturn render_to_response(\\n\\t\\t\\t\\t'myghtyboard/add_topic.html',\\n\\t\\t\\t\\t{'form': form, 'perms': list_perms(request)},\\n\\t\\t\\t\\tcontext_instance=RequestContext(request))\\n\\t\\n\\tform = AddTopicForm()\\n\\treturn render_to_response(\\n\\t\\t'myghtyboard/add_topic.html',\\n\\t\\t{'form': form, 'perms': list_perms(request)},\\n\\t\\tcontext_instance=RequestContext(request))\",\n \"def create_post(request):\\n if request.method == 'POST':\\n title = request.POST['title']\\n content = request.POST['content']\\n user_id = request.POST['author_id']\\n category = request.POST['category']\\n\\n slug = \\\"-\\\".join(list(map(lambda word: word.lower(), title.split())))\\n author = User.objects.get(id=int(user_id))\\n\\n # save info in models\\n post = Post()\\n post.author = author\\n post.category = category\\n post.title = title\\n post.content = content\\n post.slug = slug\\n post.save()\\n return redirect('post')\\n\\n return render(request, 'posts/create_post.html')\",\n \"def post(self, request):\\n\\n # crear el formulario con los datos del post\\n form = PostForm(request.POST)\\n\\n if form.is_valid():\\n #crea el post\\n post = form.save()\\n\\n #generar mensaje de exito\\n msg = \\\"Post creado con éxito\\\"\\n form = PostForm()\\n else:\\n msg = \\\"Ha ocurrido un error al guardar el post\\\" \\\\\\n\\n\\n # renderiza la plantilla con el formulario\\n context = {\\n \\\"form\\\": form,\\n \\\"msg\\\": msg\\n }\\n\\n # renderiza y devuelve la plantilla\\n return render(request, 'blogs/new-post.html', context)\",\n \"def community_post_create_view(request):\\n task = \\\"Create New\\\"\\n form = AddEditPostForm() # An unbound form\\n\\n if request.method == 'POST': # If the form has been submitted...\\n form = AddEditPostForm(request.POST, request.FILES) # A form bound to the POST data\\n if form.is_valid(): # All validation rules pass\\n post = form.save(commit=False) # Create a new object from the form, but don't save it to the database\\n post.author = request.user # Set the author to the current user\\n post.save() # Save the object to the database\\n slug_str = \\\"%s %s\\\" % (post.title, post.date_posted) # Create a slug from the title and date\\n post.slug = slugify(slug_str) # Create the slug\\n post.save() # Save the object to the database\\n return redirect('community-home') # Redirect to the home page\\n\\n context = { # Pass the variables to the template\\n 'task': task,\\n 'form': form,\\n }\\n return render(request,\\n 'pages/patient-community/community-create-update-post.html',\\n context) # render the patient community create post page\",\n \"def post(self):\\n current_user = self.authenticate_user()\\n\\n if not current_user:\\n self.redirect(\\\"/login\\\")\\n else:\\n content = self.request.get(\\\"content\\\")\\n title = self.request.get(\\\"subject\\\")\\n\\n if not content or not title:\\n self.render_front(title, content, \\\"We need both a title and content\\\")\\n else:\\n post = Post(title=title, content=content, user=current_user.key)\\n post.put()\\n\\n current_user.posts.append(post.key)\\n current_user.put()\\n\\n self.redirect(\\\"/post/\\\" + str(post.key.id()))\",\n \"def post(self):\\n teacher = self.request.get(\\\"teacher\\\")\\n temail = self.request.get(\\\"temail\\\")\\n tphone = self.request.get(\\\"tphone\\\")\\n specialty = self.request.get(\\\"specialty\\\")\\n\\n if teacher and temail and tphone and specialty:\\n\\n #create a new teacher object and store it in the database\\n teacher = Teacher(\\n teacher=teacher,\\n temail=temail,\\n tphone=tphone, \\n specialty=specialty)\\n teacher.put()\\n\\n id = teacher.key().id()\\n self.redirect(\\\"/teacher/%s\\\" % id)\\n else:\\n error = \\\"Please include a teacher, an email, a phone number, and a specialty.\\\"\\n self.render_form(teacher, temail, tphone, specialty, error)\",\n \"def post(self):\\n title = self.request.get(\\\"title\\\")\\n body = self.request.get(\\\"body\\\")\\n\\n if title and body:\\n\\n # create a new Post object and store it in the database\\n post = Post(\\n title=title,\\n body=body\\n )\\n post.put()\\n\\n # get the id of the new post, so we can render the post's page (via the permalink)\\n id = post.key().id()\\n self.redirect(\\\"/blog/%s\\\" % id)\\n else:\\n error = \\\"we need both a title and a body!\\\"\\n #self.render_form(title, body, error)\\n self.render(\\\"newpost.html\\\", title, body, error)\",\n \"def new_post(mkp_form, request):\\n newpost = Posts()\\n newpost.init()\\n newpost.authorid = int(request.user.id)\\n newpost.title = mkp_form.cleaned_data['title']\\n newpost.name = mkp_form.cleaned_data['short_title'] # 缩略名\\n newpost.cover = mkp_form.cleaned_data['cover_url']\\n newpost.introduction = mkp_form.cleaned_data['introduction']\\n newpost.content = js_resize_img(mkp_form.cleaned_data['content'])\\n newpost.status = Status.objects.get(id=2) # id为2是已发布的文章，默认为已发布，后面再改\\n tagids = mkp_form.cleaned_data['tags']\\n if len(tagids) != 0:\\n for tagid in tagids:\\n tagid = int(tagid)\\n tag = Tags.objects.get(id=tagid)\\n newpost.tags.add(tag)\\n threadtypeid = mkp_form.cleaned_data['threadtypeid']\\n newpost.threadtypeid = ThreadTypes.objects.get(id=threadtypeid)\\n if mkp_form.cleaned_data['commentnotshow'] != '':\\n newpost.comment_status = False\\n else:\\n newpost.comment_status = True\\n return newpost\",\n \"def post(self, user):\\n subject = self.request.get(\\\"subject\\\")\\n content = self.request.get(\\\"content\\\")\\n\\n if subject and content:\\n post = Post(subject=subject,\\n content=content,\\n author=self.user)\\n post.put()\\n return self.redirect(\\\"/%s\\\" % post.key().id())\\n else:\\n\\n error = \\\"subject and content, please!\\\"\\n return self.render(\\\"newpost.html\\\",\\n subject=subject,\\n content=content,\\n error=error)\",\n \"def post(self):\\n\\n title = self.request.get(\\\"title\\\")\\n blogPost = self.request.get(\\\"blogPost\\\")\\n author = self.request.cookies.get('name')\\n\\n if title and blogPost:\\n\\n bp = Blogposts(parent=blog_key(), title=title,\\n blogPost=blogPost, author=check_secure_val(author))\\n\\n bp.put()\\n\\n self.redirect('/%s' % str(bp.key.integer_id()))\\n else:\\n error = \\\"Please submit both a title and a blogpost!\\\"\\n self.render(\\\"newpost.html\\\", title=title,\\n blogPost=blogPost, error=error)\",\n \"def posts_create(request):\\n if request.method == 'POST':\\n form = PostForm(request.POST, request.FILES)\\n if form.is_valid():\\n form.save()\\n return redirect('feed')\\n\\n else:\\n form = PostForm()\\n\\n return render(\\n request=request,\\n template_name='posts/new.html',\\n context={\\n 'form': form,\\n 'user': request.user,\\n 'perfil': request.user.perfil\\n }\\n )\",\n \"def create_post():\\r\\n\\r\\n # Check for and reject empty username or whinge\\r\\n if not request.values.get(\\\"username\\\") or not request.values.get(\\\"whinge\\\"):\\r\\n print(\\\"Ignoring request to with empty username or whinge\\\")\\r\\n else:\\r\\n # Form data ok; add to DB\\r\\n con = get_db()\\r\\n con.execute(\\\"INSERT INTO posts (submitter,content,ts) VALUES (?,?,?);\\\",\\r\\n (\\r\\n request.values.get(\\\"username\\\"), # form field username -> DB column submitter\\r\\n request.values.get(\\\"whinge\\\"), # form field whinge -> DB column content\\r\\n time.time()\\r\\n )\\r\\n )\\r\\n con.commit()\\r\\n con.close()\\r\\n \\r\\n # TODO: Handle possibility of failed INSERT\\r\\n\\r\\n # Send them back to the main page\\r\\n return redirect(url_for(\\\"display_top\\\"))\",\n \"def post(request):\\n if request.method == \\\"POST\\\":\\n post = Post()\\n post.content = request.POST['content']\\n post.author = request.user\\n post.save()\\n return HttpResponseRedirect(reverse(\\\"index\\\"))\",\n \"def create_post():\\n\\n #Get prompt id\\n prompt_id = request.form.get('prompt_id')\\n\\n # Get post text\\n post_text = request.form.get('user_post')\\n\\n # Create post timestamp\\n created_at = datetime.now()\\n user_facing_date = created_at.strftime(\\\"%B %d, %Y\\\")\\n\\n # Save post and related data to database\\n post = crud.create_post(session['user_id'], prompt_id, post_text, session['lat'], session['lng'], session['user_facing_location'], created_at)\\n\\n return render_template('post_data.html', post=post, user_facing_date=user_facing_date)\",\n \"def post(self, request):\\n\\n # crear el formulario con los datos del POST\\n blog_with_user = Blog(owner=request.user)\\n form = BlogForm(request.POST, instance=blog_with_user)\\n\\n if form.is_valid():\\n #crea el post\\n blog = form.save()\\n\\n #generar mensaje de exito\\n msg = \\\"Blog creado con éxito\\\"\\n\\n # limpiamos el formulario creando uno vacío para pasar a la plantilla\\n form = BlogForm()\\n else:\\n msg = \\\"Ha ocurrido un error al guardar el blog\\\" \\\\\\n\\n\\n # renderiza la plantilla con el formulario\\n context = {\\n \\\"form\\\": form,\\n \\\"msg\\\": msg\\n }\\n\\n # renderiza y devuelve la plantilla\\n return render(request, 'blogs/new-blog.html', context)\",\n \"def post(self, req):\\n error_messages = []\\n success_message = ''\\n\\n # Creamos owner y se lo pasamos al form con un objeto pre-establecido\\n post_with_owner = Post()\\n post_with_owner.owner = req.user\\n post_with_owner.blog = Blog.objects.filter(owner=req.user)[0]\\n\\n form = PostCreateForm(req.POST, instance=post_with_owner)\\n if form.is_valid():\\n\\n new_post = form.save()\\n form = PostCreateForm()\\n success_message = u'Post guardado con éxito! '\\n success_message += u'<a href=\\\"{0}\\\">'.format(reverse('post_detail', args=[req.user.username, new_post.pk]))\\n success_message += u'(ver post)</a>'\\n else:\\n error_messages.append(u'Formulario incompleto.')\\n\\n context = {\\n 'form': form,\\n 'success_message': success_message\\n }\\n return render(req, 'posts/new_post.html', context)\",\n \"def test_new_thread(self):\\n self.helper('create_user', 'testuser', 'password')\\n self.login('testuser', 'password', 'auth_login','id_login')\\n self.url(settings.LOGIN_REDIRECT_URL)\\n self.go200('forum_new_thread', [forum.slug])\\n self.showforms()\\n self.formclear('id_newthread')\\n self.fv('id_newthread', 'id_title', 'Some cool new thread')\\n self.fv('id_newthread', 'id_body', 'Hello world!')\\n self.submit200()\\n self.go200('forum_thread_list', [forum.slug])\\n self.find('Some cool new thread')\\n self.go200('forum_view_thread', [2])\\n self.find('Hello world!')\",\n \"def test_forum_new_post(self):\\n sel = self.selenium\\n login_page_obj = login_page.LoginPage(sel)\\n forums_page_obj = forums_page.ForumsPage(sel)\\n \\n user_info = sumo_test_data.SUMOtestData().getUserInfo(0)\\n uname = user_info['username']\\n pwd = user_info['password']\\n timestamp = sel.get_eval(\\\"new Date().getTime()\\\")\\n thread_title = \\\"Litmus 7829 test\\\" + timestamp\\n thread_text = \\\"Litmus QA 7829 Testcase Test Msg\\\"\\n \\n ''' Login '''\\n login_page_obj.log_in(uname, pwd) \\n \\n \\n ''' Post a new thread '''\\n forums_page_obj.open(forums_page_obj.kb_articles_forum_url)\\n forums_page_obj.post_new_thread_first_cat(thread_title, thread_text)\\n\\n time.sleep(5)\\n self.failUnless(sel.is_text_present(thread_text))\\n # Verify post title\\n forums_page_obj.open(forums_page_obj.kb_articles_forum_url)\\n self.failUnless(sel.is_text_present(thread_title))\\n \\n ''' Logout '''\\n forums_page_obj.log_out()\",\n \"def create_welcome_forum():\\n if User.query.count() < 1:\\n return False\\n\\n user = User.query.filter_by(id=1).first()\\n\\n category = Category(title=\\\"My Category\\\", position=1)\\n category.save()\\n\\n forum = Forum(title=\\\"Welcome\\\", description=\\\"Your first forum\\\",\\n category_id=category.id)\\n forum.save()\\n\\n topic = Topic(title=\\\"Welcome!\\\")\\n post = Post(content=\\\"Have fun with your new FlaskBB Forum!\\\")\\n\\n topic.save(user=user, forum=forum, post=post)\\n return True\",\n \"def newreply(request, post_id):\\n if not request.user.is_authenticated():\\n return redirect('/login/?next=%s' % request.path)\\n else:\\n\\n reply = Reply.objects.create(\\n creator = request.user,\\n created = datetime.datetime.now(),\\n body = request.POST.get('mensaje'),)\\n post = Post.objects.get(id = post_id)\\n post.reply.add(reply) \\n return redirect('/home/')\",\n \"def get(self):\\n\\n self.render(\\\"newpost.html\\\", user=self.user)\",\n \"def create_post(user_id):\\n if CURRENT_USER_KEY not in session or session[CURRENT_USER_KEY] != user_id:\\n raise Unauthorized\\n\\n user = User.query.get_or_404(user_id)\\n\\n form = PostForm()\\n form.muscles.choices = [(m.id, m.name) for m in Muscle.query.all()]\\n form.equipment.choices = [(e.id, e.name) for e in Equipment.query.all()]\\n # import pdb\\n # pdb.set_trace()\\n if form.validate_on_submit():\\n title = form.title.data\\n details = form.details.data\\n is_private = form.is_private.data\\n muscles = form.muscles.data\\n equipment = form.equipment.data\\n post = Post(title=title, details=form.details.data,\\n is_private=form.is_private.data, user_id=user_id)\\n db.session.add(post)\\n db.session.commit()\\n\\n # create join table additions\\n muscles_to_add = []\\n equipment_to_add = []\\n for muscle in muscles:\\n muscle_post = PostMuscle(post_id=post.id, muscle_id=muscle)\\n muscles_to_add.append(muscle_post)\\n for choice in equipment:\\n equipment_post = PostEquipment(\\n post_id=post.id, equipment_id=choice)\\n equipment_to_add.append(equipment_post)\\n db.session.add_all(muscles_to_add + equipment_to_add)\\n db.session.commit()\\n flash('New post created!', 'success')\\n return redirect(url_for('show_user_profile', user_id=user_id))\\n return render_template('add_post.html', form=form, user=user)\",\n \"def add_post(request, topic_id, post_id = False):\\n\\t\\n\\ttopic = Topic.objects.values('is_locked').get(id=topic_id)\\n\\tif topic['is_locked']:\\n\\t\\treturn render_to_response('pages/bug.html', {'bug': _('Topic is closed')}, context_instance=RequestContext(request))\\n\\n\\t# check who made the last post.\\n\\tlastpost = Post.objects.order_by('-post_date').filter(post_topic=topic_id)[:1]\\n\\tis_staff = request.user.is_staff\\n\\t# if the last poster is the current one (login) and he isn't staff then we don't let him post after his post\\n\\tif str(lastpost[0].post_author) == str(request.user) and not is_staff:\\n\\t\\treturn render_to_response('pages/bug.html', {'bug': _('You can\\\\'t post after your post')}, context_instance=RequestContext(request))\\n\\t\\n\\tlastpost = Post.objects.filter(post_topic=topic_id).order_by('-id')[:10]\\n\\tif request.POST:\\n\\t\\tpage_data = request.POST.copy()\\n\\t\\tpage_data['post_author'] = str(request.user)\\n\\t\\ttags = findall( r'(?xs)\\\\[code\\\\](.*?)\\\\[/code\\\\]''', page_data['post_text'])\\n\\t\\tfor i in tags:\\n\\t\\t\\tpage_data['post_text'] = page_data['post_text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.encodestring(i)+u'[/code]')\\n\\t\\tpage_data['post_text'] = html2safehtml(page_data['post_text'] ,valid_tags=settings.VALID_TAGS)\\n\\t\\ttags = findall( r'(?xs)\\\\[code\\\\](.*?)\\\\[/code\\\\]''', page_data['post_text'])\\n\\t\\tfor i in tags:\\n\\t\\t\\tpage_data['post_text'] = page_data['post_text'].replace(u'[code]'+i+u'[/code]', u'[code]'+base64.decodestring(i)+u'[/code]')\\n\\t\\t\\n\\t\\tpage_data['post_ip'] = request.META['REMOTE_ADDR']\\n\\t\\tpage_data['post_topic'] = topic_id\\n\\t\\tpage_data['post_date'] = datetime.now()\\n\\t\\tform = AddPostForm(page_data)\\n\\t\\tif form.is_valid():\\n\\t\\t\\tform.save()\\n\\t\\t\\n\\t\\t\\ttopic = Topic.objects.get(id=topic_id)\\n\\t\\t\\tposts = Post.objects.filter(post_topic=topic_id).count()\\n\\t\\t\\t\\n\\t\\t\\tpmax = posts/10\\n\\t\\t\\tpmaxten = posts%10\\n\\t\\t\\tif pmaxten != 0:\\n\\t\\t\\t\\tpmax = pmax+1\\n\\t\\t\\t\\ttopic.topic_last_pagination_page = pmax\\n\\t\\t\\telif pmax > 0:\\n\\t\\t\\t\\ttopic.topic_last_pagination_page = pmax\\n\\t\\t\\telse:\\n\\t\\t\\t\\tpmax = 1\\n\\t\\t\\t\\ttopic.topic_last_pagination_page = 1\\n\\t\\t\\ttopic.topic_posts = posts\\n\\t\\t\\ttopic.topic_lastpost = str(request.user)+'<br />' + str(datetime.today())[:-10]\\n\\t\\t\\ttopic.save()\\n\\t\\t\\t\\n\\t\\t\\tforum = Forum.objects.get(id=topic.topic_forum.id)\\n\\t\\t\\tforum.forum_posts = forum.forum_posts +1\\n\\t\\t\\t\\n\\t\\t\\tforum.forum_lastpost = str(request.user)+' (' + str(datetime.today())[:-10] + ')<br /><a href=\\\"/forum/topic/' + str(pmax) + '/' + str(topic.id) + '/\\\">' + topic.topic_name + '</a>'\\n\\t\\t\\tforum.save()\\n\\t\\t\\t\\n\\t\\t\\tmail_admins('Post Dodany', \\\"Dodano Post: http://www.\\\" + settings.SITE_KEY + \\\"/forum/topic/\\\" + str(pmax) + \\\"/\\\" + topic_id +\\\"/\\\", fail_silently=True)\\n\\t\\t\\treturn HttpResponseRedirect(\\\"/forum/topic/\\\" + str(pmax) + \\\"/\\\" + topic_id +\\\"/\\\")\\n\\t\\telse:\\n\\t\\t\\treturn render_to_response(\\n\\t\\t\\t\\t'myghtyboard/add_post.html',\\n\\t\\t\\t\\t{'lastpost': lastpost, 'perms': list_perms(request), 'form':form},\\n\\t\\t\\t\\tcontext_instance=RequestContext(request))\\n\\telse:\\n\\t\\tif post_id:\\n\\t\\t\\tquote = Post.objects.get(id=post_id)\\n\\t\\t\\tquote_text = '<blockquote><b>' + quote.post_author + _(' wrote') + ':</b><br /><cite>' + quote.post_text + '</cite></blockquote>\\\\n\\\\n'\\n\\t\\telse:\\n\\t\\t\\tquote_text = ''\\n\\treturn render_to_response(\\n\\t\\t'myghtyboard/add_post.html',\\n\\t\\t{'quote_text': quote_text, 'lastpost': lastpost, 'perms': list_perms(request)},\\n\\t\\tcontext_instance=RequestContext(request))\",\n \"def post(self, request, *args, **kwargs):\\n self.object = self.get_object()\\n\\n # # check permissions before serving view\\n # has_permission = request.user.is_admin or (self.object and self.object.created_by == self.request.user)\\n #\\n # if not has_permission:\\n # raise PermissionDenied\\n\\n form_class = self.get_form_class()\\n form = self.get_form(form_class)\\n Topic_formset = inlineTopicFormset(self.request.POST, instance=self.object)\\n if form.is_valid() and Topic_formset.is_valid():\\n return self.form_valid(form, Topic_formset)\\n else:\\n return self.form_invalid(form, Topic_formset)\",\n \"def post_create(request):\\n\\tform = PostForm(request.POST or None, request.FILES or None)\\n\\tif request.POST:\\n\\t\\tif form.is_valid():\\n\\t\\t\\tinstance = form.save(commit=False)\\n\\t\\t\\tinstance.user = request.user\\n\\t\\t\\tinstance.save()\\n\\t\\t\\tmessages.success(request, \\\"Post created!\\\")\\n\\t\\t\\treturn HttpResponseRedirect(instance.get_absolute_url())\\n\\t\\telse:\\n\\t\\t\\tmessages.error(request, \\\"Sorry! Something went wrong.\\\", extra_tags=\\\"\\\")\\n\\tcontext = {\\n\\t\\t'title': \\\"Create Post\\\",\\n\\t\\t'form' : form,\\n\\t}\\n\\treturn render(request, 'post/create.html', context)\",\n \"def new(request):\\n\\n form = PostForm(request.POST or None)\\n\\n if request.method == \\\"POST\\\":\\n if form.is_valid():\\n instance = form.save(commit=False)\\n instance.user = request.user\\n instance.save()\\n return HttpResponseRedirect(reverse('posts:toggle_publish', args=(instance.id,)))\\n\\n context = {'form':form}\\n\\n return render(request, 'posts/new.html', context)\",\n \"def create_post(bid):\\n form = PostForm(request.form)\\n if request.method == 'POST':\\n if form.validate():\\n DB.session.add(\\n Post(\\n bid,\\n current_user.uid,\\n form.name.data,\\n form.desc.data))\\n DB.session.commit()\\n flash('Post ({}) successfully created!'.format(form.name.data))\\n else:\\n flash(constants.DEFAULT_SUBMISSION_ERR)\\n return redirect(request.referrer)\",\n \"def post(self):\\n post_title = self.request.get(\\\"post_title\\\")\\n post_content = self.request.get(\\\"post_content\\\")\\n param_list = dict(post_title=post_title, post_content=post_content)\\n any_error = False\\n\\n if not post_title:\\n param_list['title_error'] = \\\"Title is missing!\\\"\\n any_error = True\\n if not post_content:\\n param_list['content_error'] = \\\"Content is missing!\\\"\\n any_error = True\\n\\n if any_error:\\n self.render(\\\"blog/addpost.html\\\", **param_list)\\n else:\\n p = Post.add_post(post_title, post_content, self.user)\\n self.redirect('/blog/%s' % str(p.key().id()))\",\n \"def post():\\n\\n form = forms.PostForm()\\n if form.validate_on_submit():\\n models.Post.create(title=form.title.data,\\n date=form.date.data,\\n time_spent=form.time_spent.data,\\n details=form.details.data,\\n remember=form.remember.data)\\n return redirect(url_for('index'))\\n return render_template('new.html', form=form)\",\n \"def create():\\n if request.method == 'POST':\\n title = request.form['title']\\n body = request.form['body']\\n error = None\\n\\n if not title:\\n error = 'Title is required.'\\n\\n if error is not None:\\n flash(error)\\n else:\\n db = get_db()\\n db.execute(\\n 'INSERT INTO post (title, body, author_id)'\\n ' VALUES (?, ?, ?)',\\n (title, body, g.user['id'])\\n )\\n db.commit()\\n return redirect(url_for('blog.index'))\\n\\n return render_template('blog/create.html')\",\n \"def add_post(request, id):\\n template = loader.get_template('topic.html')\\n if request.method == \\\"POST\\\":\\n data = JSONParser().parse(request)\\n try:\\n user = User.objects.get(username=request.user)\\n except ObjectDoesNotExist:\\n return HttpResponse(\\\"You should login to post!\\\")\\n requested_topic = Topic.objects.get(id=data[\\\"topic_id\\\"])\\n postObject = Post.objects.create(user_id=user.id, topic_id=requested_topic.id,content=data[\\\"content\\\"])\\n for tag in data[\\\"tags\\\"]:\\n if len(tag)>0:\\n if tag['label'] == '':\\n continue\\n try:\\n tagObject = Tag.objects.get(wikidataID=tag['id'])\\n except ObjectDoesNotExist:\\n tagObject = Tag.objects.create(wikidataID=tag['id'], name=tag['label'])\\n except MultipleObjectsReturned:\\n return HttpResponse(\\\"Multiple tags exist for.\\\" + tag + \\\" Invalid State.\\\")\\n\\n unique_hidden_tags = list(set(tag['hidden_tags']))\\n if unique_hidden_tags:\\n tagObject.hidden_tags = unique_hidden_tags\\n\\n tagObject.save()\\n postObject.tags.add(tagObject)\\n try:\\n topic = Topic.objects.get(id=id)\\n serialized_topic = TopicNestedSerializer(topic)\\n topic_json = JSONRenderer().render(serialized_topic.data)\\n except ObjectDoesNotExist:\\n return HttpResponse(\\\"This topic doesn't exists!\\\")\\n\\n hot_topics = Topic.objects.order_by('-updated_at')[:5]\\n serialized_hot_topics = HotTopicsSerializer(hot_topics, many=True)\\n hot_topics_json = JSONRenderer().render(serialized_hot_topics.data)\\n context = {\\n 'topic': topic_json,\\n 'hot_topics': hot_topics_json\\n }\\n return HttpResponse(template.render(context, request))\",\n \"def new_post_form(user_id):\\n user = User.query.get_or_404(user_id)\\n tags = Tag.query.all()\\n return render_template('posts/new.html', user=user, tags=tags)\",\n \"def create_post(request):\\n\\n # modified from: http://django-angular.readthedocs.org/en/latest/angular-model-form.html\\n\\n # get data\\n in_data = getRequestData(request)\\n\\n try:\\n # save in database\\n # note that in_data.mytitle throws an error while in_data.get('mytitle') works smoothly\\n post = Thread(pub_date = datetime.datetime.now(pytz.timezone('US/Eastern')), username = in_data.get('myusername'), title = in_data.get('mytitle'), description = in_data.get('mydescription'))\\n post.save()\\n except:\\n return HttpResponseBadRequest('Error saving to database!')\\n\\n return JsonResponse(in_data)\",\n \"def create_a_post():\\n subj = create_subject()\\n post = Post.create(subject=subj, title=\\\"A great title\\\", body=\\\"Just a great day!\\\")\\n post.save()\\n return post\",\n \"def add_new_post(request):\\n\\n token = request.data.get('token')\\n if Token.objects.filter(key=request.data[\\\"token\\\"]).exists():\\n text = request.data.get('text', '')\\n image = request.data.get('image')\\n video = request.data.get('video')\\n\\n if len(request.data[\\\"text\\\"]) < 1:\\n return Response({\\\"error\\\": 21})\\n elif len(request.data[\\\"text\\\"]) > 10000:\\n return Response({\\\"error\\\": 22})\\n\\n token = get_object_or_404(Token, key=token)\\n post = Post.objects.create(permission=request.data[\\\"permission\\\"],\\n author_id=token.user_id,\\n text=request.data[\\\"text\\\"])\\n if image:\\n image_data = b64decode(image)\\n post.image = ContentFile(image_data, \\\"post.png\\\")\\n\\n if video:\\n video_data = b64decode(request.data[\\\"video\\\"])\\n post.video = ContentFile(video_data, \\\"post.mov\\\")\\n post.save()\\n\\n if \\\"hashtags\\\" in request.data and len(request.data[\\\"hashtags\\\"]) > 0:\\n for hashtag in request.data[\\\"hashtags\\\"]:\\n PostHashtag.objects.create(post=post,\\n hashtag=hashtag)\\n\\n serializer = PostSerializer(post, context={'user_id': token.user_id})\\n return Response({\\\"success\\\": 23,\\n \\\"post\\\": serializer.data})\\n else:\\n return Response({\\\"error\\\": 17})\",\n \"def create_post(user_id):\\n\\n user = User.query.get_or_404(user_id)\\n title = request.form['title']\\n content = request.form['content']\\n tag_ids = [int(num) for num in request.form.getlist(\\\"tags\\\")]\\n tags = Tag.query.filter(Tag.id.in_(tag_ids)).all()\\n \\n new_post = Post(title=title, content=content, user=user, tags=tags)\\n db.session.add(new_post)\\n db.session.commit()\\n\\n return redirect(f\\\"/users/{user_id}\\\")\",\n \"def add_post(request):\\n if 'form.submitted' in request.params:\\n title = request.params['title']\\n name = title_to_name(title)\\n\\n if not name or DBSession.query(Post).filter(Post.name==name).count():\\n # this should be a popup ajaxy box\\n return Response(\\\"Name %s is in use, choose a different title\\\" % name, content_type='text/plain', status_int=500)\\n\\n body = request.params['body']\\n post = Post(title, body, name)\\n DBSession.add(post)\\n return HTTPFound(location = request.route_url('view_post', postname=name))\\n\\n save_url = request.route_url('new_post')\\n post = Post('')\\n return environment_factory(post=post, save_url=save_url)\",\n \"def get(self, request):\\n form = PostForm()\\n context = {\\n 'form': form,\\n }\\n return render(request, 'blogs/new_post.html', context)\",\n \"def change_post(mfp_form, request):\\n article_id = int(mfp_form.cleaned_data['id'])\\n newpost = APost(article_id)\\n if newpost.exist:\\n newpost.article.title = mfp_form.cleaned_data['title']\\n # 缩略名\\n newpost.article.short_title = mfp_form.cleaned_data['short_title']\\n newpost.article.cover = mfp_form.cleaned_data['cover_url']\\n newpost.article.introduction = mfp_form.cleaned_data['introduction']\\n newpost.article.content = mfp_form.cleaned_data['content']\\n # id为2是已发布的文章，默认为已发布，后面再改\\n newpost.article.status = Status.objects.get(id=2)\\n tagids = mfp_form.cleaned_data['tags']\\n if len(tagids) != 0:\\n for tagid in tagids:\\n tagid = int(tagid)\\n tag = Tags.objects.get(id=tagid)\\n newpost.article.tags.add(tag)\\n threadtypeid = int(mfp_form.cleaned_data['threadtypeid'])\\n newpost.article.threadtypeid = ThreadTypes.objects.get(id=threadtypeid)\\n if mfp_form.cleaned_data['commentnotshow'] != '':\\n newpost.article.comment_status = False\\n else:\\n newpost.article.comment_status = True\\n return newpost.article\\n else:\\n return False\",\n \"def get(self, request):\\n\\n # crear el formulario\\n form = PostForm()\\n form.fields['owner'].queryset = Blog.objects.filter(owner=request.user)\\n # renderiza la plantilla con el formulario\\n context = {\\n \\\"form\\\": form\\n }\\n\\n # renderiza y devuelve la plantilla\\n return render(request, 'blogs/new-post.html', context)\",\n \"def add_post(request):\\n if request.session.get('id_user') is None:\\n request.session['res'] = 'Warn'\\n messages.add_message(request, messages.WARNING,\\n \\\"The session has expired\\\")\\n return HttpResponseRedirect(reverse('home'))\\n form = PostForm(request.POST or None)\\n if request.method == 'POST':\\n if form.is_valid():\\n data = form.save(commit=False)\\n data.author = User.objects.filter(id=request.session.get(\\n 'id_user'))[0]\\n data.save()\\n messages.add_message(request, messages.SUCCESS,\\n \\\"The post has been saved!\\\")\\n return HttpResponseRedirect(\\\"/posts/list/\\\")\\n return render(request, 'form.html', {'form': form})\",\n \"def admincreate(object):\\n if request.method == \\\"POST\\\":\\n\\n db = get_db()\\n execute_string = 'INSERT INTO ' + object.title()\\n\\n if object == 'post':\\n execute_string += '(title, content, authorId, categoryId) VALUES (\\\"' + request.form['title'] + '\\\", \\\"' + request.form[\\\"content\\\"] + '\\\", \\\"' + request.form[\\\"authorid\\\"] + '\\\", \\\"' + request.form[\\\"categoryid\\\"] + '\\\")'\\n elif object == 'author':\\n execute_string += '(name) VALUES (\\\"' + request.form['name'] + '\\\")'\\n elif object == 'category':\\n execute_string += '(name, description) VALUES (\\\"' + request.form['name'] + '\\\", \\\"' + request.form[\\\"description\\\"] + '\\\")'\\n\\n db.execute(execute_string)\\n db.commit()\\n return redirect(url_for(\\\"adminview\\\", object=object))\\n\\n return render_template(\\\"new.html\\\", object=object, item={})\",\n \"def create_post(request):\\n user = User.objects.get(email=request.user.email)\\n if request.method == \\\"POST\\\":\\n form = BlogPostForm(request.POST)\\n if form.is_valid():\\n post = form.save(commit=False)\\n post.author = user\\n post.avatar = user.userprofile.avatar.url\\n post.save()\\n messages.success(request, \\\"You have posted successfully\\\")\\n return redirect(\\\"get_posts\\\")\\n else:\\n messages.error(request, \\\"Unable to post at this time\\\")\\n else:\\n form = BlogPostForm()\\n return render(request, \\\"blogpostform.html\\\", {\\\"form\\\": form})\",\n \"def new_post(request):\\n if request.method != 'POST':\\n # No data submitted; create a blank form.\\n form = PostForm()\\n else:\\n # POST data submitted; process data.\\n form = PostForm(data=request.POST)\\n if form.is_valid():\\n new_post = form.save(commit=False)\\n new_post.owner = request.user\\n new_post.save()\\n return redirect('blogs:posts')\\n\\n # Display a blank or invalid form.\\n context = {'form': form}\\n return render(request, 'blogs/new_post.html', context)\",\n \"def get(self, request):\\n form = PostForm()\\n context = {\\n 'form': form,\\n 'success_message': ''\\n }\\n return render(request, 'posts/new-post.html', context)\",\n \"def new_topic(request):\\n form = Form(request, schema=TopicSchema)\\n if form.validate():\\n topic = form.data[\\\"title\\\"]\\n author = form.data[\\\"author\\\"]\\n desc = form.data[\\\"description\\\"]\\n date = datetime.datetime.now()\\n url = slugfy(topic)\\n topic_tuple = {\\n \\\"title\\\": topic,\\n \\\"url\\\": url,\\n \\\"author\\\": author,\\n \\\"description\\\": desc,\\n \\\"topic_date\\\": date.strftime(\\\"%d/%m/%Y\\\"),\\n }\\n request.db[\\\"topic\\\"].insert(topic_tuple)\\n return HTTPFound(location=\\\"/\\\")\\n\\n return render_to_response(\\n \\\"templates/new_topic.html\\\",\\n {\\\"form\\\": FormRenderer(form), \\\"count\\\": count(request)},\\n request=request,\\n )\",\n \"def show_post_form(user_id):\\n\\n user = User.query.get_or_404(user_id)\\n tags = Tag.query.all()\\n\\n return render_template(\\\"posts/create_post.html\\\", user=user, tags=tags)\",\n \"def test_createPost(self):\\n\\t\\tself.client.force_authenticate(user=User.objects.get(id=1))\\n\\t\\turl = \\\"/posts/\\\"\\n\\t\\tdata = {\\n\\t\\t\\t'text' : 'Vivaldi',\\n\\t\\t\\t'group': 3\\n\\n\\t\\t}\\n\\t\\tresponse = self.client.post(url, data, format='json')\\n\\t\\tself.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n\\t\\tself.assertEqual(response.data[\\\"id\\\"], 4)\\n\\t\\tself.assertEqual(response.data[\\\"text\\\"], 'Vivaldi')\\n\\t\\tself.assertEqual(Post.objects.count(), 4)\",\n \"def save(self, user):\\n if self.is_valid():\\n\\n topic = self.cleaned_data['topic']\\n\\n thread = models.Thread.objects.create(\\n topic=topic,\\n title=self.cleaned_data['title'])\\n\\n models.Message.objects.create(\\n user=user,\\n thread=thread,\\n body=self.cleaned_data['body'])\\n\\n return thread\",\n \"def get(self):\\n if self.user:\\n self.render(\\\"blog/addpost.html\\\")\\n else:\\n self.redirect(\\\"/login\\\")\",\n \"def create(thing):\\n fields = {}\\n errors = []\\n\\n for col in thing.cols:\\n new[col.field_name] = request.form.get(col.field_name)\\n if col.required and not new[col.field_name]:\\n errors.append('%s cannot be empty' % col.human_name)\\n\\n if errors:\\n for e in errors:\\n flash(e)\\n add_template_variable('thing', thing)\\n add_template_variable('fields', fields)\\n return my_render_template('generic/create_post.html')\\n\\n # insert into database\\n\\n db = get_db()\\n cursor = db.cursor()\\n\\n # create the two strings we use in the query\\n field_names = \\\"'\\\" + \\\"', '\\\".join(thing.field_names) + \\\"'\\\"\\n question_marks = \\\", \\\".join(map(lambda x: '?', thing.field_names.count() ))\\n\\n cursor.execute(\\\"insert into posts (%s) values (%s)\\\" % (field_names, question_marks), (title, body))\\n db.commit()\\n new_id = cursor.lastrowid\\n\\n # show new post to the user\\n flash(\\\"You made a new %s\\\" % thing.human_name)\\n return redirect(url_for('show_one', id_=new_id))\",\n \"def __addThreadAndPosts(self):\\n try:\\n self.genre = \\\"Review\\\"\\n self.__hierarchy = []\\n self.__baseuri = 'http://broncosfreaks.com/forums/'\\n self.__task_elements_dict = {\\n 'priority':self.task.priority,\\n 'level': self.task.level,\\n 'last_updated_time':datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\"),\\n 'pickup_date':datetime.strftime(datetime.utcnow(),\\\"%Y-%m-%dT%H:%M:%SZ\\\"),\\n 'connector_instance_log_id': self.task.connector_instance_log_id,\\n 'connector_instance_id':self.task.connector_instance_id,\\n 'workspace_id':self.task.workspace_id,\\n 'client_id':self.task.client_id,\\n 'client_name':self.task.client_name,\\n 'versioned':False,\\n 'category':self.task.instance_data.get('category',''),\\n 'task_log_id':self.task.id }\\n self.__setSoupForCurrentUri()\\n self.__setParentPage()\\n question_post = self.soup.find('div', id=re.compile('^edit.*?'))\\n self.__addPost(question_post, True)\\n self.__goToLastPage() \\n while self.__iteratePosts():\\n try:\\n next_page_uri = self.soup.find('a', text='<',rel='prev').parent['href']\\n data_dict = dict(parse_qsl(next_page_uri.split('?')[-1]))\\n if 's' in data_dict.keys():\\n data_dict.pop('s')\\n self.currenturi = self.__baseuri + 'showthread.php?'+ urlencode(data_dict) \\n self.__setSoupForCurrentUri()\\n except:\\n log.exception(self.log_msg('Next Page link not found for url \\\\\\n %s'%self.currenturi))\\n break\\n return True\\n \\n\\n \\\"\\\"\\\"#try: \\n # question_post = self.soup.find('div', id=re.compile ('^edit\\\\d+'))\\n #except:\\n # log.info(self.log_msg('Question post cannot be added'))\\n #main_page_soup = copy.copy(self.soup)\\n # self.__addPost(question_post, True)\\n except:\\n log.info(self.log_msg('page not added'))\\n self.__goToLastPage(main_page_soup)\\n while True:\\n main_page_soup = copy.copy(self.soup)\\n #log.info(self.log_msg('Question post cannot be added'))\\n if not self.__iteratePosts():\\n break\\n try:\\n self.currenturi = main_page_soup.find('a',text='<').parent['href']\\n log.info(self.log_msg('uri %s'%self.currenturi)) \\n except:\\n \\n log.info(self.log_msg('No Previous URL found for url \\\\\\n %s'%self.currenturi))\\n break\\n return True\\n \\\"\\\"\\\" \\n \\n \\n except:\\n log.exception(self.log_msg('Exception while add the theread posts \\\\\\n for the url %s'%self.currenturi))\\n return False\",\n \"def make_new_post(user_id):\\n user = User.query.get_or_404(user_id)\\n tags = Tag.query.all()\\n return render_template('posts/new_post.html', user=user, tags=tags)\",\n \"def __addThreadAndPosts(self):\\n self.__genre = \\\"Review\\\"\\n self.__hierarchy = []\\n self.__baseuri = 'http://forums.seagate.com'\\n self.__task_elements_dict = {\\n 'priority':self.task.priority,\\n 'level': self.task.level,\\n 'last_updated_time':datetime.strftime(datetime.utcnow()\\n , \\\"%Y-%m-%dT%H:%M:%SZ\\\"), \\n 'pickup_date':datetime.strftime(datetime.utcnow(), \\n \\\"%Y-%m-%dT%H:%M:%SZ\\\"), \\n 'connector_instance_log_id': \\\\\\n self.task.connector_instance_log_id, \\n 'connector_instance_id':\\n self.task.connector_instance_id, \\n 'workspace_id':self.task.workspace_id, \\n 'client_id':self.task.client_id, \\n 'client_name':self.task.client_name, \\n 'versioned':False, \\n 'category':self.task.instance_data.get('category',''), \\n 'task_log_id':self.task.id }\\n self.__setParentPage()\\n question_post = self.soup.find('div', 'lia-message-view')\\n self.__addPost(question_post, True)\\n self.__goToLastPage()\\n while self.__iteratePosts():\\n try:\\n self.currenturi = self.__baseuri + self.soup.find('span', \\\\\\n 'lia-paging-page-link', text='Previous').findParent('a')\\\\\\n ['href'].split(';')[0]\\n self.__setSoupForCurrentUri()\\n except:\\n log.info(self.log_msg('No Previous URL found for url \\\\\\n %s'%self.currenturi))\\n break\\n return True\",\n \"def create_topic():\\n nodes = Node.query.all()\\n form = TopicForm(nodes)\\n if request.method == 'POST':\\n topic = Topic(title=request.form.get('title'),\\n content=request.form.get('content'),\\n node_id=request.form.get('node_id'),\\n user=current_user._get_current_object())\\n db.session.add(topic)\\n db.session.commit()\\n return jsonify({\\\"result\\\": 'ok'})\\n\\n return render_template('main/create_topic.html', nodes=nodes, form=form)\",\n \"def post(self, request, pk):\\n\\n post = Blog.objects.get(pk=int(pk))\\n user_id = self.request.session.get('USER_ID')\\n\\n try:\\n user = User.objects.get(pk=user_id)\\n except:\\n pass\\n body = self.request.POST.get('body')\\n\\n if user_id is None:\\n messages.add_message(request, messages.ERROR, \\\"Please login to add comments.\\\")\\n return HttpResponseRedirect(self)\\n\\n comments = Comment.objects.create(post=post, author=user, body=body)\\n\\n d = model_to_dict(post)\\n messages.add_message(request, messages.SUCCESS, \\\"Comment added successfully.\\\")\\n return self.render_to_response(d)\",\n \"def new_post_form(user_id):\\r\\n\\r\\n user = User.query.get_or_404(user_id)\\r\\n tags = Tag.query.all()\\r\\n\\r\\n return render_template('post-form.html', user=user, tags=tags)\",\n \"def test_post_creation_success(self):\\n url = reverse('post-list', args=[self.topic1.url_name])\\n payload = {\\n 'author': self.user1.id,\\n 'title': 'Creating a post',\\n 'content': 'Rich content 4',\\n }\\n self.client.credentials(\\n HTTP_AUTHORIZATION = 'Token ' + self.user1.auth_token.key\\n )\\n response = self.client.post(url, payload)\\n\\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\\n new_post = Post.objects.filter(\\n author=self.user1,\\n title=payload.get('title'),\\n content=payload.get('content'),\\n topic=self.topic1\\n )\\n self.assertTrue(new_post.exists())\",\n \"def new_answer(request):\\n if request.method == \\\"POST\\\":\\n author = request.POST.get(\\\"author\\\")\\n content = request.POST.get(\\\"content\\\")\\n date = datetime.datetime.now()\\n answer_tuple = {\\n \\\"author\\\": author,\\n \\\"content\\\": content,\\n \\\"votes\\\": 0,\\n \\\"topic_index\\\": request.matchdict[\\\"url\\\"],\\n \\\"answer_date\\\": date.strftime(\\\"%d/%m/%Y\\\"),\\n }\\n request.db[\\\"answer\\\"].insert(answer_tuple)\\n return HTTPFound(location=\\\"/topic/\\\" + request.matchdict[\\\"url\\\"])\\n return HTTPFound(location=\\\"/\\\")\",\n \"def make_post_view(request):\\n # get方法，显示表单页面\\n data = request.extra_data\\n if request.method == 'GET':\\n mkp_form = MakePostForm()\\n return (\\n render_to_response(\\n 'manage/make_post.html',\\n locals(),\\n context_instance=RequestContext(request))\\n )\\n # post方法提交表单并跳转\\n if request.method == 'POST':\\n mkp_form = MakePostForm(request.POST)\\n # Posts.objects.get(id='1')\\n if mkp_form.is_valid():\\n newpost = new_post(mkp_form, request)\\n newpost.save()\\n return (\\n HttpResponseRedirect(\\n data['basic_info'].blog_edit_url + '/' + str(newpost.id) + '/')\\n )\\n else:\\n return (\\n render_to_response(\\n 'manage/make_post.html',\\n locals(),\\n context_instance=RequestContext(request))\\n )\",\n \"def post(self):\\n post_id = int(self.request.get('post_id'))\\n post = Posts.get_by_id(post_id)\\n comment = self.request.get('comment')\\n submitter_id = self.get_active_user().key().id()\\n\\n if submitter_id:\\n comment = Comments(post_id=post_id, content=comment,\\n submitter_id=submitter_id)\\n comment.put()\\n self.redirect('/%s' % str(post.key().id()))\\n else:\\n self.error(403)\",\n \"def teacher_forum_update(request, post_id):\\n # Deleting admin-typed user session\\n # Deleting programmer-typed-user session\\n\\n # Get the current users\\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\\n\\n current_basic_user_profile = get_current_user_profile(\\n request,\\n User,\\n BasicUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Getting the teacher profile\\n current_teacher_profile = get_current_teacher_user_profile(\\n request,\\n User,\\n TeacherUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Get the current post\\n try:\\n current_post = TeacherForumPost.objects.get(id=post_id)\\n except ObjectDoesNotExist:\\n current_post = None\\n\\n # if the post id is not existing redirect to 404\\n if current_post == None:\\n return HttpResponseRedirect(\\\"/404/\\\")\\n\\n # update form processing\\n empty_input = False\\n current_teacher_is_owner = True\\n\\n if request.POST.get(\\\"teacher_forum_update_submit_btn\\\"):\\n post_update_title = request.POST.get(\\\"post_update_title\\\")\\n post_update_content = request.POST.get(\\\"post_update_content\\\")\\n\\n # check if any of the inputs are empty\\n if bool(post_update_title) == False or post_update_title == \\\"\\\" \\\\\\n or bool(post_update_content) == False or post_update_content == \\\"\\\":\\n empty_input = True\\n else:\\n # check if the post is owned by current teacher\\n if current_post.teacher == current_teacher_profile:\\n current_post.post_title = post_update_title\\n current_post.content = post_update_content\\n current_post.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n else:\\n current_teacher_is_owner = False\\n\\n data = {\\n \\\"current_basic_user\\\": current_basic_user,\\n \\\"current_basic_user_profile\\\": current_basic_user_profile,\\n \\\"current_teacher_profile\\\": current_teacher_profile,\\n \\\"current_post\\\": current_post,\\n \\\"empty_input\\\": empty_input,\\n \\\"current_teacher_is_owner\\\": current_teacher_is_owner,\\n }\\n\\n if \\\"teacher_user_logged_in\\\" in request.session:\\n return render(request, \\\"teacher_forum/update.html\\\", data)\\n else:\\n return HttpResponseRedirect(\\\"/\\\")\",\n \"def new_post():\\n form = PostForm()\\n if form.validate_on_submit():\\n post = Post(pub_date=datetime.date.today())\\n post.title = form.title.data\\n post.content = form.content.data\\n post.slug = slugify(post.title)\\n db.session.add(post)\\n db.session.commit()\\n return flask.redirect(flask.url_for(\\n 'view_post',\\n year=post.pub_date.year,\\n month=post.pub_date.month,\\n day=post.pub_date.day,\\n slug=post.slug\\n ))\\n return flask.render_template('new.html', form=form)\",\n \"def create():\\r\\n if request.method == 'POST':\\r\\n title = request.form['title']\\r\\n body = request.form['body']\\r\\n error = None\\r\\n db = get_db()\\r\\n cur = db.cursor()\\r\\n\\r\\n cur.execute('SELECT title FROM novel.post WHERE title = %s', title)\\r\\n newTitle = cur.fetchone()\\r\\n\\r\\n if not title:\\r\\n error = 'Title is required.'\\r\\n\\r\\n if newTitle and newTitle['title'] == title:\\r\\n error = 'Title is repeated.'\\r\\n\\r\\n if error is not None:\\r\\n flash(error)\\r\\n else:\\r\\n db = get_db()\\r\\n db.cursor().execute(\\r\\n 'INSERT INTO novel.post (title, body, author_id) VALUES (\\\"{0}\\\", \\\"{1}\\\", \\\"{2}\\\")'\\r\\n .format(title, body, g.user['id'])\\r\\n )\\r\\n db.commit()\\r\\n return redirect(url_for('novel.index'))\\r\\n\\r\\n return render_template('novel/create.html')\",\n \"def test_create_post(self):\\n self.test_category = Category.objects.create(name='django')\\n self.testuser1 = User.objects.create_superuser(\\n username='test_user1', password='123456789')\\n # self.testuser1.is_staff = True\\n\\n self.client.login(username=self.testuser1.username,\\n password='123456789')\\n\\n data = {\\\"title\\\": \\\"new\\\", \\\"author\\\": 1,\\n \\\"excerpt\\\": \\\"new\\\", \\\"content\\\": \\\"new\\\"}\\n url = reverse('blog_api:listcreate')\\n response = self.client.post(url, data, format='json')\\n self.assertEqual(response.status_code, status.HTTP_201_CREATED)\",\n \"def testAddForum(self):\\n board = self.board\\n forum_id = 'forum'\\n board.addForum(forum_id, 'title', 'description')\\n self.failUnless(forum_id in board.objectIds())\\n forum = getattr(board, forum_id)\\n self.failUnless(IForum.providedBy(forum))\",\n \"def teacher_forum_read(request, post_id):\\n # Deleting admin-typed user session\\n # Deleting programmer-typed-user session\\n\\n # Get the current users\\n current_basic_user = get_current_user(request, User, ObjectDoesNotExist)\\n\\n current_basic_user_profile = get_current_user_profile(\\n request,\\n User,\\n BasicUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Getting the teacher profile\\n current_teacher_profile = get_current_teacher_user_profile(\\n request,\\n User,\\n TeacherUserProfile,\\n ObjectDoesNotExist\\n )\\n\\n # Get the current post\\n try:\\n current_post = TeacherForumPost.objects.get(id=post_id)\\n except ObjectDoesNotExist:\\n current_post = None\\n\\n # if the post id is not existing redirect to 404\\n if current_post == None:\\n return HttpResponseRedirect(\\\"/404/\\\")\\n\\n # check if the post is owned by the current user if it is pass it on to\\n # the template logic\\n current_user_is_teacher = False\\n if current_post.teacher == current_teacher_profile:\\n current_user_is_teacher = True\\n\\n # current post upvote form processing\\n if request.POST.get(\\\"teacher_forum_read_post_upvote_btn\\\"):\\n current_post.karma += 1\\n current_post.save()\\n\\n # current post downvote form processing\\n if request.POST.get(\\\"teacher_forum_read_post_downvote_btn\\\"):\\n current_post.karma -= 1\\n current_post.save()\\n\\n # get all the coments\\n try:\\n all_post_comments = TeacherForumComment.objects.filter(\\n post=current_post\\n ).order_by(\\\"-id\\\")\\n except ObjectDoesNotExist:\\n all_post_comments = None\\n\\n # comment upote form processing\\n if request.POST.get(\\\"teacher_forum_comment_upvote_submit\\\"):\\n hidden_comment_id = request.POST.get(\\\"hidden_comment_id\\\")\\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\\n current_comment.karma += 1\\n current_comment.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n # comment downvote form processing\\n if request.POST.get(\\\"teacher_forum_comment_downvote_submit\\\"):\\n hidden_comment_id = request.POST.get(\\\"hidden_comment_id\\\")\\n current_comment = TeacherForumComment.objects.get(id=hidden_comment_id)\\n current_comment.karma -= 1\\n current_comment.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n # comment create form processing\\n if request.POST.get(\\\"teacher_forum_comment_subtmit_btn\\\"):\\n comment_content = request.POST.get(\\\"comment_content\\\")\\n # check if it is empty\\n if bool(comment_content) == False or comment_content == \\\"\\\":\\n pass\\n else:\\n new_comment = TeacherForumComment(\\n teacher=current_teacher_profile,\\n post=current_post,\\n content=comment_content\\n )\\n new_comment.save()\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n # Delete the post and its comments form processing\\n if request.POST.get(\\\"teacher_forum_delete_post_submit\\\"):\\n # check if the current user is the owner\\n if current_post.teacher == current_teacher_profile:\\n # delete the ppost\\n current_post.delete()\\n # delete all the comments\\n all_post_comments.delete()\\n # redirect to landing page\\n return HttpResponseRedirect(\\\"/teacher/forum/0/\\\")\\n else:\\n return HttpResponseRedirect(\\n \\\"/teacher/forum/read/\\\"+str(current_post.id)+\\\"/\\\"\\n )\\n\\n data = {\\n \\\"current_basic_user\\\": current_basic_user,\\n \\\"current_basic_user_profile\\\": current_basic_user_profile,\\n \\\"current_teacher_profile\\\": current_teacher_profile,\\n \\\"current_post\\\": current_post,\\n \\\"current_user_is_teacher\\\": current_user_is_teacher,\\n \\\"all_post_comments\\\": all_post_comments,\\n }\\n\\n if \\\"teacher_user_logged_in\\\" in request.session:\\n return render(request, \\\"teacher_forum/read.html\\\", data)\\n else:\\n return HttpResponseRedirect(\\\"/\\\")\",\n \"def render_form(self, title=\\\"\\\", body=\\\"\\\", error=\\\"\\\"):\\n self.render(\\\"newpost.html\\\", title=title, body=body, error=error)\",\n \"def new_post(user_id):\\n user = User.query.get_or_404(user_id)\\n\\n tags = Tag.query.all()\\n return render_template('posts/new_page.html', user=user, tags=tags)\",\n \"def post(self, post_id):\\n post = Post.get_by_id(int(post_id), parent=blog_key())\\n\\n if post and self.user.key().id() == post.user.key().id():\\n post.subject = self.request.get('subject')\\n post.content = self.request.get('content')\\n\\n # initialize error to false\\n have_errors = False\\n\\n # if there is no subject or content, it will throw errors\\n if not post.subject:\\n error_subject = \\\"Please write down the subject\\\"\\n have_errors = True\\n if not post.content:\\n error_content = \\\"Content is required\\\"\\n have_errors = True\\n\\n if have_errors:\\n self.render(\\\"edit.html\\\",\\n subject=post.subject,\\n content=post.content,\\n error_subject=error_subject,\\n error_content=error_content,\\n user=self.user)\\n else:\\n post.put()\\n self.redirect('/blog/%s' % str(post.key().id()))\",\n \"def new_blog(request, form = None):\\n dajax = Dajax()\\n \\n html_content = \\\"\\\"\\n dajax.add_css_class('#showcase', 'hide')\\n dajax.add_css_class('#sponsors', 'hide')\\n \\n if request.method == 'POST':\\n form = ThreadForm(deserialize_form(form))\\n print form\\n if form.is_valid(): # check validity\\n form.save()\\n show_alert(dajax, \\\"success\\\", \\\"Your post has been saved !\\\")\\n else: # form was not valid, show errors\\n dajax.remove_css_class('#form_new_blog_post input', 'error')\\n for error in form.errors: # tell which parts had errors\\n dajax.add_css_class('#id_%s' % error, 'error')\\n print [error for error in form.errors]\\n show_alert(dajax, 'error', \\\"There were some errors : please rectify them\\\") # show alert\\n else: # GET - display empty form\\n form = ThreadForm()\\n html_content = render_to_string('blog/new.html', {'form': form}, RequestContext(request))\\n \\n if html_content:\\n dajax.assign(\\\"#features\\\", \\\"innerHTML\\\", html_content)\\n \\n return dajax.json()\",\n \"def __addPost(self, post, is_question=False):\\n try:\\n unique_key = post.find('a')['name']\\n if checkSessionInfo(self.__genre, self.session_info_out, unique_key, \\\\\\n self.task.instance_data.get('update'),parent_list\\\\\\n = [self.task.instance_data['uri']]):\\n log.info(self.log_msg('Session info returns True for uri %s'%unique_key))\\n return False\\n page = self.__getData(post, is_question)\\n if not page:\\n log.info(self.log_msg('page contains empty data, getdata \\\\\\n returns False for uri %s'%self.currenturi))\\n return True\\n result = updateSessionInfo(self.__genre, self.session_info_out, unique_key, \\\\\\n get_hash( page ),'forum', self.task.instance_data.get('update'),\\\\\\n parent_list=[self.task.instance_data['uri']])\\n if result['updated']:\\n page['parent_path'] = [self.task.instance_data['uri']]\\n page['path'] = [ self.task.instance_data['uri'], unique_key]\\n page['uri'] = self.currenturi + '#' + unique_key\\n page['uri_domain'] = urlparse.urlparse(page['uri'])[1]\\n page.update(self.__task_elements_dict)\\n self.pages.append(page)\\n else:\\n log.info(self.log_msg('Update session info returns False for \\\\\\n url %s'%self.currenturi))\\n except:\\n log.exception(self.log_msg('Cannot add the post for the uri %s'%self.currenturi))\\n return True\",\n \"def test_create_post(self):\\n with self.client:\\n result = self.client.post('/users/spike-test/posts', data={\\n \\\"post-title\\\": \\\"autotest title\\\",\\n \\\"post-content\\\": \\\"autotest content for blog post testing\\\"\\n }, follow_redirects=True)\\n self.assertEqual(result.status_code, 200)\\n self.assertIn(b'autotest title', result.data)\",\n \"def createPost(request):\\n\\n #save the organization's post\\n if request.method == 'POST':\\n form = PostForm(request.user, request.POST, request.FILES)\\n if form.is_valid():\\n filterList = ['everyone', 'black', 'hispanic', 'female', 'lgbt', 'immigrants', 'disabled', 'poor'] \\n newpost = form.save()\\n\\n #Add tags to the object only if in the filterlist\\n tags = form.cleaned_data.get('tags')\\n tags = [tag.lower() for tag in tags if tag.lower() in filterList]\\n\\n newpost.tags.add(*tags)\\n messages.success(request, 'You have successful created the post')\\n form = PostForm(request.user)\\n context = {'form':form} \\n return render(request, 'create_post.html', context=context)\\n \\n #form to fill out for the post\\n form = PostForm(request.user)\\n context = {'form':form} \\n return render(request, 'create_post.html', context=context)\",\n \"def get(self, user):\\n return self.render(\\\"post-new.html\\\", user=user)\",\n \"def dashboard_post(request):\\n template = \\\"pages/dashboard.html\\\"\\n form = CreateLeaderboardForm(request.POST)\\n if form.is_valid():\\n data = form.cleaned_data\\n add_owner = data[\\\"add_owner\\\"]\\n del data[\\\"add_owner\\\"] # Drop the fields not needed by leaderboard model\\n ldb = Leaderboard.objects.create(**data, owner=request.user)\\n if add_owner:\\n ldb.participants.add(request.user) # Add the creator as participant\\n return render(request, template, context=dashboard_context(request))\\n else:\\n ctx = dashboard_context(request)\\n ctx[\\\"creation_form\\\"] = form # Send it back with error messages\\n return render(request, template, context=ctx)\",\n \"def new(request):\\n assert isinstance(request, HttpRequest)\\n if request.method == 'POST': # フォームが提出された\\n form = EntryForm(request.POST) # POST データの束縛フォーム\\n if form.is_valid(): # バリデーションを通った\\n entry = form.save(commit=False)\\n entry.member = request.user\\n entry.save()\\n return HttpResponseRedirect(reverse('entry_list')) # POST 後のリダイレクト\\n else:\\n form = EntryForm() # 非束縛フォーム\\n article_list = Article.objects.order_by('-released_at')[:5]\\n auth_form = AuthenticationForm(None, request.POST or None)\\n return render(request, 'app/entry_edit.html', { \\n 'form': form,\\n 'title':'ブログ記事の新規登録',\\n 'year':datetime.now().year,\\n 'articles':article_list,\\n 'blogs':EntryView.get_entry_list('-posted_at',-1, request.user.pk )[:5],\\n 'submit_title':'登録する',\\n 'auth_form':auth_form,\\n 'current_user':request.user,\\n })\",\n \"def show_form_to_add_new_post(user_id):\\n user = User.query.get_or_404(user_id)\\n tags = Tag.query.all()\\n\\n return render_template('posts/new.html', user=user, tags=tags)\",\n \"def add_post(user_id):\\n\\n title = request.form['title']\\n content = request.form['content']\\n tags = request.form.getlist('tag')\\n user = User.query.get_or_404(user_id)\\n\\n if not title or not content:\\n flash(\\\"Please enter title and content.\\\")\\n return redirect(f\\\"/users/{user.id}/posts/new\\\")\\n\\n post = Post(title=title, content=content, user=user)\\n\\n if tags:\\n for tag in tags:\\n post.tags.append(Tag.query.filter(Tag.name==tag).one())\\n\\n db.session.add(post)\\n db.session.commit()\\n\\n user = User.query.get_or_404(user_id)\\n\\n return redirect(f\\\"/users/{user_id}\\\")\",\n \"def new_from_post():\\n # If you make a post request with a question_id we will assume you want a new question editor\\n # we will prepopulate the question new page with data from that question (if it is a valid question id)\\n question_id = request.form['question_id'] if request.form['question_id'] else ''\\n\\n return render_template('questionNew.html', question_id=question_id)\",\n \"def new_post(self, content):\\n return self.proxy.wp.newPost(self.blog_id, self.username, self.password,\\n content)\",\n \"def post(self):\\n\\n token = self.request.get('token')\\n user = users.get_current_user()\\n if not user:\\n self.redirect('/')\\n user_obj = utils.get_user(user)\\n if token: # Adding a token for a user\\n if utils.verify_token(token):\\n user_obj.auth_token = token\\n user_obj.put()\\n self.redirect('/privatefeeds')\\n else:\\n args = constants.TOKEN_ARGS\\n auth_url = \\\"https://trello.com/1/authorize?%s\\\" % urlencode(args)\\n self.render('private.html',\\n actions=constants.ACTIONS,\\n incorrect_token=True,\\n auth_url=auth_url,\\n signout=constants.SIGNOUT)\\n else: # Adding a board for a user\\n board_id = self.request.get('board')\\n title = self.request.get('title')\\n link = self.request.get('link')\\n description = self.request.get('description')\\n actions = [x for x in constants.ACTIONS if self.request.get(x)]\\n\\n if actions:\\n get_all = False\\n if board_id == 'all':\\n get_all = True\\n board_id = None\\n feed_url = utils.create_feed(\\n user,board_id,\\n title,link,\\n description,actions,\\n public_board=False,\\n get_all=get_all,\\n token=user_obj.auth_token)\\n self.render('congrats.html',feed_url=feed_url,signout=constants.SIGNOUT)\\n else: # They missed some required info\\n user_boards = utils.find_boards(user_obj)\\n self.render('private.html',\\n actions=constants.ACTIONS,\\n check_error=True,\\n user_boards=user_boards,\\n link=link,\\n description=description,\\n title=title,\\n signout=constants.SIGNOUT)\",\n \"def crear_userstory(request, id_proyecto):\\n band=False\\n context = RequestContext(request)\\n\\n\\n rol_en_proyecto=Equipo.objects.get(usuario_id=request.user.pk, proyecto_id=id_proyecto)\\n rol = Group.objects.get(id=rol_en_proyecto.rol.pk)\\n user_permissions_groups = list(rol.permissions.all())\\n\\n for p in user_permissions_groups:\\n if (p.codename == 'add_userstory'):\\n band = True\\n\\n if (band == True):\\n\\n #valor booleano para llamar al template cuando el registro fue correcto\\n registered = False\\n\\n if request.method == 'POST':\\n userstory_form = UserstoryForm(data=request.POST, id_proyecto=id_proyecto)\\n\\n # If the two forms are valid...\\n if userstory_form.is_valid():\\n\\n # Guarda el Usuarios en la bd\\n #us = userstory_form\\n userstory_form.clean()\\n nombre = userstory_form.cleaned_data['nombre']\\n descripcion =userstory_form.cleaned_data['descripcion']\\n tiempoestimado =userstory_form.cleaned_data['tiempoestimado']\\n usuarioasignado= userstory_form.cleaned_data['usuarioasignado']\\n prioridad =userstory_form.cleaned_data['prioridad']\\n porcentajerealizado= userstory_form.cleaned_data['porcentajerealizado']\\n sprint=userstory_form.cleaned_data['sprint']\\n\\n us = Userstory()\\n\\n if usuarioasignado and sprint:\\n us.estado = 'InPlanning'\\n\\n if userstory_form.cleaned_data['prioridad'] == 'Alta':\\n cambioDePrioridades(usuarioasignado, sprint)\\n\\n us.nombre = nombre\\n us.descripcion =descripcion\\n us.tiempoestimado =tiempoestimado\\n us.usuarioasignado =usuarioasignado\\n us.prioridad=prioridad\\n us.porcentajerealizado=porcentajerealizado\\n us.sprint = sprint\\n\\n us.save()\\n #Actualiza la variable para llamar al template cuando el registro fue correcto\\n registered = True\\n\\n # Invalid form or forms - mistakes or something else?\\n # Print problems to the terminal.\\n # They'll also be shown to the user.\\n else:\\n print userstory_form.errors\\n\\n pass\\n\\n # Not a HTTP POST, so we render our form using two ModelForm instances.\\n # These forms will be blank, ready for user input.\\n else:\\n userstory_form = UserstoryForm(id_proyecto=id_proyecto)\\n\\n\\n # Render the template depending on the context.\\n return render_to_response('./Userstories/crearUserstory.html', {'user_form': userstory_form, 'registered': registered, 'id_proyecto': id_proyecto}, context)\\n else:\\n raise Http404(\\\"No cuenta con los permisos necesarios\\\")\",\n \"def postCreate(post):\\n post_list = list()\\n comments = commentList(post)\\n comment_url = \\\"{}/api/posts/{}/comments\\\".format(DOMAIN, post.id)\\n visible_to = list()\\n visible = post.visibleTo.all()\\n if visible:\\n for author in visible:\\n auth = \\\"{}/api/author/{}\\\".format(DOMAIN, author.id)\\n visible_to.append(auth)\\n\\n # visible_to = list(post.visibleTo)\\n post_dict = {'author': addAuthor(post.author), 'title': post.title, 'description': post.description,\\n 'contentType': post.contentType, 'content': post.content, 'published': post.published,\\n 'visibility': post.visibility, 'visibleTo': visible_to, 'unlisted': post.unlisted, 'id': post.id,\\n 'comments': comments[:5], 'next': comment_url, 'count': len(comments),\\n 'source': \\\"{}/api/posts/{}\\\".format(DOMAIN, post.id),\\n 'origin': \\\"{}/api/posts/{}\\\".format(DOMAIN, post.id)}\\n post_list.append(post_dict)\\n return post_list\",\n \"def test_has_perm_post_edit(self):\\n self.context['request'].user = User.objects.get(pk=47963)\\n allowed = has_perm(self.context, 'forums_forum.post_edit_forum',\\n self.forum_1)\\n eq_(allowed, True)\\n allowed = has_perm(self.context, 'forums_forum.post_edit_forum',\\n self.forum_2)\\n eq_(allowed, False)\",\n \"def test_new_thread_anonymous(self):\\n self.go200('forum_thread_list', [forum.slug])\\n self.find('Для створення нових тем — будь-ласка авторизуйтесь.')\\n self.go200('forum_new_thread', [forum.slug])\\n self.url(settings.LOGIN_REDIRECT_URL+'.*')\",\n \"def new(request):\\n if request.method == 'POST': # フォームが提出された\\n form = ArticleForm(request.POST) # POST データの束縛フォーム\\n if form.is_valid(): # バリデーションを通った\\n article = form.save(commit=False)\\n if form.cleaned_data['no_expired_at'] is True:\\n article.expired_at = None\\n article.save()\\n return HttpResponseRedirect(reverse('article_list')) # POST 後のリダイレクト\\n else:\\n form = ArticleForm() # 非束縛フォーム\\n article_list = Article.objects.order_by('-released_at')[:5]\\n auth_form = AuthenticationForm(None, request.POST or None)\\n return render(request, 'app/article_edit.html', { \\n 'form': form,\\n 'title':'ニュース記事の新規登録',\\n 'year':datetime.now().year,\\n 'articles':article_list,\\n 'blogs':EntryView.get_entry_list('-posted_at',-1, request.user.pk )[:5],\\n 'submit_title':'登録する',\\n 'auth_form':auth_form,\\n 'current_user':request.user,\\n })\",\n \"def add(self, project_id, forum):\\n url = base_url + 'portal/' + str(self.portal_id) + '/projects/' + str(project_id) + '/forums/' \\n data = parser.to_json(forum)\\n if forum.get_upload_file():\\n file_list = []\\n for value in forum.get_upload_file():\\n attachment = {\\n 'uploadfile': {\\n 'filename': basename(value), \\n 'content':open(value).read()\\n } \\n }\\n file_list.append(attachment)\\n else:\\n file_list = []\\n response = zoho_http_client.post(url, self.details, data, None, file_list)\\n return parser.get_forums(response)[0]\",\n \"def create_task(request):\\n all_task_list = Todo.objects.all()\\n form = TaskForm()\\n if request.method == 'POST':\\n form = TaskForm(request.POST)\\n if form.is_valid():\\n # create default todolist\\n user = request.user if request.user.is_authenticated else None\\n task = Todo(\\n description=request.POST['description'],\\n content= request.POST['content'],\\n tesk_medium= request.POST['tesk_medium'],\\n creator=user\\n )\\n task.save()\\n return redirect('lists:alllist')\\n else:\\n return render(request, 'lists/index.html', {'form': form})\\n\\n context = {\\n 'form': form, \\n 'taskli':all_task_list\\n }\\n return render(request, 'lists/create_task.html',context )\",\n \"def get(self):\\n username = self.request.cookies.get('name')\\n self.render(\\\"newpost.html\\\", title=\\\"\\\",\\n blogPost=\\\"\\\", error=\\\"\\\",\\n username=check_secure_val(username))\",\n \"def post():\\n pass\",\n \"def post_permissions(request, post):\\n user = request.user\\n is_editable = has_ownership = False\\n\\n if user.is_authenticated():\\n\\n if user == post.author :\\n has_ownership = is_editable = True\\n elif user.is_moderator or user.is_staff:\\n is_editable = True\\n\\n post.is_editable = is_editable\\n post.has_ownership = has_ownership\\n\\n return post\",\n \"def post(self):\\n post_id = int(self.request.get('post_id'))\\n post = Posts.get_by_id(post_id)\\n if post.submitter_id == self.get_active_user().key().id():\\n post.delete()\\n else:\\n self.error(403)\\n self.redirect('/')\",\n \"def post(self):\\n user_id = request.args.get('user_id')\\n firstname = request.args.get('firstname')\\n return post_new_etunimi(user_id, firstname=firstname)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7329339","0.7162002","0.70594895","0.7003851","0.6994737","0.6979558","0.6978259","0.691917","0.6845622","0.68156683","0.67997193","0.6753117","0.67289805","0.6726166","0.67195654","0.66782594","0.66578925","0.6632889","0.6628704","0.6607489","0.660156","0.6597842","0.6588148","0.6547251","0.65390533","0.65204674","0.6493216","0.64835143","0.6474807","0.64537376","0.6445169","0.6442047","0.64044297","0.6400231","0.6389618","0.6328428","0.63009727","0.6284293","0.6281831","0.6243336","0.62350494","0.62296295","0.6220055","0.621242","0.6204767","0.62044436","0.62035453","0.6201421","0.619318","0.6186767","0.6181529","0.61500734","0.6148875","0.6141173","0.6138061","0.6107185","0.60964924","0.6080109","0.6076401","0.60676473","0.6065787","0.6057001","0.6048981","0.60337377","0.60336137","0.60297364","0.60224044","0.60142416","0.60138255","0.60069585","0.5983823","0.59720445","0.5958445","0.59568465","0.5947025","0.59354246","0.59260374","0.5923957","0.59192574","0.59148353","0.59035164","0.5895175","0.5881971","0.58682674","0.58621407","0.5845739","0.5838816","0.58370376","0.58325994","0.5823393","0.5820637","0.5807017","0.58056754","0.5803338","0.5799723","0.5799427","0.57903284","0.5789571","0.57867116","0.5762588"],"string":"[\n \"0.7329339\",\n \"0.7162002\",\n \"0.70594895\",\n \"0.7003851\",\n \"0.6994737\",\n \"0.6979558\",\n \"0.6978259\",\n \"0.691917\",\n \"0.6845622\",\n \"0.68156683\",\n \"0.67997193\",\n \"0.6753117\",\n \"0.67289805\",\n \"0.6726166\",\n \"0.67195654\",\n \"0.66782594\",\n \"0.66578925\",\n \"0.6632889\",\n \"0.6628704\",\n \"0.6607489\",\n \"0.660156\",\n \"0.6597842\",\n \"0.6588148\",\n \"0.6547251\",\n \"0.65390533\",\n \"0.65204674\",\n \"0.6493216\",\n \"0.64835143\",\n \"0.6474807\",\n \"0.64537376\",\n \"0.6445169\",\n \"0.6442047\",\n \"0.64044297\",\n \"0.6400231\",\n \"0.6389618\",\n \"0.6328428\",\n \"0.63009727\",\n \"0.6284293\",\n \"0.6281831\",\n \"0.6243336\",\n \"0.62350494\",\n \"0.62296295\",\n \"0.6220055\",\n \"0.621242\",\n \"0.6204767\",\n \"0.62044436\",\n \"0.62035453\",\n \"0.6201421\",\n \"0.619318\",\n \"0.6186767\",\n \"0.6181529\",\n \"0.61500734\",\n \"0.6148875\",\n \"0.6141173\",\n \"0.6138061\",\n \"0.6107185\",\n \"0.60964924\",\n \"0.6080109\",\n \"0.6076401\",\n \"0.60676473\",\n \"0.6065787\",\n \"0.6057001\",\n \"0.6048981\",\n \"0.60337377\",\n \"0.60336137\",\n \"0.60297364\",\n \"0.60224044\",\n \"0.60142416\",\n \"0.60138255\",\n \"0.60069585\",\n \"0.5983823\",\n \"0.59720445\",\n \"0.5958445\",\n \"0.59568465\",\n \"0.5947025\",\n \"0.59354246\",\n \"0.59260374\",\n \"0.5923957\",\n \"0.59192574\",\n \"0.59148353\",\n \"0.59035164\",\n \"0.5895175\",\n \"0.5881971\",\n \"0.58682674\",\n \"0.58621407\",\n \"0.5845739\",\n \"0.5838816\",\n \"0.58370376\",\n \"0.58325994\",\n \"0.5823393\",\n \"0.5820637\",\n \"0.5807017\",\n \"0.58056754\",\n \"0.5803338\",\n \"0.5799723\",\n \"0.5799427\",\n \"0.57903284\",\n \"0.5789571\",\n \"0.57867116\",\n \"0.5762588\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8074095"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":883,"numItemsPerPage":100,"numTotalItems":95772,"offset":88300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NTgxNjc4NSwianRpIjoiMmViNzRiN2EtODE4My00MGE3LWExNmQtNjNjM2YzODYyYThkIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODU4MjAzODUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.YG_GPD8OwpwO2Jwl5FcaPyyOm7D_5FtAMJGeFomFTANfSvsRvRS7wBcN_UIbf9HzqXn1jBxuuHC0D1E8CNl6Aw","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 |
|---|---|---|---|---|---|---|
from the sen retrieved, score= exp(score) and then normalize according to sum normalization file is an output file claim num, alpha, beta for each alpha beta, create and than add to it the different claims' doc scores | def normalize_sen_scores_corpus_smoothing():
param_len = 10*11# for alpha*beta =110
k_len = 1
# sen_res_files_path = linux_base_path+r"/claimLM_senLM_sen_ret_output_corpus_smoothing_corpus_beta_"+str(corpus_beta)
sen_res_files_path = base_path+r"\claimLM_senLM_sen_ret_output_corpus_smoothing_corpus_be... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_doc_scores():\n# doc_res_files_path = base_path+r\"claimLM_docLM_doc_ret_output\"\n claims_file_counters_dict = {} #for each claim numas key, have the val a counter - if not 110 per claim -> problem!\n doc_res_files_path = linux_base_path+\"/claimLM_docLM_doc_ret_output\"\n# doc_res_fil... | [
"0.7415285",
"0.707976",
"0.66742116",
"0.5899873",
"0.5807724",
"0.5787788",
"0.57867104",
"0.5783012",
"0.57770485",
"0.56916255",
"0.56486267",
"0.5600242",
"0.5599083",
"0.55359215",
"0.5517576",
"0.55115044",
"0.5456102",
"0.54504824",
"0.54460424",
"0.5435197",
"0.54262... | 0.7378386 | 1 |
from the sen retrieved, score= exp(score) and then normalize according to sum normalization file is an output file claim num, alpha, beta for each alpha beta, create and than add to it the different claims' doc scores | def normalize_sen_scores_adj_sen():
param_len = 10*11*55# alpha*beta*delta1*delta2, else just for alpha*beta =110
k_len = 1
# sen_res_files_path = linux_base_path+r"/claimLM_senLM_adjacent_sen_ret_output_corpus_beta_"+str(corpus_beta)+"/"
#norm_sen_res_path = linux_base_path+r"/sen_norm_scores_dicts_ad... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_doc_scores():\n# doc_res_files_path = base_path+r\"claimLM_docLM_doc_ret_output\"\n claims_file_counters_dict = {} #for each claim numas key, have the val a counter - if not 110 per claim -> problem!\n doc_res_files_path = linux_base_path+\"/claimLM_docLM_doc_ret_output\"\n# doc_res_fil... | [
"0.7414821",
"0.7377976",
"0.66732913",
"0.58997655",
"0.58076227",
"0.5788475",
"0.57850957",
"0.5782094",
"0.5777022",
"0.56907845",
"0.5647315",
"0.5600143",
"0.55983925",
"0.55360234",
"0.5516335",
"0.5511713",
"0.5454892",
"0.5449778",
"0.5445213",
"0.5434749",
"0.542638... | 0.7078911 | 2 |
for each alpha and beta values, Get the top k =[50,100,500] docs from which sentences will be retrieved As one of the setups is a according to the LM of the sen and the corpus alone (as done with usual sentence retieval in Indri) then I will create a file for Indri as done in pool creation n ret' process add the top do... | def get_top_k_docs():
# doc_res_dicts_path = base_path+"\\docs_norm_scores_dicts"
# sen_ret_input_path = base_path+"\\claimLM_senLM_sen_ret_input"
doc_res_dicts_path = linux_base_path+"/docs_norm_scores_dicts"
sen_ret_input_path = linux_base_path+"/claimLM_senLM_sen_ret_input"
claims_no_SW_dict = re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_sen_scores_corpus_smoothing():\n param_len = 10*11# for alpha*beta =110 \n k_len = 1\n# sen_res_files_path = linux_base_path+r\"/claimLM_senLM_sen_ret_output_corpus_smoothing_corpus_beta_\"+str(corpus_beta)\n sen_res_files_path = base_path+r\"\\claimLM_senLM_sen_ret_output_corpus_smooth... | [
"0.7060057",
"0.6779933",
"0.6676571",
"0.66038054",
"0.65266526",
"0.61835426",
"0.61230075",
"0.6115115",
"0.60696673",
"0.60688215",
"0.6056709",
"0.6049824",
"0.603279",
"0.6032701",
"0.60288477",
"0.6004372",
"0.598134",
"0.5977768",
"0.5961952",
"0.5930355",
"0.59214824... | 0.77609736 | 0 |
for each alpha, beta value turn the docs norms dicts to a single dict for all claims sen_norm_scores_dicts_path = base_path+"\\sen_norm_scores_dicts" for each alpha,beta, k value turn the sens norms dicts to a single dict for all claims | def merge_all_claims_norm_dicts_for_docs():
# docs_norm_scores_dicts_path = base_path+"\\docs_norm_scores_dicts"
docs_norm_scores_dicts_path = linux_base_path+"/docs_norm_scores_dicts"
# all_claims_norms_scores_merged_dict = base_path +"\\all_claims_norms_scores_merged_dict"
all_claims_norms_scores... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize_sen_scores_corpus_smoothing():\n param_len = 10*11# for alpha*beta =110 \n k_len = 1\n# sen_res_files_path = linux_base_path+r\"/claimLM_senLM_sen_ret_output_corpus_smoothing_corpus_beta_\"+str(corpus_beta)\n sen_res_files_path = base_path+r\"\\claimLM_senLM_sen_ret_output_corpus_smooth... | [
"0.7088313",
"0.67298317",
"0.65189683",
"0.61524886",
"0.5593098",
"0.55304724",
"0.5519807",
"0.54319054",
"0.5411976",
"0.53833836",
"0.53432316",
"0.5338235",
"0.5274585",
"0.526474",
"0.5180783",
"0.5180489",
"0.51749146",
"0.51542217",
"0.51415366",
"0.5109483",
"0.5080... | 0.76682496 | 0 |
after sen retrieval for each alpha and beta, interpolate with the weight between as free param and rank according to lambda value | def interpolate_doc_sen_score_adj_sen():
print "started interpolate_doc_sen_score"
# all_claims_norms_scores_merged_dict_docs = linux_base_path +"/all_claims_norms_scores_merged_dict_docs"
# all_claims_norms_scores_merged_dict_sen = linux_base_path +"/all_claims_norms_scores_merged_dict_adjacent_sen_corpus_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_weights(self, alpha, ind):\n inside = -alpha * self.labels * self.predictions[ind, :]\n new_weights = self.weights * np.exp(inside)\n self.weights = new_weights / np.sum(new_weights)",
"def obj(k_next) : \n \n if method==1 :\n value_vec = -1 * (log(A*k_cur... | [
"0.6074115",
"0.60367084",
"0.5989218",
"0.5975552",
"0.576305",
"0.5743471",
"0.57288766",
"0.57013637",
"0.5695949",
"0.5693833",
"0.5673339",
"0.563869",
"0.5598247",
"0.5595677",
"0.5590343",
"0.5588766",
"0.55849355",
"0.5582929",
"0.5582796",
"0.55817425",
"0.5571087",
... | 0.54549414 | 46 |
compute the nDCG for all claims, based on the ranking of each baseline | def convert_true_support_to_relevance():
clm_as_key_sen_support_score_val_wiki = read_pickle("clm_as_key_sen_support_score_val_wiki") #key is a claim num, value is a list of tuple - sen and their 0/1/2 support score)
claim_sen_true_relevance_dict = {}
claim_dict = read_pickle("claim_dict")
#t Dead Poets... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ndcg(relevances, rank=10):\n best_dcg = dcg(sorted(relevances, reverse=True), rank)\n if best_dcg == 0:\n return 0.\n return dcg(relevances, rank) / best_dcg",
"def ndcg(preds, labels):\n \n #find positions where the prediction matches the label\n relv_pos = np.where(np.equal(preds, ... | [
"0.67754275",
"0.6628465",
"0.6593899",
"0.64596516",
"0.64169276",
"0.6408325",
"0.63335246",
"0.631509",
"0.61704683",
"0.615062",
"0.6136275",
"0.6125998",
"0.61198425",
"0.6093542",
"0.60783464",
"0.6061076",
"0.606081",
"0.6028799",
"0.6009129",
"0.59800285",
"0.59335095... | 0.0 | -1 |
A doc is relevant if it has a relevant sentence, according to the true rel annotation. | def create_rel_doctitle_dict():
claim_rel_docno_dict = {} #key is claim text, value is a set of doc_title that are relevant
clm_sen_doc_title_dict = read_pickle("sen_doc_title_dict")
claim_sen_true_relevance_dict = read_pickle("claim_sen_relevance_dict_"+curr_source)
exclude = set(string.punctuation)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def IsDocumentRelated(self, *args, **kwargs):\n pass",
"def test_doc1(self):\n assert models.review.__doc__ is not None",
"def is_lyrics_approved():",
"def has_doc() -> None:",
"def allow_relation(self, obj1, obj2, **hints):\n if obj1._meta.app_label == 'researcherquery' and obj2._meta... | [
"0.6288269",
"0.62236005",
"0.6089288",
"0.58728105",
"0.5830102",
"0.5629541",
"0.5613132",
"0.559914",
"0.5593776",
"0.55932766",
"0.5588624",
"0.5546527",
"0.5536408",
"0.5524622",
"0.54359573",
"0.5395747",
"0.5385224",
"0.53797835",
"0.53793937",
"0.53676057",
"0.5354059... | 0.0 | -1 |
on the document retrieval results, calc the MAP | def calc_doc_ret_MAP():
# docs_norm_scores_dicts_path = linux_base_path+"/docs_norm_scores_dicts"
claim_rel_docno_dict = read_pickle("claim_rel_docno_dict") #key is clm, value is a set of the relevant docno
# nDCG_MAP_res = base_path +"\\nDCG_MAP_res\\"
# docs_norms_path = base_path+"\\docs_norm_sc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _docMapping(self):\n doc2quests = defaultdict(list)\n for q, d in self.quest2doc.items():\n doc2quests[d].append(q)\n return doc2quests",
"def map():",
"def getResults():",
"def _apply_mapping(self, document, mapping):\n if not mapping:\n return document\... | [
"0.6114611",
"0.6031638",
"0.59947586",
"0.5955202",
"0.58502626",
"0.5790254",
"0.57628024",
"0.5761751",
"0.5743886",
"0.57371366",
"0.5696955",
"0.5681318",
"0.56573915",
"0.56136465",
"0.5600608",
"0.5599281",
"0.55984145",
"0.5586433",
"0.5571157",
"0.55652666",
"0.55601... | 0.64025724 | 0 |
for each ranked list of sentences for alpha, beta (the lambda doesnt matter), calculate the numebr of sentences that in the true_pridiction list for the claim | def calc_intersection_true_data_baselines_data_cnt():
# final_sen_scores = linux_base_path + "/final_sen_scores/"
final_sen_scores = base_path + "\\final_sen_scores\\"
top_k_docs_values = [50]
lambda_f = "1"
claim_sen_true_relevance_dict = read_pickle("claim_sen_relevance_dict_"+curr_source)
cla... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, n, sents, corpus='', beta=None, addone=True):\n self.n = n\n self.beta = beta\n self.corpus = corpus\n self.beta_flag = True\n self.addone = addone\n self.smoothingtechnique = 'Back Off (Katz) with Discounting Smoothing'\n self.counts = counts = d... | [
"0.6603899",
"0.6272677",
"0.6156917",
"0.6153438",
"0.6046044",
"0.6021674",
"0.5953508",
"0.5943219",
"0.5927122",
"0.5906488",
"0.58450556",
"0.5834747",
"0.58299893",
"0.58284515",
"0.58246076",
"0.58082694",
"0.58082694",
"0.5799289",
"0.5791235",
"0.5764125",
"0.5757760... | 0.5704174 | 26 |
for every configuration, calc the std of the measures | def calc_std_nDCG_AP_corpus_smoothing(p):
# nDCG_MAP_res = base_path +"\\nDCG_MAP_res\\"
measures_res = linux_base_path+ "/measures_res"+setup+"/"
k_val = 50
NDCG_AP_all_claims_all_param_values = read_pickle(measures_res+"NDCG_AP_prec_at_k_all_claims_all_param_values_top_k_docs_"+str(k_val)+"_at_"+... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def std(self):\n return self._summarize(lambda c: c.std)",
"def std(self, dset):\n avg = self.mean(dset)\n variance = sum([math.pow(x - avg, 2) for x in dset])\n std = math.sqrt(variance)\n return std",
"def std(self):\n variance, mean = self.variance()\n standa... | [
"0.72832054",
"0.7275002",
"0.7248711",
"0.72363716",
"0.72285056",
"0.7219676",
"0.71546847",
"0.711142",
"0.7090396",
"0.70886666",
"0.7055412",
"0.70186174",
"0.70143723",
"0.6981223",
"0.6968023",
"0.6966007",
"0.69231254",
"0.6908948",
"0.69009334",
"0.6878737",
"0.68759... | 0.0 | -1 |
1. Leave one out each claim, 2. For every possible value of alpha,beta,lambda calc the nDCG,MAP on the train claims (without the left out) 3. Find the configuration that maximises the measures 4. report the meatures of th e left out claim with this configuration | def find_best_free_param_configuration_LOO_adj_sen(p):
measures_res = linux_base_path+ "/measures_res"+setup+"/"
# measures_res = base_path +"\\measures_res"+setup+"\\"
# nDCG_MAP_res = base_path +"\\nDCG_MAP_res\\"
claim_dict = read_pickle("claim_dict")
claim_num_list = [4,7,17,21,36,37,39,40,41,4... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_best_free_param_configuration_LOO_corpus_smoothing(p,alpha_range,beta_range,lambda_range):\n measures_res = linux_base_path+ \"/measures_res_corpus_smoothing_corpus_beta_\"+str(corpus_beta)+\"/\"\n# measures_res = \"/IBM_STORAGE/USERS_DATA/liorab/baseline_ret/sen_ret_corpus_smoothing_res/nDCG_MAP_r... | [
"0.6862903",
"0.6270026",
"0.62612617",
"0.599234",
"0.5982573",
"0.5976929",
"0.58862674",
"0.58170885",
"0.5773099",
"0.57533056",
"0.57435113",
"0.571662",
"0.56960785",
"0.5683166",
"0.5602618",
"0.559545",
"0.5578115",
"0.5569379",
"0.5545015",
"0.5527642",
"0.5518251",
... | 0.70153874 | 0 |
1. Leave one out each claim, 2. For every possible value of alpha,beta,lambda calc the nDCG,MAP on the train claims (without the left out) 3. Find the configuration that maximises the measures 4. report the meatures of th e left out claim with this configuration | def find_best_free_param_configuration_LOO_corpus_smoothing(p,alpha_range,beta_range,lambda_range):
measures_res = linux_base_path+ "/measures_res_corpus_smoothing_corpus_beta_"+str(corpus_beta)+"/"
# measures_res = "/IBM_STORAGE/USERS_DATA/liorab/baseline_ret/sen_ret_corpus_smoothing_res/nDCG_MAP_res_corpus_sm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_best_free_param_configuration_LOO_adj_sen(p):\n\n measures_res = linux_base_path+ \"/measures_res\"+setup+\"/\"\n# measures_res = base_path +\"\\\\measures_res\"+setup+\"\\\\\"\n# nDCG_MAP_res = base_path +\"\\\\nDCG_MAP_res\\\\\"\n claim_dict = read_pickle(\"claim_dict\")\n claim_num_lis... | [
"0.7014755",
"0.6269574",
"0.6260426",
"0.59911776",
"0.5981472",
"0.597715",
"0.5884376",
"0.58172673",
"0.5771162",
"0.5752471",
"0.57429314",
"0.5715644",
"0.56959563",
"0.5682965",
"0.5601803",
"0.55960995",
"0.55781525",
"0.55682933",
"0.5544764",
"0.5527773",
"0.5518287... | 0.68619835 | 1 |
After results, compare to different setups with the alpha,beta weighting settings. | def claim_document_baseline():
param_range = namedtuple('param_range','start, end')
alpha_settings = param_range(0,1)#,param_range(10,11)
beta_settings = param_range(0,1)#,param_range(9,10)] #as it finished at beta=0.9
lambda_settings = param_range(0,11)
claim_document_baseline_LOO(alpha_settin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_additive_alpha_beta(self):\n np.random.seed(912838)\n\n param_pairs = [(1.0, 0.0), (0.0, 1.0), (1.0, 1.0)]\n tmax = 4*self.dt\n\n self.conductor.out_step = np.random.randn(self.Nc)\n self.tutor.out_step = np.random.randn(self.Ns)\n\n sim = simulation.Simulation(self.conductor, self.stude... | [
"0.611615",
"0.611615",
"0.6114931",
"0.609811",
"0.6080122",
"0.598481",
"0.59555906",
"0.5920266",
"0.58922756",
"0.58922756",
"0.58922756",
"0.58922756",
"0.5883654",
"0.5871668",
"0.5863644",
"0.58578783",
"0.5856136",
"0.58423",
"0.58423",
"0.5835598",
"0.5834205",
"0.... | 0.0 | -1 |
call the loo function | def claim_document_baseline_LOO(alpha_setting, beta_setting, lambda_settings):
find_best_free_param_configuration_LOO_corpus_smoothing(10, alpha_setting, beta_setting, lambda_settings) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loan(self):",
"def loo(trace, model=None, pointwise=False, reff=None, progressbar=False):\n model = modelcontext(model)\n\n if reff is None:\n if trace.nchains == 1:\n reff = 1.\n else:\n eff = pm.effective_n(trace)\n eff_ave = pm.stats.dict2pd(eff, 'eff')... | [
"0.61510205",
"0.5998763",
"0.59260106",
"0.5722653",
"0.5680222",
"0.5623486",
"0.5571951",
"0.5565588",
"0.5565588",
"0.5565588",
"0.5565588",
"0.5565588",
"0.5533538",
"0.5505728",
"0.5433628",
"0.540592",
"0.5388204",
"0.53445035",
"0.5337844",
"0.5270219",
"0.5263789",
... | 0.0 | -1 |
Update a source Docker image with environment config and publish it to deisregistry. | def publish_release(self, source, config, target, deis_registry):
# get the source repository name and tag
src_name, src_tag = docker.utils.parse_repository_tag(source)
# get the target repository name and tag
name, tag = docker.utils.parse_repository_tag(target)
# strip any "htt... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build(self, source, config, repo, tag):\n check_blacklist(repo)\n env = ' '.join(\"{}='{}'\".format(\n k, v.encode('unicode-escape').replace(\"'\", \"\\\\'\")) for k, v in config.viewitems())\n dockerfile = \"FROM {}\\nENV {}\".format(source, env)\n f = io.BytesIO(dockerf... | [
"0.610328",
"0.5974144",
"0.5876449",
"0.57455844",
"0.5714578",
"0.57040226",
"0.5610458",
"0.5601322",
"0.5594505",
"0.5568667",
"0.54921347",
"0.54339135",
"0.5416365",
"0.5412983",
"0.54030377",
"0.53847176",
"0.53753495",
"0.5353201",
"0.5352105",
"0.5350578",
"0.5342924... | 0.6775295 | 0 |
Add a "lastmile" layer of environment config to a Docker image for deisregistry. | def build(self, source, config, repo, tag):
check_blacklist(repo)
env = ' '.join("{}='{}'".format(
k, v.encode('unicode-escape').replace("'", "\\'")) for k, v in config.viewitems())
dockerfile = "FROM {}\nENV {}".format(source, env)
f = io.BytesIO(dockerfile.encode('utf-8'))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initializeSystem():\n dockerapi.writeDockerConfig()",
"def add_new_last_layer(base_model, nb_classes):\r\n x = base_model.output\r\n x = AveragePooling2D((8, 8), border_mode='valid', name='avg_pool')(x)\r\n x = Dropout(0.25)(x)\r\n x = Flatten()(x)\r\n predictions = Dense(7, activation='sof... | [
"0.49154678",
"0.48906717",
"0.48791206",
"0.4833639",
"0.4813655",
"0.48127934",
"0.47168905",
"0.4642947",
"0.45713437",
"0.45476964",
"0.454493",
"0.4542153",
"0.45378584",
"0.45290574",
"0.450392",
"0.44974288",
"0.448868",
"0.4449875",
"0.4443322",
"0.44422632",
"0.44383... | 0.0 | -1 |
Pull a Docker image into the local storage graph. | def pull(self, repo, tag):
check_blacklist(repo)
logger.info("Pulling Docker image {}:{}".format(repo, tag))
with SimpleFlock(self.FLOCKFILE, timeout=1200):
stream = self.client.pull(repo, tag=tag, stream=True, insecure_registry=True)
log_output(stream) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pull_image(image):\n\n subprocess.check_call(['docker', 'pull', image])",
"def _pull_image(self, docker_client: \"DockerClient\"):\n image, tag = self._get_image_and_tag()\n\n return docker_client.images.pull(image, tag)",
"def fetch_image(client, name):\n try:\n image = client.i... | [
"0.75792754",
"0.72861683",
"0.6884008",
"0.6882427",
"0.6866366",
"0.6799547",
"0.67634326",
"0.6614292",
"0.65722054",
"0.6526053",
"0.6421416",
"0.63941723",
"0.63735044",
"0.6344396",
"0.63258123",
"0.62319577",
"0.6221783",
"0.6129149",
"0.60782826",
"0.60653406",
"0.600... | 0.6688671 | 7 |
Push a local Docker image to a registry. | def push(self, repo, tag):
logger.info("Pushing Docker image {}:{}".format(repo, tag))
stream = self.client.push(repo, tag=tag, stream=True, insecure_registry=True)
log_output(stream) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push_image(image):\n\n subprocess.check_call(['docker', 'push', image])",
"def push(images, tag, registry):\n manager = Manager('push', tag, images=images, registry_url=registry)\n manager.run()",
"def Push(self, docker_client):\n docker_client.tag(self.id, self.repo_tag, force=True)\n log.i... | [
"0.81385744",
"0.7947424",
"0.7744581",
"0.74444735",
"0.73166674",
"0.7316662",
"0.72692245",
"0.7238543",
"0.71569896",
"0.7097341",
"0.6858782",
"0.67677134",
"0.65243113",
"0.64571184",
"0.6349448",
"0.6315263",
"0.6307589",
"0.6149461",
"0.614088",
"0.6092131",
"0.607589... | 0.7845292 | 2 |
Tag a local Docker image with a new name and tag. | def tag(self, image, repo, tag):
check_blacklist(repo)
logger.info("Tagging Docker image {} as {}:{}".format(image, repo, tag))
if not self.client.tag(image, repo, tag=tag, force=True):
raise docker.errors.DockerException("tagging failed") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, repo, tag):\n logger.info(\"Pushing Docker image {}:{}\".format(repo, tag))\n stream = self.client.push(repo, tag=tag, stream=True, insecure_registry=True)\n log_output(stream)",
"def update(tag_name: str):\n\n image_full_name = f\"{GITLAB_IMAGE_URL}:{tag_name}\"\n _buil... | [
"0.65464705",
"0.65072083",
"0.64666855",
"0.6431756",
"0.6422313",
"0.62344396",
"0.6217048",
"0.6179603",
"0.61187536",
"0.6083696",
"0.6049853",
"0.60115",
"0.6009453",
"0.5975412",
"0.5973849",
"0.59461796",
"0.5944714",
"0.5910567",
"0.5837",
"0.5825065",
"0.58246857",
... | 0.71745235 | 0 |
Check a Docker repository name for collision with deis/ components. | def check_blacklist(repo):
blacklisted = [ # NOTE: keep this list up to date!
'builder', 'cache', 'controller', 'database', 'logger', 'logspout',
'publisher', 'registry', 'router', 'store-admin', 'store-daemon',
'store-gateway', 'store-metadata', 'store-monitor', 'swarm', 'mesos-master',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def docker_repo_field(value, name):\n if not DOCKER_REPO_RE.match(value):\n raise ValueError((\"Invalid %s. Must start with a lower case, \"\n \"alphanumeric character, and contain only the \"\n \"additional characters '-', '_' and '.'\") % name)\n ret... | [
"0.6755347",
"0.6468596",
"0.6273505",
"0.5908212",
"0.58465743",
"0.58431125",
"0.57671696",
"0.57315993",
"0.573047",
"0.5721501",
"0.57143027",
"0.56826484",
"0.56826484",
"0.56549484",
"0.56091887",
"0.5582749",
"0.55753964",
"0.55694026",
"0.5562148",
"0.55573213",
"0.55... | 0.0 | -1 |
Log a stream at DEBUG level, and raise DockerException if it contains "error". | def log_output(stream):
for chunk in stream:
logger.debug(chunk)
# error handling requires looking at the response body
if '"error"' in chunk.lower():
raise docker.errors.DockerException(chunk) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stream_error(self,err):\n self.__logger.debug(\"Stream error: condition: %s %r\"\n % (err.get_condition().name,err.serialize()))",
"def debug(log):\n write(syslog.LOG_DEBUG, 'debug', '{log}'.format(log=log))",
"def debug(msg, resource=None, stream_id=None):\n engine = get_engine... | [
"0.59884083",
"0.5917202",
"0.5891739",
"0.56892204",
"0.56684613",
"0.5657212",
"0.55786264",
"0.55449605",
"0.55404776",
"0.55256677",
"0.5513519",
"0.5486321",
"0.5478189",
"0.5445965",
"0.54356295",
"0.54103154",
"0.53925633",
"0.53724486",
"0.53709",
"0.53615487",
"0.535... | 0.72306085 | 0 |
Checks inputs and forks between implicit/backprop exec of Sinkhorn. | def _sinkhorn(
geom: geometry.Geometry,
a: Optional[jnp.ndarray] = None,
b: Optional[jnp.ndarray] = None,
tau_a: float = 1.0,
tau_b: float = 1.0,
threshold: float = 1e-3,
norm_error: int = 1,
inner_iterations: int = 10,
min_iterations: int = 0,
max_iterations: int = 2000,
mom... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def validate_input(self):\n\n inputs = self.inputs\n inputs_ok = True\n\n if not 'kkrimp_remote' in inputs:\n if not ('host_imp_startpot' in inputs and 'remote_data' in inputs):\n inputs_ok = False\n self.ctx.exit_code = self.exit_codes.ERROR_HOST_IMP_P... | [
"0.62660146",
"0.5898407",
"0.58596665",
"0.58210665",
"0.5779729",
"0.573997",
"0.5686902",
"0.5649694",
"0.5615524",
"0.56127435",
"0.5544417",
"0.5505252",
"0.54916924",
"0.5482584",
"0.5474087",
"0.5440653",
"0.5435655",
"0.54212564",
"0.5415849",
"0.5412049",
"0.5387389"... | 0.0 | -1 |
The jittable Sinkhorn loop, that uses a custom backward or not. | def _sinkhorn_iterations(
tau_a: float,
tau_b: float,
inner_iterations: int,
min_iterations: int,
max_iterations: int,
momentum_default: float,
chg_momentum_from: int,
lse_mode: bool,
implicit_differentiation: bool,
threshold: float,
norm_error: Sequence[int],
geom: geome... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_iter_backward(self, runner):\n runner.optimizer.zero_grad()\n runner.loss.backward()\n runner.optimizer.step()",
"def backward(self, *output_grads):\n raise NotImplementedError",
"def post_backward_generator(self):\n pass",
"def backward(self, dout):\n \n #####... | [
"0.70739937",
"0.6807868",
"0.67775184",
"0.6762841",
"0.6524559",
"0.64676994",
"0.64280504",
"0.6413513",
"0.63601685",
"0.62899834",
"0.6265906",
"0.6244667",
"0.6244667",
"0.6244667",
"0.6242385",
"0.6242385",
"0.6242385",
"0.62321997",
"0.621499",
"0.6193118",
"0.6178678... | 0.0 | -1 |
Carries out sinkhorn iteration. | def body_fn(iteration, const, state, compute_error):
geom, a, b, _ = const
errors, f_u, g_v = state
# compute momentum term if needed, using previously seen errors.
w = jax.lax.stop_gradient(jnp.where(iteration >= (
inner_iterations * chg_momentum_from + min_iterations),
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loop(self):\n pass",
"def run(self):\n self.running = True\n for channel in self:\n sleep(self.hop_interval)\n if self.running is False:\n return\n self.hop_channel(channel)",
"def simple_sink(riter):\n for r in riter:\n pass",
"def... | [
"0.64314777",
"0.6394602",
"0.62053657",
"0.6161966",
"0.6158346",
"0.61251426",
"0.606128",
"0.6059073",
"0.60076135",
"0.59654975",
"0.5962125",
"0.59553146",
"0.59256214",
"0.5917795",
"0.5866112",
"0.58040047",
"0.5802265",
"0.5798182",
"0.5782615",
"0.5779526",
"0.573078... | 0.0 | -1 |
Runs forward pass of the Sinkhorn algorithm storing side information. | def _sinkhorn_iterations_taped(
tau_a: float,
tau_b: float,
inner_iterations: int,
min_iterations: int,
max_iterations: int,
momentum_default: float,
chg_momentum_from: int,
lse_mode: bool,
implicit_differentiation: bool,
threshold: float,
norm_error: Sequence[int],
geom:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def forward_pass(self):",
"def forward(self):\n pass",
"def forward(self):\n pass",
"def forward(self, features, features_lengths, spkids):\n pass",
"def forward(self, obs):\n\t\tpass",
"def forward(self)->None:",
"def forward(self, input):\n\n common = self.common_tower(inp... | [
"0.60292",
"0.5702385",
"0.5702385",
"0.5681689",
"0.5644615",
"0.5601841",
"0.5557204",
"0.5541835",
"0.55348027",
"0.5484265",
"0.5484265",
"0.5469709",
"0.5469709",
"0.5469709",
"0.5458874",
"0.54275465",
"0.54246515",
"0.5411879",
"0.5342686",
"0.5322752",
"0.5285507",
... | 0.0 | -1 |
Runs Sinkhorn in backward mode, using implicit differentiation. | def _sinkhorn_iterations_implicit_bwd(
tau_a, tau_b, inner_iterations, min_iterations, max_iterations,
momentum_default, chg_momentum_from, lse_mode, implicit_differentiation,
res, gr) -> Tuple[Any, Any, geometry.Geometry, jnp.ndarray, jnp.ndarray]:
del inner_iterations, min_iterations, max_iterations, mo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def backward(self, *output_grads):\n raise NotImplementedError",
"def backward(self, dout):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n for l in range(len(self.layers)-1,-1,-1):\n act_dout = self.activations[l].backward(dout)\n dout = self.l... | [
"0.69852996",
"0.68194205",
"0.6752031",
"0.6567173",
"0.6535789",
"0.65302145",
"0.65302145",
"0.65216994",
"0.6514366",
"0.644436",
"0.6381626",
"0.63740325",
"0.6360264",
"0.63470936",
"0.6304719",
"0.6304719",
"0.6304719",
"0.6304719",
"0.6304719",
"0.6304719",
"0.6304719... | 0.0 | -1 |
Computes vector of first order conditions for the regOT problem. The output of this vector should be close to zero at optimality. Upon completion of the Sinkhorn forward pass, its norm (as computed using the norm_error setting) should be below the threshold parameter. This error will be itself assumed to be close to ze... | def first_order_conditions(geom: geometry.Geometry,
a: jnp.ndarray,
b: jnp.ndarray,
fg: jnp.ndarray):
grad_a, grad_b = grad_of_marginal_fit(
a, b, fg[:n], fg[n:], tau_a, tau_b, geom)
return jnp.concatenate((
j... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_initial_condition(self):\n X0 = np.array([0.5, 0.5])\n XB = self.bary\n q0 = 1 + np.exp(-0.5*(np.sum((XB-X0[np.newaxis])**2., axis=1))/0.1**2)\n q1 = np.zeros(q0.shape)\n #import pdb; pdb.set_trace()\n return np.array([q0, q1, q1]).T",
"def buildWPriorTerm(self):... | [
"0.5671115",
"0.5641746",
"0.5570537",
"0.5496455",
"0.5372268",
"0.53037494",
"0.5230425",
"0.51915425",
"0.5160275",
"0.50784904",
"0.50669193",
"0.50549674",
"0.5047859",
"0.50226414",
"0.5003567",
"0.49921483",
"0.49834663",
"0.4970644",
"0.49686915",
"0.49627993",
"0.494... | 0.0 | -1 |
Conputes marginal error, the stopping criterion used to terminate Sinkhorn. | def marginal_error(geom: geometry.Geometry, a: jnp.ndarray, b: jnp.ndarray,
tau_a: float, tau_b: float, f_u: jnp.ndarray,
g_v: jnp.ndarray, norm_error: int, lse_mode) -> jnp.ndarray:
if tau_b == 1.0:
err = geom.error(f_u, g_v, b, 0, norm_error, lse_mode)
elif tau_a == 1.0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _computeError(self, inputs, targets):\n return .5*np.sum((targets-self._pcnfwd(inputs))**2)",
"def calc_error_dist(self):\n pass",
"def cps_err(self):\n return np.sqrt(self.totalcounts) / self.exptime",
"def calcError(self, inherited_error):\r\n\t\tif inherited_error == None:\t\t# ou... | [
"0.55752885",
"0.55262184",
"0.53878623",
"0.53458256",
"0.5242713",
"0.5219906",
"0.51388973",
"0.513811",
"0.51329106",
"0.51179904",
"0.50959706",
"0.5045472",
"0.5027726",
"0.501926",
"0.50111884",
"0.5003115",
"0.4994308",
"0.49891266",
"0.49881127",
"0.49779963",
"0.496... | 0.6124 | 0 |
Computes objective of regularized OT given dual solutions f,g. In all sums below, jnp.where handle situations in which some coordinates of a and b are zero. For those coordinates, their potential is inf. This leads to inf inf or inf x 0 operations which result in NaN. These contributions are discarded when computing th... | def ent_reg_cost(geom: geometry.Geometry,
a: jnp.ndarray,
b: jnp.ndarray,
tau_a: float,
tau_b: float,
f: jnp.ndarray,
g: jnp.ndarray) -> jnp.ndarray:
if tau_a == 1.0:
div_a = jnp.sum(
jnp.where(a > 0, (f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def objective_func(self, topology, grad_func, tmax, eta):\n f = objective_function_numpy\n x_func = partial(self._optimize_form, topology=topology, tmax=tmax, eta=eta)\n return partial(f, x_func=x_func, grad_func=grad_func)",
"def dual_objective_expression_rule(_m):\r\n\r\n # Buil... | [
"0.60246664",
"0.58848155",
"0.584778",
"0.58339036",
"0.576397",
"0.5628816",
"0.5617787",
"0.560414",
"0.5598312",
"0.55587715",
"0.55584806",
"0.5530736",
"0.5519905",
"0.5510261",
"0.5503501",
"0.54910654",
"0.5487054",
"0.548219",
"0.5477244",
"0.54708964",
"0.5469146",
... | 0.561347 | 7 |
Computes grad of terms linked to marginals a, b in objective. Computes gradient w.r.t. f and g of terms in | def grad_of_marginal_fit(a, b, f, g, tau_a, tau_b, geom):
if tau_a == 1.0:
grad_a = a
else:
rho_a = geom.epsilon * tau_a / (1 - tau_a)
grad_a = jnp.where(a > 0, a * derivative_phi_star(-f, rho_a), 0.0)
if tau_b == 1.0:
grad_b = b
else:
rho_b = geom.epsilon * tau_b / (1 - tau_b)
grad_b =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grad(self,w):\n # Calculate the vector -sigma(-y_i * x_i.w)\n s = -np.array([sigmoid(-yi * np.dot(xi,w)) for xi,yi in zip(self.x,self.y)])\n # Multiply it by xy\n g = np.array([np.dot(xyj,s) for xyj in self.xy.transpose()])\n # Add regularisation\n g += self.alpha*w\n return g\n #g = np... | [
"0.70722276",
"0.69424504",
"0.6891617",
"0.6874898",
"0.6870639",
"0.68621045",
"0.68616676",
"0.68609214",
"0.6854778",
"0.68153954",
"0.6803334",
"0.680243",
"0.6780593",
"0.6712635",
"0.66944325",
"0.6691906",
"0.6669815",
"0.6658177",
"0.6646453",
"0.6594153",
"0.6582312... | 0.7828975 | 0 |
Derivative of Legendre transform of KL, see phi_star. | def derivative_phi_star(f: jnp.ndarray, rho: float) -> jnp.ndarray:
return jnp.exp(f / rho) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _Kgradients(self):\r\n dL_dfhat, I_KW_i = self._shared_gradients_components()\r\n dlp = self.noise_model.dlogpdf_df(self.f_hat, self.data, extra_data=self.extra_data)\r\n\r\n #Explicit\r\n #expl_a = np.dot(self.Ki_f, self.Ki_f.T)\r\n #expl_b = self.Wi_K_i\r\n #expl = 0... | [
"0.61092794",
"0.61055094",
"0.6030606",
"0.5972036",
"0.5966971",
"0.59054434",
"0.5902631",
"0.58994365",
"0.58914834",
"0.5864667",
"0.5842159",
"0.5837313",
"0.582848",
"0.5810532",
"0.5781278",
"0.5744244",
"0.57416415",
"0.5712278",
"0.57101023",
"0.57049537",
"0.567282... | 0.52620405 | 73 |
Actualize the snake through time, making it older and more hungryat each game iteration, sorry snek | def update(self):
self.age += 1
self.starve -= 1
if self.starve < 1:
self.alive = False
self.move() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def on_draw(delta_time):\n # draws all our objects\n arcade.start_render()\n\n generate_grid()\n apple()\n snake(on_draw.snake_part_x, on_draw.snake_part_y, 20, 20, snake_color)\n snake(on_draw.snake_part2_x, on_draw.snake_part2_y, 20, 20, snake_color)\n snake(on_draw.snake_part3_x, on_draw.sn... | [
"0.6826523",
"0.6738613",
"0.66854745",
"0.6468907",
"0.6377065",
"0.6312511",
"0.63061565",
"0.621615",
"0.61987853",
"0.6187258",
"0.61799073",
"0.6174087",
"0.61577815",
"0.6136083",
"0.6125809",
"0.61203724",
"0.609418",
"0.6085315",
"0.60353434",
"0.6017452",
"0.600701",... | 0.55258 | 98 |
Makes snake grow one block longer Called by map.update() when snake's head is in collision with food | def grow(self):
self.starve = 500 # useful to avoid looping AI snakes (they die younger -> bad fitness)
self.body.append(self.old_tail) # that's why I keep old_tail | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update(self):\n head = (\n (self.snake[0][0] + self.xv * self.ac),\n (self.snake[0][1] + self.yv * self.ac),\n )\n self.snake.insert(0, head)\n\n if head == self.apple:\n self.score += 10\n self.apple = None\n while not self.app... | [
"0.7277614",
"0.66949636",
"0.66329545",
"0.6514946",
"0.65060645",
"0.65026385",
"0.6497427",
"0.6453022",
"0.63167936",
"0.6293433",
"0.6293245",
"0.6209517",
"0.6101574",
"0.6066382",
"0.6060743",
"0.60461587",
"0.604199",
"0.60198057",
"0.6012406",
"0.59504473",
"0.592508... | 0.6535498 | 3 |
Makes the snake move, head moves in current direction and each blocks replace its predecessor | def move(self):
self.old_tail = self.body[-1][:] # save old position of last block
self.head[0] += self.direction[0] # moves head
self.head[1] += self.direction[1]
self.head[0] = (self.head[0] + self.xMaxSize) % self.xMaxSize
self.head[1] = (self.head[1] + s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __snake_move(self):\n self.__eat_candy()\n # move tail and body\n n_snake = len(self.__snake)\n for i in range(1, n_snake):\n s2 = self.__snake[n_snake - i]\n s1 = self.__snake[n_snake - i - 1]\n s2.move(s1.pos())\n # move head\n pos = ... | [
"0.7895844",
"0.7185265",
"0.7008609",
"0.67999005",
"0.6541893",
"0.6265843",
"0.6260639",
"0.62456954",
"0.62426347",
"0.6241239",
"0.62059575",
"0.6096831",
"0.6057173",
"0.60542494",
"0.6027465",
"0.59052736",
"0.58953947",
"0.5891848",
"0.5857788",
"0.584062",
"0.5828308... | 0.79912674 | 0 |
Makes the snake direction to the right of the current direction Current direction = [x,y], turn_right gives [y,x] | def turn_right(self):
temp = self.direction[0]
self.direction[0] = -self.direction[1]
self.direction[1] = temp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn_right(self):\n self.facing_direction += self.config\n if self.facing_direction > 7:\n self.facing_direction -= 8\n self.x, self.y = self.compute_positions()",
"def turn_ship_right(self):\n self.degrees -= movement",
"def turn_right(self):\n pass",
"def t... | [
"0.7601584",
"0.75017947",
"0.74439204",
"0.7421596",
"0.7255912",
"0.7253135",
"0.7243722",
"0.7217155",
"0.71768004",
"0.715687",
"0.7089985",
"0.7026401",
"0.69998384",
"0.69393873",
"0.69342035",
"0.6932262",
"0.6792831",
"0.6776827",
"0.6776374",
"0.6773701",
"0.67681515... | 0.8202334 | 0 |
Makes the snake direction to the right of the current direction Current direction = [x,y], turn_right gives [y,x] | def turn_left(self):
temp = self.direction[0]
self.direction[0] = self.direction[1]
self.direction[1] = -temp | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn_right(self):\n temp = self.direction[0]\n self.direction[0] = -self.direction[1]\n self.direction[1] = temp",
"def turn_right(self):\n self.facing_direction += self.config\n if self.facing_direction > 7:\n self.facing_direction -= 8\n self.x, self.y =... | [
"0.82036936",
"0.7602102",
"0.7502819",
"0.74446523",
"0.7422422",
"0.72565275",
"0.7254244",
"0.72445714",
"0.7218234",
"0.7176285",
"0.71571696",
"0.70907134",
"0.7026792",
"0.70008147",
"0.6939965",
"0.69347",
"0.6932813",
"0.6794251",
"0.67778355",
"0.6777165",
"0.6773733... | 0.65929574 | 28 |
Makes decision for the snake direction according to its current vision Vision is given to the NeuralNetwork and most activated output neuron is considered as decision | def AI(self):
decision = np.argmax(self.neural_net.feed_forward(self.vision))
if decision == 1:
self.turn_right()
elif decision == 2:
self.turn_left() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def learning_Utility(self):\n # Shape the input that we give to the neural network with the value of sensors, the previous actions the life of the agent \n # Get the results from the sensors according the different movement executed by the agent \n sensors_result_N = self.agent.sensors(self, d... | [
"0.6688485",
"0.6361603",
"0.59948283",
"0.5954132",
"0.58629715",
"0.58203393",
"0.5806262",
"0.5754885",
"0.5748835",
"0.57286066",
"0.5708874",
"0.5706578",
"0.5691866",
"0.5690479",
"0.56737447",
"0.56602836",
"0.5638474",
"0.56360745",
"0.5631764",
"0.5631183",
"0.562801... | 0.70886225 | 0 |
Measures how well the snake is doing as a function of its length and age | def fitness(self):
return (len(self.body)**2) * self.age | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def length_score( canvas ):\n score = 0\n for seqpos, nt in canvas.nucleotides.iteritems():\n if seqpos + 1 not in canvas.nucleotides.keys(): continue\n\n d = distance( nt, canvas.nucleotides[seqpos+1] )\n #print \"Distance between %d and %d is %f\" % (seqpos, seqpos+1, d)\n #scor... | [
"0.60380936",
"0.57333344",
"0.54979473",
"0.5467171",
"0.5467171",
"0.5467171",
"0.544647",
"0.54396564",
"0.538005",
"0.5369122",
"0.53458786",
"0.5312285",
"0.53122807",
"0.53094715",
"0.53053826",
"0.5291157",
"0.5266947",
"0.5255792",
"0.52374715",
"0.52374715",
"0.52200... | 0.5414438 | 8 |
Renders the map (background, walls and food) on the window surface and calls render() of snake Very very very unoptimized since render does not affect the genetic algorithm | def render(self, window):
body = pygame.image.load(IMAGE_SNAKE).convert_alpha() # loading image
for block in self.body:
window.blit(body, (block[0]*SPRITE_SIZE, block[1]*SPRITE_SIZE)) # painting a beautiful snek
if self.neural_net: ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render():\n screen.blit(background ,[0,0]) # paint the background with white colour\n for position in wall_positions:\n screen.blit(wall_surface , position)\n for position in hole_positions:\n screen.blit(hole_surface , position) \n for position in food_positions: \n scre... | [
"0.7684691",
"0.730828",
"0.72512734",
"0.7219235",
"0.706247",
"0.7059873",
"0.7053361",
"0.7049064",
"0.7045334",
"0.7005095",
"0.686253",
"0.6850011",
"0.6842687",
"0.67898893",
"0.67864984",
"0.67463654",
"0.67366016",
"0.6717466",
"0.67080384",
"0.6699559",
"0.667331",
... | 0.70831907 | 4 |
pddf_fanutil Command line utility for providing FAN information | def cli():
global platform_fanutil
global platform_chassis
if os.geteuid() != 0:
click.echo("Root privileges are required for this operation")
sys.exit(1)
# Load the helper class
helper = UtilHelper()
if not helper.check_pddf_mode():
click.echo("PDDF mode should be su... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_fan_util(fan_data):\n sdata = fan_data.split(\"\\n\")\n for line in sdata:\n m = re.match(r\"Fan .*\\sSpeed:\\s+(\\d+)\\s\", line)\n if m is not None:\n return int(m.group(1))\n return -1",
"def usage():",
"def usage():",
"def setup_fan():\n global dev_fan\n ... | [
"0.6178414",
"0.6018657",
"0.6018657",
"0.59550864",
"0.58940756",
"0.5803944",
"0.5769445",
"0.5760094",
"0.5700807",
"0.5637864",
"0.56191415",
"0.5610372",
"0.56093544",
"0.5562641",
"0.54855925",
"0.5466351",
"0.54559624",
"0.5426739",
"0.54131746",
"0.54064846",
"0.53905... | 0.55828595 | 13 |
Display number of FANs installed on device | def numfans():
click.echo(_wrapper_get_num_fans()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_count():\n _check_init()\n return _pypm.CountDevices()",
"def get_num_fans(self):\n return len(self._fan_list)",
"def get_number_of_devices(self):\n return self.drt_manager.get_number_of_devices()",
"def get_display_devs_count(self):\n\t\treturn call_sdk_function('PrlVmCfg_GetDisplayD... | [
"0.6714575",
"0.644456",
"0.6435766",
"0.59978145",
"0.58996135",
"0.58919",
"0.58656466",
"0.5776997",
"0.5773106",
"0.56975675",
"0.56902885",
"0.5675769",
"0.5651405",
"0.56348354",
"0.5632863",
"0.56094426",
"0.56056833",
"0.55822414",
"0.55681175",
"0.55310243",
"0.55297... | 0.6648106 | 1 |
Display FAN airflow direction | def direction(index):
supported_fan = list(range(1, _wrapper_get_num_fans() + 1))
fan_ids = []
if (index < 0):
fan_ids = supported_fan
else:
fan_ids = [index]
header = ['FAN', 'Direction']
status_table = []
for fan in fan_ids:
fan_name = _wrapper_get_fan_name(fan)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_direction(self, feats):\n if feats.name == \"ARNC\":\n if feats[\"z-score\"] < -1.5:\n return Directions.long_dir\n elif feats[\"z-score\"] > 1.5:\n return Directions.short_dir\n elif feats.name == \"UNG\":\n if feats[\"z-scor... | [
"0.571697",
"0.570948",
"0.56856555",
"0.55924267",
"0.55637264",
"0.55029374",
"0.55010337",
"0.54541796",
"0.5447349",
"0.5428513",
"0.5391463",
"0.5365725",
"0.5363149",
"0.52824366",
"0.52821505",
"0.5261962",
"0.52349085",
"0.5229372",
"0.52178097",
"0.51884",
"0.5187201... | 0.66997015 | 0 |
Display FAN speed in RPM | def getspeed(index):
supported_fan = list(range(1, _wrapper_get_num_fans() + 1))
fan_ids = []
if (index < 0):
fan_ids = supported_fan
else:
fan_ids = [index]
if platform_chassis is not None:
header = ['FAN', 'SPEED (RPM)']
else:
header = ['FAN', 'Front Fan RPM', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_fan_speed(self):\n return self.__fan_speed",
"def get_fan_speed(self):\n response = self.parent.fancoolers.get_speed()\n if response is not None:\n response = response[0]\n return response",
"def get_fan_speed_volts(self):\n return self.__fan_speed_raw ... | [
"0.6203536",
"0.59481585",
"0.59469396",
"0.58515924",
"0.5779223",
"0.5757819",
"0.57366604",
"0.5703687",
"0.56516325",
"0.5622664",
"0.5622664",
"0.56049806",
"0.5601598",
"0.5575566",
"0.5564433",
"0.5561737",
"0.5548297",
"0.5547397",
"0.55427736",
"0.5536652",
"0.553567... | 0.6414959 | 0 |
Set FAN speed in percentage | def setspeed(speed):
if speed is None:
click.echo("speed value is required")
raise click.Abort()
for fan in range(_wrapper_get_num_fans()):
status = _wrapper_set_fan_speed(fan, speed)
if not status:
click.echo("Failed")
sys.exit(1)
click.echo("Succes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_fan_speed(self, value):\n self.parent.fancoolers.set_speed(value)",
"async def async_set_percentage(self, percentage: int) -> None:\n self._device.fan_speed = math.ceil(\n percentage_to_ranged_value(self._device.fan_speed_limits, percentage)\n )",
"def set_pwm(self, fan,... | [
"0.6955172",
"0.6838897",
"0.66531014",
"0.66170365",
"0.640071",
"0.6399659",
"0.62479794",
"0.6239728",
"0.62061906",
"0.61876327",
"0.6170493",
"0.6122558",
"0.6093277",
"0.6079112",
"0.6059065",
"0.60427785",
"0.60256606",
"0.5981594",
"0.5981594",
"0.59630585",
"0.595412... | 0.6423588 | 4 |
Dump all Fan related SysFS paths | def dump_sysfs():
for fan in range(_wrapper_get_num_fans()):
status = _wrapper_dump_sysfs(fan)
if status:
for i in status:
click.echo(i) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dump_sysfs():\n for psu in range(_wrapper_get_num_psus()):\n status = _wrapper_dump_sysfs(psu)\n\n if status:\n for i in status:\n click.echo(i)",
"def get_file_systems(self):\n result = {}\n if os.access('/proc/mounts', os.R_OK):\n file = o... | [
"0.6681959",
"0.55133736",
"0.53833324",
"0.5353859",
"0.5342153",
"0.53066385",
"0.5271987",
"0.5269195",
"0.52592564",
"0.5256507",
"0.52527386",
"0.5240411",
"0.5195627",
"0.51453215",
"0.5107888",
"0.50829154",
"0.5072956",
"0.5066273",
"0.5066273",
"0.5060286",
"0.503605... | 0.71562386 | 0 |
Waldencompatible view of this dataset's metadata. | def metadata(self):
return {
"namespace": self.namespace,
"short_name": f"{self.namespace}_{self._dataset_metadata['DatasetCode']}",
"name": f"{self._dataset_metadata['DatasetName']} - FAO ({self.publication_year})",
"description": self._dataset_metadata["DatasetD... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def metadata(self):\n return self.meta.metadata",
"def metadata(self):\r\n return self._metadata",
"def db_metadata(self):\n return self.metadata",
"def metadata(self):\n return self._metadata",
"def metadata(self):\n return self._metadata",
"def metadata(self):\n ... | [
"0.7639628",
"0.7538726",
"0.75340915",
"0.75079805",
"0.75079805",
"0.75079805",
"0.75079805",
"0.75079805",
"0.7485954",
"0.73242635",
"0.73177975",
"0.72954065",
"0.72666806",
"0.7258335",
"0.7184078",
"0.7184078",
"0.7171556",
"0.7165001",
"0.7161704",
"0.7132985",
"0.712... | 0.73774046 | 9 |
Run faostat > walden pipeline. Downloads the dataset from source, uploads it to Walden (DO/S3), creates the corresponding metadata file and places it in the walden local project repository. | def to_walden(self):
with tempfile.NamedTemporaryFile() as f:
# fetch the file locally
files.download(self.source_data_url, f.name)
# add it to walden, both locally, and to our remote file cache
add_to_catalog(self.metadata, f.name, upload=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main(unused_argv):\n make_dir(FLAGS.raw_dir)\n\n # Get paths of download/extracted training and evaluation files.\n print(\"Downloading data from source\")\n train_files = get_raw_files(FLAGS.raw_dir, constants.TRAIN_DATA_SOURCES)\n eval_files = get_raw_files(FLAGS.raw_dir, constants.EVAL_DATA_SOURCES)",
... | [
"0.6101038",
"0.59202915",
"0.58754313",
"0.57625264",
"0.5744202",
"0.5728764",
"0.5715347",
"0.56936353",
"0.5672364",
"0.5663005",
"0.5636707",
"0.5596809",
"0.5572518",
"0.55700964",
"0.5529982",
"0.55235684",
"0.5514555",
"0.55031085",
"0.549753",
"0.5478355",
"0.5470127... | 0.6103682 | 0 |
Analyze the TIFF image header, which is "specific" for Philips/FEI 30XL microscope control software (running under WinNT from early 2000s) | def analyze_header_XL30(imname, allow_underscore_alias=True):
try:
with open(imname, encoding = "ISO-8859-1") as of:
# TODO seek for [DatabarData] first, then count the 194 lines!
ih = dict(l.strip().split(' = ') for l in of.read().split('\n')[:194] if '=' in l)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def verify_header (filename, htypes=None):\n\n # dictionary\n dict_head = {\n # raw header\n # commenting out SIMPLE, BSCALE and BZERO - basic keywords\n # that will be present in images but not in binary fits tables\n #'SIMPLE': {'htype':'raw', 'dtype':bool, 'DB':False, 'None_... | [
"0.6709758",
"0.63940704",
"0.6387472",
"0.6311921",
"0.627738",
"0.62717474",
"0.62314963",
"0.62271684",
"0.61668515",
"0.61574554",
"0.60508275",
"0.6018981",
"0.60126644",
"0.6010723",
"0.59902763",
"0.593532",
"0.5927394",
"0.5897869",
"0.57868385",
"0.57868385",
"0.5757... | 0.66334915 | 1 |
For a given set of dimensionless heat capacity data `Cvlist` corresponding to temperature list `Tlist` in K, fit `Nvib` harmonic oscillator and `Nrot` hindered internal rotor modes. External and other previouslyknown modes should have already been removed from `Cvlist` prior to calling this function. You must provide a... | def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):
# You must specify at least 7 heat capacity points to use in the fitting;
# you can specify as many as you like above that minimum
if len(Tlist) < 7:
raise StatmechFitError('You must specify at least 7 heat capacity points to ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # Construct the lower and upper bounds for each variable\n bounds = []\n # Bounds for harmonic oscillator frequencies\n for i in range(Nvib):\n bounds.append((hoFreqLowerBound, hoFreqUpperBound))\n # Bounds for hindered roto... | [
"0.6258205",
"0.59177995",
"0.57747304",
"0.53855324",
"0.52379996",
"0.5189323",
"0.51705194",
"0.5094938",
"0.5057895",
"0.49590996",
"0.49028978",
"0.48883164",
"0.4881741",
"0.48618186",
"0.48579624",
"0.4830536",
"0.47857985",
"0.47836864",
"0.47786778",
"0.47585952",
"0... | 0.6634018 | 0 |
Fit `Nvib` harmonic oscillator and `Nrot` hindered internal rotor modes to the provided dimensionless heat capacities `Cvlist` at temperatures `Tlist` in K. This method assumes that there are enough heat capacity points provided that the vibrational frequencies and hindered rotation frequency barrier pairs can be fit d... | def fitStatmechDirect(Tlist, Cvlist, Nvib, Nrot, molecule=None):
# Construct the lower and upper bounds for each variable
bounds = []
# Bounds for harmonic oscillator frequencies
for i in range(Nvib):
bounds.append((hoFreqLowerBound, hoFreqUpperBound))
# Bounds for hindered rotor frequencie... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity ... | [
"0.7132348",
"0.6019964",
"0.57076234",
"0.5255491",
"0.5208966",
"0.50486803",
"0.49962127",
"0.49387914",
"0.48546904",
"0.47602648",
"0.4752867",
"0.47441545",
"0.47350878",
"0.47301233",
"0.4673184",
"0.46208584",
"0.46154496",
"0.46078372",
"0.45996413",
"0.45746738",
"0... | 0.6103077 | 1 |
Fit `Nvib` harmonic oscillator and `Nrot` hindered internal rotor modes to the provided dimensionless heat capacities `Cvlist` at temperatures `Tlist` in K. This method assumes that there are enough heat capacity points provided that the vibrational frequencies can be fit directly, but the hindered rotors must be combi... | def fitStatmechPseudoRotors(Tlist, Cvlist, Nvib, Nrot, molecule=None):
# Construct the lower and upper bounds for each variable
bounds = []
# Bounds for harmonic oscillator frequencies
for i in range(Nvib):
bounds.append((hoFreqLowerBound, hoFreqUpperBound))
# Bounds for pseudo-hindered rot... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity ... | [
"0.7044471",
"0.6196605",
"0.60360116",
"0.50493073",
"0.50484276",
"0.5042975",
"0.48713553",
"0.47226658",
"0.46531764",
"0.4640844",
"0.46398926",
"0.45862988",
"0.45844907",
"0.45613056",
"0.4558295",
"0.45362642",
"0.4533591",
"0.45092642",
"0.4467235",
"0.44669557",
"0.... | 0.6537572 | 1 |
Fit `Nvib` harmonic oscillator and `Nrot` hindered internal rotor modes to the provided dimensionless heat capacities `Cvlist` at temperatures `Tlist` in K. This method assumes that there are relatively few heat capacity points provided, so the vibrations must be combined into one real vibration and two "pseudovibratio... | def fitStatmechPseudo(Tlist, Cvlist, Nvib, Nrot, molecule=None):
# Construct the lower and upper bounds for each variable
bounds = []
# x[0] corresponds to the first harmonic oscillator (real) frequency
bounds.append((hoFreqLowerBound, hoFreqUpperBound))
# x[1] corresponds to the degeneracy of the... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fitStatmechToHeatCapacity(Tlist, Cvlist, Nvib, Nrot, molecule=None):\n\n # You must specify at least 7 heat capacity points to use in the fitting;\n # you can specify as many as you like above that minimum\n if len(Tlist) < 7:\n raise StatmechFitError('You must specify at least 7 heat capacity ... | [
"0.68661004",
"0.631563",
"0.6123873",
"0.5089853",
"0.50879455",
"0.49770182",
"0.4871406",
"0.48591155",
"0.484959",
"0.47010407",
"0.4681783",
"0.46318635",
"0.45723057",
"0.45695278",
"0.45665184",
"0.4564709",
"0.45531625",
"0.4551914",
"0.45249",
"0.4496649",
"0.4472451... | 0.5910316 | 3 |
Return the heat capacity in J/molK at the given set of temperatures `Tlist` in K for the harmonic oscillator with a frequency `freq` in cm^1. | def harmonicOscillator_heatCapacity(T, freq):
x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K
exp_x = math.exp(x)
one_minus_exp_x = 1.0 - exp_x
return x * x * exp_x / one_minus_exp_x / one_minus_exp_x | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getHeatCapacity(self, Tlist):\n\t\treturn _modes.harmonicoscillator_heatcapacity(Tlist, self.frequency) * self.degeneracy",
"def harmonicOscillator_d_heatCapacity_d_freq(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n re... | [
"0.7163064",
"0.71257627",
"0.68290627",
"0.6795192",
"0.6786145",
"0.6622097",
"0.64092433",
"0.62078923",
"0.6155763",
"0.60118943",
"0.5884279",
"0.5819744",
"0.5750861",
"0.57141733",
"0.56468594",
"0.5608937",
"0.5543009",
"0.5515287",
"0.5447956",
"0.53431475",
"0.53323... | 0.7431342 | 0 |
Return the first derivative of the heat capacity with respect to the harmonic oscillator frequency in J/molK/cm^1 at the given set of temperatures `Tlist` in K, evaluated at the frequency `freq` in cm^1. | def harmonicOscillator_d_heatCapacity_d_freq(T, freq):
x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K
exp_x = math.exp(x)
one_minus_exp_x = 1.0 - exp_x
return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2.0 + x + 2.0 * x * exp_x / one_minus_exp_x) * x / freq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def harmonicOscillator_heatCapacity(T, freq):\n x = freq / (0.695039 * T) # kB = 0.695039 cm^-1/K\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * x * exp_x / one_minus_exp_x / one_minus_exp_x",
"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * c... | [
"0.66852283",
"0.6590223",
"0.621406",
"0.61375594",
"0.58432394",
"0.5664569",
"0.5585242",
"0.55327094",
"0.5501561",
"0.5434934",
"0.5308666",
"0.5281351",
"0.5243485",
"0.52303797",
"0.5228673",
"0.51834196",
"0.5166179",
"0.51437104",
"0.51344746",
"0.5100388",
"0.508913... | 0.75777584 | 0 |
Return the heat capacity in J/molK at the given set of temperatures `Tlist` in K for the 1D hindered rotor with a frequency `freq` in cm^1 and a barrier height `barr` in cm^1. | def hinderedRotor_heatCapacity(T, freq, barr):
x = constants.h * constants.c * 100. * freq / constants.kB / T
exp_x = math.exp(x)
one_minus_exp_x = 1.0 - exp_x
z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T
BB = scipy.special.i1(z) / scipy.special.i0(z)
return x * x * exp_x... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr",
"def hinderedRotor_d_heatCapacity_d_freq(T, freq, ba... | [
"0.6776927",
"0.6629585",
"0.6302823",
"0.6265761",
"0.6249234",
"0.6213433",
"0.61068034",
"0.59889144",
"0.5958544",
"0.59443885",
"0.58387303",
"0.5672785",
"0.5489304",
"0.535626",
"0.5331149",
"0.5270583",
"0.5189233",
"0.5121388",
"0.49093267",
"0.48052287",
"0.47886142... | 0.68888056 | 0 |
Return the first derivative of the heat capacity with respect to the hindered rotor frequency in J/molK/cm^1 at the given set of temperatures `Tlist` in K, evaluated at the frequency `freq` in cm^1 and a barrier height `barr` in cm^1. | def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):
x = constants.h * constants.c * 100. * freq / constants.kB / T
exp_x = math.exp(x)
one_minus_exp_x = 1.0 - exp_x
return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):\n z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T\n BB = scipy.special.i1(z) / scipy.special.i0(z)\n return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr",
"def hinderedRotor_heatCapacity(T, freq, barr):\n ... | [
"0.71285737",
"0.6478923",
"0.6444968",
"0.5749547",
"0.56793684",
"0.5572982",
"0.54065436",
"0.53827864",
"0.5258031",
"0.5257182",
"0.52520823",
"0.519607",
"0.50965065",
"0.49622813",
"0.49369383",
"0.49278474",
"0.48772767",
"0.4856664",
"0.48498905",
"0.48304605",
"0.47... | 0.7382771 | 0 |
Return the first derivative of the heat capacity with respect to the hindered rotor frequency in J/molK/cm^1 at the given set of temperatures `Tlist` in K, evaluated at the frequency `freq` in cm^1 and a barrier height `barr` in cm^1. | def hinderedRotor_d_heatCapacity_d_barr(T, freq, barr):
z = 0.5 * constants.h * constants.c * 100. * barr / constants.kB / T
BB = scipy.special.i1(z) / scipy.special.i0(z)
return z * (1 - 2 * z * BB + BB * BB + 2 * z * BB * BB * BB) * z / barr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hinderedRotor_d_heatCapacity_d_freq(T, freq, barr):\n x = constants.h * constants.c * 100. * freq / constants.kB / T\n exp_x = math.exp(x)\n one_minus_exp_x = 1.0 - exp_x\n return x * exp_x / one_minus_exp_x / one_minus_exp_x * (2 + x + 2 * x * exp_x / one_minus_exp_x) * x / freq",
"def hinderedR... | [
"0.73835194",
"0.64815336",
"0.64464134",
"0.57504225",
"0.5682341",
"0.557329",
"0.54102564",
"0.53866494",
"0.5260977",
"0.5259946",
"0.5251516",
"0.5194793",
"0.5095279",
"0.49629185",
"0.4936573",
"0.49281287",
"0.48756847",
"0.48563507",
"0.48486865",
"0.4834765",
"0.479... | 0.71289545 | 1 |
compute the n period relative strength indicator | def relative_strength(prices, n):
deltas = np.diff(prices)
seed = deltas[:n+1] # takes the last 1 price differences? 12 market days?
up = seed[seed>=0].sum()/n
down = -seed[seed<0].sum()/n
rs = up/down
rsi = np.zeros_like(prices)
rsi[:n] = 100. - 100./(1.+rs)
for i in range(n, len(pric... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calculateRelativeStrengthIndex(self, series, interval=14):\n\n if not isinstance(series, pd.Series):\n raise TypeError('Pandas Series required.')\n\n if not isinstance(interval, int):\n raise TypeError('Interval integer required.')\n\n if(len(series) < interval):\n ... | [
"0.62993854",
"0.6251063",
"0.62505263",
"0.61611295",
"0.6143028",
"0.5975309",
"0.5954106",
"0.58517736",
"0.5804187",
"0.57787424",
"0.57643014",
"0.5751086",
"0.5728138",
"0.5679147",
"0.56747293",
"0.5648136",
"0.56302524",
"0.56128484",
"0.55958307",
"0.556552",
"0.5563... | 0.66415566 | 0 |
r"""Encodes the input by passing through the encoder network and returns the latent codes. | def encode(self, inputs):
result = self.encoder(inputs) # [N x 512 x 4 x 4]
result = torch.flatten(result, start_dim=1) # [N x 8192]
return self.fc_mu(result), self.fc_var(result) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def encoder(self, inputs):\n pass",
"def encode(self):\n with tf.name_scope(\"encode\"):\n self.encoder_inputs = tf.layers.dense(\n inputs=self.encoder_inputs,\n units=self.options['hidden_size'], activation=None, use_bias=True,\n kernel_initi... | [
"0.7359279",
"0.715711",
"0.7042397",
"0.6925385",
"0.67847055",
"0.6707564",
"0.6687429",
"0.66821134",
"0.66587514",
"0.6600888",
"0.65923876",
"0.65555626",
"0.6519889",
"0.64369076",
"0.6398737",
"0.634382",
"0.6303421",
"0.6291561",
"0.6290792",
"0.6282953",
"0.6275337",... | 0.65906525 | 11 |
r"""Maps the given latent codes onto the image space. | def decode(self, z):
result = self.decoder_input(z)
result = result.view(-1, 512, 4, 4)
result = self.decoder(result)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def preprocess(self, latent_codes, **kwargs):\n raise NotImplementedError(f'Should be implemented in derived class!')",
"def prepare_map(self):\n for y_coord, row in enumerate(self.contents):\n for x_coord, tile in enumerate(row):\n bit_map = self.get_tile_bitmap(tile)\n ... | [
"0.6005514",
"0.5933257",
"0.5838075",
"0.5818631",
"0.5656862",
"0.56560636",
"0.56560636",
"0.56314653",
"0.5581515",
"0.55739915",
"0.55533266",
"0.55513483",
"0.55221444",
"0.54776543",
"0.5458927",
"0.5432332",
"0.5427928",
"0.53670174",
"0.5355888",
"0.53041667",
"0.530... | 0.0 | -1 |
r"""Reparameterization trick to sample from N(mu, var) from N(0,1). | def reparameterize(self, mu, log_var):
std = torch.exp(0.5 * log_var)
eps = torch.randn_like(std)
return eps * std + mu | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _reparameterized_sample(self, mean, std):\n eps = torch.zeros(std.size(), device=self.device, dtype=torch.float32).normal_()\n eps = eps.requires_grad_()\n return eps.mul(std).add_(mean)",
"def sample_low_rank(self, n_samples, mu, logvar, F):\n #F = torch.unsqueeze(F, dim=1).repea... | [
"0.6662356",
"0.65233475",
"0.65074307",
"0.644771",
"0.6394351",
"0.6394351",
"0.6386821",
"0.63468987",
"0.6301969",
"0.6298426",
"0.62799734",
"0.62720144",
"0.6258597",
"0.6256825",
"0.6253637",
"0.6253637",
"0.6253637",
"0.6253637",
"0.6253637",
"0.6240244",
"0.62155056"... | 0.6309882 | 8 |
r"""Computes the VAE loss function. KL(N(\mu, \sigma), N(0, 1)) = \log \frac{1}{\sigma} + \frac{\sigma^2 + \mu^2}{2} \frac{1}{2} | def loss_fn(self, recons, inputs, mu, log_var, **kwargs):
# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset
recons_loss = F.mse_loss(recons, inputs)
# recons_loss = F.binary_cross_entropy(recons, inputs)
KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def vae_loss(recon_x, x, mu_logvar):\n mu = mu_logvar[:, 0:int(mu_logvar.size()[1]/2)]\n logvar = mu_logvar[:, int(mu_logvar.size()[1]/2):]\n# KLD = -0.5 * torch.sum(1 + 2 * logvar - mu.pow(2) - (2 * logvar).exp())\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n# BCE = F.binary_c... | [
"0.71050805",
"0.6940623",
"0.6602319",
"0.6597178",
"0.6597178",
"0.6597178",
"0.6597178",
"0.6519826",
"0.6477681",
"0.64758873",
"0.64575756",
"0.64531076",
"0.64357793",
"0.63821673",
"0.63579816",
"0.631307",
"0.6311189",
"0.6289294",
"0.62851536",
"0.6265628",
"0.625308... | 0.6408748 | 13 |
r"""Samples from the latent space and return the corresponding image space map. | def sample(self, num_samples, current_device, **kwargs):
z = torch.randn(num_samples, self.latent_dim)
z = z.to(current_device)
samples = self.decode(z)
return samples | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map_to_latent_space(data_sample, model) -> np.ndarray: # [N x Z]\n\n latent_coords = []\n\n for batch in data_sample:\n # run encoder\n coords = model.encoder(batch)\n latent_coords.append(coords)\n\n # return latent (per jet?)\n return np.concatenate(latent_coords, axis=0)",
... | [
"0.61733603",
"0.6100167",
"0.60555536",
"0.59709185",
"0.59704363",
"0.5918826",
"0.5892295",
"0.58649856",
"0.5847293",
"0.581955",
"0.58138406",
"0.5768181",
"0.5711329",
"0.57023966",
"0.5692044",
"0.56795436",
"0.5646572",
"0.5634537",
"0.5623634",
"0.5615229",
"0.561106... | 0.5777933 | 11 |
r"""Given an input image x, returns the reconstructed image | def generate(self, x):
return self.forward(x)[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recreate_image(x):\n reverse_mean = [-0.485, -0.456, -0.406]\n reverse_std = [1/0.229, 1/0.224, 1/0.225]\n in_channel = x.shape[-1]\n recreated_im = copy.copy(x) # C, H, W\n if in_channel == 3:\n for c in range(in_channel):\n recreated_im[:, :, c] /= reverse_std[c]\n ... | [
"0.7366667",
"0.6921181",
"0.6734784",
"0.6608169",
"0.6577374",
"0.64686996",
"0.64662826",
"0.6452119",
"0.6434497",
"0.62245506",
"0.62063634",
"0.62025005",
"0.6197715",
"0.6181233",
"0.61551434",
"0.6153792",
"0.61470103",
"0.6140627",
"0.6138117",
"0.61186534",
"0.61101... | 0.0 | -1 |
Get account data from SWAG (via S3) | def get_swag():
swag_opts = {
'swag.type': 's3',
'swag.bucket_name': CONFIG.swag_bucket,
'swag.data_file': CONFIG.swag_data_file,
'swag.region': CONFIG.swag_region,
'swag.cache_expires': 0
}
return SWAGManager(**parse_swag_config_options(swag_opts)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_usofa_data(bucketname):\n client = boto3.client('s3')\n result = client.get_object(Bucket=bucketname, Key='accounts.json')\n return json.loads(result['Body'].read().decode('utf-8'))",
"def s3_read_data(self):\n\n self.k.open()\n self.k.read()",
"def __retrieve_from_bucket(fname):\n b... | [
"0.678359",
"0.67407",
"0.65665984",
"0.64687663",
"0.62724787",
"0.6271271",
"0.61905503",
"0.6168407",
"0.6160477",
"0.6136951",
"0.613336",
"0.6129173",
"0.61195844",
"0.61035234",
"0.6100174",
"0.60862297",
"0.6084497",
"0.60571164",
"0.6030108",
"0.5998103",
"0.59974277"... | 0.0 | -1 |
Given a network G, a dict of characteristics chars for node IDs, and dict of node IDs for each node in the network, find the homophily of the network. | def homophily(G, chars, IDs):
num_same_ties = 0
num_ties = 0
for n1, n2 in G.edges():
if IDs[n1] in chars and IDs[n2] in chars:
if G.has_edge(n1, n2):
num_ties += 1
if chars[IDs[n1]] == chars[IDs[n2]]:
num_same_ties += 1
return (num... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_Motifs(H, m):\n\t#This function will take each possible subgraphs of gr of size 3, then\n\t#compare them to the mo dict using .subgraph() and is_isomorphic\n\t\n\t#This line simply creates a dictionary with 0 for all values, and the\n\t#motif names as keys\n\n\t##paper source \"Higher-order organization ... | [
"0.63757825",
"0.61899877",
"0.60356104",
"0.6001322",
"0.59994",
"0.5963691",
"0.59627503",
"0.5926058",
"0.5918671",
"0.59054536",
"0.582346",
"0.5799736",
"0.5697312",
"0.5679989",
"0.5668",
"0.5662608",
"0.5636551",
"0.5565752",
"0.5540963",
"0.553925",
"0.5511987",
"0.... | 0.6105953 | 2 |
Agent which implements Q Learning | def __init__(self, state_shape: tuple, action_shape: tuple, name: str, side: str = "up", epsilon: float = 0.0,
intervall_turns_train: int = np.Inf, intervall_turns_load: int = np.Inf,
save_path: str = "../data/modeldata/q/model.ckpt", caching: bool = False,
config: Con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0, **args):\n args['epsilon'] = epsilon\n args['gamma'] = gamma\n args['alpha'] = alpha\n args['numTraining'] = numTraining\n QLearningAgent.__init__(self, **args)",
"def __init__(self, epsilon=0.05,gamma=0.8,alpha=0.2, numTraining=0... | [
"0.7534157",
"0.72916085",
"0.7178249",
"0.70445454",
"0.7",
"0.6985736",
"0.6985736",
"0.6985736",
"0.689876",
"0.68947405",
"0.6880697",
"0.68613094",
"0.6834198",
"0.6831387",
"0.6820141",
"0.6799026",
"0.6772288",
"0.6765899",
"0.67192644",
"0.6704822",
"0.66806555",
"0... | 0.0 | -1 |
triggered by get play turn method of super class. This is the method were the magic should happen that chooses the right action | def decision(self, state_space: np.ndarray, action_space: ActionSpace):
# preprocess state space
# normalizing state space between zero and one ( 2 is max value of stone and -2 is min value of stone
state_space = min_max_scaling(state_space)
state_space = state_space.reshape(1, multiply(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def turn(self):\n pass",
"def play(self, player, game): \n super().play(player, game)\n game.set_action(\"SLEEP_CODER\")",
"def game_play(self):",
"def play(self, player, game):\n super().play(player, game)\n game.set_action(\"STEAL_CODER\")",
"def begin_turn(self)... | [
"0.7292713",
"0.7109823",
"0.7075418",
"0.7049332",
"0.695085",
"0.68663824",
"0.6862658",
"0.67548853",
"0.67518234",
"0.67462504",
"0.67203665",
"0.6714001",
"0.66854596",
"0.66723174",
"0.6632199",
"0.65679246",
"0.6557006",
"0.6557006",
"0.65565354",
"0.6540824",
"0.65384... | 0.0 | -1 |
pick actions given qvalues. Uses epsilongreedy exploration strategy. | def _sample_actions(self, qvalues: np.ndarray, action_space: ActionSpace):
epsilon = self.epsilon
batch_size, x = qvalues.shape
dim = int(x ** 0.25)
qvalues_reshaped = np.reshape(qvalues, (dim, dim, dim, dim))
if random.random() < epsilon:
keys = [key for key in actio... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def select_action(self, q_values):\n assert q_values.ndim == 1\n q_values = q_values.astype('float64')\n nb_actions = q_values.shape[0]\n\n exp_values = np.exp(np.clip(q_values / self.tau, self.clip[0], self.clip[1]))\n probs = exp_values / np.sum(exp_values)\n action = np... | [
"0.760534",
"0.75458944",
"0.7489394",
"0.7308543",
"0.7302607",
"0.7277997",
"0.7277997",
"0.7277997",
"0.70307344",
"0.68159276",
"0.6684784",
"0.6582526",
"0.6519748",
"0.6445827",
"0.6419524",
"0.64174616",
"0.6408558",
"0.6391456",
"0.63895744",
"0.6350018",
"0.6345844",... | 0.65002364 | 13 |
takes agent's observation, returns qvalues. Both are tf Tensors | def _get_qvalues(self, state_t):
qvalues = self.network(state_t)
return qvalues | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_q_values(self, observations, twin_q=False):\n if twin_q:\n q_model = self.twin_q_model\n else:\n q_model = self.main_q_model\n\n q_vals = q_model([observations[self.vf_obs_key]])\n return tf.reshape(q_vals, [-1, self.num_outputs])",
"def get_qvalues(self,... | [
"0.75412387",
"0.7281996",
"0.71252626",
"0.69886816",
"0.6963875",
"0.6963875",
"0.69577503",
"0.68997633",
"0.65830016",
"0.6473342",
"0.6445998",
"0.64198893",
"0.63429874",
"0.6339201",
"0.63150895",
"0.63051134",
"0.63030916",
"0.6275476",
"0.62655336",
"0.6251307",
"0.6... | 0.64679205 | 10 |
assign target_network.weights variables to their respective agent.weights values. | def load_weigths_into_target_network(self):
logging.debug("Transfer Weight!")
self.network.save_weights(self._save_path)
self.target_network.load_weights(self._save_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_target_network(self):\n self.target.set_weights(self.policy.get_weights()) # Update weights of target network with weights of policy network",
"def transfer_weights(self):\n W, target_W = self.model.get_weights(), self.target_model.get_weights()\n for i in range(len(W)):\n ... | [
"0.74298966",
"0.7240756",
"0.7069389",
"0.70639586",
"0.6890794",
"0.6858491",
"0.68172055",
"0.67953044",
"0.66856223",
"0.6684053",
"0.6666912",
"0.66301864",
"0.66301864",
"0.66301864",
"0.6627997",
"0.6626138",
"0.66244763",
"0.6613709",
"0.6606935",
"0.65739423",
"0.657... | 0.7086991 | 2 |
relative if true, the exclusion of the ratios (relative to the inputs given) are plotted. If False, these ratios are multiplied by the SM cross sections and branching ratios into gamma gamma inputIsAbs is a list (set) of file names which should be treated as if they had ABSOLUTE limits on cross sections rather than rel... | def makePlot(csvFnames, relative, includeExpected = True, fermiophobic = None, ymax = None, inputIsAbs = None, drawXsectBR = False,
minMass = None,
maxMass = None,
plotLog = False
):
#--------------------
# read the files
#--------------------... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plotBatch(inp,output='spectra_plot.pdf',comparisons=None,classify=False,normalize=False,normrange=[0.9,1.4],layout=[2,2],basecolors=['k','m'],legend=[],fontscale=0.7,classify_kwargs={},plot_kwargs={},**kwargs):\n\n# alt keyword check\n for k in ['file','filename']: \n if kwargs.get(k,'') != '': outpu... | [
"0.5534918",
"0.515236",
"0.51322854",
"0.49179512",
"0.48812607",
"0.48483542",
"0.4839429",
"0.47949347",
"0.47881106",
"0.47665024",
"0.47452495",
"0.4722007",
"0.47154492",
"0.46393847",
"0.462126",
"0.46191898",
"0.460472",
"0.46012208",
"0.4596538",
"0.4591982",
"0.4580... | 0.60177034 | 0 |
Generates a string of chuncks from an initial chunk. | def chunk_seq(f, text, order=3, length=50):
next_chunk = text[-1]
chunklist = next_chunk.split()
while len(text) * order < length:
candidates = gather_next_chunks(f, chunklist, order) #1
candidates_edited = edit_chunks(candidates)
#print candidates_edited
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chunkify(msg):\n return [\"%s %s\" % (i, msg[i*158 : (i+1)*158]) for i in range(len(msg)/158 + 1)]",
"def getChunks():",
"def full_chromosomes(reader):\n for line in reader.header.get_lines(\"contig\"):\n if line.id in CHROMS:\n name = line.id\n length = line.length or 1_... | [
"0.54023075",
"0.5305364",
"0.5266323",
"0.52563137",
"0.5210865",
"0.51348937",
"0.5116953",
"0.50660634",
"0.5042289",
"0.50343066",
"0.5030568",
"0.5028163",
"0.50268525",
"0.5004204",
"0.49979058",
"0.4997518",
"0.49932313",
"0.49587467",
"0.4947032",
"0.49435583",
"0.491... | 0.0 | -1 |
Test the CommandList class | def test_CommandList():
from paradrop.confd.command import CommandList
clist = CommandList()
clist.append(20, "b")
clist.append(20, "c")
clist.append(10, "a")
commands = list(clist.commands())
assert commands == ["a", "b", "c"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_arg_parser_list(self):\n args = self.parser.parse_args(['list'])\n self.assertEqual(args.command, 'list')",
"def test_listCommand(self):\n acli = ArmiCLI()\n\n origout = sys.stdout\n try:\n out = io.StringIO()\n sys.stdout = out\n acli.... | [
"0.7797336",
"0.7349881",
"0.72588724",
"0.72235614",
"0.72235614",
"0.7143625",
"0.71298486",
"0.70965886",
"0.68910056",
"0.68389577",
"0.68290025",
"0.6811658",
"0.67939836",
"0.6771567",
"0.6757199",
"0.6725292",
"0.669489",
"0.6669298",
"0.65990645",
"0.6597851",
"0.6595... | 0.81857985 | 0 |
Test the Command.execute method | def test_Command_execute(Popen, out):
from paradrop.confd.command import Command
proc = MagicMock()
proc.stdout = ["output"]
proc.stderr = ["error"]
Popen.return_value = proc
command = Command(["callme"])
command.parent = MagicMock()
command.execute()
assert out.verbose.called_onc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def execute():\n pass",
"def test_command(self):\n output, _error = self.executor.command(['echo', 'hello']).batch()\n self.assertEqual(output, 'hello\\n')",
"def execute_command(self):\n raise Exception(\"Not implemented\")",
"def test_command(self):\n\n expected = \"PyFun... | [
"0.76571196",
"0.76401484",
"0.76354915",
"0.7635409",
"0.75945634",
"0.73478067",
"0.73478067",
"0.73478067",
"0.73478067",
"0.73478067",
"0.73478067",
"0.73469025",
"0.7315164",
"0.7250304",
"0.7222985",
"0.72060025",
"0.72060025",
"0.72060025",
"0.72060025",
"0.72033477",
... | 0.6589691 | 69 |
Test the KillCommand class | def test_KillCommand(execute):
from paradrop.confd.command import KillCommand
# Test with a numeric pid.
command = KillCommand(12345)
assert command.getPid() == 12345
expected = ["kill", "12345"]
command.execute()
assert execute.called_once_with(expected)
execute.reset_mock()
pid... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_kill(self):\n A = ConwayAgent(23, True)\n self.assertTrue(A.status() == 1)\n A.kill()\n self.assertTrue(A.status() == 0)",
"def remote_kill():",
"def test_build_kill_command(self):\n actual_result = IperfKillCommandBuilder(SERVER_USER)\\\n .set_ip_address(... | [
"0.7480365",
"0.71652985",
"0.6940902",
"0.6931124",
"0.6846783",
"0.6776122",
"0.6691397",
"0.6687754",
"0.6556142",
"0.6425788",
"0.64247656",
"0.6313827",
"0.6313541",
"0.6313541",
"0.63063496",
"0.62784046",
"0.6265679",
"0.6265679",
"0.62479097",
"0.6243085",
"0.6227352"... | 0.7495398 | 0 |
A hook to start the Selenium Server provided with SeleniumLibrary. `logfile` must be either an opened file (or filelike object) or None. If not None, Selenium Server log will be written to it. `jarpath` must be either the absolute path to the seleniumserver.jar or None. If None, the jar file distributed with the librar... | def start_selenium_server(logfile=None, jarpath=None, *params):
if not subprocess:
raise RuntimeError('This function requires `subprocess` module which '
'is available on Python/Jython 2.5 or newer.')
cmd = _server_startup_command(jarpath, *params)
try:
subprocess.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_selenium_server(self, *params):\n params = ('-port', str(self._server_port)) + params\n logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')\n self._selenium_log = open(logpath, 'w')\n start_selenium_server(self._selenium_log, self._jar_path, *params)\n ... | [
"0.6576157",
"0.59147495",
"0.551453",
"0.5020369",
"0.4867105",
"0.48326635",
"0.48120183",
"0.48082626",
"0.4748094",
"0.4661346",
"0.4636292",
"0.46114662",
"0.4580532",
"0.4558185",
"0.45508748",
"0.45206273",
"0.45122933",
"0.44885132",
"0.4487213",
"0.44591105",
"0.4454... | 0.81625164 | 0 |
Shuts down the Selenium Server. `host` and `port` define where the location of Selenium Server. Does not fail even if the Selenium Server is not running. | def shut_down_selenium_server(host='localhost', port=4444):
try:
selenium(host, port, '', '').shut_down_selenium_server()
except socket.error:
pass | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_selenium_server(self):\n shut_down_selenium_server(self._server_host, self._server_port)\n self._selenium = NoBrowserOpen()\n if self._selenium_log:\n self._selenium_log.close()",
"def shutdown(self):\n # TODO: Build a certificate chain so we can verify our localho... | [
"0.6310834",
"0.6110192",
"0.6078012",
"0.59138757",
"0.57922274",
"0.5763965",
"0.56827766",
"0.566105",
"0.55425066",
"0.55398613",
"0.5532105",
"0.5505663",
"0.54810226",
"0.5456112",
"0.5435537",
"0.5409633",
"0.5404485",
"0.5392909",
"0.53838885",
"0.53706366",
"0.532538... | 0.8380863 | 0 |
SeleniumLibrary can be imported with optional arguments. `timeout` is the default timeout used to wait for page load actions. It can be later set with `Set Selenium Timeout` `server_host` and `server_port` are used to connect to Selenium Server. Browsers opened with this SeleniumLibrary instance will be attached to tha... | def __init__(self, timeout=5.0, server_host='localhost', server_port=4444,
jar_path=None, run_on_failure='Capture Screenshot'):
self._cache = utils.ConnectionCache()
self._selenium = NoBrowserOpen()
self.set_selenium_timeout(timeout or 5.0)
self._server_host, self._serve... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, driver_path: str = None, waiter_timeout: int = 3, options: List[str] = None):\n\n # selecting driver\n if not driver_path:\n driver = webdriver.Firefox\n driver_options = FireFoxOptions()\n else:\n driver = webdriver.Chrome\n drive... | [
"0.5883255",
"0.5759221",
"0.57567716",
"0.5650392",
"0.5649762",
"0.55207306",
"0.5444826",
"0.53997815",
"0.535544",
"0.5268799",
"0.5228582",
"0.5209584",
"0.5167454",
"0.5134206",
"0.50916547",
"0.50906485",
"0.505967",
"0.5057035",
"0.50250274",
"0.49927777",
"0.49799502... | 0.5961083 | 0 |
The selenium remote control instance of currently active browser. | def selenium(self):
return self._selenium | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_webdriver_instance():\n return selenium._current_browser()\n # return PageBase.get_selenium2library_instance()._current_browser()",
"def remote_control(self) -> interface.RemoteControl:\n return cast(interface.RemoteControl, self._interfaces[interface.RemoteControl])",
"def get_ins... | [
"0.71983075",
"0.6925138",
"0.64066046",
"0.6203262",
"0.6168742",
"0.5982635",
"0.5981238",
"0.5977537",
"0.58916575",
"0.5799441",
"0.57358706",
"0.572651",
"0.57153845",
"0.5688557",
"0.5687891",
"0.56801546",
"0.56783015",
"0.5634735",
"0.5615675",
"0.5575124",
"0.5522626... | 0.62758404 | 3 |
Starts the Selenium Server provided with SeleniumLibrary. `params` can contain additional command line options given to the Selenium Server. This keyword uses some command line options | def start_selenium_server(self, *params):
params = ('-port', str(self._server_port)) + params
logpath = os.path.join(self._get_log_dir(), 'selenium_server_log.txt')
self._selenium_log = open(logpath, 'w')
start_selenium_server(self._selenium_log, self._jar_path, *params)
self._ht... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def start_selenium_server(logfile=None, jarpath=None, *params):\n if not subprocess:\n raise RuntimeError('This function requires `subprocess` module which '\n 'is available on Python/Jython 2.5 or newer.')\n cmd = _server_startup_command(jarpath, *params)\n try:\n ... | [
"0.62242675",
"0.58627564",
"0.56516945",
"0.56402934",
"0.56345683",
"0.56059575",
"0.56059575",
"0.5513187",
"0.5233649",
"0.5220939",
"0.51877004",
"0.51692015",
"0.51691693",
"0.5165994",
"0.51010007",
"0.50910467",
"0.50774854",
"0.5061027",
"0.50559413",
"0.5016454",
"0... | 0.6509325 | 0 |
Stops the selenium server (and closes all browsers). | def stop_selenium_server(self):
shut_down_selenium_server(self._server_host, self._server_port)
self._selenium = NoBrowserOpen()
if self._selenium_log:
self._selenium_log.close() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def stop_browser(self):\n self.driver.quit()",
"def shut_down_selenium_server(host='localhost', port=4444):\n try:\n selenium(host, port, '', '').shut_down_selenium_server()\n except socket.error:\n pass",
"def __exit__(self, exc_type, exc_val, exc_tb):\n self.server.stop()\n ... | [
"0.7995364",
"0.7863133",
"0.7835495",
"0.74924666",
"0.7464111",
"0.7453941",
"0.7446109",
"0.7424754",
"0.7343588",
"0.73252535",
"0.7277652",
"0.72618127",
"0.7260277",
"0.7200706",
"0.71930265",
"0.71509975",
"0.7085253",
"0.70522535",
"0.7039435",
"0.7002137",
"0.699096"... | 0.83716977 | 0 |
Sets the timeout used by various keywords. Keywords that expect a page load to happen will fail if the page is not loaded within the timeout specified with `seconds`. Starting from SeleniumLibrary 2.6, this timeout is also the default timeout with various `Wait ...` keywords. See `introduction` for more information abo... | def set_selenium_timeout(self, seconds):
timeout = utils.timestr_to_secs(seconds)
old = getattr(self, '_timeout', timeout)
self._timeout = timeout
self._selenium.set_timeout(timeout * 1000)
return utils.secs_to_timestr(old) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_timeout(self, seconds):\n self._timeout = seconds",
"def timeout_seconds(self, timeout_seconds):\n\n self._timeout_seconds = timeout_seconds",
"def timeout_seconds(self, timeout_seconds):\n\n self._timeout_seconds = timeout_seconds",
"def set_timeout(self, timeout_secs):\n sel... | [
"0.7244905",
"0.7077083",
"0.7077083",
"0.6927818",
"0.6727418",
"0.6487171",
"0.63730776",
"0.63308954",
"0.6328697",
"0.632715",
"0.63181335",
"0.6302803",
"0.61149293",
"0.5976687",
"0.5967412",
"0.5945675",
"0.59285706",
"0.5925558",
"0.592076",
"0.58889365",
"0.5865888",... | 0.6873225 | 4 |
Sets the delay that is waited after each Selenium command. This is useful mainly in slowing down the test execution to be able to view the execution. `seconds` may be given in Robot Framework time format. Returns the previous speed value. | def set_selenium_speed(self, seconds):
old = self._selenium.get_speed()
seconds = str(int(utils.timestr_to_secs(seconds)*1000))
self._selenium.set_speed(seconds)
return utils.secs_to_timestr(float(old)/1000) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delay(seconds):\n\n # Perform the delay\n time.sleep(seconds)",
"def set_selenium_timeout(self, seconds):\n timeout = utils.timestr_to_secs(seconds)\n old = getattr(self, '_timeout', timeout)\n self._timeout = timeout\n self._selenium.set_timeout(timeout * 1000)\n ret... | [
"0.66323715",
"0.6297846",
"0.6280223",
"0.62300897",
"0.6206175",
"0.6159071",
"0.6082828",
"0.60776395",
"0.60160977",
"0.60102314",
"0.59985185",
"0.59399515",
"0.5932031",
"0.5910213",
"0.5898481",
"0.58874804",
"0.5863831",
"0.5814787",
"0.5781439",
"0.5781439",
"0.56741... | 0.6863085 | 0 |
Calls a method in the Selenium remote control API directly. This keyword can be used if some functionality provided by Selenium is not yet exposed as a keyword. `method_name` is the name of the method to call in the Selenium API and `args` specify the arguments it expects. The keyword first tries to find a method in Se... | def call_selenium_api(self, method_name, *args):
try:
method = getattr(self._selenium, method_name)
except AttributeError:
method = lambda *args: self._selenium.do_command(method_name, args)
return method(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _call_command_method(self, name, original_method, args, kwargs):\n if threadprop.current_controller() is not self:\n action=self._direct_comm_call_action\n if action==\"warning\":\n if name not in self._command_warned:\n print(\"Warning: direct cal... | [
"0.64679945",
"0.6191388",
"0.6156052",
"0.614689",
"0.6126066",
"0.61218405",
"0.6005276",
"0.59827995",
"0.59674746",
"0.5966414",
"0.5953731",
"0.5952385",
"0.5854593",
"0.576358",
"0.5734514",
"0.5709739",
"0.5668814",
"0.56597054",
"0.5618796",
"0.55931056",
"0.5582841",... | 0.7929701 | 0 |
Adds a custom location strategy. `strategy_name` is the name of the strategy; a prefix used when addressing an element. `function_definition` is the JavaScript that will be called. It must return a DOM reference, an array with DOM references, or null. Together with the modified seleniumserver.jar it can provide a new m... | def add_location_strategy(self, strategy_name, function_definition):
self._locator_parser.add_strategy(strategy_name)
self._selenium.add_location_strategy(strategy_name, function_definition) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def strategy(func):\n strategies.append(func)\n return func",
"def strategy(strategy_name: str):\r\n def wrapper(finder_class):\r\n global strategies\r\n strategies[strategy_name] = finder_class\r\n return finder_class\r\n return wrapper",
"def _apply_hooks(\n context: HookC... | [
"0.5778675",
"0.5589892",
"0.47768068",
"0.4705223",
"0.46349427",
"0.45650652",
"0.44619638",
"0.44110903",
"0.43347523",
"0.42556694",
"0.42554522",
"0.4228382",
"0.41904864",
"0.41884336",
"0.41832274",
"0.41638365",
"0.4158864",
"0.4145258",
"0.41342977",
"0.41133204",
"0... | 0.85643756 | 0 |
Squash deeply nested dictionary. | def squash(data, parent_key="", sep="."):
items = []
for k, v in data.items():
k = str(k)
if k[0] == "_":
k = k[1:]
new_key = parent_key + sep + k if parent_key else k
if isinstance(v, collections.abc.MutableMapping):
items.extend(squash(v, new_key, sep=s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def recursive_squeeze(dictlike):\n out = {}\n for k, v in dictlike.items():\n if isinstance(v, dict):\n out[k] = recursive_squeeze(v)\n else:\n out[k] = np.squeeze(v)\n return out",
"def unflatten(\n d: Dict[str, Any],\n base: Dict[str, Any] = None,\n) -> Dict[s... | [
"0.6798054",
"0.6370052",
"0.63272715",
"0.62804824",
"0.6247005",
"0.6229685",
"0.6208201",
"0.62053543",
"0.6178594",
"0.61608326",
"0.6072516",
"0.6069942",
"0.5972645",
"0.5956857",
"0.59553653",
"0.5934359",
"0.59289074",
"0.59246",
"0.5923879",
"0.5918683",
"0.5888782",... | 0.6701361 | 1 |
Logarithm of the hyperbolic cosine of the prediction error. `log(cosh(x))` is approximately equal to `(x 2) / 2` for small `x` and to `abs(x) log(2)` for large `x`. This means that 'logcosh' works mostly like the mean squared error, but will not be so strongly affected by the occasional wildly incorrect prediction. | def logcosh(y_true, y_pred):
def _logcosh(x):
return x + nn.softplus(-2. * x) - math_ops.log(2.)
return K.mean(_logcosh(y_pred - y_true), axis=-1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_cosh(y_true, y_pred):\n y_pred = tensor_conversion.convert_to_tensor_v2_with_dispatch(y_pred)\n y_true = math_ops.cast(y_true, y_pred.dtype)\n\n def _logcosh(x):\n return x + math_ops.softplus(-2. * x) - math_ops.cast(\n math_ops.log(2.), x.dtype)\n\n return backend.mean(_logcosh(y_pred - y_t... | [
"0.76132387",
"0.72645205",
"0.70176494",
"0.6731372",
"0.6226951",
"0.62121165",
"0.6074388",
"0.6073056",
"0.59627014",
"0.5937668",
"0.5929191",
"0.5901009",
"0.58072233",
"0.5728377",
"0.5656887",
"0.5649234",
"0.5644657",
"0.5626796",
"0.56044716",
"0.55885035",
"0.55826... | 0.74146074 | 1 |
Restarts the current program. | def get(self):
#python = sys.executable
#os.execl(python, python, * sys.argv)
os.execl(sys.executable, *([sys.executable] + sys.argv)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def restart(self):\n print \"Restarting \" + executable + \" \" + str(argv) \n execl(executable, *([executable]+argv))",
"def restart_program():\r\n\tpython = sys.executable\r\n\tos.execl(python, python, * sys.argv)\r\n\troot = tk.Tk()",
"def Restart(self):\n handler = self.get_command_obj... | [
"0.81809056",
"0.77184916",
"0.7704029",
"0.76525164",
"0.76247376",
"0.7567915",
"0.75503725",
"0.75503725",
"0.75476766",
"0.7467852",
"0.7454058",
"0.7446032",
"0.7443567",
"0.7435153",
"0.7336499",
"0.7296281",
"0.7243043",
"0.72082216",
"0.71947414",
"0.7190868",
"0.7169... | 0.0 | -1 |
Returns the pascal triangle of n. | def pascal_triangle(n):
if n <= 0:
return []
l = [[0 for x in range(i + 1)] for i in range(n)]
l[0] = [1]
for i in range(1, n):
l[i][0] = 1
for j in range(1, i + 1):
if j < len(l[i - 1]):
l[i][j] = l[i - 1][j - 1] + l[i - 1][j]
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_pascal_triangle(self, n):\r\n if n == 0:\r\n return list()\r\n\r\n return [self.gen_triangle_level(i)\r\n for i\r\n in range(1, n + 1, 1)]",
"def pascal_triangle(n):\n if n <= 0:\n return []\n\n a = [[1 for i in range(1, j + 1)] for j... | [
"0.83876556",
"0.8313631",
"0.8303543",
"0.82191485",
"0.8042562",
"0.8002575",
"0.7965688",
"0.7950681",
"0.7875324",
"0.7869357",
"0.78521544",
"0.7814328",
"0.7648985",
"0.7577198",
"0.7450272",
"0.7302716",
"0.71677047",
"0.7041317",
"0.6824642",
"0.6618727",
"0.659417",
... | 0.83408237 | 1 |
Read simulation parameters and coordinate file | def __init__(self):
self.read_input_file()
self.read_simulation_files() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_simulation_files(self):\n\n # Check if simulation files exist in current directory, if not kill process\n if not os.path.isfile('{}.xyz'.format(self.prefix)):\n print('Cannot find simulation file \"{}.xyz\"'.format(self.prefix))\n sys.exit()\n if not os.path.isfi... | [
"0.6841979",
"0.6729605",
"0.66394055",
"0.66348255",
"0.64284354",
"0.6424802",
"0.64047414",
"0.6300033",
"0.62991303",
"0.6293398",
"0.624105",
"0.62298125",
"0.6183919",
"0.6102133",
"0.609614",
"0.60784197",
"0.6073304",
"0.6040738",
"0.5993862",
"0.59910494",
"0.5977948... | 0.5666166 | 60 |
Read visualise setup file | def read_input_file(self):
# Check if input file exists in current directory, if not kill process
if not os.path.isfile('./visualise.inpt'):
print('Cannot find input file "visualise.inpt" in current directory')
sys.exit()
# Read input file and analysis options and param... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_setup(inifile):\n # inifile = os.path.join(spathy_path, inifile)\n print(inifile)\n cfg = configparser.ConfigParser()\n cfg.read(inifile)\n\n pp = {}\n for s in cfg.sections():\n section = s.encode('ascii', 'ignore')\n pp[section] = {}\n for k, v in cfg.items(section... | [
"0.6377754",
"0.60416627",
"0.5966378",
"0.5848778",
"0.57741296",
"0.57032096",
"0.564497",
"0.5521531",
"0.54921776",
"0.5488427",
"0.544995",
"0.5425102",
"0.5385421",
"0.5385421",
"0.53816396",
"0.5381369",
"0.5374962",
"0.5364246",
"0.5362655",
"0.53585416",
"0.535645",
... | 0.59166896 | 3 |
Read XYZ and visualisation files from simulation | def read_simulation_files(self):
# Check if simulation files exist in current directory, if not kill process
if not os.path.isfile('{}.xyz'.format(self.prefix)):
print('Cannot find simulation file "{}.xyz"'.format(self.prefix))
sys.exit()
if not os.path.isfile('{}_vis2d.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_simulation_results(self,\n fname_sims, \n fname_pareto = None, \n fname_cull = None):\n\n \n self.fname_sims = fname_sims\n self.__read_file(fname_sims, 'sim_results')\n \n if fname_pareto is no... | [
"0.61848754",
"0.6042058",
"0.59669006",
"0.59361804",
"0.58964205",
"0.5878065",
"0.58193845",
"0.57807654",
"0.57697374",
"0.57643694",
"0.5762156",
"0.5759421",
"0.57102454",
"0.56983227",
"0.56967455",
"0.569428",
"0.56905067",
"0.5686337",
"0.56723523",
"0.5671769",
"0.5... | 0.74568313 | 0 |
Visualise particles and polygons | def visualise(self):
# Initialise figure
params = {"figure.figsize": (5, 5)}
pylab.rcParams.update(params)
self.fig = plt.figure()
self.ax = self.fig.add_subplot(111)
# Add particles if selected
print(self.crds)
cmap=cm.get_cmap('coolwarm')
norm=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def visualize(title, particles):\n\n plt.figure(figsize=(10,10))\n plt.title(\"Best configuration for \" + str(len(particles)) + \" particles\", size=25)\n plt.xlabel(\"xcoordinate\", size=18)\n plt.ylabel(\"ycoordinate\", size=18)\n\n plt.xticks(size=13)\n plt.yticks(size=13)\n\n circle = plt... | [
"0.717661",
"0.68778163",
"0.67623657",
"0.65606654",
"0.65092915",
"0.64102745",
"0.6362865",
"0.63186747",
"0.6282361",
"0.6227061",
"0.6184886",
"0.616295",
"0.61177635",
"0.6107491",
"0.6087164",
"0.6042589",
"0.59876037",
"0.59707433",
"0.5968525",
"0.5959219",
"0.594656... | 0.72570527 | 0 |
When called with an instance of L{bytes}, L{bytes_to_str} decodes its input using I{ascii} and returns the resulting str string as an instance of L{str}. | def test_bytes(self):
self.assertRaises(
UnicodeDecodeError,
lambda: bytes_to_str("\N{SNOWMAN}".encode("utf-8")),
)
decoded = bytes_to_str(b"hello world")
self.assertIsInstance(decoded, str)
self.assertEqual(decoded, "hello world") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to_string(_bytes: bytes)-> str:\n # print('input bytes: ', _bytes)\n # print('string: ', binascii.hexlify(_bytes))\n # print('string2: ', _bytes.hex())\n # print('string3: ', \" \".join([\"{:02x}\".format(x) for x in _bytes]))\n return \" \".join([\"{:02x}\".format(x) for x in _bytes])",... | [
"0.7246639",
"0.7208778",
"0.7151885",
"0.71390045",
"0.7111041",
"0.7110607",
"0.7110607",
"0.70306545",
"0.70047045",
"0.6990467",
"0.6975962",
"0.6801189",
"0.6800496",
"0.6777518",
"0.6772956",
"0.6617866",
"0.65932745",
"0.65838194",
"0.652744",
"0.6471219",
"0.6455923",... | 0.7150879 | 3 |
When called with an instance of L{str}, L{bytes_to_str} returns its input unmodified. | def test_str(self):
self.assertEqual(
"\N{SNOWMAN}",
bytes_to_str("\N{SNOWMAN}"),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def always_str(str_or_bytes: Union[None, str, bytes], *decode_args) -> Union[None, str]:\n if str_or_bytes is None or isinstance(str_or_bytes, str):\n return str_or_bytes\n elif isinstance(str_or_bytes, bytes):\n return str_or_bytes.decode(*decode_args)\n else:\n raise TypeError(\"Exp... | [
"0.6703084",
"0.6667159",
"0.665698",
"0.66231215",
"0.65923953",
"0.6549901",
"0.6501315",
"0.6458548",
"0.64560145",
"0.6408117",
"0.6405631",
"0.6373941",
"0.63643",
"0.62835956",
"0.62750614",
"0.6263772",
"0.62543184",
"0.6227834",
"0.62072873",
"0.6200505",
"0.61952037"... | 0.0 | -1 |
When called with L{None}, L{to_xml} returns a L{Deferred} that fires with C{b""}. | def test_none(self):
self.assertEqual(b"", self.successResultOf(to_xml(None))) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def xml_string(self):\r\n if self._xml_string is not None:\r\n return self._xml_string\r\n\r\n return etree.tostring(... | [
"0.6010409",
"0.5807119",
"0.5803181",
"0.57231146",
"0.5688771",
"0.5660354",
"0.54970235",
"0.5462216",
"0.54385936",
"0.538115",
"0.53393245",
"0.5326203",
"0.5314152",
"0.53080094",
"0.5306955",
"0.52890134",
"0.52495795",
"0.5163723",
"0.5145049",
"0.513027",
"0.5113245"... | 0.70309347 | 0 |
When called with an instance of L{txaws.route53._util.Tag}, L{to_xml} returns a L{Defered} giving the result of flattening it as an instance of L{bytes} with an xml doctype prepended. | def test_something(self):
self.assertEqual(
b"""<?xml version="1.0" encoding="UTF-8"?>\n<Foo>bar</Foo>""",
self.successResultOf(to_xml(tags.Foo("bar"))),
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_xml(self):\n with io.StringIO() as string:\n string.write(ET.tostring(self.root, encoding=\"unicode\"))\n return string.getvalue()",
"def to_xml(self):\r\n if self.alias_hosted_zone_id != None and self.alias_dns_name != None:\r\n # Use alias\r\n b... | [
"0.6391548",
"0.61091745",
"0.6022592",
"0.58278495",
"0.56610465",
"0.5652941",
"0.56497854",
"0.5648577",
"0.5553133",
"0.55280334",
"0.55280334",
"0.5448845",
"0.5372592",
"0.5368684",
"0.53555965",
"0.53358155",
"0.5322113",
"0.5322113",
"0.5310961",
"0.530388",
"0.530242... | 0.0 | -1 |
in this page teacher can see all of the forum posts | def teacher_forum_landing_page(request, page):
# Deleting admin-typed user session
# Deleting programmer-typed-user session
# Get the current users
current_basic_user = get_current_user(request, User, ObjectDoesNotExist)
current_basic_user_profile = get_current_user_profile(
request,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post_list(request):\n\timage_post_list = list(ImagePost.objects.all())\n\tvideo_post_list = list(VideoPost.objects.all())\n\tall_post = image_post_list + video_post_list\n\treturn render(request,'devblog/post_list.html', {'posts':all_post})",
"def view_blog(self):",
"def forum(request, forum_id):\n topi... | [
"0.65342",
"0.6510963",
"0.6504755",
"0.6503333",
"0.6503325",
"0.65012",
"0.6413255",
"0.636724",
"0.6361781",
"0.63528556",
"0.634705",
"0.6344606",
"0.62456393",
"0.6225456",
"0.62220657",
"0.62189585",
"0.61770386",
"0.6170098",
"0.61636835",
"0.61625767",
"0.6136682",
... | 0.6446999 | 6 |
in this view the teacher can create a forum post | def teacher_forum_create(request):
# Deleting admin-typed user session
# Deleting programmer-typed-user session
# Get the current users
current_basic_user = get_current_user(request, User, ObjectDoesNotExist)
current_basic_user_profile = get_current_user_profile(
request,
User,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n teacher = self.request.get(\"teacher\")\n student = self.request.get(\"student\")\n lessondate = self.request.get(\"lessondate\")\n reason = self.request.get(\"reason\")\n comment = self.request.get(\"comment\")\n\n if teacher and student and lessondate a... | [
"0.7329339",
"0.7162002",
"0.70594895",
"0.7003851",
"0.6994737",
"0.6979558",
"0.6978259",
"0.691917",
"0.6845622",
"0.68156683",
"0.67997193",
"0.6753117",
"0.67289805",
"0.6726166",
"0.67195654",
"0.66782594",
"0.66578925",
"0.6632889",
"0.6628704",
"0.6607489",
"0.660156"... | 0.8074095 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.